gop2p/p2p.go

package main

import (
  "net"
  "os"
  "fmt"
  "strings"
)

func main() {
  if len(os.Args) <= 1 {
      fmt.Fprintf(os.Stderr, "Usage: %s <local node port> <remote node port>\n", os.Args[0])
      os.Exit(1)
  }

  // Configure this local node's listening port.
  service := ":" + os.Args[1]
  tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
  checkError(err)

  listener, err := net.ListenTCP("tcp", tcpAddr)
  checkError(err)

  // If a remote peer's port is specified, we want to connect and message it
  if len(os.Args) == 3 {
    fmt.Println("Found a remote peer")
    remote := ":" + os.Args[2]
    tcpRemote, err := net.ResolveTCPAddr("tcp4", remote)
    checkError(err)

    peerconn, err := net.DialTCP("tcp4", nil, tcpRemote)
    checkError(err)

    _, err = peerconn.Write([]byte("Hello from " + os.Args[1]))
    checkError(err)

    var buf [512]byte

    n, err := peerconn.Read(buf[0:])
    checkError(err)

    result := string(buf[0:n])
    fmt.Println(string(result))
  }

  fmt.Printf("(%s) Waiting for peer connections...\n", os.Args[1])
  for {
    conn, err := listener.Accept()
    if err != nil {
      continue
    }

    handleConnection(conn)
  }
}

func handleConnection(conn net.Conn) {
  // close connection on exit
  defer conn.Close()

  var buf [512]byte

  for {
    // read up to 512 bytes
    n, err := conn.Read(buf[0:])
    if err != nil {
      return
    }

    message := string(buf[0:n])
    fmt.Println(message)

    tokens := strings.Split(message, " ")
    if tokens[0] != "" {
      response := "Hi " + tokens[2] + ", from " + os.Args[1]
      // write the n bytes read
      _, err2 := conn.Write([]byte(response))
      if err2 != nil {
        return
      }
    }

  }
}

func checkError(err error) {
  if err != nil {
    fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
    os.Exit(1)
  }
}