added some option handling functions

server.go

@@ -31,6 +31,7 @@ type DhcpServer struct {
 	p int // epoll
 	efd int // eventfd
 
+	pkt_chan chan[]byte
 
 	log              Logger
 }
@@ -104,6 +105,7 @@ func NewDhcpServer(ctx context.Context, name string, logger Logger) (*DhcpServer
 	s.p = p
 	s.conns = make(map[string]DhcpConn, 0)
 	s.conns_by_fd = make(map[int]DhcpConn, 0)
+	s.pkt_chan = make(chan[]byte, 256)
 
 	runtime.SetFinalizer(s, finalize_dhcp_server)
 	return s, nil
@@ -154,9 +156,9 @@ func (s *DhcpServer) RunTask(wg *sync.WaitGroup) {
 		go s.run_handlers(&l_wg)
 	}
 */
-fmt.Printf ("beginning of recv loop\n")
+	s.log.Write("", LOG_INFO, "Receiver loop started")
 	s.run_recv_loop()
-fmt.Printf ("end of recv loop\n")
+	s.log.Write("", LOG_INFO, "Receiver loop ended")
 
 //	l_wg.Wait()
 	finalize_dhcp_server(s)
@@ -168,6 +170,7 @@ func (s *DhcpServer) ReqStop() {
 		// eventfd needs an 8-byte integer.
 		v = 1
 		unix.Write(s.efd, (*[8]byte)(unsafe.Pointer(&v))[:])
+		s.CtxCancel()
 	}
 }
 
@@ -256,13 +259,92 @@ func get_offsets(frame []byte) (int, int, int, int, int, error) {
 	return eth_off, ip_off, udp_off, dhcp_off, dhcp_end, nil
 }
 
+func (s *DhcpServer) dhcp4_discover(pkt *Dhcp4Pkt) {
+	fmt.Printf("discover...\n")
+
+
+/*
+	ans = NewDhcp4Pkt(
+		Dhcp4OptMsgType(HDCP4_MSG_OFFER),
+		Dhcp4Ciaddr("192.168.2.3")
+	)
+*/
+
+	//Send(ans)
+}
+
+func (s *DhcpServer) dhcp4_request(pkt *Dhcp4Pkt) {
+	fmt.Printf("request...\n")
+}
+
+func (s *DhcpServer) dhcp4_release(pkt *Dhcp4Pkt) {
+	fmt.Printf("release...\n")
+}
+
+func (s *DhcpServer) dhcp4_inform(pkt *Dhcp4Pkt) {
+	fmt.Printf("inform...\n")
+}
+
+func (s *DhcpServer) dhcp4_lease_query(pkt *Dhcp4Pkt) {
+	fmt.Printf("lease query...\n")
+}
+// TODO:bulk lease query, etc
+
+func (s *DhcpServer) dhcp4_packet_proc(wg *sync.WaitGroup, id int) {
+	var buf []byte
+	var err error
+
+	defer wg.Done()
+
+	s.log.Write("", LOG_INFO, "dhcp4 packet processor(%d) started", id)
+
+proc_loop:
+	for {
+		select {
+			case <- s.Ctx.Done():
+				break proc_loop
+
+			case buf = <- s.pkt_chan:
+				var pkt Dhcp4Pkt
+				//TODO: ethernet part???
+				err = pkt.Decode(buf)
+				if err != nil { continue }
+
+				switch pkt.MsgType() {
+					case DHCP4_MSG_DISCOVER:
+						s.dhcp4_discover(&pkt)
+					case DHCP4_MSG_REQUEST:
+						s.dhcp4_request(&pkt)
+					case DHCP4_MSG_RELEASE:
+						s.dhcp4_release(&pkt)
+					case DHCP4_MSG_INFORM:
+						s.dhcp4_inform(&pkt)
+					case DHCP4_MSG_LEASE_QUERY:
+						s.dhcp4_lease_query(&pkt)
+					default:
+						// do nothing. ignore other types?
+						// TODO: logging?
+				}
+				//fmt.Printf("[%d] PKT: %+v\n", id, pkt)
+		}
+	}
+
+	s.log.Write("", LOG_INFO, "dhcp4 packet processor(%d) ended", id)
+}
+
 func (s *DhcpServer) run_recv_loop() error {
 	var buf [1500]byte
 	var nevts int
 	var i int
 	var evts [128]unix.EpollEvent
+	var l_wg sync.WaitGroup
 	var err error
 
+	for i = 0; i < 10; i++ { // how many go rootines would be the best?
+		l_wg.Add(1)
+		go s.dhcp4_packet_proc(&l_wg, i)
+	}
+
 epoll_loop:
 	for {
 		nevts, err = unix.EpollWait(s.p, evts[:], -1)
@@ -297,15 +379,11 @@ epoll_loop:
 						if err != nil {
 							fmt.Printf ("PACKET -> %s\n", err.Error())
 						} else {
-							//fmt.Printf (">>%d [%s]<<\n", epos - spos, string(buf[spos: epos]))
-							if string(buf[spos:epos]) == "quit\n" {
-								break epoll_loop
-							}
-
-
-							var pkt Dhcp4Pkt
-							pkt.Decode(buf[spos:epos])
-							fmt.Printf("%+v\n", pkt)
+							//var pkt Dhcp4Pkt
+							//TODO: ethernet part???
+							//pkt.Decode(buf[spos:epos])
+							//fmt.Printf("%+v\n", pkt)
+							s.pkt_chan <- buf[spos:epos]
 						}
 					}
 
@@ -319,5 +397,6 @@ epoll_loop:
 	}
 
 	// if there are subtasks wait here for termination and close the dockets
+	l_wg.Wait()
 	return nil
 }