Document how to create a Callhome Server

[dazhuang6]

May I ask when NetConf Call Home will be supported?

[nemith]

Can you please talk more about exactly what you would be looking for from call home. Really it's supported now. Evertime I have gone to create some sort of actual "call home" feature. It comes back down to just having a network socket that listens for connections and then creates a new session on top of that connection.

The only real thing is it needs to be documented.

However It would be good to know your exact requirements?

[dazhuang6]

I have a requirement: the netconf server on the device is located in different campuses, and at this time, the netconf client cannot directly communicate with the device, so the netconf call home function needs to be used.

As you mentioned, it listens for TCP connections and then establishes SSH and Netconf sessions based on this connection.

Could you please submit that part of the code? That would be very helpful. Thank you.

[nemith]

I am more curious on what you would do across the sessions? Is this for notificaitons or for issuing RPCs over them? If it's RPCs how would you index them? How would you do auth? (see how each one of these makes it harder to havea generic handler).

Here is a rough way to do it. I haven't added this to the library as the abstraction is already good and eveything else would be added noise to it.

Something like

func startCallHome() {
	listener, err := net.Listen("tcp", ":4334")
	if err != nil {
		log.Fatalf("Failed to bind to port: %v", err)
	}
	defer listener.Close() // Ensure resource cleanup

	fmt.Println("Call home server listening on 4334...")

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Printf("Failed to accept connection: %v", err)
			continue
		}

		go handleConnection(conn)
	}
}

func handleConnection(conn *net.Conn) {
  // you may need to customize this config on a per connection basis.  
   config := &ssh.ClientConfig{
		User: "username",
		Auth: []ssh.AuthMethod{
			ssh.Password("password"),
		},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(), // just for example purposes, you probably want to validate this for security purposes 
		Timeout:         10 * time.Second,
	}

	// Perform the SSH handshake over the existing net.Conn.
	c, chans, reqs, err := ssh.NewClientConn(conn, conn.RemoteAddr().String(), config)
	if err != nil {
		return nil, err
	}

   client := ssh.NewClient(c, chans, reqs)

   tr, err := ncssh.NewTransport(client)
   if err != nil {
      log.Printf("failed to create netconf transport: %v", err)
   } 

   session, err := netconf.NewSession(tr) 
   if err != nil {
      log.Printf("failed to create netconf session: %v", err)
   }

  // Do something with the session?  Put it in a map based on the hostname?   Just issue commands?  Do you need to send some sort of keepalive?  This will all be dependent on what you needs are.  
}

i'd probably take your requirements and wrap that into a struct to hold a map of sessions (assuming that is how you are going to use it) and make the startCallHome() and handleConnection() methods off of that struct.

But each step here could require some sort of customization and just making this a bunch of call back feels wrong and I don't thinks it's necessary as a core part of this library at this point, but I am open to feedback.

[nemith]

Let me know if this doesn't work or if you have some other questions. The real meat & potatoes here is what to do with the sessions? Do you hold onto them? Do you track them? Do you use them only for push notifications, etc.

Given how wide that all is I still looking at this and I don't think the netconf library can abstract this any better (but perhaps maybe a helper func or two?)

[dazhuang6]

The problem I'm currently facing is how to handle device authentication, which is related to my specific business.

For sessions established via call home, my requirement is to retain this session indefinitely and rely on it for all RPC requests.