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 import "termios"
   9 import "flag"
  10 import "regexp"
  11
  12 var cmdHandler = map[string]func([]string,string,*bufio.ReadWriter ) {
  13   "test":handleCmdTest,
  14   "open":handleCmdController,
  15   "close":handleCmdController,
  16   "toggle":handleCmdController,
  17 }
  18
  19
  20 func readLineSafe(rw *bufio.Reader) (string, error) {
  21   wasPrefix:=false
  22   var line string
  23   for isPrefix:=true;isPrefix; {
  24     var lineBuf []byte
  25     var err error
  26     lineBuf,isPrefix,err = rw.ReadLine()
  27     if err != nil {
  28         return "",err
  29     }
  30     if isPrefix {
  31       wasPrefix=true
  32     } else {
  33       line=string(lineBuf)
  34     }
  35   }
  36   if wasPrefix {
  37       fmt.Println("line too long")
  38       //fmt.Fprintf(rw,"line too long\n")
  39       //rw.Flush()
  40       return "",nil
  41   }
  42   reg := regexp.MustCompile("\r")
  43   safe := reg.ReplaceAllString(line, "")
  44   return safe,nil
  45 }
  46
  47 func connToReadWriter(c io.Reader,cw io.Writer) (*bufio.ReadWriter) {
  48     client_r := bufio.NewReaderSize(c,1024)
  49     client_w := bufio.NewWriterSize(cw,1024)
  50     return bufio.NewReadWriter(client_r,client_w)
  51 }
  52
  53 func handleConnection(c net.Conn) () {
  54     client:=connToReadWriter(c,c)
  55     fmt.Println("new connection")
  56     for {
  57          line,err:=readLineSafe(bufio.NewReader(client))
  58          if err != nil {
  59           if err.Error() != "EOF" {
  60             fmt.Printf("Error: readLineSafe returned %v\n",err.Error())
  61           } else {
  62             fmt.Printf("Connection closed by remote host\n");
  63           }
  64           c.Close()
  65           return
  66          }
  67          if line == "" {
  68            continue
  69          }
  70          fmt.Printf("Received: %v\n", line)
  71          tokens:=strings.Fields(line)
  72          remainStr:=strings.Join(tokens[1:]," ")
  73          handleCmd(tokens,remainStr,client)
  74     }
  75 }
  76
  77 func handleCmd(tokens []string, remainStr string,client * bufio.ReadWriter) {
  78   cmd:=tokens[0]
  79   func_ptr,present := cmdHandler[cmd]
  80   if present {
  81     func_ptr(tokens, remainStr,client)
  82   } else {
  83     fmt.Printf("Error: unknown Cmd: %v\n", cmd)
  84   }
  85 }
  86
  87 func handleCmdTest(tokens []string, remainStr string, client * bufio.ReadWriter) {
  88   //cmd:=tokens[0]
  89   fmt.Printf("Test: %v\n", remainStr)
  90 }
  91
  92 func handleCmdController(tokens []string, remainStr string, client * bufio.ReadWriter) {
  93   cmd:=tokens[0]
  94   s_r:=strings.NewReader(cmd)
  95   char := make([]byte,1)
  96   s_r.Read(char)
  97   fmt.Println(string(char))
  98 }
  99
 100
 101 func openTTY(name string) *os.File {
 102   file, err := os.OpenFile(name,os.O_RDWR  ,0600) // For read access.
 103   if err != nil {
 104     fmt.Println(err.Error())
 105   }
 106   termios.Ttyfd(file.Fd())
 107   termios.SetRaw()
 108   return file
 109 }
 110 func usage() {
 111     fmt.Fprintf(os.Stderr, "usage: myprog [inputfile]\n")
 112     flag.PrintDefaults()
 113     os.Exit(2)
 114 }
 115
 116 func SerialWriter(c chan string, serial * os.File ) {
 117   for {
 118     serial.WriteString(<-c)
 119     serial.Sync()
 120   }
 121 }
 122
 123 func SerialReader(c chan string , serial * bufio.Reader) {
 124   for {
 125     s,err := readLineSafe(serial)
 126     if (s=="") {
 127      continue
 128     }
 129     if (err!=nil) {
 130      fmt.Printf("Error in read from serial: %v\n",err.Error())
 131      os.Exit(1)
 132     }
 133     //fmt.Printf("Serial: Read %v\n",s);
 134     c<-s
 135   }
 136 }
 137
 138 func openSerial(filename string) (chan string,chan string) {
 139   serial:=openTTY(filename)
 140   in:=make(chan string)
 141   out:=make(chan string)
 142   //go SerialWriter(out,serial)
 143   go SerialReader(in,bufio.NewReaderSize(serial,128))
 144   return in,out
 145 }
 146
 147 func SerialHandler(serial_i chan string) {
 148   for {
 149     fmt.Printf("Serial Read: %s\n",<-serial_i);
 150   }
 151 }
 152 func main() {
 153     flag.Usage = usage
 154     flag.Parse()
 155
 156     args := flag.Args()
 157     if len(args) < 1 {
 158         fmt.Println("Input file is missing.");
 159         os.Exit(1);
 160     }
 161   ln, err := net.Listen("unix", "/tmp/test.sock")
 162   if err != nil {
 163     fmt.Printf("Error: %s\n",err.Error())
 164     return
 165   }
 166   fmt.Printf("Listener started\n")
 167
 168   serial_i,serial_o:=openSerial(args[0])
 169   go SerialHandler(serial_i)
 170   serial_o<-"f"
 171
 172   for {
 173     conn, err := ln.Accept()
 174     if err != nil {
 175       // handle error
 176      continue
 177     }
 178     go handleConnection(conn)
 179   }
 180 }