func main() { username := flag.String("username", "", "User to login with") password := flag.String("password", "", "Password to login with") flag.Usage = func() { fmt.Fprintf(os.Stderr, "usage: %s [flags] targets...\n", os.Args[0]) flag.PrintDefaults() os.Exit(2) } flag.Parse() if flag.NArg() == 0 { flag.Usage() } s, err := netconf.DialSSH(flag.Arg(0), netconf.SSHConfigPassword(*username, *password)) if err != nil { panic(err) } defer s.Close() fmt.Printf("Server Capabilities: '%+v'\n", s.ServerCapabilities) fmt.Printf("Session Id: %d\n\n", s.SessionID) //reply, err := s.Exec([]byte("<rpc><get-config><source><running/></source></get-config></rpc>")) reply, err := s.ExecRPC(netconf.RPCGetConfig("running")) if err != nil { panic(err) } fmt.Printf("Reply: %+v", reply) }
func (zr *ChassisZonesRequest) Run(count int, replyChan chan<- *netconf.RPCReply) { go func() { ticker := time.NewTicker(zr.Interval) for { select { case <-ticker.C: // Get SSH/NETCONF session going for use throughout the life of this request. if s, err := netconf.DialSSH(zr.LoopBackIP.String(), netconf.SSHConfigPassword(zr.UserName, zr.Password)); err != nil { log.Errorln(err) s.Close() close(replyChan) } else if ncReply, err := s.Exec(zr.Method()); err != nil { log.Errorln(err) s.Close() close(replyChan) } else { s.Close() replyChan <- ncReply } count-- if count < 0 { break } } } }() /* cfg := config.GetConfig() file, err := os.Create(cfg.ChassisZonesResultsFile) if err != nil { log.Fatalln(err) } for _ = range ticker.C { if ncReply, err := s.Exec(zr.Method()); err != nil { log.Error(err) } else if chassisEnvResp, err := response.NewChassisEnvResponse(&ncReply.Data); err != nil { log.Error(err) } else { chassisEnvResp.WriteCSV(file) } }*/ }
func BuildConfig() *ssh.ClientConfig { var config *ssh.ClientConfig var pass string if *pubkey == true { if *agent { var err error config, err = netconf.SSHConfigPubKeyAgent(*username) if err != nil { log.Fatal(err) } } else { if *nopassphrase { pass = "******" } else { if *passphrase != "" { pass = *passphrase } else { var readpass []byte var err error fmt.Printf("Enter Passphrase for %s: ", *key) readpass, err = terminal.ReadPassword(int(syscall.Stdin)) if err != nil { log.Fatal(err) } pass = string(readpass) fmt.Println() } } var err error config, err = netconf.SSHConfigPubKeyFile(*username, *key, pass) if err != nil { log.Fatal(err) } } } else { fmt.Printf("Enter Password: ") bytePassword, err := terminal.ReadPassword(int(syscall.Stdin)) if err != nil { log.Fatal(err) } fmt.Println() config = netconf.SSHConfigPassword(*username, string(bytePassword)) } return config }
func main() { rawMethod := netconf.RawMethod("<traceroute><host>8.8.8.8</host></traceroute>") s := new(netconf.Session) var err error if s, err = netconf.DialSSH("192.168.1.1", netconf.SSHConfigPassword("username", "password")); err != nil { log.Fatal(err) } else { defer s.Close() } tr := new(traceroute.TraceRoute) if ncReply, err := s.Exec(rawMethod); err != nil { log.Fatal(err) } else if _, err := tr.ReadXMLFrom(bytes.NewBuffer([]byte(ncReply.Data))); err != nil { log.Fatal(err) } else { tr.WriteCLITo(os.Stdout) } }
func foo() { username := "******" password := "******" host := "172.19.100.49" s, err := netconf.DialSSH(host, netconf.SSHConfigPassword(username, password)) if err != nil { panic(err) } defer s.Close() fmt.Printf("Session Id: %d\n\n", s.SessionID) reply, err := s.Exec(netconf.RawMethod("<command format=\"ascii\">show version</command>")) if err != nil { panic(err) } p := &Parser{} v := p.Trim(reply.Data) fmt.Println("REPLY START") fmt.Printf("%s", v) fmt.Println("REPLY END") }
func (cer *ChassisEnvCmd) Run() (<-chan *netconf.RPCReply, <-chan error) { replyChan := make(chan *netconf.RPCReply) errChan := make(chan error) go func() { const thisFunc = "*ChassisEnvCmd.Run()" cntxLog := log.WithFields(log.Fields{ "func": thisFunc, "deadline": cer.Deadline, "interval": cer.Interval, "username": cer.UserName, "ip": cer.LoopBackIP, }) cntxLog.Debugln("Starting") // Flag for breaking loop done := false // Use a ticker to notify us when it's time to execute the command again. ticker := time.NewTicker(cer.Interval) // Use time.After to let us know when we've reached our deadline. deadline := time.After(cer.Deadline) for !done { select { case <-ticker.C: cntxLog.Debugln("dialing SSH") if s, err := netconf.DialSSH(cer.LoopBackIP.String(), netconf.SSHConfigPassword(cer.UserName, cer.Password)); err != nil { cntxLog.Debugln(err) errChan <- &RunError{ Method: thisFunc, ClientErr: fmt.Sprintf("could not dial %s via NETCONF over SSH", cer.LoopBackIP.String()), Err: err, Cmd: cer, } } else if ncReply, err := s.Exec(cer.Method()); err != nil { cntxLog.Debugln(err) s.Close() errChan <- &RunError{ Method: thisFunc, ClientErr: fmt.Sprintf("could not execute show chassis enviornment command"), } } else { s.Close() replyChan <- ncReply } case <-deadline: cntxLog.Debugln("deadline reached") close(replyChan) close(errChan) done = true case <-cer.cancelled: cntxLog.Debugln("command cancelled") close(replyChan) close(errChan) done = true } } cntxLog.Debugln("Exiting") }() return replyChan, errChan }