1package dns 2 3import ( 4 "fmt" 5 "time" 6) 7 8// Envelope is used when doing a zone transfer with a remote server. 9type Envelope struct { 10 RR []RR // The set of RRs in the answer section of the xfr reply message. 11 Error error // If something went wrong, this contains the error. 12} 13 14// A Transfer defines parameters that are used during a zone transfer. 15type Transfer struct { 16 *Conn 17 DialTimeout time.Duration // net.DialTimeout, defaults to 2 seconds 18 ReadTimeout time.Duration // net.Conn.SetReadTimeout value for connections, defaults to 2 seconds 19 WriteTimeout time.Duration // net.Conn.SetWriteTimeout value for connections, defaults to 2 seconds 20 TsigSecret map[string]string // Secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be in canonical form (lowercase, fqdn, see RFC 4034 Section 6.2) 21 tsigTimersOnly bool 22} 23 24// Think we need to away to stop the transfer 25 26// In performs an incoming transfer with the server in a. 27// If you would like to set the source IP, or some other attribute 28// of a Dialer for a Transfer, you can do so by specifying the attributes 29// in the Transfer.Conn: 30// 31// d := net.Dialer{LocalAddr: transfer_source} 32// con, err := d.Dial("tcp", master) 33// dnscon := &dns.Conn{Conn:con} 34// transfer = &dns.Transfer{Conn: dnscon} 35// channel, err := transfer.In(message, master) 36// 37func (t *Transfer) In(q *Msg, a string) (env chan *Envelope, err error) { 38 switch q.Question[0].Qtype { 39 case TypeAXFR, TypeIXFR: 40 default: 41 return nil, &Error{"unsupported question type"} 42 } 43 44 timeout := dnsTimeout 45 if t.DialTimeout != 0 { 46 timeout = t.DialTimeout 47 } 48 49 if t.Conn == nil { 50 t.Conn, err = DialTimeout("tcp", a, timeout) 51 if err != nil { 52 return nil, err 53 } 54 } 55 56 if err := t.WriteMsg(q); err != nil { 57 return nil, err 58 } 59 60 env = make(chan *Envelope) 61 switch q.Question[0].Qtype { 62 case TypeAXFR: 63 go t.inAxfr(q, env) 64 case TypeIXFR: 65 go t.inIxfr(q, env) 66 } 67 68 return env, nil 69} 70 71func (t *Transfer) inAxfr(q *Msg, c chan *Envelope) { 72 first := true 73 defer t.Close() 74 defer close(c) 75 timeout := dnsTimeout 76 if t.ReadTimeout != 0 { 77 timeout = t.ReadTimeout 78 } 79 for { 80 t.Conn.SetReadDeadline(time.Now().Add(timeout)) 81 in, err := t.ReadMsg() 82 if err != nil { 83 c <- &Envelope{nil, err} 84 return 85 } 86 if q.Id != in.Id { 87 c <- &Envelope{in.Answer, ErrId} 88 return 89 } 90 if first { 91 if in.Rcode != RcodeSuccess { 92 c <- &Envelope{in.Answer, &Error{err: fmt.Sprintf(errXFR, in.Rcode)}} 93 return 94 } 95 if !isSOAFirst(in) { 96 c <- &Envelope{in.Answer, ErrSoa} 97 return 98 } 99 first = !first 100 // only one answer that is SOA, receive more 101 if len(in.Answer) == 1 { 102 t.tsigTimersOnly = true 103 c <- &Envelope{in.Answer, nil} 104 continue 105 } 106 } 107 108 if !first { 109 t.tsigTimersOnly = true // Subsequent envelopes use this. 110 if isSOALast(in) { 111 c <- &Envelope{in.Answer, nil} 112 return 113 } 114 c <- &Envelope{in.Answer, nil} 115 } 116 } 117} 118 119func (t *Transfer) inIxfr(q *Msg, c chan *Envelope) { 120 var serial uint32 // The first serial seen is the current server serial 121 axfr := true 122 n := 0 123 qser := q.Ns[0].(*SOA).Serial 124 defer t.Close() 125 defer close(c) 126 timeout := dnsTimeout 127 if t.ReadTimeout != 0 { 128 timeout = t.ReadTimeout 129 } 130 for { 131 t.SetReadDeadline(time.Now().Add(timeout)) 132 in, err := t.ReadMsg() 133 if err != nil { 134 c <- &Envelope{nil, err} 135 return 136 } 137 if q.Id != in.Id { 138 c <- &Envelope{in.Answer, ErrId} 139 return 140 } 141 if in.Rcode != RcodeSuccess { 142 c <- &Envelope{in.Answer, &Error{err: fmt.Sprintf(errXFR, in.Rcode)}} 143 return 144 } 145 if n == 0 { 146 // Check if the returned answer is ok 147 if !isSOAFirst(in) { 148 c <- &Envelope{in.Answer, ErrSoa} 149 return 150 } 151 // This serial is important 152 serial = in.Answer[0].(*SOA).Serial 153 // Check if there are no changes in zone 154 if qser >= serial { 155 c <- &Envelope{in.Answer, nil} 156 return 157 } 158 } 159 // Now we need to check each message for SOA records, to see what we need to do 160 t.tsigTimersOnly = true 161 for _, rr := range in.Answer { 162 if v, ok := rr.(*SOA); ok { 163 if v.Serial == serial { 164 n++ 165 // quit if it's a full axfr or the the servers' SOA is repeated the third time 166 if axfr && n == 2 || n == 3 { 167 c <- &Envelope{in.Answer, nil} 168 return 169 } 170 } else if axfr { 171 // it's an ixfr 172 axfr = false 173 } 174 } 175 } 176 c <- &Envelope{in.Answer, nil} 177 } 178} 179 180// Out performs an outgoing transfer with the client connecting in w. 181// Basic use pattern: 182// 183// ch := make(chan *dns.Envelope) 184// tr := new(dns.Transfer) 185// var wg sync.WaitGroup 186// go func() { 187// tr.Out(w, r, ch) 188// wg.Done() 189// }() 190// ch <- &dns.Envelope{RR: []dns.RR{soa, rr1, rr2, rr3, soa}} 191// close(ch) 192// wg.Wait() // wait until everything is written out 193// w.Close() // close connection 194// 195// The server is responsible for sending the correct sequence of RRs through the channel ch. 196func (t *Transfer) Out(w ResponseWriter, q *Msg, ch chan *Envelope) error { 197 for x := range ch { 198 r := new(Msg) 199 // Compress? 200 r.SetReply(q) 201 r.Authoritative = true 202 // assume it fits TODO(miek): fix 203 r.Answer = append(r.Answer, x.RR...) 204 if tsig := q.IsTsig(); tsig != nil && w.TsigStatus() == nil { 205 r.SetTsig(tsig.Hdr.Name, tsig.Algorithm, tsig.Fudge, time.Now().Unix()) 206 } 207 if err := w.WriteMsg(r); err != nil { 208 return err 209 } 210 w.TsigTimersOnly(true) 211 } 212 return nil 213} 214 215// ReadMsg reads a message from the transfer connection t. 216func (t *Transfer) ReadMsg() (*Msg, error) { 217 m := new(Msg) 218 p := make([]byte, MaxMsgSize) 219 n, err := t.Read(p) 220 if err != nil && n == 0 { 221 return nil, err 222 } 223 p = p[:n] 224 if err := m.Unpack(p); err != nil { 225 return nil, err 226 } 227 if ts := m.IsTsig(); ts != nil && t.TsigSecret != nil { 228 if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok { 229 return m, ErrSecret 230 } 231 // Need to work on the original message p, as that was used to calculate the tsig. 232 err = TsigVerify(p, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly) 233 t.tsigRequestMAC = ts.MAC 234 } 235 return m, err 236} 237 238// WriteMsg writes a message through the transfer connection t. 239func (t *Transfer) WriteMsg(m *Msg) (err error) { 240 var out []byte 241 if ts := m.IsTsig(); ts != nil && t.TsigSecret != nil { 242 if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok { 243 return ErrSecret 244 } 245 out, t.tsigRequestMAC, err = TsigGenerate(m, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly) 246 } else { 247 out, err = m.Pack() 248 } 249 if err != nil { 250 return err 251 } 252 _, err = t.Write(out) 253 return err 254} 255 256func isSOAFirst(in *Msg) bool { 257 return len(in.Answer) > 0 && 258 in.Answer[0].Header().Rrtype == TypeSOA 259} 260 261func isSOALast(in *Msg) bool { 262 return len(in.Answer) > 0 && 263 in.Answer[len(in.Answer)-1].Header().Rrtype == TypeSOA 264} 265 266const errXFR = "bad xfr rcode: %d" 267