moved go stuff arround

[svn42.git] / go / door_daemon / unix_socket_server.go

diff --git a/go/door_daemon/unix_socket_server.go b/go/door_daemon/unix_socket_server.go
new file mode 100644 (file)
index 0000000..6598e6b
--- /dev/null
+++ b/go/door_daemon/unix_socket_server.go
@@ -0,0 +1,225 @@
+package main
+import "fmt"
+import "net"
+import "bufio"
+import "strings"
+import "os"
+import "io"
+import "realraum.at/termios"
+import "flag"
+import "regexp"
+import "sync"
+import "time"
+
+var lock sync.RWMutex
+
+type DoorConnection struct {
+  rw * bufio.ReadWriter
+  c net.Conn
+  wchan chan string
+}
+
+var DoorConnectionMap = map[uint]DoorConnection {
+}
+
+var cmdHandler = map[string]func([]string,string,*bufio.ReadWriter ) {
+  "test":handleCmdTest,
+  "open":handleCmdController,
+  "close":handleCmdController,
+  "toggle":handleCmdController,
+}
+
+
+func readLineSafe(rw *bufio.Reader) (string, error) {
+  wasPrefix:=false
+  var line string
+  for isPrefix:=true;isPrefix; {
+    var lineBuf []byte 
+    var err error
+    lineBuf,isPrefix,err = rw.ReadLine()
+    if err != nil {
+        return "",err
+    }
+    if isPrefix {
+      wasPrefix=true
+    } else {
+      line=string(lineBuf)
+    }
+  }
+  if wasPrefix {
+      fmt.Println("line too long")
+      //fmt.Fprintf(rw,"line too long\n")
+      //rw.Flush()
+      return "",nil
+  }
+  reg := regexp.MustCompile("\r")
+  safe := reg.ReplaceAllString(line, "")
+  return safe,nil
+}
+
+func connToReadWriter(c io.Reader,cw io.Writer) (*bufio.ReadWriter) {
+    client_r := bufio.NewReaderSize(c,1024)
+    client_w := bufio.NewWriterSize(cw,1024)
+    return bufio.NewReadWriter(client_r,client_w)
+}
+
+func handleConnection(c net.Conn, client * bufio.ReadWriter, connID uint) () {
+    fmt.Println("new connection")
+    defer func () {
+     lock.Lock()
+     delete(DoorConnectionMap,connID)
+     lock.Unlock()
+    }()
+    for {
+         line,err:=readLineSafe(bufio.NewReader(client))
+         if err != nil {
+          if err.Error() != "EOF" {
+            fmt.Printf("Error: readLineSafe returned %v\n",err.Error())
+          } else {
+            fmt.Printf("Connection closed by remote host\n");
+          }
+          c.Close()
+          return
+         }
+         if line == "" {
+           continue
+         }
+         fmt.Printf("Received: %v\n", line)
+         tokens:=strings.Fields(line)
+         remainStr:=strings.Join(tokens[1:]," ")
+         handleCmd(tokens,remainStr,client)
+    }
+}
+
+func handleCmd(tokens []string, remainStr string,client * bufio.ReadWriter) {
+  cmd:=tokens[0]
+  func_ptr,present := cmdHandler[cmd]
+  if present {
+    func_ptr(tokens, remainStr,client)
+  } else {
+    fmt.Printf("Error: unknown Cmd: %v\n", cmd)
+  }
+}
+
+func handleCmdTest(tokens []string, remainStr string, client * bufio.ReadWriter) {
+  //cmd:=tokens[0]
+  fmt.Printf("Test: %v\n", remainStr)
+}
+
+func handleCmdController(tokens []string, remainStr string, client * bufio.ReadWriter) {
+  cmd:=tokens[0]
+  s_r:=strings.NewReader(cmd)
+  char := make([]byte,1)
+  s_r.Read(char)
+  fmt.Println(string(char))
+}
+
+
+func openTTY(name string) *os.File {
+  file, err := os.OpenFile(name,os.O_RDWR  ,0600) // For read access.
+  if err != nil {
+    fmt.Println(err.Error())
+  }
+  termios.Ttyfd(file.Fd())
+  termios.SetRaw()
+  return file 
+}
+func usage() {
+    fmt.Fprintf(os.Stderr, "usage: myprog [inputfile]\n")
+    flag.PrintDefaults()
+    os.Exit(2)
+}
+
+func SerialWriter(c chan string, serial * os.File ) {
+  for {
+    serial.WriteString(<-c)
+    serial.Sync()
+  }
+}
+
+func SerialReader(c chan string , serial * bufio.Reader) {
+  for {
+    s,err := readLineSafe(serial)
+    if (s=="") {
+     continue
+    }
+    if (err!=nil) {
+     fmt.Printf("Error in read from serial: %v\n",err.Error())
+     os.Exit(1)
+    }
+    //fmt.Printf("Serial: Read %v\n",s);
+    c<-s
+  }
+}
+
+func openSerial(filename string) (chan string,chan string) {
+  serial:=openTTY(filename)
+  in:=make(chan string)
+  out:=make(chan string)
+  go SerialWriter(out,serial)
+  go SerialReader(in,bufio.NewReaderSize(serial,128))
+  return in,out
+}
+
+func SerialHandler(serial_i chan string) {
+  for {
+    line:=<-serial_i
+    fmt.Printf("Serial Read: %s\n",line)
+    lock.RLock()
+    for _, v := range DoorConnectionMap{
+      select {
+        case v.wchan<-line:
+
+        case <-time.After(2):
+
+      }
+    }
+    lock.RUnlock()
+  }
+}
+
+func chanWriter(c chan string, w io.Writer) {
+  for {
+    line := <-c
+     w.Write([]byte(line))
+     w.Write([]byte("\n"))
+  }
+}
+func main() {
+//    lock = make(sync.RWMutex)
+    flag.Usage = usage
+    flag.Parse()
+
+    args := flag.Args()
+    if len(args) < 1 {
+        fmt.Println("Input file is missing.");
+        os.Exit(1);
+    }
+  serial_i,serial_o:=openSerial(args[0]) 
+  go SerialHandler(serial_i)
+  serial_o<-"f"
+
+  ln, err := net.Listen("unix", "/tmp/test.sock")
+  if err != nil {
+    fmt.Printf("Error: %s\n",err.Error())
+    return
+  }
+  fmt.Printf("Listener started\n")
+
+  var connectionID uint =0
+  for {
+    conn, err := ln.Accept()
+    if err != nil {
+      // handle error
+     continue
+    }
+   client:=connToReadWriter(conn,conn)
+   connectionID++
+   writeChan := make(chan string)
+   lock.Lock()
+   DoorConnectionMap[connectionID]= DoorConnection{ rw:client,c:conn, wchan:writeChan }
+   lock.Unlock()
+   go handleConnection(conn,client,connectionID)
+   go chanWriter(writeChan,conn)
+  }
+}