22da5607216c20b0c2bc109194b9b72eee2a1615
3 * Background reverse name resolution
5 * (c) 1999 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the mLib utilities library.
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.
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.
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,
28 /*----- Header files ------------------------------------------------------*/
38 #include <sys/types.h>
43 #include <sys/socket.h>
44 #include <netinet/in.h>
45 #include <arpa/inet.h>
54 /*----- Magic numbers -----------------------------------------------------*/
56 #define BRES_MAX 15 /* Maximum number of resolvers */
57 #define BRES_IDLE 60 /* Lifetime of an idle resolver */
59 /*----- Static variables --------------------------------------------------*/
61 #ifndef BRES_STANDALONE
63 static bres_server servers
[BRES_MAX
]; /* Statically allocated servers */
65 static bres_server
*freelist
, *freetail
;
66 static bres_client
*qhead
, *qtail
;
67 static sel_state
*sel
;
68 static const char *server
= 0;
70 #define UNLINK(head, tail, p) do { \
71 *((p)->next ? &(p)->next->prev : &(tail)) = (p)->prev; \
72 *((p)->prev ? &(p)->prev->next : &(head)) = (p)->next; \
75 #define LINKHEAD(head, tail, p) do { \
78 *((head) ? &(head)->prev : &(tail)) = (p); \
82 #define LINKTAIL(head, tail, p) do { \
85 *((tail) ? &(tail)->next : &(head)) = (p); \
91 /*----- Background resolver protocol --------------------------------------*/
93 /* --- Requests and responses --- *
95 * There are two types of requests: name and addr, corresponding to the
96 * standard @gethostbyname@ and @gethostbyaddr@ calls. There are two types
97 * of responses too: a positive response consists of an encoded equivalent of
98 * a @struct hostent@ structure containing the requested information; a
99 * negative response consists of an @h_errno@ value explaining the problem.
102 #define BRES_BYNAME 0 /* Request: resolve given name */
103 #define BRES_BYADDR 1 /* Request: resolve given address */
105 #define BRES_HOSTENT 0 /* Response: resolved ok */
106 #define BRES_ERROR 1 /* Response: resolution failed */
108 /* --- Encodings --- *
110 * A string is encoded as a @size_t@ length followed by the actual data. The
111 * null terminator is not transmitted.
113 * Addresses for resolution are transmitted as raw @struct in_addr@
116 * A @hostent@ structure is transmitted as a header containing fixed-size
117 * information, followed by the official name, an array of aliases, and an
118 * array of addresses. The number of items in the arrays is specified in the
121 * The implementation assumes that a complete request or reply is always
122 * sent. Undesirable blocking will occur if this is not the case. Both ends
123 * are assumed to trust each other. A protocol failure results in the child
124 * in question being terminated.
127 typedef struct hostskel
{
134 /* --- @doread@, @dowrite@ --- *
136 * Arguments: @int fd@ = file descriptor
137 * @void *buf@ = buffer for data
138 * @size_t sz@ = size of data
140 * Returns: Zero if successful, nonzero otherwise.
142 * Use: Reads or writes a chunk of data. @EINTR@ errors are retried;
143 * incomplete reads and writes are continued from where they
144 * left off. End-of-file is considered an I/O error.
147 static int doread(int fd
, void *buf
, size_t sz
)
151 int r
= read(fd
, p
, sz
);
166 static int dowrite(int fd
, const void *buf
, size_t sz
)
170 int r
= write(fd
, p
, sz
);
185 /* --- @getstring@ --- *
187 * Arguments: @int fd@ = file descriptor to read
189 * Returns: String in heap-allocated block, or a null pointer.
191 * Use: Decodes a string.
194 static char *getstring(int fd
)
199 if (doread(fd
, &sz
, sizeof(sz
)) || (p
= malloc(sz
+ 1)) == 0)
201 if (doread(fd
, p
, sz
)) {
209 /* --- @putstring@ --- *
211 * Arguments: @int fd@ = file descriptor to write on
212 * @const char *p@ = pointer to string to write
214 * Returns: Zero if successful.
216 * Use: Encodes a string.
219 static int putstring(int fd
, const char *p
)
221 size_t sz
= strlen(p
);
222 if (dowrite(fd
, &sz
, sizeof(sz
)) || dowrite(fd
, p
, sz
))
227 /* --- @gethost@ --- *
229 * Arguments: @int fd@ = file descriptor to read
231 * Returns: Pointer to heap-allocated @struct hostent@, or null.
233 * Use: Decodes a host structure. The resulting structure is all in
234 * one big heap block.
237 #ifndef BRES_STANDALONE
239 static struct hostent
*gethost(int fd
)
246 /* --- Read the skeleton structure --- */
248 if (doread(fd
, &hsk
, sizeof(hsk
)))
251 /* --- Read the hostname and alias strings --- *
253 * Count the length of the strings as we go.
258 sizeof(struct hostent
) +
259 hsk
.naddr
* hsk
.addrsz
+
260 (hsk
.naddr
+ hsk
.nalias
+ 2) * sizeof(char *);
262 /* --- Read the primary host name --- */
264 if ((name
= getstring(fd
)) == 0)
266 sz
+= strlen(name
) + 1;
268 /* --- Read in the alias names --- */
272 if ((alias
= malloc(hsk
.nalias
* sizeof(char *))) == 0)
274 for (i
= 0; i
< hsk
.nalias
; i
++)
276 for (i
= 0; i
< hsk
.nalias
; i
++) {
277 if ((alias
[i
] = getstring(fd
)) == 0)
279 sz
+= strlen(alias
[i
]) + 1;
283 /* --- Allocate the output structure --- */
285 if ((h
= malloc(sz
)) == 0)
289 /* --- Fill in the base structure --- */
291 h
->h_addrtype
= hsk
.addrtype
;
292 h
->h_length
= hsk
.addrsz
;
294 /* --- Start putting everything else in --- */
297 char **p
= (char **)(h
+ 1);
298 char *a
= (char *)(p
+ hsk
.nalias
+ hsk
.naddr
+ 2);
301 /* --- Start with the address table --- */
304 if (doread(fd
, a
, hsk
.naddr
* hsk
.addrsz
))
306 for (i
= 0; i
< hsk
.naddr
; i
++) {
312 /* --- Finally copy the strings over --- */
314 #define PUT(_p) do { \
315 size_t _len = strlen(_p) + 1; \
316 memcpy(a, (_p), _len); \
324 for (i
= 0; i
< hsk
.nalias
; i
++) {
337 /* --- Tidy up after various types of failure --- */
342 for (i
= 0; i
< hsk
.nalias
&& alias
[i
]; i
++)
354 /* --- @puthost@ --- *
356 * Arguments: @int fd@ = file descriptor
357 * @struct hostent *h@ = pointer to host structure
359 * Returns: Zero if successful.
361 * Use: Encodes a host structure.
364 static int puthost(int fd
, struct hostent
*h
)
369 /* --- Fill in and send the skeleton structure --- */
371 for (i
= 0; h
->h_aliases
[i
]; i
++)
374 for (i
= 0; h
->h_addr_list
[i
]; i
++)
377 hsk
.addrtype
= h
->h_addrtype
;
378 hsk
.addrsz
= h
->h_length
;
379 if (dowrite(fd
, &hsk
, sizeof(hsk
)))
382 /* --- Send the name and alias strings --- */
384 if (putstring(fd
, h
->h_name
))
386 for (i
= 0; h
->h_aliases
[i
]; i
++) {
387 if (putstring(fd
, h
->h_aliases
[i
]))
391 /* --- Send the address data --- */
393 for (i
= 0; h
->h_addr_list
[i
]; i
++) {
394 if (dowrite(fd
, h
->h_addr_list
[i
], hsk
.addrsz
))
398 /* --- OK, done --- */
403 /*----- Resolver server ---------------------------------------------------*/
407 * Arguments: @int rfd@ = output file descriptor for resolved hostnames
408 * @int cfd@ = input file descriptor for raw addresses
412 * Use: Asynchronous name resolving process.
415 static void child(int rfd
, int cfd
)
417 /* --- Close other file descriptors --- */
421 #if defined(_SC_OPEN_MAX)
422 int maxfd
= sysconf(_SC_OPEN_MAX
);
423 #elif defined(OPEN_MAX)
424 int maxfd
= OPEN_MAX
;
430 maxfd
= 256; /* Fingers crossed... */
431 for (i
= 0; i
< maxfd
; i
++) {
432 if (i
!= rfd
&& i
!= cfd
&& i
!= 1)
437 signal(SIGTERM
, SIG_DFL
);
438 signal(SIGHUP
, SIG_DFL
);
439 signal(SIGQUIT
, SIG_DFL
);
440 signal(SIGALRM
, SIG_DFL
);
441 signal(SIGINT
, SIG_DFL
);
443 /* --- Main request/response loop --- */
449 /* --- Read the request --- */
451 if (doread(cfd
, &req
, sizeof(req
)))
454 /* --- Process it into a host structure --- */
458 /* --- Normal forward lookup --- */
461 char *name
= getstring(cfd
);
464 h
= gethostbyname(name
);
468 /* --- Reverse lookup --- */
473 if (doread(cfd
, &addr
, sizeof(addr
)))
475 if ((h
= gethostbyaddr((char *)&addr
, sizeof(addr
), AF_INET
)) == 0)
478 /* --- Do a forward lookup to confirm --- */
481 size_t sz
= strlen(h
->h_name
) + 1;
482 if ((p
= malloc(sz
)) == 0)
484 memcpy(p
, h
->h_name
, sz
);
487 h
= gethostbyname(p
);
493 for (pp
= h
->h_addr_list
; *pp
; pp
++) {
495 memcpy(&a
, *pp
, sizeof(a
));
496 if (a
.s_addr
== addr
.s_addr
)
501 h_errno
= NO_RECOVERY
;
505 /* --- Unknown request -- may have lost sync --- */
511 /* --- Transmit the response --- */
515 if (dowrite(rfd
, &resp
, sizeof(resp
)) || puthost(rfd
, h
))
519 if (dowrite(rfd
, &resp
, sizeof(resp
)) ||
520 dowrite(rfd
, &h_errno
, sizeof(h_errno
)))
531 * Arguments: @int argc@ = number of command line arguments
532 * @char *argv[]@ = array of arguments
534 * Returns: Runs until killed or an error occurs.
536 * Use: A name resolver server process for mLib programs which need
537 * this sort of thing.
540 #ifdef BRES_STANDALONE
542 int main(int argc
, char *argv
[])
544 if (isatty(STDIN_FILENO
)) {
545 char *p
= strrchr(argv
[0], '/');
551 "%s: don't run this program unless you know what you're doing.\n",
555 child(STDOUT_FILENO
, STDIN_FILENO
);
561 /*----- Main code ---------------------------------------------------------*/
563 #ifndef BRES_STANDALONE
567 * Arguments: @bres_server *rs@ = pointer to server block
571 * Use: Kills a server process, reaps the losing child and makes
572 * things generally clean again.
575 static void zap(bres_server
*rs
)
577 /* --- Close the pipes, kill the child, and reap it --- */
582 kill(rs
->kid
, SIGTERM
);
583 waitpid(rs
->kid
, 0, 0);
587 /* --- Move the server to the back of the list --- */
589 if (!rs
->rc
) UNLINK(freelist
, freetail
, rs
);
590 LINKTAIL(freelist
, freetail
, rs
);
593 /* --- @bres_abort@ --- *
595 * Arguments: @bres_client *rc@ = pointer to client block
599 * Use: Removes a queued job.
602 void bres_abort(bres_client
*rc
)
604 if (rc
->q
== BRES_BYNAME
)
607 UNLINK(qhead
, qtail
, rc
);
609 sel_rmfile(&rc
->rs
->f
);
617 * Arguments: @struct timeval *tv@ = pointer to the current time
618 * @void *vp@ = pointer to a server block
622 * Use: Kills off a child which has been idle for too long.
625 static void idle(struct timeval
*tv
, void *vp
)
627 bres_server
*rs
= vp
;
631 /* --- @answer@ --- *
633 * Arguments: @int fd@ = file descriptor which is ready
634 * @unsigned mode@ = what it's doing now
635 * @void *vp@ = pointer to server block
639 * Use: Retrieves an answer from a name resolver process.
642 static void attach(bres_client */
*rc*/
);
644 static void answer(int fd
, unsigned mode
, void *vp
)
646 bres_server
*rs
= vp
;
647 bres_client
*rc
= rs
->rc
;
648 struct hostent
*h
= 0;
652 /* --- Report the result to my client --- */
656 if (doread(fd
, &resp
, sizeof(resp
)) == 0) {
659 doread(fd
, &h_errno
, sizeof(h_errno
));
670 if (rc
->q
== BRES_BYNAME
)
680 /* --- Wrap up the various structures --- */
684 LINKHEAD(freelist
, freetail
, rs
);
686 /* --- Tie a timer onto the server block --- */
691 gettimeofday(&tv
, 0);
692 tv
.tv_sec
+= BRES_IDLE
;
693 sel_addtimer(sel
, &rs
->t
, &tv
, idle
, rs
);
696 /* --- If there are any clients waiting, attach one --- */
700 UNLINK(qhead
, qtail
, rc
);
707 * Arguments: @bres_server *rs@ = pointer to a server block
709 * Returns: Zero if OK, nonzero if something failed.
711 * Use: Starts up a child resolver process.
714 static int start(bres_server
*rs
)
720 /* --- Make the pipes --- */
727 /* --- Start up the child process --- */
729 if ((kid
= fork()) < 0)
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
);
741 child(rfd
[1], cfd
[0]);
745 /* --- Fix up everything in the server block --- */
750 sel_initfile(sel
, &rs
->f
, rfd
[0], SEL_READ
, answer
, rs
);
754 /* --- Fix up after errors --- */
766 /* --- @attach@ --- *
768 * Arguments: @bres_client *rc@ = pointer to a client block
772 * Use: Attaches a client to a spare server (which is assumed to
776 static void attach(bres_client
*rc
)
781 /* --- Fix up the server ready for the job --- *
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.
794 if (lose
|| start(rs
))
799 /* --- Submit the job to the resolver --- */
802 struct sigaction sa
, osa
;
805 /* --- Ignore @SIGPIPE@ for now --- *
807 * This way I can trap @EPIPE@ and reap a losing child, if there was one.
810 sa
.sa_handler
= SIG_IGN
;
812 sigemptyset(&sa
.sa_mask
);
813 sigaction(SIGPIPE
, &sa
, &osa
);
815 /* --- Write the new job to the child --- */
818 if (dowrite(rs
->fd
, &rc
->q
, sizeof(rc
->q
)))
820 else switch (rc
->q
) {
822 if (dowrite(rs
->fd
, &rc
->u
.addr
, sizeof(rc
->u
.addr
)))
826 if (putstring(rs
->fd
, rc
->u
.name
))
830 sigaction(SIGPIPE
, &osa
, 0);
832 /* --- Sort out various errors --- *
834 * This was once more complicated, handling @EPIPE@ separately from other
835 * errors. Now everything's handled the same way.
844 /* --- Fiddle with lists so that everything's OK --- */
847 UNLINK(freelist
, freetail
, rs
);
854 if (rc
->q
== BRES_BYNAME
)
858 /* --- @resolve@ --- *
860 * Arguments: @bres_client *rc@ = pointer to filled-in client block
864 * Use: Dispatcher for incoming resolution jobs.
867 static void resolve(bres_client
*rc
)
869 /* --- If there's a free server, plug it in --- */
875 LINKTAIL(qhead
, qtail
, rc
);
878 /* --- @bres_byaddr@ --- *
880 * Arguments: @bres_client *rc@ = pointer to client block
881 * @struct in_addr addr@ = address to resolve
882 * @void (*func)(struct hostent *h, void *p)@ = handler function
883 * @void *p@ = argument for handler function
887 * Use: Adds an address lookup job to the queue. The job will be
888 * processed when there's a spare resolver process to deal with
892 void bres_byaddr(bres_client
*rc
, struct in_addr addr
,
893 void (*func
)(struct hostent */
*h*/
, void */
*p*/
),
903 /* --- @bres_byname@ --- *
905 * Arguments: @bres_client *rc@ = pointer to client block
906 * @const char *name@ = name to resolve
907 * @void (*func)(struct hostent *h, void *p)@ = handler function
908 * @void *p@ = argument for handler function
912 * Use: Adds a name lookup job to the queue. The job will be
913 * processed when there's a spare resolver process to deal with
917 void bres_byname(bres_client
*rc
, const char *name
,
918 void (*func
)(struct hostent */
*h*/
, void */
*p*/
),
922 rc
->u
.name
= xstrdup(name
);
928 /* --- @bres_exec@ --- *
930 * Arguments: @const char *file@ = file containing server code or null
934 * Use: Makes `bres' use a standalone server rather than copies of
935 * the current process. This can reduce memory consumption for
936 * large processes, at the expense of startup time (which
937 * shouldn't be too bad anyway, because of the resolver design).
938 * If the filename is null, a default set up at install time is
939 * used. It's probably a good idea to leave it alone.
942 void bres_exec(const char *file
)
947 server
= BRES_SERVER
;
950 /* --- @bres_init@ --- *
952 * Arguments: @sel_state *s@ = pointer to select multiplexor
956 * Use: Initializes the background resolver for use.
959 void bres_init(sel_state
*s
)
964 for (i
= 0; i
< BRES_MAX
; i
++) {
967 LINKTAIL(freelist
, freetail
, &servers
[i
]);
973 /*----- That's all, folks -------------------------------------------------*/