sys/src/cmd/ndb/dnudpserver.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <ip.h>
   4 #include "dns.h"
   5
   6 enum {
   7         Logqueries = 0,
   8 };
   9
  10 static int      udpannounce(char*);
  11 static void     reply(int, uchar*, DNSmsg*, Request*);
  12
  13 typedef struct Inprogress Inprogress;
  14 struct Inprogress
  15 {
  16         int     inuse;
  17         Udphdr  uh;
  18         DN      *owner;
  19         ushort  type;
  20         int     id;
  21 };
  22 Inprogress inprog[Maxactive+2];
  23
  24 typedef struct Forwtarg Forwtarg;
  25 struct Forwtarg {
  26         char    *host;
  27         uchar   addr[IPaddrlen];
  28         int     fd;
  29         ulong   lastdial;
  30 };
  31 Forwtarg forwtarg[10];
  32 int currtarg;
  33
  34 static char *hmsg = "headers";
  35
  36 /*
  37  *  record client id and ignore retransmissions.
  38  *  we're still single thread at this point.
  39  */
  40 static Inprogress*
  41 clientrxmit(DNSmsg *req, uchar *buf)
  42 {
  43         Inprogress *p, *empty;
  44         Udphdr *uh;
  45
  46         uh = (Udphdr *)buf;
  47         empty = nil;
  48         for(p = inprog; p < &inprog[Maxactive]; p++){
  49                 if(p->inuse == 0){
  50                         if(empty == nil)
  51                                 empty = p;
  52                         continue;
  53                 }
  54                 if(req->id == p->id)
  55                 if(req->qd->owner == p->owner)
  56                 if(req->qd->type == p->type)
  57                 if(memcmp(uh, &p->uh, Udphdrsize) == 0)
  58                         return nil;
  59         }
  60         if(empty == nil)
  61                 return nil; /* shouldn't happen: see slave() & Maxactive def'n */
  62
  63         empty->id = req->id;
  64         empty->owner = req->qd->owner;
  65         empty->type = req->qd->type;
  66         if (empty->type != req->qd->type)
  67                 dnslog("clientrxmit: bogus req->qd->type %d", req->qd->type);
  68         memmove(&empty->uh, uh, Udphdrsize);
  69         empty->inuse = 1;
  70         return empty;
  71 }
  72
  73 int
  74 addforwtarg(char *host)
  75 {
  76         Forwtarg *tp;
  77
  78         if (currtarg >= nelem(forwtarg)) {
  79                 dnslog("too many forwarding targets");
  80                 return -1;
  81         }
  82         tp = forwtarg + currtarg;
  83         if (parseip(tp->addr, host) < 0) {
  84                 dnslog("can't parse ip %s", host);
  85                 return -1;
  86         }
  87         tp->lastdial = time(nil);
  88         tp->fd = udpport(mntpt);
  89         if (tp->fd < 0)
  90                 return -1;
  91
  92         free(tp->host);
  93         tp->host = estrdup(host);
  94         currtarg++;
  95         return 0;
  96 }
  97
  98 /*
  99  * fast forwarding of incoming queries to other dns servers.
 100  * intended primarily for debugging.
 101  */
 102 static void
 103 redistrib(uchar *buf, int len)
 104 {
 105         Forwtarg *tp;
 106         Udphdr *uh;
 107         static uchar outpkt[1500];
 108
 109         assert(len <= sizeof outpkt);
 110         memmove(outpkt, buf, len);
 111         uh = (Udphdr *)outpkt;
 112         for (tp = forwtarg; tp < forwtarg + currtarg; tp++)
 113                 if (tp->fd > 0) {
 114                         memmove(outpkt, tp->addr, sizeof tp->addr);
 115                         hnputs(uh->rport, 53);          /* dns port */
 116                         if (write(tp->fd, outpkt, len) != len) {
 117                                 close(tp->fd);
 118                                 tp->fd = -1;
 119                         }
 120                 } else if (tp->host && time(nil) - tp->lastdial > 60) {
 121                         tp->lastdial = time(nil);
 122                         tp->fd = udpport(mntpt);
 123                 }
 124 }
 125
 126 /*
 127  *  a process to act as a dns server for outside reqeusts
 128  */
 129 void
 130 dnudpserver(char *mntpt)
 131 {
 132         volatile int fd, len, op, rcode;
 133         char *volatile err;
 134         volatile char tname[32];
 135         volatile uchar buf[Udphdrsize + Maxudp + 1024];
 136         volatile DNSmsg reqmsg, repmsg;
 137         Inprogress *volatile p;
 138         volatile Request req;
 139         Udphdr *volatile uh;
 140
 141         /*
 142          * fork sharing text, data, and bss with parent.
 143          * stay in the same note group.
 144          */
 145         switch(rfork(RFPROC|RFMEM|RFNOWAIT)){
 146         case -1:
 147                 break;
 148         case 0:
 149                 break;
 150         default:
 151                 return;
 152         }
 153
 154         fd = -1;
 155 restart:
 156         procsetname("udp server announcing");
 157         if(fd >= 0)
 158                 close(fd);
 159         while((fd = udpannounce(mntpt)) < 0)
 160                 sleep(5000);
 161
 162 //      procsetname("udp server");
 163         memset(&req, 0, sizeof req);
 164         if(setjmp(req.mret))
 165                 putactivity(0);
 166         req.isslave = 0;
 167         req.id = 0;
 168         req.aborttime = 0;
 169
 170         /* loop on requests */
 171         for(;; putactivity(0)){
 172                 procsetname("served %d udp; %d alarms",
 173                         stats.qrecvdudp, stats.alarms);
 174                 memset(&repmsg, 0, sizeof repmsg);
 175                 memset(&reqmsg, 0, sizeof reqmsg);
 176
 177                 alarm(60*1000);
 178                 len = read(fd, buf, sizeof buf);
 179                 alarm(0);
 180                 if(len <= Udphdrsize)
 181                         goto restart;
 182
 183                 redistrib(buf, len);
 184
 185                 uh = (Udphdr*)buf;
 186                 len -= Udphdrsize;
 187
 188                 // dnslog("read received UDP from %I to %I",
 189                 //      ((Udphdr*)buf)->raddr, ((Udphdr*)buf)->laddr);
 190                 getactivity(&req, 0);
 191                 req.aborttime = timems() + Maxreqtm;
 192                 req.from = smprint("%I", buf);
 193                 rcode = 0;
 194                 stats.qrecvdudp++;
 195
 196                 err = convM2DNS(&buf[Udphdrsize], len, &reqmsg, &rcode);
 197                 if(err){
 198                         /* first bytes in buf are source IP addr */
 199                         dnslog("server: input error: %s from %I", err, buf);
 200                         free(err);
 201                         goto freereq;
 202                 }
 203                 if (rcode == 0)
 204                         if(reqmsg.qdcount < 1){
 205                                 dnslog("server: no questions from %I", buf);
 206                                 goto freereq;
 207                         } else if(reqmsg.flags & Fresp){
 208                                 dnslog("server: reply not request from %I", buf);
 209                                 goto freereq;
 210                         }
 211                 op = reqmsg.flags & Omask;
 212                 if(op != Oquery && op != Onotify){
 213                         dnslog("server: op %d from %I", reqmsg.flags & Omask,
 214                                 buf);
 215                         goto freereq;
 216                 }
 217
 218                 if(debug || (trace && subsume(trace, reqmsg.qd->owner->name)))
 219                         dnslog("%d: serve (%I/%d) %d %s %s",
 220                                 req.id, buf, uh->rport[0]<<8 | uh->rport[1],
 221                                 reqmsg.id, reqmsg.qd->owner->name,
 222                                 rrname(reqmsg.qd->type, tname, sizeof tname));
 223
 224                 p = clientrxmit(&reqmsg, buf);
 225                 if(p == nil){
 226                         if(debug)
 227                                 dnslog("%d: duplicate", req.id);
 228                         goto freereq;
 229                 }
 230
 231                 if (Logqueries) {
 232                         RR *rr;
 233
 234                         for (rr = reqmsg.qd; rr; rr = rr->next)
 235                                 syslog(0, "dnsq", "id %d: (%I/%d) %d %s %s",
 236                                         req.id, buf, uh->rport[0]<<8 |
 237                                         uh->rport[1], reqmsg.id,
 238                                         reqmsg.qd->owner->name,
 239                                         rrname(reqmsg.qd->type, tname,
 240                                         sizeof tname));
 241                 }
 242                 /* loop through each question */
 243                 while(reqmsg.qd){
 244                         memset(&repmsg, 0, sizeof repmsg);
 245                         switch(op){
 246                         case Oquery:
 247                                 dnserver(&reqmsg, &repmsg, &req, buf, rcode);
 248                                 break;
 249                         case Onotify:
 250                                 dnnotify(&reqmsg, &repmsg, &req);
 251                                 break;
 252                         }
 253                         /* send reply on fd to address in buf's udp hdr */
 254                         reply(fd, buf, &repmsg, &req);
 255                         freeanswers(&repmsg);
 256                 }
 257
 258                 p->inuse = 0;
 259 freereq:
 260                 free(req.from);
 261                 req.from = nil;
 262                 freeanswers(&reqmsg);
 263                 if(req.isslave){
 264                         putactivity(0);
 265                         _exits(0);
 266                 }
 267         }
 268 }
 269
 270 /*
 271  *  announce on well-known dns udp port and set message style interface
 272  */
 273 static int
 274 udpannounce(char *mntpt)
 275 {
 276         int data, ctl;
 277         char dir[64], datafile[64+6];
 278         static int whined;
 279
 280         /* get a udp port */
 281         sprint(datafile, "%s/udp!*!dns", mntpt);
 282         ctl = announce(datafile, dir);
 283         if(ctl < 0){
 284                 if(!whined++)
 285                         warning("can't announce on %s", datafile);
 286                 return -1;
 287         }
 288
 289         /* turn on header style interface */
 290         if(write(ctl, hmsg, strlen(hmsg)) != strlen(hmsg)){
 291                 close(ctl);
 292                 if(!whined++)
 293                         warning("can't enable headers on %s", datafile);
 294                 return -1;
 295         }
 296
 297         snprint(datafile, sizeof(datafile), "%s/data", dir);
 298         data = open(datafile, ORDWR);
 299         if(data < 0){
 300                 close(ctl);
 301                 if(!whined++)
 302                         warning("can't open %s to announce on dns udp port",
 303                                 datafile);
 304                 return -1;
 305         }
 306
 307         close(ctl);
 308         return data;
 309 }
 310
 311 static void
 312 reply(int fd, uchar *buf, DNSmsg *rep, Request *reqp)
 313 {
 314         int len;
 315         char tname[32];
 316
 317         if(debug || (trace && subsume(trace, rep->qd->owner->name)))
 318                 dnslog("%d: reply (%I/%d) %d %s %s qd %R an %R ns %R ar %R",
 319                         reqp->id, buf, buf[4]<<8 | buf[5],
 320                         rep->id, rep->qd->owner->name,
 321                         rrname(rep->qd->type, tname, sizeof tname),
 322                         rep->qd, rep->an, rep->ns, rep->ar);
 323
 324         len = convDNS2M(rep, &buf[Udphdrsize], Maxudp);
 325         len += Udphdrsize;
 326         if(write(fd, buf, len) != len)
 327                 dnslog("error sending reply: %r");
 328 }