chiark - git - mdw - mLib/blob - bres.c

   1 /* -*-c-*-
   2  *
   3  * Background reverse name resolution
   4  *
   5  * (c) 1999 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of the mLib utilities library.
  11  *
  12  * mLib is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU Library General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * mLib is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with mLib; if not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25  * MA 02111-1307, USA.
  26  */
  27
  28 /*----- Header files ------------------------------------------------------*/
  29
  30 #include "config.h"
  31
  32 #include <errno.h>
  33 #include <signal.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include <sys/types.h>
  39 #include <sys/time.h>
  40 #include <unistd.h>
  41 #include <sys/wait.h>
  42
  43 #include <sys/socket.h>
  44 #include <netinet/in.h>
  45 #include <arpa/inet.h>
  46 #include <netdb.h>
  47
  48 #include "alloc.h"
  49 #include "bres.h"
  50 #include "mdup.h"
  51 #include "report.h"
  52 #include "sel.h"
  53
  54 /*----- Magic numbers -----------------------------------------------------*/
  55
  56 #define BRES_MAX 15                     /* Maximum number of resolvers */
  57 #define BRES_IDLE 60                    /* Lifetime of an idle resolver */
  58
  59 /*----- Static variables --------------------------------------------------*/
  60
  61 #ifndef BRES_STANDALONE
  62
  63 static bres_server servers[BRES_MAX];   /* Statically allocated servers */
  64
  65 #define FREE ((bres_server *)&freelist)
  66 static struct { bres_server *next, *prev; } freelist = { FREE, FREE };
  67
  68 #define QUEUE ((bres_client *)&queue)
  69 static struct { bres_client *next, *prev; } queue = { QUEUE, QUEUE };
  70
  71 static sel_state *sel;
  72
  73 static const char *server = 0;
  74
  75 #endif
  76
  77 /*----- Background resolver protocol --------------------------------------*/
  78
  79 /* --- Requests and responses --- *
  80  *
  81  * There are two types of requests: name and addr, corresponding to the
  82  * standard @gethostbyname@ and @gethostbyaddr@ calls.  There are two types
  83  * of responses too: a positive response consists of an encoded equivalent of
  84  * a @struct hostent@ structure containing the requested information; a
  85  * negative response consists of an @h_errno@ value explaining the problem.
  86  */
  87
  88 #define BRES_BYNAME 0                   /* Request: resolve given name */
  89 #define BRES_BYADDR 1                   /* Request: resolve given address */
  90
  91 #define BRES_HOSTENT 0                  /* Response: resolved ok */
  92 #define BRES_ERROR 1                    /* Response: resolution failed */
  93
  94 /* --- Encodings --- *
  95  *
  96  * A string is encoded as a @size_t@ length followed by the actual data.  The
  97  * null terminator is not transmitted.
  98  *
  99  * Addresses for resolution are transmitted as raw @struct in_addr@
 100  * structures.
 101  *
 102  * A @hostent@ structure is transmitted as a header containing fixed-size
 103  * information, followed by the official name, an array of aliases, and an
 104  * array of addresses.  The number of items in the arrays is specified in the
 105  * header.
 106  *
 107  * The implementation assumes that a complete request or reply is always
 108  * sent.  Undesirable blocking will occur if this is not the case.  Both ends
 109  * are assumed to trust each other.  A protocol failure results in the child
 110  * in question being terminated.
 111  */
 112
 113 typedef struct hostskel {
 114   size_t nalias;
 115   int addrtype;
 116   size_t addrsz;
 117   size_t naddr;
 118 } hostskel;
 119
 120 /* --- @doread@, @dowrite@ --- *
 121  *
 122  * Arguments:   @int fd@ = file descriptor
 123  *              @void *buf@ = buffer for data
 124  *              @size_t sz@ = size of data
 125  *
 126  * Returns:     Zero if successful, nonzero otherwise.
 127  *
 128  * Use:         Reads or writes a chunk of data.  @EINTR@ errors are retried;
 129  *              incomplete reads and writes are continued from where they
 130  *              left off.  End-of-file is considered an I/O error.
 131  */
 132
 133 static int doread(int fd, void *buf, size_t sz)
 134 {
 135   char *p = buf;
 136   while (sz) {
 137     int r = read(fd, p, sz);
 138     if (r < 0) {
 139       if (errno == EINTR)
 140         continue;
 141       return (-1);
 142     } else if (r == 0) {
 143       errno = EIO;
 144       return (-1);
 145     }
 146     sz -= r;
 147     p += r;
 148   }
 149   return (0);
 150 }
 151
 152 static int dowrite(int fd, const void *buf, size_t sz)
 153 {
 154   const char *p = buf;
 155   while (sz) {
 156     int r = write(fd, p, sz);
 157     if (r < 0) {
 158       if (errno == EINTR)
 159         continue;
 160       return (-1);
 161     } else if (r == 0) {
 162       errno = EIO;
 163       return (-1);
 164     }
 165     sz -= r;
 166     p += r;
 167   }
 168   return (0);
 169 }
 170
 171 /* --- @getstring@ --- *
 172  *
 173  * Arguments:   @int fd@ = file descriptor to read
 174  *
 175  * Returns:     String in heap-allocated block, or a null pointer.
 176  *
 177  * Use:         Decodes a string.
 178  */
 179
 180 static char *getstring(int fd)
 181 {
 182   size_t sz;
 183   char *p;
 184
 185   if (doread(fd, &sz, sizeof(sz)) || (p = malloc(sz + 1)) == 0)
 186     return (0);
 187   if (doread(fd, p, sz)) {
 188     free(p);
 189     return (0);
 190   }
 191   p[sz] = 0;
 192   return (p);
 193 }
 194
 195 /* --- @putstring@ --- *
 196  *
 197  * Arguments:   @int fd@ = file descriptor to write on
 198  *              @const char *p@ = pointer to string to write
 199  *
 200  * Returns:     Zero if successful.
 201  *
 202  * Use:         Encodes a string.
 203  */
 204
 205 static int putstring(int fd, const char *p)
 206 {
 207   size_t sz = strlen(p);
 208   if (dowrite(fd, &sz, sizeof(sz)) || dowrite(fd, p, sz))
 209     return (-1);
 210   return (0);
 211 }
 212
 213 /* --- @gethost@ --- *
 214  *
 215  * Arguments:   @int fd@ = file descriptor to read
 216  *
 217  * Returns:     Pointer to heap-allocated @struct hostent@, or null.
 218  *
 219  * Use:         Decodes a host structure.  The resulting structure is all in
 220  *              one big heap block.
 221  */
 222
 223 #ifndef BRES_STANDALONE
 224
 225 static struct hostent *gethost(int fd)
 226 {
 227   hostskel hsk;
 228   struct hostent *h;
 229   char *name;
 230   char **alias = 0;
 231
 232   /* --- Read the skeleton structure --- */
 233
 234   if (doread(fd, &hsk, sizeof(hsk)))
 235     goto tidy_0;
 236
 237   /* --- Read the hostname and alias strings --- *
 238    *
 239    * Count the length of the strings as we go.
 240    */
 241
 242   {
 243     size_t sz =
 244       sizeof(struct hostent) +
 245       hsk.naddr * hsk.addrsz +
 246       (hsk.naddr + hsk.nalias + 2) * sizeof(char *);
 247
 248     /* --- Read the primary host name --- */
 249
 250     if ((name = getstring(fd)) == 0)
 251       goto tidy_0;
 252     sz += strlen(name) + 1;
 253
 254     /* --- Read in the alias names --- */
 255
 256     if (hsk.nalias) {
 257       int i;
 258       if ((alias = malloc(hsk.nalias * sizeof(char *))) == 0)
 259         goto tidy_1;
 260       for (i = 0; i < hsk.nalias; i++)
 261         alias[i] = 0;
 262       for (i = 0; i < hsk.nalias; i++) {
 263         if ((alias[i] = getstring(fd)) == 0)
 264           goto tidy_2;
 265         sz += strlen(alias[i]) + 1;
 266       }
 267     }
 268
 269     /* --- Allocate the output structure --- */
 270
 271     if ((h = malloc(sz)) == 0)
 272       goto tidy_2;
 273   }
 274
 275   /* --- Fill in the base structure --- */
 276
 277   h->h_addrtype = hsk.addrtype;
 278   h->h_length = hsk.addrsz;
 279
 280   /* --- Start putting everything else in --- */
 281
 282   {
 283     char **p = (char **)(h + 1);
 284     char *a = (char *)(p + hsk.nalias + hsk.naddr + 2);
 285     int i;
 286
 287     /* --- Start with the address table --- */
 288
 289     h->h_addr_list = p;
 290     if (doread(fd, a, hsk.naddr * hsk.addrsz))
 291       goto tidy_2;
 292     for (i = 0; i < hsk.naddr; i++) {
 293       *p++ = a;
 294       a += hsk.addrsz;
 295     }
 296     *p++ = 0;
 297
 298     /* --- Finally copy the strings over --- */
 299
 300 #define PUT(_p) do {                                                    \
 301   size_t _len = strlen(_p) + 1;                                         \
 302   memcpy(a, (_p), _len);                                                \
 303   a += _len;                                                            \
 304 } while (0)
 305
 306     h->h_name = a;
 307     PUT(name);
 308     free(name);
 309     h->h_aliases = p;
 310     for (i = 0; i < hsk.nalias; i++) {
 311       *p++ = a;
 312       PUT(alias[i]);
 313       free(alias[i]);
 314     }
 315     *p++ = 0;
 316     free(alias);
 317
 318 #undef PUT
 319   }
 320
 321   return (h);
 322
 323   /* --- Tidy up after various types of failure --- */
 324
 325 tidy_2:
 326   {
 327     int i;
 328     for (i = 0; i < hsk.nalias && alias[i]; i++)
 329       free(alias[i]);
 330     free(alias);
 331   }
 332 tidy_1:
 333   free(name);
 334 tidy_0:
 335   return (0);
 336 }
 337
 338 #endif
 339
 340 /* --- @puthost@ --- *
 341  *
 342  * Arguments:   @int fd@ = file descriptor
 343  *              @struct hostent *h@ = pointer to host structure
 344  *
 345  * Returns:     Zero if successful.
 346  *
 347  * Use:         Encodes a host structure.
 348  */
 349
 350 static int puthost(int fd, struct hostent *h)
 351 {
 352   hostskel hsk;
 353   int i;
 354
 355   /* --- Fill in and send the skeleton structure --- */
 356
 357   for (i = 0; h->h_aliases[i]; i++)
 358     ;
 359   hsk.nalias = i;
 360   for (i = 0; h->h_addr_list[i]; i++)
 361     ;
 362   hsk.naddr = i;
 363   hsk.addrtype = h->h_addrtype;
 364   hsk.addrsz = h->h_length;
 365   if (dowrite(fd, &hsk, sizeof(hsk)))
 366     return (-1);
 367
 368   /* --- Send the name and alias strings --- */
 369
 370   if (putstring(fd, h->h_name))
 371     return (-1);
 372   for (i = 0; h->h_aliases[i]; i++) {
 373     if (putstring(fd, h->h_aliases[i]))
 374       return (-1);
 375   }
 376
 377   /* --- Send the address data --- */
 378
 379   for (i = 0; h->h_addr_list[i]; i++) {
 380     if (dowrite(fd, h->h_addr_list[i], hsk.addrsz))
 381       return (-1);
 382   }
 383
 384   /* --- OK, done --- */
 385
 386   return (0);
 387 }
 388
 389 /*----- Resolver server ---------------------------------------------------*/
 390
 391 /* --- @child@ --- *
 392  *
 393  * Arguments:   @int rfd@ = output file descriptor for resolved hostnames
 394  *              @int cfd@ = input file descriptor for raw addresses
 395  *
 396  * Returns:     Never.
 397  *
 398  * Use:         Asynchronous name resolving process.
 399  */
 400
 401 static void child(int rfd, int cfd)
 402 {
 403   /* --- Close other file descriptors --- */
 404
 405   {
 406     int i;
 407 #if defined(_SC_OPEN_MAX)
 408     int maxfd = sysconf(_SC_OPEN_MAX);
 409 #elif defined(OPEN_MAX)
 410     int maxfd = OPEN_MAX;
 411 #else
 412     int maxfd = -1;
 413 #endif
 414
 415     if (maxfd < 0)
 416       maxfd = 256; /* Fingers crossed... */
 417     for (i = 0; i < maxfd; i++) {
 418       if (i != rfd && i != cfd && i != 1)
 419         close(i);
 420     }
 421   }
 422
 423   signal(SIGTERM, SIG_DFL);
 424   signal(SIGHUP, SIG_DFL);
 425   signal(SIGQUIT, SIG_DFL);
 426   signal(SIGALRM, SIG_DFL);
 427   signal(SIGINT, SIG_DFL);
 428
 429   /* --- Main request/response loop --- */
 430
 431   for (;;) {
 432     int req, resp;
 433     struct hostent *h;
 434
 435     /* --- Read the request --- */
 436
 437     if (doread(cfd, &req, sizeof(req)))
 438       goto lose;
 439
 440     /* --- Process it into a host structure --- */
 441
 442     switch (req) {
 443
 444       /* --- Normal forward lookup --- */
 445
 446       case BRES_BYNAME: {
 447         char *name = getstring(cfd);
 448         if (!name)
 449           goto lose;
 450         h = gethostbyname(name);
 451         free(name);
 452       } break;
 453
 454       /* --- Reverse lookup --- */
 455
 456       case BRES_BYADDR: {
 457         struct in_addr addr;
 458         char *p;
 459         if (doread(cfd, &addr, sizeof(addr)))
 460           goto lose;
 461         if ((h = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET)) == 0)
 462           goto fail;
 463
 464         /* --- Do a forward lookup to confirm --- */
 465
 466         {
 467           size_t sz = strlen(h->h_name) + 1;
 468           if ((p = malloc(sz)) == 0)
 469             goto fail;
 470           memcpy(p, h->h_name, sz);
 471         }
 472
 473         h = gethostbyname(p);
 474         free(p);
 475         if (!h)
 476           goto fail;
 477         p = 0;
 478         if (h) {
 479           char **pp;
 480           for (pp = h->h_addr_list; *pp; pp++) {
 481             struct in_addr a;
 482             memcpy(&a, *pp, sizeof(a));
 483             if (a.s_addr == addr.s_addr) {
 484               p = h->h_name;
 485               break;
 486             }
 487           }
 488         }
 489         if (!p) {
 490           h = 0;
 491           h_errno = NO_RECOVERY;
 492         }
 493       fail:;
 494       } break;
 495
 496       /* --- Unknown request -- may have lost sync --- */
 497
 498       default:
 499         goto lose;
 500     }
 501
 502     /* --- Transmit the response --- */
 503
 504     if (h) {
 505       resp = BRES_HOSTENT;
 506       if (dowrite(rfd, &resp, sizeof(resp)) || puthost(rfd, h))
 507         goto lose;
 508     } else {
 509       resp = BRES_ERROR;
 510       if (dowrite(rfd, &resp, sizeof(resp)) ||
 511           dowrite(rfd, &h_errno, sizeof(h_errno)))
 512         goto lose;
 513     }
 514   }
 515
 516 lose:
 517   _exit(1);
 518 }
 519
 520 /* --- @main@ --- *
 521  *
 522  * Arguments:   @int argc@ = number of command line arguments
 523  *              @char *argv[]@ = array of arguments
 524  *
 525  * Returns:     Runs until killed or an error occurs.
 526  *
 527  * Use:         A name resolver server process for mLib programs which need
 528  *              this sort of thing.
 529  */
 530
 531 #ifdef BRES_STANDALONE
 532
 533 int main(int argc, char *argv[])
 534 {
 535   if (isatty(STDIN_FILENO)) {
 536     char *p = strrchr(argv[0], '/');
 537     if (p)
 538       p++;
 539     else
 540       p = argv[0];
 541     fprintf(stderr,
 542             "%s: don't run this program unless you know what you're doing.\n",
 543             p);
 544     exit(1);
 545   }
 546   child(STDOUT_FILENO, STDIN_FILENO);
 547   return (1);
 548 }
 549
 550 #endif
 551
 552 /*----- Main code ---------------------------------------------------------*/
 553
 554 #ifndef BRES_STANDALONE
 555
 556 /* --- @zap@ --- *
 557  *
 558  * Arguments:   @bres_server *rs@ = pointer to server block
 559  *
 560  * Returns:     ---
 561  *
 562  * Use:         Kills a server process, reaps the losing child and makes
 563  *              things generally clean again.
 564  */
 565
 566 static void zap(bres_server *rs)
 567 {
 568   /* --- Close the pipes, kill the child, and reap it --- */
 569
 570   if (rs->kid != -1) {
 571     close(rs->fd);
 572     close(rs->f.fd);
 573     kill(rs->kid, SIGTERM);
 574     waitpid(rs->kid, 0, 0);
 575     rs->kid = -1;
 576   }
 577
 578   /* --- Move the server to the back of the list --- */
 579
 580   rs->next->prev = rs->prev;
 581   rs->prev->next = rs->next;
 582   rs->next = FREE;
 583   rs->prev = FREE->prev;
 584   FREE->prev->next = rs;
 585   FREE->prev = rs;
 586 }
 587
 588 /* --- @bres_abort@ --- *
 589  *
 590  * Arguments:   @bres_client *rc@ = pointer to client block
 591  *
 592  * Returns:     ---
 593  *
 594  * Use:         Removes a queued job.
 595  */
 596
 597 void bres_abort(bres_client *rc)
 598 {
 599   if (rc->q == BRES_BYNAME)
 600     xfree(rc->u.name);
 601   if (rc->rs) {
 602     sel_rmfile(&rc->rs->f);
 603     zap(rc->rs);
 604     rc->rs = 0;
 605   } else {
 606     rc->next->prev = rc->prev;
 607     rc->prev->next = rc->next;
 608   }
 609 }
 610
 611 /* --- @idle@ --- *
 612  *
 613  * Arguments:   @struct timeval *tv@ = pointer to the current time
 614  *              @void *vp@ = pointer to a server block
 615  *
 616  * Returns:     ---
 617  *
 618  * Use:         Kills off a child which has been idle for too long.
 619  */
 620
 621 static void idle(struct timeval *tv, void *vp)
 622 {
 623   bres_server *rs = vp;
 624   zap(rs);
 625 }
 626
 627 /* --- @answer@ --- *
 628  *
 629  * Arguments:   @int fd@ = file descriptor which is ready
 630  *              @unsigned mode@ = what it's doing now
 631  *              @void *vp@ = pointer to server block
 632  *
 633  * Returns:     ---
 634  *
 635  * Use:         Retrieves an answer from a name resolver process.
 636  */
 637
 638 static void attach(bres_client */*rc*/);
 639
 640 static void answer(int fd, unsigned mode, void *vp)
 641 {
 642   bres_server *rs = vp;
 643   bres_client *rc = rs->rc;
 644   struct hostent *h = 0;
 645   int resp;
 646   int fail = 1;
 647
 648   /* --- Report the result to my client --- */
 649
 650   sel_rmfile(&rs->f);
 651   h_errno = -1;
 652   if (doread(fd, &resp, sizeof(resp)) == 0) {
 653     switch (resp) {
 654       case BRES_ERROR:
 655         doread(fd, &h_errno, sizeof(h_errno));
 656         fail = 0;
 657         break;
 658       case BRES_HOSTENT:
 659         h = gethost(fd);
 660         fail = 0;
 661         break;
 662     }
 663   }
 664   if (rc) {
 665     rc->func(h, rc->p);
 666     if (rc->q == BRES_BYNAME)
 667       xfree(rc->u.name);
 668   }
 669   if (h)
 670     free(h);
 671   if (fail)
 672     zap(rs);
 673   if (!rc)
 674     return;
 675
 676   /* --- Wrap up the various structures --- */
 677
 678   rs->rc = 0;
 679   rc->rs = 0;
 680   rs->next = FREE->next;
 681   rs->prev = FREE;
 682   FREE->next->prev = rs;
 683   FREE->next = rs;
 684
 685   /* --- Tie a timer onto the server block --- */
 686
 687   {
 688     struct timeval tv;
 689
 690     gettimeofday(&tv, 0);
 691     tv.tv_sec += BRES_IDLE;
 692     sel_addtimer(sel, &rs->t, &tv, idle, rs);
 693   }
 694
 695   /* --- If there are any clients waiting, attach one --- */
 696
 697   if (QUEUE->next != QUEUE) {
 698     rc = QUEUE->next;
 699     QUEUE->next = rc->next;
 700     rc->next->prev = QUEUE;
 701     attach(rc);
 702   }
 703 }
 704
 705 /* --- @start@ --- *
 706  *
 707  * Arguments:   @bres_server *rs@ = pointer to a server block
 708  *
 709  * Returns:     Zero if OK, nonzero if something failed.
 710  *
 711  * Use:         Starts up a child resolver process.
 712  */
 713
 714 static int start(bres_server *rs)
 715 {
 716   int rfd[2], cfd[2];
 717   pid_t kid;
 718   mdup_fd md[2];
 719
 720   /* --- Make the pipes --- */
 721
 722   if (pipe(rfd))
 723     goto fail_0;
 724   if (pipe(cfd))
 725     goto fail_1;
 726
 727   /* --- Start up the child process --- */
 728
 729   if ((kid = fork()) < 0)
 730     goto fail_2;
 731   if (kid == 0) {
 732     close(cfd[1]);
 733     close(rfd[0]);
 734
 735     if (server) {
 736       md[0].cur = cfd[0]; md[0].want = STDIN_FILENO;
 737       md[1].cur = rfd[1]; md[1].want = STDOUT_FILENO;
 738       if (mdup(md, 2) ||  execlp(server, server, (char *)0))
 739         child(STDOUT_FILENO, STDIN_FILENO);
 740     } else
 741       child(rfd[1], cfd[0]);
 742     _exit(1);
 743   }
 744
 745   /* --- Fix up everything in the server block --- */
 746
 747   close(cfd[0]);
 748   close(rfd[1]);
 749   rs->fd = cfd[1];
 750   sel_initfile(sel, &rs->f, rfd[0], SEL_READ, answer, rs);
 751   rs->kid = kid;
 752   return (0);
 753
 754   /* --- Fix up after errors --- */
 755
 756 fail_2:
 757   close(cfd[0]);
 758   close(cfd[1]);
 759 fail_1:
 760   close(rfd[0]);
 761   close(rfd[1]);
 762 fail_0:
 763   return (-1);
 764 }
 765
 766 /* --- @attach@ --- *
 767  *
 768  * Arguments:   @bres_client *rc@ = pointer to a client block
 769  *
 770  * Returns:     ---
 771  *
 772  * Use:         Attaches a client to a spare server (which is assumed to
 773  *              exist).
 774  */
 775
 776 static void attach(bres_client *rc)
 777 {
 778   bres_server *rs;
 779   int lose = 0;
 780
 781   /* --- Fix up the server ready for the job --- *
 782    *
 783    * If the server has a process, remove its timer.  Otherwise, fork off a
 784    * new resolver process.  This is also where I go if I find that the child
 785    * resolver process has lost while I wasn't looking.  Only one attempt at
 786    * forking is performed.
 787    */
 788
 789 again:
 790   rs = FREE->next;
 791   if (rs->kid != -1)
 792     sel_rmtimer(&rs->t);
 793   else {
 794     if (lose || start(rs))
 795       goto lost;
 796     lose = 1;
 797   }
 798
 799   /* --- Submit the job to the resolver --- */
 800
 801   {
 802     struct sigaction sa, osa;
 803     int e;
 804
 805     /* --- Ignore @SIGPIPE@ for now --- *
 806      *
 807      * This way I can trap @EPIPE@ and reap a losing child, if there was one.
 808      */
 809
 810     sa.sa_handler = SIG_IGN;
 811     sa.sa_flags = 0;
 812     sigemptyset(&sa.sa_mask);
 813     sigaction(SIGPIPE, &sa, &osa);
 814
 815     /* --- Write the new job to the child --- */
 816
 817     e = 0;
 818     if (dowrite(rs->fd, &rc->q, sizeof(rc->q)))
 819       e = errno;
 820     else switch (rc->q) {
 821       case BRES_BYADDR:
 822         if (dowrite(rs->fd, &rc->u.addr, sizeof(rc->u.addr)))
 823           e = errno;
 824         break;
 825       case BRES_BYNAME:
 826         if (putstring(rs->fd, rc->u.name))
 827           e = errno;
 828         break;
 829     }
 830     sigaction(SIGPIPE, &osa, 0);
 831
 832     /* --- Sort out various errors --- *
 833      *
 834      * This was once more complicated, handling @EPIPE@ separately from other
 835      * errors.  Now everything's handled the same way.
 836      */
 837
 838     if (e) {
 839       zap(rs);
 840       goto again;
 841     }
 842   }
 843
 844   /* --- Fiddle with lists so that everything's OK --- */
 845
 846   sel_addfile(&rs->f);
 847   rs->next->prev = FREE;
 848   FREE->next = rs->next;
 849   rs->next = rs->prev = rs;
 850   rs->rc = rc;
 851   rc->rs = rs;
 852   return;
 853
 854 lost:
 855   rc->func(0, rc->p);
 856   if (rc->q == BRES_BYNAME)
 857     xfree(rc->u.name);
 858 }
 859
 860 /* --- @resolve@ --- *
 861  *
 862  * Arguments:   @bres_client *rc@ = pointer to filled-in client block
 863  *
 864  * Returns:     ---
 865  *
 866  * Use:         Dispatcher for incoming resolution jobs.
 867  */
 868
 869 static void resolve(bres_client *rc)
 870 {
 871   /* --- If there's a free server, plug it in --- */
 872
 873   rc->rs = 0;
 874   if (FREE->next == FREE) {
 875     rc->next = QUEUE;
 876     rc->prev = QUEUE->prev;
 877     QUEUE->prev->next = rc;
 878     QUEUE->prev = rc;
 879   } else
 880     attach(rc);
 881 }
 882
 883 /* --- @bres_byaddr@ --- *
 884  *
 885  * Arguments:   @bres_client *rc@ = pointer to client block
 886  *              @struct in_addr addr@ = address to resolve
 887  *              @void (*func)(struct hostent *h, void *p)@ = handler function
 888  *              @void *p@ = argument for handler function
 889  *
 890  * Returns:     ---
 891  *
 892  * Use:         Adds an address lookup job to the queue.  The job will be
 893  *              processed when there's a spare resolver process to deal with
 894  *              it.
 895  */
 896
 897 void bres_byaddr(bres_client *rc, struct in_addr addr,
 898                  void (*func)(struct hostent */*h*/, void */*p*/),
 899                  void *p)
 900 {
 901   rc->q = BRES_BYADDR;
 902   rc->u.addr = addr;
 903   rc->func = func;
 904   rc->p = p;
 905   resolve(rc);
 906 }
 907
 908 /* --- @bres_byname@ --- *
 909  *
 910  * Arguments:   @bres_client *rc@ = pointer to client block
 911  *              @const char *name@ = name to resolve
 912  *              @void (*func)(struct hostent *h, void *p)@ = handler function
 913  *              @void *p@ = argument for handler function
 914  *
 915  * Returns:     ---
 916  *
 917  * Use:         Adds a name lookup job to the queue.  The job will be
 918  *              processed when there's a spare resolver process to deal with
 919  *              it.
 920  */
 921
 922 void bres_byname(bres_client *rc, const char *name,
 923                  void (*func)(struct hostent */*h*/, void */*p*/),
 924                  void *p)
 925 {
 926   rc->q = BRES_BYNAME;
 927   rc->u.name = xstrdup(name);
 928   rc->func = func;
 929   rc->p = p;
 930   resolve(rc);
 931 }
 932
 933 /* --- @bres_exec@ --- *
 934  *
 935  * Arguments:   @const char *file@ = file containing server code or null
 936  *
 937  * Returns:     ---
 938  *
 939  * Use:         Makes `bres' use a standalone server rather than copies of
 940  *              the current process.  This can reduce memory consumption for
 941  *              large processes, at the expense of startup time (which
 942  *              shouldn't be too bad anyway, because of the resolver design).
 943  *              If the filename is null, a default set up at install time is
 944  *              used.  It's probably a good idea to leave it alone.
 945  */
 946
 947 void bres_exec(const char *file)
 948 {
 949   if (file)
 950     server = file;
 951   else
 952     server = BRES_SERVER;
 953 }
 954
 955 /* --- @bres_init@ --- *
 956  *
 957  * Arguments:   @sel_state *s@ = pointer to select multiplexor
 958  *
 959  * Returns:     ---
 960  *
 961  * Use:         Initializes the background resolver for use.
 962  */
 963
 964 void bres_init(sel_state *s)
 965 {
 966   int i;
 967
 968   sel = s;
 969   for (i = 0; i < BRES_MAX; i++) {
 970     servers[i].next = FREE;
 971     servers[i].prev = FREE->prev;
 972     servers[i].kid = -1;
 973     servers[i].rc = 0;
 974     FREE->prev->next = &servers[i];
 975     FREE->prev = &servers[i];
 976   }
 977 }
 978
 979 #endif
 980
 981 /*----- That's all, folks -------------------------------------------------*/