func doRecvFromResolver(server, conn *net.UDPConn) {
log.Println("start doRecvFromResolver")
buf := make([]byte, MAX_BUF_LEN)
for {
length, _, err := conn.ReadFromUDP(buf)
if err != nil {
log.Println(err)
continue
}
log.Println("receive response from resolver")
//unpack message
var msg dns.Message
_, err = msg.UnpackHeaderAndQuestion(buf[:length])
if err != nil {
log.Println(err)
continue
}
var key SessionKey
key.forwardConn = conn
question := &msg.Question[0]
key.name = question.Name
key.id = msg.Hdr.Id
gsession.Lock()
value, ok := gsession.buffer[key]
if ok {
delete(gsession.buffer, key)
gsession.Unlock()
} else {
log.Println("key not find in session: ", key)
gsession.Unlock()
continue
}
log.Println("write response to client")
//modify id
newId := value.id
buf[0] = uint8(newId >> 8)
buf[1] = uint8(newId)
_, err = server.WriteToUDP(buf[:length], &value.clientAddr)
if err != nil {
log.Println(err)
continue
}
}
}
func doForwardToResolver(server *net.UDPConn, forwardConns []*net.UDPConn, resolverAddrs []string, recvMsgChannel chan RecvMsg) {
buf := make([]byte, MAX_BUF_LEN)
log.Println("start doForwardToResolver")
addrIndex := 0
connIndex := 0
rand.Seed(time.Now().UTC().UnixNano())
for recvMsg := range recvMsgChannel {
//unpack message
var msg dns.Message
_, err := msg.UnpackHeaderAndQuestion(recvMsg.data)
if err != nil {
log.Println(err)
continue
}
//if only one question in message
if len(msg.Question) == 1 {
//check whether the domain name is in record manager
question := &msg.Question[0]
var records []db.Record
dbmap, err := db.OpenDbmap()
if err != nil {
log.Println(err)
continue
}
defer db.CloseDbmap(dbmap)
_, err = dbmap.Select(&records, "select * from record where name=? and class=? and type=?", question.Name, question.Class, question.Type)
if err != nil {
log.Println(err)
continue
}
//construct an answer record and send to client
if len(records) > 0 {
msg.Hdr.Rcode = dns.RCODE_SUCCESS
msg.Hdr.QueryResponse = dns.QR_RESPONSE
msg.Hdr.RecursionAvailable = true
for _, record := range records {
rr, err := RRConstruct(&record)
if err != nil {
log.Println(err)
continue
}
msg.Answer = append(msg.Answer, rr)
}
log.Println("construct answer ")
buflen, err := msg.Pack(buf, true)
_, err = server.WriteToUDP(buf[:buflen], &recvMsg.addr)
if err != nil {
log.Println(err)
continue
}
continue
}
}
//forward to upstream resolver
addr, err := net.ResolveUDPAddr("udp", resolverAddrs[addrIndex])
if err != nil {
log.Println(err)
continue
}
log.Println("write request to resolver")
conn := forwardConns[connIndex]
//modify id
newId := uint16(rand.Int())
recvMsg.data[0] = uint8(newId >> 8)
recvMsg.data[1] = uint8(newId)
_, err = conn.WriteToUDP(recvMsg.data, addr)
if err != nil {
log.Println(err)
continue
}
connIndex += 1
if connIndex >= len(forwardConns) {
connIndex = 0
}
addrIndex += 1
if addrIndex >= len(resolverAddrs) {
addrIndex = 0
}
var key SessionKey
key.forwardConn = conn
key.name = (&msg.Question[0]).Name
key.id = newId
var value SessionValue
value.clientAddr = recvMsg.addr
value.id = msg.Hdr.Id
value.time = time.Now().Unix()
gsession.Lock()
gsession.buffer[key] = value
gsession.Unlock()
}
}