door_daemon_go/unix_socket_server.go

   1 package main
   2 import "fmt"
   3 import "net"
   4 import "bufio"
   5 import "strings"
   6 import "os"
   7 import "io"
   8
   9 var cmdHandler = map[string]func([]string,string,*bufio.ReadWriter ) {
  10   "test":handleCmdTest,
  11   "open":handleCmdController,
  12   "close":handleCmdController,
  13   "toggle":handleCmdController,
  14 }
  15
  16
  17 func readLineSafe(rw *bufio.ReadWriter) (string, error) {
  18   wasPrefix:=false
  19   var line string
  20   for isPrefix:=true;isPrefix; {
  21     var lineBuf []byte
  22     var err error
  23     lineBuf,isPrefix,err = rw.ReadLine()
  24     if err != nil {
  25         return "",err
  26     }
  27     if isPrefix {
  28       wasPrefix=true
  29     } else {
  30       line=string(lineBuf)
  31     }
  32   }
  33   if wasPrefix {
  34       fmt.Println("line too long")
  35       fmt.Fprintf(rw,"line too long\n")
  36       rw.Flush()
  37       return "",nil
  38   }
  39   return line,nil
  40 }
  41
  42 func connToReadWriter(c io.Reader,cw io.Writer) (*bufio.ReadWriter) {
  43     client_r := bufio.NewReaderSize(c,14)
  44     client_w := bufio.NewWriterSize(cw,14)
  45     return bufio.NewReadWriter(client_r,client_w)
  46 }
  47
  48 func handleConnection(c net.Conn) () {
  49     client:=connToReadWriter(c,c)
  50     fmt.Println("new connection")
  51     for {
  52          line,err:=readLineSafe(client)
  53          if err != nil {
  54           if err.Error() != "EOF" {
  55             fmt.Printf("Error: readLineSafe returned %v\n",err.Error())
  56           } else {
  57             fmt.Printf("Connection closed by remote host\n");
  58           }
  59           c.Close()
  60           return
  61          }
  62          if line == "" {
  63            continue
  64          }
  65          fmt.Printf("Received: %v\n", line)
  66          tokens:=strings.Fields(line)
  67          remainStr:=strings.Join(tokens[1:]," ")
  68          handleCmd(tokens,remainStr,client)
  69     }
  70 }
  71
  72 func handleCmd(tokens []string, remainStr string,client * bufio.ReadWriter) {
  73   cmd:=tokens[0]
  74   func_ptr,present := cmdHandler[cmd]
  75   if present {
  76     func_ptr(tokens, remainStr,client)
  77   } else {
  78     fmt.Printf("Error: unknown Cmd: %v\n", cmd)
  79   }
  80 }
  81
  82 func handleCmdTest(tokens []string, remainStr string, client * bufio.ReadWriter) {
  83   //cmd:=tokens[0]
  84   fmt.Printf("Test: %v\n", remainStr)
  85 }
  86
  87 func handleCmdController(tokens []string, remainStr string, client * bufio.ReadWriter) {
  88   cmd:=tokens[0]
  89   s_r:=strings.NewReader(cmd)
  90   char := make([]byte,1)
  91   s_r.Read(char)
  92   fmt.Println(string(char))
  93 }
  94
  95
  96 func openTTY(name string) *bufio.ReadWriter{
  97   file, err := os.OpenFile(name,os.O_RDWR  ,0600) // For read access.
  98   if err != nil {
  99     fmt.Println(err.Error())
 100   }
 101   return connToReadWriter(file,file)
 102 }
 103
 104 func main() {
 105   serial:=openTTY("tty")
 106   serial.WriteString("foo")
 107   serial.Flush()
 108   ln, err := net.Listen("unix", "/tmp/test.sock")
 109   if err != nil {
 110     fmt.Printf("Error: %s\n",err.Error())
 111     return
 112   }
 113   fmt.Printf("Listener started\n")
 114   for {
 115     conn, err := ln.Accept()
 116     if err != nil {
 117       // handle error
 118       continue
 119     }
 120     go handleConnection(conn)
 121   }
 122 }