g10: Unattended key generation "Key-Grip" and "Subkey-Grip".
[gnupg.git] / tools / watchgnupg.c
1 /* watchgnupg.c - Socket server for GnuPG logs
2  *      Copyright (C) 2003, 2004, 2010 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <stdarg.h>
29 #include <assert.h>
30 #include <unistd.h>
31 #include <sys/socket.h>
32 #include <sys/un.h>
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
35 #include <fcntl.h>
36 #include <time.h>
37 #ifdef HAVE_SYS_SELECT_H
38 # include <sys/select.h>
39 #endif
40
41 #define PGM "watchgnupg"
42
43 /* Allow for a standalone build on most systems. */
44 #ifdef VERSION
45 #define MYVERSION_LINE PGM " ("GNUPG_NAME") " VERSION
46 #define BUGREPORT_LINE "\nReport bugs to <bug-gnupg@gnu.org>.\n"
47 #else
48 #define MYVERSION_LINE PGM " (standalone build) " __DATE__
49 #define BUGREPORT_LINE ""
50 #endif
51 #if !defined(SUN_LEN) || !defined(PF_LOCAL) || !defined(AF_LOCAL)
52 #define GNUPG_COMMON_NEED_AFLOCAL
53 #include "../common/mischelp.h"
54 #endif
55
56
57 static int verbose;
58 static int time_only;
59
60 static void
61 die (const char *format, ...)
62 {
63   va_list arg_ptr;
64
65   fflush (stdout);
66   fprintf (stderr, "%s: ", PGM);
67
68   va_start (arg_ptr, format);
69   vfprintf (stderr, format, arg_ptr);
70   va_end (arg_ptr);
71   putc ('\n', stderr);
72
73   exit (1);
74 }
75
76
77 static void
78 err (const char *format, ...)
79 {
80   va_list arg_ptr;
81
82   fflush (stdout);
83   fprintf (stderr, "%s: ", PGM);
84
85   va_start (arg_ptr, format);
86   vfprintf (stderr, format, arg_ptr);
87   va_end (arg_ptr);
88   putc ('\n', stderr);
89 }
90
91 static void *
92 xmalloc (size_t n)
93 {
94   void *p = malloc (n);
95   if (!p)
96     die ("out of core");
97   return p;
98 }
99
100 static void *
101 xcalloc (size_t n, size_t m)
102 {
103   void *p = calloc (n, m);
104   if (!p)
105     die ("out of core");
106   return p;
107 }
108
109 static void *
110 xrealloc (void *old, size_t n)
111 {
112   void *p = realloc (old, n);
113   if (!p)
114     die ("out of core");
115   return p;
116 }
117
118
119 struct client_s {
120   struct client_s *next;
121   int fd;
122   size_t size;  /* Allocated size of buffer. */
123   size_t len;   /* Current length of buffer. */
124   unsigned char *buffer; /* Buffer to with data already read. */
125
126 };
127 typedef struct client_s *client_t;
128
129 /* The list of all connected peers.  */
130 static client_t client_list;
131
132
133
134
135 static void
136 print_fd_and_time (int fd)
137 {
138   struct tm *tp;
139   time_t atime = time (NULL);
140
141   tp = localtime (&atime);
142   if (time_only)
143     printf ("%3d - %02d:%02d:%02d ",
144             fd,
145             tp->tm_hour, tp->tm_min, tp->tm_sec );
146   else
147     printf ("%3d - %04d-%02d-%02d %02d:%02d:%02d ",
148             fd,
149             1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
150             tp->tm_hour, tp->tm_min, tp->tm_sec );
151 }
152
153
154 /* Print LINE for the client identified by C.  Calling this function
155    with LINE set to NULL, will flush the internal buffer. */
156 static void
157 print_line (client_t c, const char *line)
158 {
159   const char *s;
160   size_t n;
161
162   if (!line)
163     {
164       if (c->buffer && c->len)
165         {
166           print_fd_and_time (c->fd);
167           fwrite (c->buffer, c->len, 1, stdout);
168           putc ('\n', stdout);
169           c->len = 0;
170         }
171       return;
172     }
173
174   while ((s = strchr (line, '\n')))
175     {
176       print_fd_and_time (c->fd);
177       if (c->buffer && c->len)
178         {
179           fwrite (c->buffer, c->len, 1, stdout);
180           c->len = 0;
181         }
182       fwrite (line, s - line + 1, 1, stdout);
183       line = s + 1;
184     }
185   n = strlen (line);
186   if (n)
187     {
188       if (c->len + n >= c->size)
189         {
190           c->size += ((n + 255) & ~255);
191           c->buffer = (c->buffer
192                        ? xrealloc (c->buffer, c->size)
193                        : xmalloc (c->size));
194         }
195       memcpy (c->buffer + c->len, line, n);
196       c->len += n;
197     }
198 }
199
200
201 static void
202 setup_client (int server_fd, int is_un)
203 {
204   struct sockaddr_un addr_un;
205   struct sockaddr_in addr_in;
206   struct sockaddr *addr;
207   socklen_t addrlen;
208   int fd;
209   client_t client;
210
211   if (is_un)
212     {
213       addr = (struct sockaddr *)&addr_un;
214       addrlen = sizeof addr_un;
215     }
216   else
217     {
218       addr = (struct sockaddr *)&addr_in;
219       addrlen = sizeof addr_in;
220     }
221
222   fd = accept (server_fd, addr, &addrlen);
223   if (fd == -1)
224     {
225       printf ("[accepting %s connection failed: %s]\n",
226               is_un? "local":"tcp", strerror (errno));
227     }
228   else if (fd >= FD_SETSIZE)
229     {
230       close (fd);
231       printf ("[connection request denied: too many connections]\n");
232     }
233   else
234     {
235       for (client = client_list; client && client->fd != -1;
236            client = client->next)
237         ;
238       if (!client)
239         {
240           client = xcalloc (1, sizeof *client);
241           client->next = client_list;
242           client_list = client;
243         }
244       client->fd = fd;
245       printf ("[client at fd %d connected (%s)]\n",
246               client->fd, is_un? "local":"tcp");
247     }
248 }
249
250
251
252 static void
253 print_version (int with_help)
254 {
255   fputs (MYVERSION_LINE "\n"
256          "Copyright (C) 2017 Free Software Foundation, Inc.\n"
257          "License GPLv3+: "
258          "GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>\n"
259          "This is free software: you are free to change and redistribute it.\n"
260          "There is NO WARRANTY, to the extent permitted by law.\n",
261          stdout);
262   if (with_help)
263     fputs
264       ("\n"
265        "Usage: " PGM " [OPTIONS] SOCKETNAME\n"
266        "       " PGM " [OPTIONS] PORT [SOCKETNAME]\n"
267        "Open the local socket SOCKETNAME (or the TCP port PORT)\n"
268        "and display log messages\n"
269        "\n"
270        "  --tcp       listen on a TCP port and optionally on a local socket\n"
271        "  --force     delete an already existing socket file\n"
272        "  --verbose   enable extra informational output\n"
273        "  --time-only print only the time; not a full timestamp\n"
274        "  --version   print version of the program and exit\n"
275        "  --help      display this help and exit\n"
276        BUGREPORT_LINE, stdout );
277
278   exit (0);
279 }
280
281 int
282 main (int argc, char **argv)
283 {
284   int last_argc = -1;
285   int force = 0;
286   int tcp = 0;
287
288   struct sockaddr_un srvr_addr_un;
289   struct sockaddr_in srvr_addr_in;
290   struct sockaddr *addr_in = NULL;
291   struct sockaddr *addr_un = NULL;
292   socklen_t addrlen_in, addrlen_un;
293   unsigned short port;
294   int server_un, server_in;
295   int flags;
296
297   if (argc)
298     {
299       argc--; argv++;
300     }
301   while (argc && last_argc != argc )
302     {
303       last_argc = argc;
304       if (!strcmp (*argv, "--"))
305         {
306           argc--; argv++;
307           break;
308         }
309       else if (!strcmp (*argv, "--version"))
310         print_version (0);
311       else if (!strcmp (*argv, "--help"))
312         print_version (1);
313       else if (!strcmp (*argv, "--verbose"))
314         {
315           verbose = 1;
316           argc--; argv++;
317         }
318       else if (!strcmp (*argv, "--time-only"))
319         {
320           time_only = 1;
321           argc--; argv++;
322         }
323       else if (!strcmp (*argv, "--force"))
324         {
325           force = 1;
326           argc--; argv++;
327         }
328       else if (!strcmp (*argv, "--tcp"))
329         {
330           tcp = 1;
331           argc--; argv++;
332         }
333     }
334
335   if (!((!tcp && argc == 1) || (tcp && (argc == 1 || argc == 2))))
336     {
337       fprintf (stderr, "usage: " PGM " socketname\n"
338                        "       " PGM " --tcp port [socketname]\n");
339       exit (1);
340     }
341
342   if (tcp)
343     {
344       port = atoi (*argv);
345       argc--; argv++;
346     }
347   else
348     {
349       port = 0;
350     }
351
352   setvbuf (stdout, NULL, _IOLBF, 0);
353
354   if (tcp)
355     {
356       int i = 1;
357       server_in = socket (PF_INET, SOCK_STREAM, 0);
358       if (server_in == -1)
359         die ("socket(PF_INET) failed: %s\n", strerror (errno));
360       if (setsockopt (server_in, SOL_SOCKET, SO_REUSEADDR,
361                       (unsigned char *)&i, sizeof (i)))
362         err ("setsockopt(SO_REUSEADDR) failed: %s\n", strerror (errno));
363       if (verbose)
364         fprintf (stderr, "listening on port %hu\n", port);
365     }
366   else
367     server_in = -1;
368
369   if (argc)
370     {
371       server_un = socket (PF_LOCAL, SOCK_STREAM, 0);
372       if (server_un == -1)
373         die ("socket(PF_LOCAL) failed: %s\n", strerror (errno));
374       if (verbose)
375         fprintf (stderr, "listening on socket '%s'\n", *argv);
376     }
377   else
378     server_un = -1;
379
380   /* We better set the listening socket to non-blocking so that we
381      don't get bitten by race conditions in accept.  The should not
382      happen for Unix Domain sockets but well, shit happens. */
383   if (server_in != -1)
384     {
385       flags = fcntl (server_in, F_GETFL, 0);
386       if (flags == -1)
387         die ("fcntl (F_GETFL) failed: %s\n", strerror (errno));
388       if ( fcntl (server_in, F_SETFL, (flags | O_NONBLOCK)) == -1)
389         die ("fcntl (F_SETFL) failed: %s\n", strerror (errno));
390     }
391   if (server_un != -1)
392     {
393       flags = fcntl (server_un, F_GETFL, 0);
394       if (flags == -1)
395         die ("fcntl (F_GETFL) failed: %s\n", strerror (errno));
396       if ( fcntl (server_un, F_SETFL, (flags | O_NONBLOCK)) == -1)
397         die ("fcntl (F_SETFL) failed: %s\n", strerror (errno));
398     }
399
400   if (tcp)
401     {
402       memset (&srvr_addr_in, 0, sizeof srvr_addr_in);
403       srvr_addr_in.sin_family = AF_INET;
404       srvr_addr_in.sin_port = htons (port);
405       srvr_addr_in.sin_addr.s_addr = htonl (INADDR_ANY);
406       addr_in = (struct sockaddr *)&srvr_addr_in;
407       addrlen_in = sizeof srvr_addr_in;
408     }
409   if (argc)
410     {
411       memset (&srvr_addr_un, 0, sizeof srvr_addr_un);
412       srvr_addr_un.sun_family = AF_LOCAL;
413       strncpy (srvr_addr_un.sun_path, *argv, sizeof (srvr_addr_un.sun_path)-1);
414       srvr_addr_un.sun_path[sizeof (srvr_addr_un.sun_path) - 1] = 0;
415       addr_un = (struct sockaddr *)&srvr_addr_un;
416       addrlen_un = SUN_LEN (&srvr_addr_un);
417     }
418   else
419     addrlen_un = 0;  /* Silent gcc.  */
420
421   if (server_in != -1 && bind (server_in, addr_in, addrlen_in))
422     die ("bind to port %hu failed: %s\n", port, strerror (errno));
423
424  again:
425   if (server_un != -1 && bind (server_un, addr_un, addrlen_un))
426     {
427       if (errno == EADDRINUSE && force)
428         {
429           force = 0;
430           remove (srvr_addr_un.sun_path);
431           goto again;
432         }
433       else
434         die ("bind to '%s' failed: %s\n", *argv, strerror (errno));
435     }
436
437   if (server_in != -1 && listen (server_in, 5))
438     die ("listen on inet failed: %s\n", strerror (errno));
439   if (server_un != -1 && listen (server_un, 5))
440     die ("listen on local failed: %s\n", strerror (errno));
441
442   for (;;)
443     {
444       fd_set rfds;
445       int max_fd;
446       client_t client;
447
448       /* Usually we don't have that many connections, thus it is okay
449          to set them always from scratch and don't maintain an active
450          fd_set. */
451       FD_ZERO (&rfds);
452       max_fd = -1;
453       if (server_in != -1)
454         {
455           FD_SET (server_in, &rfds);
456           max_fd = server_in;
457         }
458       if (server_un != -1)
459         {
460           FD_SET (server_un, &rfds);
461           if (server_un > max_fd)
462             max_fd = server_un;
463         }
464       for (client = client_list; client; client = client->next)
465         if (client->fd != -1)
466           {
467             FD_SET (client->fd, &rfds);
468             if (client->fd > max_fd)
469               max_fd = client->fd;
470           }
471
472       if (select (max_fd + 1, &rfds, NULL, NULL, NULL) <= 0)
473         continue;  /* Ignore any errors. */
474
475       if (server_in != -1 && FD_ISSET (server_in, &rfds))
476         setup_client (server_in, 0);
477       if (server_un != -1 && FD_ISSET (server_un, &rfds))
478         setup_client (server_un, 1);
479
480       for (client = client_list; client; client = client->next)
481         if (client->fd != -1 && FD_ISSET (client->fd, &rfds))
482           {
483             char line[256];
484             int n;
485
486             n = read (client->fd, line, sizeof line - 1);
487             if (n < 0)
488               {
489                 int save_errno = errno;
490                 print_line (client, NULL); /* flush */
491                 printf ("[client at fd %d read error: %s]\n",
492                         client->fd, strerror (save_errno));
493                 close (client->fd);
494                 client->fd = -1;
495               }
496             else if (!n)
497               {
498                 print_line (client, NULL); /* flush */
499                 close (client->fd);
500                 printf ("[client at fd %d disconnected]\n", client->fd);
501                 client->fd = -1;
502               }
503             else
504               {
505                 line[n] = 0;
506                 print_line (client, line);
507               }
508           }
509     }
510
511   return 0;
512 }
513
514
515 /*
516 Local Variables:
517 compile-command: "gcc -Wall -g -o watchgnupg watchgnupg.c"
518 End:
519 */