chiark / gitweb /
Make file descriptors be nonblocking and close-on-exec.
[tripe] / admin.c
1 /* -*-c-*-
2  *
3  * $Id: admin.c,v 1.3 2001/02/04 01:17:12 mdw Exp $
4  *
5  * Admin interface for configuration
6  *
7  * (c) 2001 Straylight/Edgeware
8  */
9
10 /*----- Licensing notice --------------------------------------------------* 
11  *
12  * This file is part of Trivial IP Encryption (TrIPE).
13  *
14  * TrIPE is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  * 
19  * TrIPE is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  * 
24  * You should have received a copy of the GNU General Public License
25  * along with TrIPE; if not, write to the Free Software Foundation,
26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27  */
28
29 /*----- Revision history --------------------------------------------------* 
30  *
31  * $Log: admin.c,v $
32  * Revision 1.3  2001/02/04 01:17:12  mdw
33  * The `DAEMON' notification to stdout is replaced by a warning.  The
34  * `DAEMON' and `QUIT' command send `OK' on successful completion.  Put
35  * assignment of sequence number in a T(...) guard.
36  *
37  * Revision 1.2  2001/02/03 22:40:29  mdw
38  * Put timer information into the entropy pool when packets are received
39  * and on similar events.  Reseed the generator on the interval timer.
40  *
41  * Revision 1.1  2001/02/03 20:26:37  mdw
42  * Initial checkin.
43  *
44  */
45
46 /*----- Header files ------------------------------------------------------*/
47
48 #include "tripe.h"
49
50 /*----- Global variables --------------------------------------------------*/
51
52 #ifndef NTRACE
53
54 const trace_opt tr_opts[] = {
55   { 't',        T_TUNNEL,       "tunnel events" },
56   { 'r',        T_PEER,         "peer events" },
57   { 'a',        T_ADMIN,        "admin interface" },
58   { 'p',        T_PACKET,       "packet contents" },
59   { 'c',        T_CRYPTO,       "crypto details" },
60   { 's',        T_KEYSET,       "symmetric keyset management" },
61   { 'x',        T_KEYEXCH,      "key exchange" },
62   { 'm',        T_KEYMGMT,      "key management" },
63   { 'A',        T_ALL,          "all of the above" },
64   { 0,          0,              0 }
65 };
66
67 unsigned tr_flags = 0;
68 #endif
69
70 /*----- Static variables --------------------------------------------------*/
71
72 static admin *admins;
73 static sel_file sock;
74 static const char *sockname;
75 static unsigned flags = 0;
76 static admin *a_stdin = 0;
77 static sig s_term, s_int, s_hup;
78
79 #define F_DAEMON 1u
80 #define F_INIT 2u
81
82 #define T_RESOLVE SEC(30)
83
84 /*----- Utility functions -------------------------------------------------*/
85
86 /* --- @a_write@ --- *
87  *
88  * Arguments:   @admin *a@ = admin connection to write to
89  *              @const char *fmt@ = pointer to format string
90  *              @...@ = other arguments
91  *
92  * Returns:     ---
93  *
94  * Use:         Sends a message to an admin connection.
95  */
96
97 static void a_write(admin *a, const char *fmt, ...)
98 {
99   va_list ap;
100   dstr d = DSTR_INIT;
101   va_start(ap, fmt);
102   dstr_vputf(&d, fmt, ap);
103   va_end(ap);
104   write(a->fd, d.buf, d.len);
105   dstr_destroy(&d);
106 }
107
108 /* --- @a_warn@ --- *
109  *
110  * Arguments:   @const char *fmt@ = pointer to format string
111  *              @...@ = other arguments
112  *
113  * Returns:     ---
114  *
115  * Use:         Informs all admin connections of a warning.
116  */
117
118 void a_warn(const char *fmt, ...)
119 {
120   va_list ap;
121   admin *a;
122   dstr d = DSTR_INIT;
123
124   if (flags & F_INIT)
125     dstr_puts(&d, "WARN ");
126   va_start(ap, fmt);
127   dstr_vputf(&d, fmt, ap);
128   va_end(ap);
129   if (!(flags & F_INIT))
130     moan("%s", d.buf);
131   else {
132     dstr_putc(&d, '\n');
133     for (a = admins; a; a = a->next)
134       write(a->fd, d.buf, d.len);
135   }
136   dstr_destroy(&d);
137 }
138
139 /* --- @a_trace@ --- *
140  *
141  * Arguments:   @const char *p@ = pointer to a buffer
142  *              @size_t sz@ = size of the buffer
143  *              @void *v@ = uninteresting pointer
144  *
145  * Returns:     ---
146  *
147  * Use:         Custom trace output handler.
148  */
149
150 #ifndef NTRACE
151 static void a_trace(const char *p, size_t sz, void *v)
152 {
153   dstr d = DSTR_INIT;
154   admin *a;
155
156   dstr_puts(&d, "TRACE ");
157   dstr_putm(&d, p, sz);
158   dstr_putc(&d, '\n');
159   for (a = admins; a; a = a->next)
160     write(a->fd, d.buf, d.len);
161   dstr_destroy(&d);  
162 }
163 #endif
164
165 /* --- @a_quit@ --- *
166  *
167  * Arguments:   ---
168  *
169  * Returns:     ---
170  *
171  * Use:         Shuts things down nicely.
172  */
173
174 void a_quit(void)
175 {
176   close(sock.fd);
177   unlink(sockname);
178   exit(0);
179 }
180
181 /* --- @a_sigdie@ --- *
182  *
183  * Arguments:   @int sig@ = signal number
184  *              @void *v@ = an uninteresting argument
185  *
186  * Returns:     ---
187  *
188  * Use          Shuts down on receipt of a fatal signal.
189  */
190
191 static void a_sigdie(int sig, void *v)
192 {
193   char *p;
194   char buf[20];
195
196   switch (sig) {
197     case SIGTERM:       p = "SIGTERM"; break;
198     case SIGINT:        p = "SIGINT"; break;
199     default:
200       sprintf(buf, "signal %i", sig);
201       p = buf;
202       break;
203   }
204   a_warn("shutting down on %s", p);
205   a_quit();
206 }
207
208 /* --- @a_sighup@ --- *
209  *
210  * Arguments:   @int sig@ = signal number
211  *              @void *v@ = an uninteresting argument
212  *
213  * Returns:     ---
214  *
215  * Use          Logs a message about SIGHUP not being useful.
216  */
217
218 static void a_sighup(int sig, void *v)
219 {
220   a_warn("received SIGHUP: ignoring");
221 }
222
223 /*----- Adding peers ------------------------------------------------------*/
224  
225 /* --- @a_resolve@ --- *
226  *
227  * Arguments:   @struct hostent *h@ = pointer to resolved hostname
228  *              @void *v@ = pointer to admin block
229  *
230  * Returns:     ---
231  *
232  * Use:         Handles a completed name resolution.
233  */
234
235 static void a_resolve(struct hostent *h, void *v)
236 {
237   admin *a = v;
238   T( trace(T_ADMIN, "admin: %u resolved", a->seq); )
239   TIMER;
240   sel_rmtimer(&a->t);
241   if (!h)
242     a_write(a, "ERR couldn't resolve hostname `%s'\n", a->paddr);
243   else if (p_find(a->pname))
244     a_write(a, "ERR peer `%s' already registered\n", a->pname);
245   else {
246     memcpy(&a->peer.sin.sin_addr, h->h_addr, sizeof(struct in_addr));
247     if (!p_create(a->pname, &a->peer.sa, a->sasz))
248       a_write(a, "ERR couldn't create peer\n");
249     else
250       a_write(a, "OK\n");
251   }
252   xfree(a->pname);
253   xfree(a->paddr);
254   a->pname = 0;
255   selbuf_enable(&a->b);
256 }
257
258 /* --- @a_timer@ --- *
259  *
260  * Arguments:   @struct timeval *tv@ = timer
261  *              @void *v@ = pointer to admin block
262  *
263  * Returns:     ---
264  *
265  * Use:         Times out a resolver.
266  */
267
268 static void a_timer(struct timeval *tv, void *v)
269 {
270   admin *a = v;
271   T( trace(T_ADMIN, "admin: %u resolver timeout", a->seq); )
272   bres_abort(&a->r);
273   a_write(a, "ERR timeout resolving `%s'\n", a->paddr);
274   xfree(a->pname);
275   xfree(a->paddr);
276   a->pname = 0;
277   selbuf_enable(&a->b);
278 }
279
280 /* --- @acmd_add@ --- *
281  *
282  * Arguments:   @admin *a@ = connection which requested the addition
283  *              @unsigned ac@ = argument count
284  *              @char *av[]@ = pointer to the argument list
285  *
286  * Returns:     ---
287  *
288  * Use:         Adds a new peer.
289  */
290
291 static void acmd_add(admin *a, unsigned ac, char *av[])
292 {
293   unsigned long pt;
294   struct timeval tv;
295   char *p;
296
297   /* --- Make sure someone's not got there already --- */
298
299   if (p_find(av[0])) {
300     a_write(a, "ERR peer `%s' already registered\n", av[0]);
301     return;
302   }
303
304   /* --- Fill in the easy bits of address --- */
305
306   BURN(a->peer);
307   a->peer.sin.sin_family = AF_INET;
308   a->sasz = sizeof(a->peer.sin);
309   pt = strtoul(av[2], &p, 0);
310   if (*p) {
311     struct servent *s = getservbyname(av[2], "udp");
312     if (!s) {
313       a_write(a, "ERR service `%s' not known\n", av[2]);
314       return;
315     }
316     pt = ntohs(s->s_port);
317   }
318   if (pt == 0 || pt >= 65536) {
319     a_write(a, "ERR bad port number %lu\n", pt);
320     return;
321   }
322   a->peer.sin.sin_port = htons(pt);
323
324   /* --- If the name is numeric, do it the easy way --- */
325   
326   if (inet_aton(av[1], &a->peer.sin.sin_addr)) {
327     if (!p_create(av[0], &a->peer.sa, a->sasz))
328       a_write(a, "ERR couldn't create peer\n");
329     else
330       a_write(a, "OK\n");
331     return;
332   }
333
334   /* --- Store everything for later and crank up the resolver --- *
335    *
336    * We disable the line buffer until the resolver completes (or times out).
337    * This prevents other commands on the same connection (though the rest of
338    * the system continues regardless), but makes life simpler for the client.
339    */
340
341   a->pname = xstrdup(av[0]);
342   a->paddr = xstrdup(av[1]);
343   selbuf_disable(&a->b);
344   gettimeofday(&tv, 0);
345   tv.tv_sec += T_RESOLVE;
346   sel_addtimer(&sel, &a->t, &tv, a_timer, a);
347   bres_byname(&a->r, a->paddr, a_resolve, a);
348   T( trace(T_ADMIN, "admin: %u resolving hostname `%s'",
349            a->seq, a->paddr); )
350 }
351
352 /*----- Administration commands -------------------------------------------*/
353
354 /* --- Miscellaneous commands --- */
355
356 #ifndef NTRACE
357
358 static void acmd_trace(admin *a, unsigned ac, char *av[])
359 {
360   if (!ac || strcmp(av[0], "?") == 0) {
361     const trace_opt *t;
362     a_write(a, "INFO Trace options:\n");
363     for (t = tr_opts; t->ch; t++) {
364       a_write(a, "INFO %c %c  %s\n",
365               t->ch, (tr_flags & t->f) == t->f ? '*' : ' ', t->help);
366     }
367   } else {
368     unsigned sense = 1;
369     unsigned f = tr_flags;
370     const trace_opt *tt;
371     char *p = av[0];
372
373     while (*p) {
374       switch (*p) {
375         case '+': sense = 1; break;
376         case '-': sense = 0; break;
377         default:
378           for (tt = tr_opts; tt->ch; tt++) {
379             if (tt->ch == *p) {
380               if (sense) f |= tt->f;
381               else f &= ~tt->f;
382               goto tropt_ok;
383             }
384           }
385           a_write(a, "ERR unknown trace option `%c'\n", *p);
386           return;
387         tropt_ok:;
388           break;
389       }
390       p++;
391     }
392     tr_flags = f;
393     trace_level(tr_flags);
394   }
395   a_write(a, "OK\n");
396 }
397
398 #endif
399
400 static void acmd_port(admin *a, unsigned ac, char *av[])
401 {
402   a_write(a, "INFO %u\nOK\n", p_port());
403 }
404
405 static void a_destroy(admin */*a*/);
406
407 static void acmd_daemon(admin *a, unsigned ac, char *av[])
408 {
409   if (flags & F_DAEMON)
410     a_write(a, "ERR already running as a daemon\n");
411   else {
412     a_warn("becoming a daemon");
413     if (a_stdin)
414       a_destroy(a_stdin);
415     if (u_daemon())
416       a_write(a, "ERR error becoming a daemon: %s", strerror(errno));
417     else {
418       flags |= F_DAEMON;
419       a_write(a, "OK\n");
420     }
421   }
422 }
423
424 static void acmd_list(admin *a, unsigned ac, char *av[])
425 {
426   peer *p;
427   for (p = p_first(); p; p = p_next(p))
428     a_write(a, "INFO %s\n", p_name(p));
429   a_write(a, "OK\n");
430 }
431
432 static void acmd_ifname(admin *a, unsigned ac, char *av[])
433 {
434   peer *p;
435
436   if ((p = p_find(av[0])) == 0)
437     a_write(a, "ERR peer `%s' not found\n", av[0]);
438   else
439     a_write(a, "INFO %s\nOK\n", p_ifname(p));
440 }
441
442 static void acmd_addr(admin *a, unsigned ac, char *av[])
443 {
444   peer *p;
445   const addr *ad;
446
447   if ((p = p_find(av[0])) == 0)
448     a_write(a, "ERR peer `%s' not found\n", av[0]);
449   else {
450     ad = p_addr(p);
451     assert(ad->sa.sa_family == AF_INET);
452     a_write(a, "INFO %s %u\nOK\n",
453             inet_ntoa(ad->sin.sin_addr),
454             (unsigned)ntohs(ad->sin.sin_port));
455   }
456 }
457
458 static void acmd_kill(admin *a, unsigned ac, char *av[])
459 {
460   peer *p;
461   if ((p = p_find(av[0])) == 0)
462     a_write(a, "ERR peer `%s' not found\n", av[0]);
463   else {
464     p_destroy(p);
465     a_write(a, "OK\n");
466   }
467 }
468
469 static void acmd_quit(admin *a, unsigned ac, char *av[])
470 {
471   a_warn("closing down on admin request");
472   a_write(a, "OK\n");
473   a_quit();
474 }
475
476 /* --- The command table and help --- */
477
478 typedef struct acmd {
479   const char *name;
480   const char *help;
481   unsigned argmin, argmax;
482   void (*func)(admin */*a*/, unsigned /*ac*/, char */*av*/[]);
483 } acmd;
484
485 static void acmd_help(admin */*a*/, unsigned /*ac*/, char */*av*/[]);
486
487 static const acmd acmdtab[] = {
488   { "help",     "HELP",                 0,      0,      acmd_help },
489 #ifndef NTRACE
490   { "trace",    "TRACE [options]",      0,      1,      acmd_trace },
491 #endif
492   { "port",     "PORT",                 0,      0,      acmd_port },
493   { "daemon",   "DAEMON",               0,      0,      acmd_daemon },
494   { "list",     "LIST",                 0,      0,      acmd_list },
495   { "ifname",   "IFNAME peer",          1,      1,      acmd_ifname },
496   { "addr",     "ADDR peer",            1,      1,      acmd_addr },
497   { "kill",     "KILL peer",            1,      1,      acmd_kill },
498   { "add",      "ADD peer addr port",   3,      3,      acmd_add },
499   { "quit",     "QUIT",                 0,      0,      acmd_quit },
500   { 0,          0,                      0,      0,      0 }
501 };
502
503 static void acmd_help(admin *a, unsigned ac, char *av[])
504 {
505   const acmd *c;
506   for (c = acmdtab; c->name; c++)
507     a_write(a, "INFO %s\n", c->help);
508   a_write(a, "OK\n");
509 }
510
511 /*----- Connection handling -----------------------------------------------*/
512
513 /* --- @a_destroy@ --- *
514  *
515  * Arguments:   @admin *a@ = pointer to an admin block
516  *
517  * Returns:     ---
518  *
519  * Use:         Destroys an admin block.
520  */
521
522 static void a_destroy(admin *a)
523 {
524   T( trace(T_ADMIN, "admin: destroying connection %u", a->seq); )
525   selbuf_destroy(&a->b);
526   if (a->b.reader.fd != a->fd)
527     close(a->b.reader.fd);
528   close(a->fd);
529   if (a->pname) {
530     xfree(a->pname);
531     xfree(a->paddr);
532     bres_abort(&a->r);
533     sel_rmtimer(&a->t);
534   }
535   if (a->next)
536     a->next->prev = a->prev;
537   if (a->prev)
538     a->prev->next = a->next;
539   else
540     admins = a->next;
541   if (a_stdin == a)
542     a_stdin = 0;
543   DESTROY(a);
544 }
545
546 /* --- @a_line@ --- *
547  *
548  * Arguments:   @char *p@ = pointer to the line read
549  *              @void *vp@ = pointer to my admin block
550  *
551  * Returns:     ---
552  *
553  * Use:         Handles a line of input.
554  */
555
556 static void a_line(char *p, void *vp)
557 {
558   admin *a = vp;
559   const acmd *c;
560   char *av[4];
561   size_t ac;
562
563   TIMER;
564   if (!p) {
565     a_destroy(a);
566     return;
567   }
568   ac = str_qsplit(p, av, 4, 0, STRF_QUOTE);
569   if (!ac)
570     return;
571   for (p = av[0]; *p; p++) *p = tolower((unsigned char)*p);
572   for (c = acmdtab; c->name; c++) {
573     if (strcmp(av[0], c->name) == 0) {
574       ac--;
575       if (c->argmin > ac || ac > c->argmax)
576         a_write(a, "ERR syntax: %s\n", c->help);
577       else
578         c->func(a, ac, av + 1);
579       return;
580     }
581   }
582   a_write(a, "ERR unknown command `%s'\n", av[0]);
583 }
584
585 /* --- @a_create@ --- *
586  *
587  * Arguments:   @int fd_in, fd_out@ = file descriptors to use
588  *
589  * Returns:     ---
590  *
591  * Use:         Creates a new admin connection.
592  */
593
594 void a_create(int fd_in, int fd_out)
595 {
596   admin *a = CREATE(admin);
597   T( static unsigned seq = 0;
598      a->seq = seq++; )
599   T( trace(T_ADMIN, "admin: accepted connection %u", a->seq); )
600   a->pname = 0;
601   if (fd_in == STDIN_FILENO)
602     a_stdin = a;
603   fdflags(fd_in, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
604   if (fd_out != fd_in)
605     fdflags(fd_out, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
606   a->fd = fd_out;
607   selbuf_init(&a->b, &sel, fd_in, a_line, a);
608   a->next = admins;
609   a->prev = 0;
610   if (admins)
611     admins->prev = a;
612   admins = a;
613 }
614
615 /* --- @a_accept@ --- *
616  *
617  * Arguments:   @int fd@ = file descriptor to accept
618  *              @unsigned mode@ = what to do
619  *              @void *v@ = uninteresting pointer
620  *
621  * Returns:     ---
622  *
623  * Use:         Accepts a new admin connection.
624  */
625
626 static void a_accept(int fd, unsigned mode, void *v)
627 {
628   int nfd;
629   struct sockaddr_un sun;
630   size_t sz = sizeof(sun);
631
632   if ((nfd = accept(fd, (struct sockaddr *)&sun, &sz)) < 0) {
633     a_warn("accept admin connection failed: %s", strerror(errno));
634     return;
635   }
636   a_create(nfd, nfd);
637 }
638
639 /* --- @a_daemon@ --- *
640  *
641  * Arguments:   ---
642  *
643  * Returns:     ---
644  *
645  * Use:         Informs the admin module that it's a daemon.
646  */
647
648 void a_daemon(void)
649 {
650   flags |= F_DAEMON;
651 }
652
653 /* --- @a_init@ --- *
654  *
655  * Arguments:   @const char *name@ = socket name to create
656  *
657  * Returns:     ---
658  *
659  * Use:         Creates the admin listening socket.
660  */
661
662 void a_init(const char *name)
663 {
664   int fd;
665   int n = 5;
666   struct sockaddr_un sun;
667   struct sigaction sa;
668   size_t sz;
669
670   /* --- Set up the socket address --- */
671
672   sz = strlen(name) + 1;
673   if (sz > sizeof(sun.sun_path))
674     die(EXIT_FAILURE, "socket name `%s' too long", name);
675   BURN(sun);
676   sun.sun_family = AF_UNIX;
677   memcpy(sun.sun_path, name, sz);
678   sz += offsetof(struct sockaddr_un, sun_path);
679
680   /* --- Attempt to bind to the socket --- */
681
682   umask(0077);
683 again:
684   if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
685     die(EXIT_FAILURE, "couldn't create socket: %s", strerror(errno));
686   if (bind(fd, (struct sockaddr *)&sun, sz) < 0) {
687     struct stat st;
688     int e = errno;
689     if (errno != EADDRINUSE) {
690       die(EXIT_FAILURE, "couldn't bind to address `%s': %s",
691           sun.sun_path, strerror(e));
692     }
693     if (!n)
694       die(EXIT_FAILURE, "too many retries; giving up");
695     n--;
696     if (!connect(fd, (struct sockaddr *)&sun, sz)) {
697       die(EXIT_FAILURE, "server already listening on admin socket `%s'",
698           sun.sun_path);
699     }
700     if (errno != ECONNREFUSED)
701       die(EXIT_FAILURE, "couldn't bind to address: %s", strerror(e));
702     if (stat(sun.sun_path, &st)) {
703       die(EXIT_FAILURE, "couldn't stat `%s': %s",
704           sun.sun_path, strerror(errno));
705     }
706     if (!S_ISSOCK(st.st_mode))
707       die(EXIT_FAILURE, "object `%s' isn't a socket", sun.sun_path);
708     T( trace(T_ADMIN, "stale socket found; removing it"); )
709     unlink(sun.sun_path);
710     close(fd);
711     goto again;
712   }
713   chmod(sun.sun_path, 0600);
714   fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
715   if (listen(fd, 5))
716     die(EXIT_FAILURE, "couldn't listen on socket: %s", strerror(errno));
717
718   /* --- Listen to the socket --- */
719
720   sel_initfile(&sel, &sock, fd, SEL_READ, a_accept, 0);
721   sel_addfile(&sock);
722   sockname = name;
723   bres_init(&sel);
724   T( trace_custom(a_trace, 0);
725      trace(T_ADMIN, "admin: enabled custom tracing"); )
726   flags |= F_INIT;
727
728   /* --- Set up signal handlers --- */
729
730   sig_add(&s_term, SIGTERM, a_sigdie, 0);
731   sig_add(&s_hup, SIGHUP, a_sighup, 0);
732   sigaction(SIGINT, 0, &sa);
733   if (sa.sa_handler != SIG_IGN)
734     sig_add(&s_int, SIGINT, a_sigdie, 0);
735 }
736
737 /*----- That's all, folks -------------------------------------------------*/