?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Show the error code along with its description to console.
[pwmd.git] / src / pwmd.c
blob1caef16c64a641c3b0e7a95ca48e564ebfd86c87
1 /*
2 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
3 Ben Kibbey <bjk@luxsci.net>
4
5 This file is part of pwmd.
6
7 Pwmd is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 2 of the License, or
10 (at your option) any later version.
11
12 Pwmd is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Pwmd. If not, see <http://www.gnu.org/licenses/>.
19 */
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <err.h>
28 #include <ctype.h>
29 #include <string.h>
30 #include <sys/socket.h>
31 #include <sys/un.h>
32 #include <signal.h>
33 #include <stdarg.h>
34 #include <string.h>
35 #include <sys/wait.h>
36 #include <fcntl.h>
37 #include <pwd.h>
38 #include <grp.h>
39 #include <pthread.h>
40 #include <sys/mman.h>
41 #include <termios.h>
42 #include <assert.h>
43 #include <syslog.h>
44 #include <netinet/in.h>
45 #include <arpa/inet.h>
46 #include <netdb.h>
47 #include <sys/time.h>
48 #include <sys/resource.h>
49 #include <setjmp.h>
50
51 #ifdef TM_IN_SYS_TIME
52 #include <sys/time.h>
53 #else
54 #include <time.h>
55 #endif
56
57 #ifdef HAVE_LIMITS_H
58 #include <limits.h>
59 #endif
60
61 #ifdef HAVE_GETOPT_LONG
62 #ifdef HAVE_GETOPT_H
63 #include <getopt.h>
64 #endif
65 #else
66 #include "getopt_long.h"
67 #endif
68
69 #ifdef HAVE_PR_SET_NAME
70 #include <sys/prctl.h>
71 #endif
72
73 #include "pwmd-error.h"
74 #include <gcrypt.h>
75
76 #include "util-misc.h"
77 #include "mem.h"
78 #include "xml.h"
79 #include "common.h"
80 #include "commands.h"
81 #include "cache.h"
82 #include "util-string.h"
83 #include "mutex.h"
84 #include "rcfile.h"
85 #include "crypto.h"
86 #include "convert.h"
87 #include "pinentry.h"
88
89 /* In tenths of a second. */
90 #define SIG_TIMEOUT 1
91
92 /* For (tcp_)accept_thread (usec). */
93 #define ACCEPT_TIMEOUT 30000
94
95 static int quit;
96 static int exiting;
97 static int cmdline;
98 static jmp_buf jmp;
99 static int nofork;
100 static pthread_cond_t quit_cond;
101 static pthread_mutex_t quit_mutex;
102 static int no_passphrase_file = 0;
103 static pthread_t keepalive_tid;
104
105 #ifndef HAVE_PTHREAD_CANCEL
106 static pthread_key_t signal_thread_key;
107 #endif
108
109 #ifdef WITH_GNUTLS
110 static int tls_fd;
111 static int tls6_fd;
112 static pthread_t tls_tid;
113 static pthread_t tls6_tid;
114 static int spawned_tls;
115 static int spawned_tls6;
116
117 static int start_stop_tls (int term);
118 #endif
119
120 static int do_cache_push (const char *filename, struct crypto_s *crypto);
121 static int signal_loop (sigset_t sigset);
122
123 GCRY_THREAD_OPTION_PTHREAD_IMPL;
124
125 #ifndef HAVE_PTHREAD_CANCEL
126 #define INIT_THREAD_SIGNAL do { \
127 struct sigaction act; \
128 sigset_t sigset; \
129 sigemptyset (&sigset); \
130 sigaddset (&sigset, SIGUSR2); \
131 pthread_sigmask (SIG_UNBLOCK, &sigset, NULL); \
132 memset (&act, 0, sizeof(act)); \
133 act.sa_flags = SA_SIGINFO; \
134 act.sa_mask = sigset; \
135 act.sa_sigaction = catch_thread_signal; \
136 sigaction (SIGUSR2, &act, NULL); \
137 } while (0)
138
139 static void
140 catch_thread_signal (int sig, siginfo_t *info, void *ctx)
141 {
142 int *n = (int *) pthread_getspecific (signal_thread_key);
143
144 *n = 1;
145 pthread_setspecific (signal_thread_key, n);
146 }
147 #endif
148
149 static void
150 cache_push_from_rcfile ()
151 {
152 struct crypto_s *crypto = NULL;
153 char **cache_push;
154 gpg_error_t rc = init_client_crypto (&crypto);
155
156 if (rc)
157 {
158 log_write ("%s: %s", __FUNCTION__, pwmd_strerror (rc));
159 return;
160 }
161
162 #ifdef WITH_AGENT
163 if (use_agent)
164 {
165 rc = set_agent_option (crypto->agent, "pinentry-mode", "error");
166 if (rc)
167 {
168 log_write ("%s: %s", __FUNCTION__, pwmd_strerror (rc));
169 return;
170 }
171 }
172 #endif
173
174 cache_push = config_get_list ("global", "cache_push");
175 if (cache_push)
176 {
177 char **p;
178
179 for (p = cache_push; *p; p++)
180 {
181 (void) do_cache_push (*p, crypto);
182 cleanup_crypto_stage1 (crypto);
183 }
184
185 strv_free (cache_push);
186 }
187
188 #ifdef WITH_AGENT
189 (void) kill_scd (crypto->agent);
190 #endif
191 cleanup_crypto (&crypto);
192 }
193
194 static void
195 setup_logging ()
196 {
197 int n = config_get_boolean ("global", "enable_logging");
198
199 if (n)
200 {
201 char *p = config_get_string ("global", "log_path");
202
203 xfree (logfile);
204 logfile = expand_homedir (p);
205 xfree (p);
206 }
207 else
208 {
209 xfree (logfile);
210 logfile = NULL;
211 }
212
213 log_syslog = config_get_boolean ("global", "syslog");
214 if (log_syslog == 1)
215 openlog ("pwmd", LOG_NDELAY | LOG_PID, LOG_DAEMON);
216 }
217
218 static void *
219 reload_rcfile_thread (void *arg)
220 {
221 #ifndef HAVE_PTHREAD_CANCEL
222 int *n = xmalloc (sizeof (int));
223
224 *n = 0;
225 pthread_setspecific (signal_thread_key, n);
226 INIT_THREAD_SIGNAL;
227 #endif
228
229 #ifdef HAVE_PR_SET_NAME
230 prctl (PR_SET_NAME, "reload rcfile");
231 #endif
232 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
233 MUTEX_LOCK (&rcfile_mutex);
234 pthread_cleanup_push (cleanup_mutex_cb, &rcfile_mutex);
235
236 for (;;)
237 {
238 struct slist_s *config;
239 char **users;
240 int b = disable_list_and_dump;
241 #ifdef WITH_GNUTLS
242 int exists;
243 int tcp_require_key = config_get_bool_param (global_config, "global",
244 "tcp_require_key",
245 &exists);
246 #endif
247
248 pthread_cond_wait (&rcfile_cond, &rcfile_mutex);
249 #ifndef HAVE_PTHREAD_CANCEL
250 int *n = (int *) pthread_getspecific (signal_thread_key);
251 if (*n)
252 break;
253 #endif
254
255 users = config_get_list ("global", "allowed");
256 log_write (_("reloading configuration file '%s'"), rcfile);
257 config = config_parse (rcfile);
258 if (config)
259 {
260 config_free (global_config);
261 global_config = config;
262 setup_logging ();
263 cache_push_from_rcfile ();
264 config_clear_keys ();
265 }
266
267 disable_list_and_dump = !disable_list_and_dump ? b : 1;
268 #ifdef WITH_GNUTLS
269 if (config_get_bool_param (global_config, "global", "tcp_require_key",
270 &exists) && exists)
271 tcp_require_key = 1;
272
273 config_set_bool_param (&global_config, "global", "tcp_require_key",
274 tcp_require_key ? "true" : "false");
275 #endif
276 char *tmp = strv_join (",", users);
277 config_set_list_param (&global_config, "global", "allowed", tmp);
278 xfree (tmp);
279 strv_free (users);
280 #ifdef WITH_GNUTLS
281 /* Kill existing listening threads since the configured listening
282 * protocols may have changed. */
283 start_stop_tls (1);
284 start_stop_tls (0);
285 #endif
286 }
287
288 pthread_cleanup_pop (1);
289 return NULL;
290 }
291
292 gpg_error_t
293 send_error (assuan_context_t ctx, gpg_error_t e)
294 {
295 struct client_s *client = assuan_get_pointer (ctx);
296
297 if (gpg_err_source (e) == GPG_ERR_SOURCE_UNKNOWN)
298 e = gpg_error (e);
299
300 if (client)
301 client->last_rc = e;
302
303 if (!e)
304 return assuan_process_done (ctx, 0);
305
306 if (!ctx)
307 {
308 log_write ("ERR %i: %s", e, pwmd_strerror (e));
309 return e;
310 }
311
312 if (client && gpg_err_code (e) == GPG_ERR_BAD_DATA)
313 {
314 xmlErrorPtr xe = client->xml_error;
315
316 if (!xe)
317 xe = xmlGetLastError ();
318 if (xe)
319 {
320 log_write ("%s", xe->message);
321 if (client->last_error)
322 xfree (client->last_error);
323
324 client->last_error = str_dup (xe->message);
325 }
326
327 e = assuan_process_done (ctx, assuan_set_error (ctx, e,
328 xe ? xe->message :
329 NULL));
330
331 if (xe == client->xml_error)
332 xmlResetError (xe);
333 else
334 xmlResetLastError ();
335
336 client->xml_error = NULL;
337 return e;
338 }
339
340 return assuan_process_done (ctx,
341 assuan_set_error (ctx, e, pwmd_strerror (e)));
342 }
343
344 int
345 assuan_log_cb (assuan_context_t ctx, void *data, unsigned cat,
346 const char *msg)
347 {
348 static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
349 int i, t;
350 int match = 0;
351
352 pthread_mutex_lock (&m);
353 pthread_cleanup_push ((void (*)(void *)) pthread_mutex_unlock, &m);
354 t = strv_length (debug_level);
355
356 for (i = 0; i < t; i++)
357 {
358 if (!strcasecmp (debug_level[i], (char *) "init")
359 && cat == ASSUAN_LOG_INIT)
360 {
361 match = 1;
362 break;
363 }
364
365 if (!strcasecmp (debug_level[i], (char *) "ctx")
366 && cat == ASSUAN_LOG_CTX)
367 {
368 match = 1;
369 break;
370 }
371
372 if (!strcasecmp (debug_level[i], (char *) "engine")
373 && cat == ASSUAN_LOG_ENGINE)
374 {
375 match = 1;
376 break;
377 }
378
379 if (!strcasecmp (debug_level[i], (char *) "data")
380 && cat == ASSUAN_LOG_DATA)
381 {
382 match = 1;
383 break;
384 }
385
386 if (!strcasecmp (debug_level[i], (char *) "sysio")
387 && cat == ASSUAN_LOG_SYSIO)
388 {
389 match = 1;
390 break;
391 }
392
393 if (!strcasecmp (debug_level[i], (char *) "control")
394 && cat == ASSUAN_LOG_CONTROL)
395 {
396 match = 1;
397 break;
398 }
399 }
400
401 if (match && msg)
402 {
403 if (logfile)
404 {
405 int fd;
406
407 if ((fd =
408 open (logfile, O_WRONLY | O_CREAT | O_APPEND, 0600)) == -1)
409 warn ("%s", logfile);
410 else
411 {
412 pthread_cleanup_push (cleanup_fd_cb, &fd);
413 write (fd, msg, strlen (msg));
414 pthread_cleanup_pop (1);
415 }
416 }
417
418 if (nofork)
419 {
420 fprintf (stderr, "%s%s", data ? (char *) data : "", msg);
421 fflush (stderr);
422 }
423 }
424
425 pthread_cleanup_pop (1);
426 return match;
427 }
428
429 void
430 log_write (const char *fmt, ...)
431 {
432 char *args, *line;
433 va_list ap;
434 struct tm *tm;
435 time_t now;
436 char tbuf[21];
437 int fd = -1;
438 char *name = NULL;
439 char buf[255];
440 pthread_t tid = pthread_self ();
441 static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
442
443 if ((!logfile && !isatty (STDERR_FILENO) && !log_syslog) || !fmt)
444 return;
445
446 pthread_mutex_lock (&m);
447 pthread_cleanup_push ((void (*)(void *)) pthread_mutex_unlock, &m);
448 pthread_cleanup_push (cleanup_fd_cb, &fd);
449
450 if (!cmdline && logfile)
451 {
452 if ((fd = open (logfile, O_WRONLY | O_CREAT | O_APPEND, 0600)) == -1)
453 warn ("%s", logfile);
454 }
455
456 va_start (ap, fmt);
457
458 if (str_vasprintf (&args, fmt, ap) != -1)
459 {
460 if (cmdline)
461 {
462 pthread_cleanup_push (xfree, args);
463 fprintf (stderr, "%s\n", args);
464 fflush (stderr);
465 pthread_cleanup_pop (1);
466 }
467 else
468 {
469 pthread_cleanup_push (xfree, args);
470 name = pthread_getspecific (thread_name_key);
471 snprintf (buf, sizeof (buf), "%s(%p): ", name ? name : _("unknown"),
472 (pthread_t *) tid);
473 name = buf;
474
475 if (!cmdline && log_syslog && !nofork)
476 syslog (LOG_INFO, "%s%s", name, args);
477
478 time (&now);
479 tm = localtime (&now);
480 strftime (tbuf, sizeof (tbuf), "%b %d %Y %H:%M:%S ", tm);
481 tbuf[sizeof (tbuf) - 1] = 0;
482
483 if (args[strlen (args) - 1] == '\n')
484 args[strlen (args) - 1] = 0;
485
486 line = str_asprintf ("%s %i %s%s\n", tbuf, getpid (), name, args);
487 pthread_cleanup_pop (1);
488 if (line)
489 {
490 pthread_cleanup_push (xfree, line);
491 if (logfile && fd != -1)
492 {
493 write (fd, line, strlen (line));
494 fsync (fd);
495 }
496
497 if (nofork)
498 {
499 fprintf (stdout, "%s", line);
500 fflush (stdout);
501 }
502
503 pthread_cleanup_pop (1);
504 }
505 }
506 }
507
508 va_end (ap);
509 pthread_cleanup_pop (1);
510 pthread_cleanup_pop (0);
511 pthread_mutex_unlock (&m);
512 }
513
514 #ifdef WITH_GNUTLS
515 static int
516 secure_mem_check (const void *arg)
517 {
518 return 1;
519 }
520 #endif
521
522 static gpg_error_t
523 setup_crypto ()
524 {
525 gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
526
527 if (!gcry_check_version (GCRYPT_VERSION))
528 {
529 fprintf (stderr, _("gcry_check_version(): Incompatible libgcrypt. "
530 "Wanted %s, got %s.\n"), GCRYPT_VERSION,
531 gcry_check_version (NULL));
532 return GPG_ERR_UNKNOWN_VERSION;
533 }
534
535 gcry_set_allocation_handler (xmalloc, xmalloc, NULL, xrealloc, xfree);
536 return 0;
537 }
538
539 #ifdef HAVE_GETGRNAM_R
540 static gpg_error_t
541 do_validate_peer (struct client_s *cl, assuan_peercred_t * peer)
542 {
543 char **users;
544 int allowed = 0;
545 gpg_error_t rc;
546
547 rc = assuan_get_peercred (cl->ctx, peer);
548 if (rc)
549 return rc;
550
551 users = config_get_list ("global", "allowed");
552 if (users)
553 {
554 for (char **p = users; *p; p++)
555 {
556 struct passwd pw, *result;
557 struct group gr, *gresult;
558 char *buf;
559
560 if (*(*p) == '@')
561 {
562 size_t len = sysconf (_SC_GETGR_R_SIZE_MAX);
563
564 if (len == -1)
565 len = 16384;
566
567 buf = xmalloc (len);
568 if (!buf)
569 {
570 strv_free (users);
571 return GPG_ERR_ENOMEM;
572 }
573
574 if (!getgrnam_r (*(p) + 1, &gr, buf, len, &gresult) && gresult)
575 {
576 if (gresult->gr_gid == (*peer)->gid)
577 {
578 xfree (buf);
579 allowed = 1;
580 break;
581 }
582
583 len = sysconf (_SC_GETPW_R_SIZE_MAX);
584 if (len == -1)
585 len = 16384;
586
587 char *tbuf = xmalloc (len);
588 for (char **t = gresult->gr_mem; *t; t++)
589 {
590 if (!getpwnam_r (*t, &pw, tbuf, len, &result) && result)
591 {
592 if (result->pw_uid == (*peer)->uid)
593 {
594 xfree (buf);
595 allowed = 1;
596 break;
597 }
598 }
599 }
600
601 xfree (tbuf);
602
603 if (allowed)
604 break;
605 }
606 }
607 else
608 {
609 size_t len = sysconf (_SC_GETPW_R_SIZE_MAX);
610
611 if (len == -1)
612 len = 16384;
613
614 buf = xmalloc (len);
615
616 if (!buf)
617 {
618 strv_free (users);
619 return GPG_ERR_ENOMEM;
620 }
621
622 if (!getpwnam_r (*p, &pw, buf, len, &result) && result)
623 {
624 if (result->pw_uid == (*peer)->uid)
625 {
626 xfree (buf);
627 allowed = 1;
628 break;
629 }
630 }
631 }
632
633 xfree (buf);
634 }
635
636 strv_free (users);
637 }
638
639 return allowed ? 0 : GPG_ERR_INV_USER_ID;
640 }
641 #else
642 static gpg_error_t
643 do_validate_peer (struct client_s *cl, assuan_peercred_t * peer)
644 {
645 char **users;
646 int allowed = 0;
647 gpg_error_t rc;
648
649 rc = assuan_get_peercred (cl->ctx, peer);
650 if (rc)
651 return rc;
652
653 users = config_get_list ("global", "allowed");
654 if (users)
655 {
656 for (char **p = users; *p; p++)
657 {
658 struct passwd *result;
659 struct group *gresult;
660
661 if (*(*p) == '@')
662 {
663 gresult = getgrnam (*(p) + 1);
664 if (gresult && gresult->gr_gid == (*peer)->gid)
665 {
666 allowed = 1;
667 break;
668 }
669
670 for (char **t = gresult->gr_mem; *t; t++)
671 {
672 result = getpwnam (*t);
673 if (result && result->pw_uid == (*peer)->uid)
674 {
675 allowed = 1;
676 break;
677 }
678 }
679 }
680 else
681 {
682 result = getpwnam (*p);
683 if (result && result->pw_uid == (*peer)->uid)
684 {
685 allowed = 1;
686 break;
687 }
688 }
689
690 if (allowed)
691 break;
692 }
693
694 strv_free (users);
695 }
696
697 return allowed ? 0 : GPG_ERR_INV_USER_ID;
698 }
699 #endif
700
701 static gpg_error_t
702 validate_peer (struct client_s *cl)
703 {
704 gpg_error_t rc;
705 assuan_peercred_t peer;
706
707 #ifdef WITH_GNUTLS
708 if (cl->thd->remote)
709 return tls_validate_access (cl, NULL);
710 #endif
711
712 rc = do_validate_peer (cl, &peer);
713 if (!rc || gpg_err_code (rc) == GPG_ERR_INV_USER_ID)
714 log_write ("peer %s: uid=%i, gid=%i, pid=%i",
715 !rc ? _("accepted") : _("rejected"), peer->uid, peer->gid,
716 peer->pid);
717 else if (rc)
718 log_write ("%s: %s", __FUNCTION__, pwmd_strerror (rc));
719
720 return rc;
721 }
722
723 static void
724 xml_error_cb (void *data, xmlErrorPtr e)
725 {
726 struct client_s *client = data;
727
728 /*
729 * Keep the first reported error as the one to show in the error
730 * description. Reset in send_error().
731 */
732 if (client->xml_error)
733 return;
734
735 xmlCopyError (e, client->xml_error);
736 }
737
738 static pid_t
739 hook_waitpid (assuan_context_t ctx, pid_t pid, int action,
740 int *status, int options)
741 {
742 return waitpid (pid, status, options);
743 }
744
745 static ssize_t
746 hook_read (assuan_context_t ctx, assuan_fd_t fd, void *data, size_t len)
747 {
748 #ifdef WITH_GNUTLS
749 struct client_s *client = assuan_get_pointer (ctx);
750
751 if (client->thd->remote)
752 return tls_read_hook (ctx, (int) fd, data, len);
753 #endif
754
755 return read ((int) fd, data, len);
756 }
757
758 static ssize_t
759 hook_write (assuan_context_t ctx, assuan_fd_t fd,
760 const void *data, size_t len)
761 {
762 #ifdef WITH_GNUTLS
763 struct client_s *client = assuan_get_pointer (ctx);
764
765 if (client->thd->remote)
766 return tls_write_hook (ctx, (int) fd, data, len);
767 #endif
768
769 return write ((int) fd, data, len);
770 }
771
772 static int
773 new_connection (struct client_s *cl)
774 {
775 gpg_error_t rc;
776 static struct assuan_malloc_hooks mhooks = { xmalloc, xrealloc, xfree };
777 static struct assuan_system_hooks shooks = {
778 ASSUAN_SYSTEM_HOOKS_VERSION,
779 __assuan_usleep,
780 __assuan_pipe,
781 __assuan_close,
782 hook_read,
783 hook_write,
784 //FIXME
785 NULL, //recvmsg
786 NULL, //sendmsg both are used for FD passing
787 __assuan_spawn,
788 hook_waitpid,
789 __assuan_socketpair,
790 __assuan_socket,
791 __assuan_connect
792 };
793
794 #ifdef WITH_GNUTLS
795 if (cl->thd->remote)
796 {
797 char *prio = config_get_string ("global", "tls_cipher_suite");
798
799 cl->thd->tls = tls_init (cl->thd->fd, cl->thd->timeout, prio);
800 xfree (prio);
801 if (!cl->thd->tls)
802 return 0;
803 }
804 #endif
805
806 rc = assuan_new_ext (&cl->ctx, GPG_ERR_SOURCE_DEFAULT, &mhooks,
807 debug_level ? assuan_log_cb : NULL, NULL);
808 if (rc)
809 goto fail;
810
811 assuan_ctx_set_system_hooks (cl->ctx, &shooks);
812 rc = assuan_init_socket_server (cl->ctx, cl->thd->fd, 2);
813 if (rc)
814 goto fail;
815
816 assuan_set_pointer (cl->ctx, cl);
817 assuan_set_hello_line (cl->ctx, PACKAGE_STRING);
818 rc = register_commands (cl->ctx);
819 if (rc)
820 goto fail;
821
822 #ifdef WITH_GNUTLS
823 if (cl->thd->remote)
824 {
825 cl->thd->timeout = config_get_integer ("global", "tls_timeout");
826 fcntl (cl->thd->fd, F_SETFL, O_NONBLOCK);
827 }
828 #endif
829
830 rc = assuan_accept (cl->ctx);
831 if (rc)
832 goto fail;
833
834 rc = validate_peer (cl);
835 /* May not be implemented on all platforms. */
836 if (rc && gpg_err_code (rc) != GPG_ERR_ASS_GENERAL)
837 goto fail;
838
839 rc = init_client_crypto (&cl->crypto);
840 if (rc)
841 goto fail;
842
843 #ifdef WITH_AGENT
844 if (use_agent)
845 cl->crypto->agent->client_ctx = cl->ctx;
846 #endif
847
848 cl->crypto->client_ctx = cl->ctx;
849 xmlSetStructuredErrorFunc (cl, xml_error_cb);
850 return 1;
851
852 fail:
853 log_write ("%s", pwmd_strerror (rc));
854 return 0;
855 }
856
857 /*
858 * This is called after a client_thread() terminates. Set with
859 * pthread_cleanup_push().
860 */
861 static void
862 cleanup_cb (void *arg)
863 {
864 struct client_thread_s *cn = arg;
865 struct client_s *cl = cn->cl;
866
867 MUTEX_LOCK (&cn_mutex);
868 cn_thread_list = slist_remove (cn_thread_list, cn);
869 MUTEX_UNLOCK (&cn_mutex);
870
871 if (cl)
872 {
873 cleanup_client (cl);
874
875 #ifdef WITH_GNUTLS
876 if (cn->tls)
877 {
878 gnutls_deinit (cn->tls->ses);
879 xfree (cn->tls->fp);
880 xfree (cn->tls);
881 }
882 #endif
883
884 if (!cn->atfork && cl->ctx)
885 assuan_release (cl->ctx);
886 else if (!cn->atfork && cl->thd && cl->thd->fd != -1)
887 close (cl->thd->fd);
888
889 if (cl->crypto)
890 cleanup_crypto (&cl->crypto);
891
892 pinentry_free_opts (&cl->pinentry_opts);
893 xfree (cl);
894 }
895 else
896 {
897 if (cn->fd != -1)
898 close (cn->fd);
899 }
900
901 while (cn->msg_queue)
902 {
903 struct status_msg_s *msg = cn->msg_queue;
904
905 cn->msg_queue = msg->next;
906 xfree (msg->line);
907 xfree (msg);
908 }
909
910 if (!cn->atfork && cn->status_msg_pipe[0] != -1)
911 close (cn->status_msg_pipe[0]);
912
913 if (!cn->atfork && cn->status_msg_pipe[1] != -1)
914 close (cn->status_msg_pipe[1]);
915
916 pthread_mutex_destroy (&cn->status_mutex);
917
918 if (!cn->atfork)
919 {
920 log_write (_("exiting, fd=%i"), cn->fd);
921 send_status_all (STATUS_CLIENTS, NULL);
922 }
923
924 xfree (cn);
925 pthread_cond_signal (&quit_cond);
926 }
927
928 void
929 cleanup_all_clients (int atfork)
930 {
931 /* This function may be called from pthread_atfork() which requires
932 reinitialization. */
933 if (atfork)
934 {
935 pthread_mutexattr_t attr;
936
937 pthread_mutexattr_init (&attr);
938 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
939 pthread_mutex_init (&cn_mutex, &attr);
940 pthread_mutexattr_destroy (&attr);
941 cache_mutex_init ();
942 }
943
944 MUTEX_LOCK (&cn_mutex);
945
946 while (slist_length (cn_thread_list))
947 {
948 struct client_thread_s *thd = slist_nth_data (cn_thread_list, 0);
949
950 thd->atfork = atfork;
951 cleanup_cb (thd);
952 }
953
954 exiting = 1;
955 cache_deinit (atfork);
956 MUTEX_UNLOCK (&cn_mutex);
957 }
958
959 static gpg_error_t
960 send_msg_queue (struct client_thread_s *thd)
961 {
962 MUTEX_LOCK (&thd->status_mutex);
963 gpg_error_t rc = 0;
964 char c;
965
966 read (thd->status_msg_pipe[0], &c, 1);
967
968 while (thd->msg_queue)
969 {
970 struct status_msg_s *msg = thd->msg_queue;
971
972 thd->msg_queue = thd->msg_queue->next;
973 MUTEX_UNLOCK (&thd->status_mutex);
974 rc = send_status (thd->cl->ctx, msg->s, msg->line);
975 MUTEX_LOCK (&thd->status_mutex);
976 xfree (msg->line);
977 xfree (msg);
978
979 if (rc)
980 break;
981 }
982
983 MUTEX_UNLOCK (&thd->status_mutex);
984 if (rc && gpg_err_code (rc) != GPG_ERR_EPIPE)
985 log_write ("%s: %s", __FUNCTION__, pwmd_strerror (rc));
986
987 return rc;
988 }
989
990 static void *
991 client_thread (void *data)
992 {
993 struct client_thread_s *thd = data;
994 struct client_s *cl = xcalloc (1, sizeof (struct client_s));
995
996 #ifdef HAVE_PR_SET_NAME
997 prctl (PR_SET_NAME, "client");
998 #endif
999 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
1000
1001 if (!cl)
1002 {
1003 log_write ("%s(%i): %s", __FILE__, __LINE__,
1004 pwmd_strerror (GPG_ERR_ENOMEM));
1005 return NULL;
1006 }
1007
1008 MUTEX_LOCK (&cn_mutex);
1009 pthread_cleanup_push (cleanup_cb, thd);
1010 thd->cl = cl;
1011 cl->thd = thd;
1012 MUTEX_UNLOCK (&cn_mutex);
1013
1014 if (new_connection (cl))
1015 {
1016 int finished = 0;
1017 gpg_error_t rc;
1018
1019 send_status_all (STATUS_CLIENTS, NULL);
1020 rc = send_status (cl->ctx, STATUS_CACHE, NULL);
1021 if (rc)
1022 {
1023 log_write ("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror (rc));
1024 finished = 1;
1025 }
1026
1027 while (!finished)
1028 {
1029 fd_set rfds;
1030 int n;
1031 int eof;
1032
1033 FD_ZERO (&rfds);
1034 FD_SET (thd->fd, &rfds);
1035 FD_SET (thd->status_msg_pipe[0], &rfds);
1036 n = thd->fd > thd->status_msg_pipe[0]
1037 ? thd->fd : thd->status_msg_pipe[0];
1038
1039 n = select (n + 1, &rfds, NULL, NULL, NULL);
1040 if (n == -1)
1041 {
1042 log_write ("%s", strerror (errno));
1043 break;
1044 }
1045
1046 if (FD_ISSET (thd->status_msg_pipe[0], &rfds))
1047 {
1048 rc = send_msg_queue (thd);
1049 if (rc && gpg_err_code (rc) != GPG_ERR_EPIPE)
1050 break;
1051 }
1052
1053 if (!FD_ISSET (thd->fd, &rfds))
1054 continue;
1055
1056 rc = assuan_process_next (cl->ctx, &eof);
1057 if (rc || eof)
1058 {
1059 if (gpg_err_code (rc) == GPG_ERR_EOF || eof)
1060 break;
1061
1062 log_write ("assuan_process_next(): rc=%i %s", rc,
1063 pwmd_strerror (rc));
1064 if (rc == gpg_error (GPG_ERR_ETIMEDOUT))
1065 break;
1066
1067 rc = send_error (cl->ctx, rc);
1068 if (rc)
1069 {
1070 log_write ("assuan_process_done(): rc=%i %s", rc,
1071 pwmd_strerror (rc));
1072 break;
1073 }
1074 }
1075
1076 /* Since the msg queue pipe fd's are non-blocking, check for
1077 * pending status msgs here. GPG_ERR_EPIPE can be seen when the
1078 * client has already disconnected and will be converted to
1079 * GPG_ERR_EOF during assuan_process_next().
1080 */
1081 rc = send_msg_queue (thd);
1082 if (rc && gpg_err_code (rc) != GPG_ERR_EPIPE)
1083 break;
1084 }
1085 }
1086
1087 pthread_cleanup_pop (1);
1088 return NULL;
1089 }
1090
1091 static int
1092 xml_import (const char *filename, const char *outfile,
1093 const char *keygrip, const char *sign_keygrip,
1094 const char *keyfile, int no_passphrase, const char *cipher,
1095 const char *params, unsigned long s2k_count, uint64_t iterations)
1096 {
1097 xmlDocPtr doc;
1098 int fd;
1099 struct stat st;
1100 int len;
1101 xmlChar *xmlbuf;
1102 xmlChar *xml;
1103 gpg_error_t rc;
1104 struct crypto_s *crypto = NULL;
1105 void *key = NULL;
1106 size_t keylen = 0;
1107 int algo = cipher ? cipher_string_to_gcrypt ((char *) cipher) :
1108 GCRY_CIPHER_AES256;
1109
1110 if (algo == -1)
1111 {
1112 log_write ("ERR %i: %s", gpg_error (GPG_ERR_CIPHER_ALGO),
1113 pwmd_strerror (GPG_ERR_CIPHER_ALGO));
1114 return 0;
1115 }
1116
1117 if (stat (filename, &st) == -1)
1118 {
1119 log_write ("%s: %s", filename,
1120 pwmd_strerror (gpg_error_from_syserror ()));
1121 return 0;
1122 }
1123
1124 rc = init_client_crypto (&crypto);
1125 if (rc)
1126 return 0;
1127
1128 memcpy (&crypto->save.hdr, &crypto->hdr, sizeof (file_header_t));
1129 crypto->save.hdr.flags = set_cipher_flag (crypto->save.hdr.flags, algo);
1130 log_write (_("Importing XML from '%s'. Output will be written to '%s' ..."),
1131 filename, outfile);
1132
1133 if ((fd = open (filename, O_RDONLY)) == -1)
1134 {
1135 log_write ("%s: %s", filename,
1136 pwmd_strerror (gpg_error_from_syserror ()));
1137 goto fail;
1138 }
1139
1140 if ((xmlbuf = xmalloc (st.st_size + 1)) == NULL)
1141 {
1142 close (fd);
1143 log_write ("%s(%i): %s", __FILE__, __LINE__,
1144 pwmd_strerror (GPG_ERR_ENOMEM));
1145 goto fail;
1146 }
1147
1148 if (read (fd, xmlbuf, st.st_size) == -1)
1149 {
1150 rc = gpg_error_from_syserror ();
1151 close (fd);
1152 log_write ("%s: %s", filename, pwmd_strerror (rc));
1153 goto fail;
1154 }
1155
1156 close (fd);
1157 xmlbuf[st.st_size] = 0;
1158 /*
1159 * Make sure the document validates.
1160 */
1161 if ((doc = xmlReadDoc (xmlbuf, NULL, "UTF-8", XML_PARSE_NOBLANKS)) == NULL)
1162 {
1163 log_write ("xmlReadDoc() failed");
1164 xfree (xmlbuf);
1165 goto fail;
1166 }
1167
1168 xfree (xmlbuf);
1169 xmlNodePtr n = xmlDocGetRootElement (doc);
1170 if (n && !xmlStrEqual (n->name, (xmlChar *) "pwmd"))
1171 {
1172 log_write (_("Could not find root \"pwmd\" element."));
1173 rc = GPG_ERR_BAD_DATA;
1174 }
1175
1176 if (!rc)
1177 rc = validate_import (n ? n->children : n);
1178
1179 if (rc)
1180 {
1181 log_write ("ERR %i: %s", rc, pwmd_strerror (rc));
1182 xmlFreeDoc (doc);
1183 goto fail;
1184 }
1185
1186 xmlDocDumpMemory (doc, &xml, &len);
1187 xmlFreeDoc (doc);
1188 crypto->save.s2k_count = s2k_count;
1189 crypto->save.hdr.iterations = iterations;
1190 if (!use_agent)
1191 {
1192 rc = export_common (NULL, 0, crypto, xml, len, outfile, keyfile, &key,
1193 &keylen, 0, 0);
1194 if (!rc)
1195 log_write (_("Success!"));
1196 }
1197 #ifdef WITH_AGENT
1198 else
1199 {
1200 rc = agent_set_pinentry_options (crypto->agent);
1201 if (!rc)
1202 rc = agent_export_common (crypto, keygrip, sign_keygrip, no_passphrase,
1203 xml, len, outfile, params, keyfile);
1204 }
1205 #endif
1206
1207 gcry_free (key);
1208 xmlFree (xml);
1209 if (rc)
1210 {
1211 send_error (NULL, rc);
1212 goto fail;
1213 }
1214
1215 cleanup_crypto (&crypto);
1216 return 1;
1217
1218 fail:
1219 cleanup_crypto (&crypto);
1220 return 0;
1221 }
1222
1223 static int
1224 do_cache_push (const char *filename, struct crypto_s *crypto)
1225 {
1226 unsigned char md5file[16];
1227 gpg_error_t rc;
1228 char *key = NULL;
1229 size_t keylen = 0;
1230 xmlDocPtr doc;
1231 struct cache_data_s *cdata;
1232 unsigned char *crc;
1233 size_t len;
1234
1235 log_write (_("Trying to add datafile '%s' to the file cache ..."),
1236 filename);
1237
1238 if (valid_filename (filename) == 0)
1239 {
1240 log_write (_("%s: Invalid characters in filename"), filename);
1241 return 0;
1242 }
1243
1244 rc = decrypt_common (NULL, 0, crypto, filename, &key, &keylen);
1245 if (rc)
1246 return 0;
1247
1248 doc = parse_doc ((char *) crypto->plaintext, crypto->plaintext_len);
1249 if (!doc)
1250 {
1251 log_write ("%s", pwmd_strerror (GPG_ERR_ENOMEM));
1252 xfree (key);
1253 return 0;
1254 }
1255
1256 gcry_md_hash_buffer (GCRY_MD_MD5, md5file, filename, strlen (filename));
1257 cdata = xcalloc (1, sizeof (struct cache_data_s));
1258 if (!cdata)
1259 {
1260 xmlFreeDoc (doc);
1261 log_write ("%s", pwmd_strerror (GPG_ERR_ENOMEM));
1262 xfree (key);
1263 return 0;
1264 }
1265
1266 rc = get_checksum (filename, &crc, &len);
1267 if (rc)
1268 {
1269 log_write ("ERR %i: %s", rc, pwmd_strerror (rc));
1270 xmlFreeDoc (doc);
1271 free_cache_data_once (cdata);
1272 xfree (key);
1273 return 0;
1274 }
1275
1276 cdata->crc = crc;
1277 rc = encrypt_xml (NULL, cache_key, cache_keysize, GCRY_CIPHER_AES,
1278 crypto->plaintext, crypto->plaintext_len, &cdata->doc,
1279 &cdata->doclen, &cache_iv, &cache_blocksize, 0);
1280 if (!rc && !IS_PKI (crypto))
1281 {
1282 cdata->key = key;
1283 cdata->keylen = keylen;
1284 }
1285 else
1286 xfree (key);
1287
1288 if (rc)
1289 {
1290 log_write ("ERR %i: %s", rc, pwmd_strerror (rc));
1291 xmlFreeDoc (doc);
1292 free_cache_data_once (cdata);
1293 return 0;
1294 }
1295
1296 #ifdef WITH_AGENT
1297 if (use_agent && IS_PKI (crypto))
1298 {
1299 gcry_sexp_build ((gcry_sexp_t *) & cdata->pubkey, NULL, "%S",
1300 crypto->pkey_sexp);
1301 gcry_sexp_build ((gcry_sexp_t *) & cdata->sigkey, NULL, "%S",
1302 crypto->sigpkey_sexp);
1303 }
1304 #endif
1305
1306 int timeout = config_get_integer (filename, "cache_timeout");
1307 cache_add_file (md5file, crypto->grip, cdata, timeout);
1308 log_write (_("Successfully added '%s' to the cache."), filename);
1309 return 1;
1310 }
1311
1312 static gpg_error_t
1313 init_client (int fd, const char *addr)
1314 {
1315 gpg_error_t rc = 0;
1316 struct client_thread_s *new = xcalloc (1, sizeof (struct client_thread_s));
1317
1318 if (!new)
1319 {
1320 close (fd);
1321 return GPG_ERR_ENOMEM;
1322 }
1323
1324 MUTEX_LOCK (&cn_mutex);
1325 pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
1326
1327 if (pipe (new->status_msg_pipe) == -1)
1328 rc = gpg_error_from_syserror ();
1329
1330 if (!rc)
1331 {
1332 fcntl (new->status_msg_pipe[0], F_SETFL, O_NONBLOCK);
1333 fcntl (new->status_msg_pipe[1], F_SETFL, O_NONBLOCK);
1334 pthread_mutex_init (&new->status_mutex, NULL);
1335 }
1336
1337 if (!rc)
1338 {
1339 #ifdef WITH_GNUTLS
1340 new->remote = addr ? 1 : 0;
1341 #endif
1342 new->fd = fd;
1343 rc = create_thread (client_thread, new, &new->tid, 1);
1344 if (rc)
1345 {
1346 close (new->status_msg_pipe[0]);
1347 close (new->status_msg_pipe[1]);
1348 pthread_mutex_destroy (&new->status_mutex);
1349 }
1350 }
1351
1352 if (!rc)
1353 {
1354 struct slist_s *list = slist_append (cn_thread_list, new);
1355
1356 if (list)
1357 {
1358 cn_thread_list = list;
1359 if (addr)
1360 log_write (_("new connection: tid=%p, fd=%i, addr=%s"),
1361 (pthread_t *) new->tid, fd, addr);
1362 else
1363 log_write (_("new connection: tid=%p, fd=%i"),
1364 (pthread_t *) new->tid, fd);
1365 }
1366 else
1367 rc = GPG_ERR_ENOMEM;
1368 }
1369
1370 pthread_cleanup_pop (1);
1371
1372 if (rc)
1373 {
1374 xfree (new);
1375 close (fd);
1376 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
1377 pwmd_strerror (rc));
1378 }
1379 return rc;
1380 }
1381
1382 static void*
1383 keepalive_thread (void *arg)
1384 {
1385 #ifndef HAVE_PTHREAD_CANCEL
1386 int *n = xmalloc (sizeof (int));
1387
1388 *n = 0;
1389 pthread_setspecific (signal_thread_key, n);
1390 INIT_THREAD_SIGNAL;
1391 #endif
1392
1393 #ifdef HAVE_PR_SET_NAME
1394 prctl (PR_SET_NAME, "keepalive");
1395 #endif
1396 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
1397
1398 for (;;)
1399 {
1400 int n = config_get_integer ("global", "keepalive_interval");
1401 struct timeval tv = { n, 0 };
1402 #ifndef HAVE_PTHREAD_CANCEL
1403 int *sigusr2;
1404
1405 sigusr2 = (int *) pthread_getspecific (signal_thread_key);
1406 if (*sigusr2)
1407 break;
1408 #endif
1409
1410 send_status_all (STATUS_KEEPALIVE, NULL);
1411 select (0, NULL, NULL, NULL, &tv);
1412 }
1413
1414 return NULL;
1415 }
1416
1417 #ifdef WITH_GNUTLS
1418 /* From Beej's Guide to Network Programming. It's a good tutorial. */
1419 static void *
1420 get_in_addr (struct sockaddr *sa)
1421 {
1422 if (sa->sa_family == AF_INET)
1423 return &(((struct sockaddr_in *) sa)->sin_addr);
1424
1425 return &(((struct sockaddr_in6 *) sa)->sin6_addr);
1426 }
1427
1428 static void *
1429 tcp_accept_thread (void *arg)
1430 {
1431 int sockfd = *(int *) arg;
1432 #ifndef HAVE_PTHREAD_CANCEL
1433 int *n = xmalloc (sizeof (int));
1434
1435 *n = 0;
1436 pthread_setspecific (signal_thread_key, n);
1437 INIT_THREAD_SIGNAL;
1438 fcntl (sockfd, F_SETFL, O_NONBLOCK);
1439 #endif
1440
1441 #ifdef HAVE_PR_SET_NAME
1442 prctl (PR_SET_NAME, "tcp_accept");
1443 #endif
1444 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
1445
1446 for (;;)
1447 {
1448 struct sockaddr_storage raddr;
1449 socklen_t slen = sizeof (raddr);
1450 int fd = -1;
1451 unsigned long n;
1452 char s[INET6_ADDRSTRLEN];
1453 struct timeval tv = { 0, ACCEPT_TIMEOUT };
1454 #ifndef HAVE_PTHREAD_CANCEL
1455 int *sigusr2;
1456
1457 sigusr2 = (int *) pthread_getspecific (signal_thread_key);
1458 if (*sigusr2)
1459 break;
1460 #endif
1461
1462 fd = accept (sockfd, (struct sockaddr *) &raddr, &slen);
1463 if (fd == -1)
1464 {
1465 if (errno == EMFILE || errno == ENFILE)
1466 log_write ("accept(): %s",
1467 pwmd_strerror (gpg_error_from_syserror ()));
1468 else if (errno != EAGAIN)
1469 {
1470 if (!quit) // probably EBADF
1471 log_write ("accept(): %s", strerror (errno));
1472
1473 break;
1474 }
1475
1476 #ifndef HAVE_PTHREAD_CANCEL
1477 select (0, NULL, NULL, NULL, &tv);
1478 #endif
1479 continue;
1480 }
1481
1482 if (quit)
1483 break;
1484
1485 inet_ntop (raddr.ss_family, get_in_addr ((struct sockaddr *) &raddr),
1486 s, sizeof s);
1487 (void) init_client (fd, s);
1488 n = config_get_integer ("global", "tcp_wait");
1489 if (n > 0)
1490 {
1491 tv.tv_sec = (n * 100000) / 100000;
1492 tv.tv_usec = (n * 100000) % 100000;
1493 select (0, NULL, NULL, NULL, &tv);
1494 }
1495 }
1496
1497 return NULL;
1498 }
1499
1500 static int
1501 start_stop_tls_with_protocol (int ipv6, int term)
1502 {
1503 struct addrinfo hints, *servinfo, *p;
1504 int port = config_get_integer ("global", "tcp_port");
1505 char buf[7];
1506 int n;
1507 gpg_error_t rc;
1508 int *fd = ipv6 ? &tls6_fd : &tls_fd;
1509
1510 if (term || config_get_boolean ("global", "enable_tcp") == 0)
1511 {
1512 if (tls6_fd != -1)
1513 {
1514 if (spawned_tls6)
1515 {
1516 #ifdef HAVE_PTHREAD_CANCEL
1517 pthread_cancel (tls6_tid);
1518 #else
1519 pthread_kill (tls6_tid, SIGUSR2);
1520 #endif
1521 pthread_join (tls6_tid, NULL);
1522 }
1523
1524 shutdown (tls6_fd, SHUT_RDWR);
1525 close (tls6_fd);
1526 tls6_fd = -1;
1527 spawned_tls6 = 0;
1528 }
1529
1530 if (tls_fd != -1)
1531 {
1532 if (spawned_tls)
1533 {
1534 #ifdef HAVE_PTHREAD_CANCEL
1535 pthread_cancel (tls_tid);
1536 #else
1537 pthread_kill (tls_tid, SIGUSR2);
1538 #endif
1539 pthread_join (tls_tid, NULL);
1540 }
1541
1542 shutdown (tls_fd, SHUT_RDWR);
1543 close (tls_fd);
1544 tls_fd = -1;
1545 spawned_tls = 0;
1546 }
1547
1548 /* A client may still be connected. */
1549 if (!quit && x509_cred != NULL)
1550 tls_deinit_params ();
1551
1552 return 1;
1553 }
1554
1555 if ((ipv6 && tls6_fd != -1) || (!ipv6 && tls_fd != -1))
1556 return 1;
1557
1558 memset (&hints, 0, sizeof (hints));
1559 hints.ai_family = ipv6 ? AF_INET6 : AF_INET;
1560 hints.ai_socktype = SOCK_STREAM;
1561 hints.ai_flags = AI_PASSIVE;
1562 snprintf (buf, sizeof (buf), "%i", port);
1563
1564 if ((n = getaddrinfo (NULL, buf, &hints, &servinfo)) == -1)
1565 {
1566 log_write ("getaddrinfo(): %s", gai_strerror (n));
1567 return 0;
1568 }
1569
1570 for (n = 0, p = servinfo; p != NULL; p = p->ai_next)
1571 {
1572 int r = 1;
1573
1574 if ((ipv6 && p->ai_family != AF_INET6)
1575 || (!ipv6 && p->ai_family != AF_INET))
1576 continue;
1577
1578 if ((*fd = socket (p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
1579 {
1580 log_write ("socket(): %s", strerror (errno));
1581 continue;
1582 }
1583
1584 if (setsockopt (*fd, SOL_SOCKET, SO_REUSEADDR, &r, sizeof (int)) == -1)
1585 {
1586 log_write ("setsockopt(): %s",
1587 pwmd_strerror (gpg_error_from_syserror ()));
1588 freeaddrinfo (servinfo);
1589 goto fail;
1590 }
1591
1592 if (bind (*fd, p->ai_addr, p->ai_addrlen) == -1)
1593 {
1594 close (*fd);
1595 log_write ("bind(): %s",
1596 pwmd_strerror (gpg_error_from_syserror ()));
1597 continue;
1598 }
1599
1600 n++;
1601 break;
1602 }
1603
1604 freeaddrinfo (servinfo);
1605
1606 if (!n)
1607 goto fail;
1608
1609 #if HAVE_DECL_SO_BINDTODEVICE != 0
1610 char *tmp = config_get_string ("global", "tcp_interface");
1611 if (tmp && setsockopt (*fd, SOL_SOCKET, SO_BINDTODEVICE, tmp,
1612 strlen (tmp)) == -1)
1613 {
1614 log_write ("setsockopt(): %s",
1615 pwmd_strerror (gpg_error_from_syserror ()));
1616 xfree (tmp);
1617 goto fail;
1618 }
1619
1620 xfree (tmp);
1621 #endif
1622
1623 if (x509_cred == NULL)
1624 {
1625 rc = tls_init_params ();
1626 if (rc)
1627 goto fail;
1628 }
1629
1630 if (listen (*fd, 0) == -1)
1631 {
1632 log_write ("listen(): %s", strerror (errno));
1633 goto fail;
1634 }
1635
1636 if (ipv6)
1637 rc = create_thread (tcp_accept_thread, fd, &tls6_tid, 0);
1638 else
1639 rc = create_thread (tcp_accept_thread, fd, &tls_tid, 0);
1640
1641 if (rc)
1642 {
1643 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
1644 pwmd_strerror (rc));
1645 goto fail;
1646 }
1647
1648 if (ipv6)
1649 spawned_tls6 = 1;
1650 else
1651 spawned_tls = 1;
1652
1653 return 1;
1654
1655 fail:
1656 start_stop_tls_with_protocol (0, 1);
1657 if (tls_fd != -1)
1658 close (tls_fd);
1659
1660 if (tls6_fd != -1)
1661 close (tls6_fd);
1662
1663 tls_fd = -1;
1664 tls6_fd = -1;
1665 return 0;
1666 }
1667
1668 static int
1669 start_stop_tls (int term)
1670 {
1671 char *s = config_get_string ("global", "tcp_bind");
1672 int b;
1673
1674 if (!s)
1675 return 0;
1676
1677 if (!strcmp (s, "any"))
1678 {
1679 b = start_stop_tls_with_protocol (0, term);
1680 if (b)
1681 b = start_stop_tls_with_protocol (1, term);
1682 }
1683 else if (!strcmp (s, "ipv4"))
1684 b = start_stop_tls_with_protocol (0, term);
1685 else if (!strcmp (s, "ipv6"))
1686 b = start_stop_tls_with_protocol (1, term);
1687 else
1688 b = 0;
1689
1690 xfree (s);
1691 return b;
1692 }
1693 #endif
1694
1695 static void *
1696 accept_thread (void *arg)
1697 {
1698 int sockfd = *(int *) arg;
1699 #ifndef HAVE_PTHREAD_CANCEL
1700 int *n = xmalloc (sizeof (int));
1701
1702 *n = 0;
1703 pthread_setspecific (signal_thread_key, n);
1704 INIT_THREAD_SIGNAL;
1705 fcntl (sockfd, F_SETFL, O_NONBLOCK);
1706 #endif
1707
1708 #ifdef HAVE_PR_SET_NAME
1709 prctl (PR_SET_NAME, "accept");
1710 #endif
1711 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
1712
1713 for (;;)
1714 {
1715 socklen_t slen = sizeof (struct sockaddr_un);
1716 struct sockaddr_un raddr;
1717 int fd;
1718 #ifndef HAVE_PTHREAD_CANCEL
1719 struct timeval tv = { 0, ACCEPT_TIMEOUT };
1720 int *sigusr2 = (int *) pthread_getspecific (signal_thread_key);
1721
1722 if (*sigusr2)
1723 break;
1724 #endif
1725
1726 fd = accept (sockfd, (struct sockaddr *) &raddr, &slen);
1727 if (fd == -1)
1728 {
1729 if (errno == EMFILE || errno == ENFILE)
1730 log_write ("accept(): %s",
1731 pwmd_strerror (gpg_error_from_syserror ()));
1732 else if (errno != EAGAIN)
1733 {
1734 if (!quit) // probably EBADF
1735 log_write ("accept(): %s",
1736 pwmd_strerror (gpg_error_from_syserror ()));
1737
1738 break;
1739 }
1740
1741 #ifndef HAVE_PTHREAD_CANCEL
1742 select (0, NULL, NULL, NULL, &tv);
1743 #endif
1744 continue;
1745 }
1746
1747 (void) init_client (fd, NULL);
1748 }
1749
1750 /* Just in case accept() failed for some reason other than EBADF */
1751 quit = 1;
1752 return NULL;
1753 }
1754
1755 static void *
1756 cache_timer_thread (void *arg)
1757 {
1758 #ifndef HAVE_PTHREAD_CANCEL
1759 int *n = xmalloc (sizeof (int));
1760
1761 *n = 0;
1762 pthread_setspecific (signal_thread_key, n);
1763 INIT_THREAD_SIGNAL;
1764 #endif
1765
1766 #ifdef HAVE_PR_SET_NAME
1767 prctl (PR_SET_NAME, "cache timer");
1768 #endif
1769 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
1770
1771 for (;;)
1772 {
1773 struct timeval tv = { 1, 0 };
1774 #ifndef HAVE_PTHREAD_CANCEL
1775 int *n;
1776
1777 n = (int *) pthread_getspecific (signal_thread_key);
1778 if (*n)
1779 break;
1780 #endif
1781
1782 select (0, NULL, NULL, NULL, &tv);
1783 cache_adjust_timeout ();
1784 }
1785
1786 return NULL;
1787 }
1788
1789 static void
1790 catch_sigabrt (int sig)
1791 {
1792 cache_clear (NULL);
1793 #ifndef MEM_DEBUG
1794 xpanic ();
1795 #endif
1796 }
1797
1798 static int
1799 signal_loop (sigset_t sigset)
1800 {
1801 int done = 0;
1802 int siint = 0;
1803
1804 do
1805 {
1806 int sig;
1807
1808 sigwait (&sigset, &sig);
1809
1810 if (sig != SIGQUIT)
1811 log_write (_("caught signal %i (%s)"), sig, strsignal (sig));
1812
1813 switch (sig)
1814 {
1815 case SIGHUP:
1816 pthread_cond_signal (&rcfile_cond);
1817 break;
1818 case SIGABRT:
1819 // not really handled here.
1820 catch_sigabrt (SIGABRT);
1821 break;
1822 case SIGUSR1:
1823 log_write (_("clearing file cache"));
1824 cache_clear (NULL);
1825 send_status_all (STATUS_CACHE, NULL);
1826 break;
1827 case SIGQUIT:
1828 done = 1;
1829 break;
1830 default:
1831 siint = 1;
1832 done = 1;
1833 break;
1834 }
1835 }
1836 while (!done);
1837
1838 return siint;
1839 }
1840
1841 static void
1842 catchsig (int sig)
1843 {
1844 log_write ("Caught SIGSEGV. Exiting.");
1845 #ifdef HAVE_BACKTRACE
1846 BACKTRACE (__FUNCTION__);
1847 #endif
1848 longjmp (jmp, 1);
1849 }
1850
1851 static void *
1852 waiting_for_exit (void *arg)
1853 {
1854 int last = 0;
1855 #ifndef HAVE_PTHREAD_CANCEL
1856 int *n = xmalloc (sizeof (int));
1857
1858 *n = 0;
1859 pthread_setspecific (signal_thread_key, n);
1860 INIT_THREAD_SIGNAL;
1861 #endif
1862
1863 #ifdef HAVE_PR_SET_NAME
1864 prctl (PR_SET_NAME, "exiting");
1865 #endif
1866 pthread_setspecific (thread_name_key, str_dup (__FUNCTION__));
1867 log_write (_("waiting for all clients to disconnect"));
1868 MUTEX_LOCK (&quit_mutex);
1869 pthread_cleanup_push (cleanup_mutex_cb, &quit_mutex);
1870
1871 for (;;)
1872 {
1873 struct timespec ts;
1874 int n;
1875
1876 MUTEX_LOCK (&cn_mutex);
1877 n = slist_length (cn_thread_list);
1878 MUTEX_UNLOCK (&cn_mutex);
1879 if (!n)
1880 break;
1881
1882 #ifndef HAVE_PTHREAD_CANCEL
1883 int *s = (int *) pthread_getspecific (signal_thread_key);
1884 if (*s)
1885 break;
1886 #endif
1887
1888 if (last != n)
1889 {
1890 log_write (_("%i clients remain"), n);
1891 last = n;
1892 }
1893
1894 INIT_TIMESPEC (SIG_TIMEOUT, ts);
1895 pthread_cond_timedwait (&quit_cond, &quit_mutex, &ts);
1896 }
1897
1898 kill (getpid (), SIGQUIT);
1899 pthread_cleanup_pop (1);
1900 return NULL;
1901 }
1902
1903 static int
1904 server_loop (int sockfd, char **socketpath)
1905 {
1906 pthread_t accept_tid;
1907 pthread_t cache_timeout_tid;
1908 int cancel_timeout_thread = 0, cancel_accept_thread = 0;
1909 int cancel_keepalive_thread = 0;
1910 sigset_t sigset;
1911 int n;
1912 int segv = 0;
1913 gpg_error_t rc;
1914
1915 init_commands ();
1916 sigemptyset (&sigset);
1917
1918 /* Termination */
1919 sigaddset (&sigset, SIGTERM);
1920 sigaddset (&sigset, SIGINT);
1921
1922 /* Clears the file cache. */
1923 sigaddset (&sigset, SIGUSR1);
1924
1925 /* Configuration file reloading. */
1926 sigaddset (&sigset, SIGHUP);
1927
1928 /* For exiting cleanly. */
1929 sigaddset (&sigset, SIGQUIT);
1930
1931 #ifndef HAVE_PTHREAD_CANCEL
1932 /*
1933 The socket, cache and rcfile threads use this signal when
1934 pthread_cancel() is unavailable. Prevent the main thread from
1935 catching this signal from another process.
1936 */
1937 sigaddset (&sigset, SIGUSR2);
1938 #endif
1939
1940 /* Clears the cache and exits when something bad happens. */
1941 signal (SIGABRT, catch_sigabrt);
1942 sigaddset (&sigset, SIGABRT);
1943 sigprocmask (SIG_BLOCK, &sigset, NULL);
1944
1945 #ifndef HAVE_PTHREAD_CANCEL
1946 /* Remove this signal from the watched signals in signal_loop(). */
1947 sigdelset (&sigset, SIGUSR2);
1948 #endif
1949
1950 /* Ignored everywhere. When a client disconnects abnormally this signal
1951 * gets raised. It isn't needed though because client_thread() will check
1952 * for rcs even after the client disconnects. */
1953 signal (SIGPIPE, SIG_IGN);
1954
1955 /* Can show a backtrace of the stack in the log. */
1956 signal (SIGSEGV, catchsig);
1957
1958 #ifdef WITH_GNUTLS
1959 /* Needs to be done after the fork(). */
1960 if (!start_stop_tls (0))
1961 {
1962 segv = 1;
1963 goto done;
1964 }
1965 #endif
1966
1967 pthread_mutex_init (&quit_mutex, NULL);
1968 pthread_cond_init (&quit_cond, NULL);
1969 log_write (_("%s started for user %s"), PACKAGE_STRING, get_username ());
1970
1971 #ifdef WITH_GNUTLS
1972 if (config_get_boolean ("global", "enable_tcp"))
1973 log_write (_("Listening on %s and TCP port %i"), *socketpath,
1974 config_get_integer ("global", "tcp_port"));
1975 else
1976 log_write (_("Listening on %s"), *socketpath);
1977 #else
1978 log_write (_("Listening on %s"), *socketpath);
1979 #endif
1980
1981 rc = create_thread (keepalive_thread, NULL, &keepalive_tid, 0);
1982 if (rc)
1983 {
1984 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
1985 pwmd_strerror (rc));
1986 goto done;
1987 }
1988
1989 cancel_keepalive_thread = 1;
1990 rc = create_thread (reload_rcfile_thread, NULL, &rcfile_tid, 0);
1991 if (rc)
1992 {
1993 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
1994 pwmd_strerror (rc));
1995 goto done;
1996 }
1997
1998 rc = create_thread (cache_timer_thread, NULL, &cache_timeout_tid, 0);
1999 if (rc)
2000 {
2001 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
2002 pwmd_strerror (rc));
2003 goto done;
2004 }
2005
2006 cancel_timeout_thread = 1;
2007 rc = create_thread (accept_thread, &sockfd, &accept_tid, 0);
2008 if (rc)
2009 {
2010 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
2011 pwmd_strerror (rc));
2012 goto done;
2013 }
2014
2015 cancel_accept_thread = 1;
2016 if (!setjmp (jmp))
2017 signal_loop (sigset);
2018 else
2019 segv = 1;
2020
2021 done:
2022 /*
2023 * We're out of the main server loop. This happens when a signal was sent
2024 * to terminate the daemon. We'll wait for all clients to disconnect
2025 * before exiting but exit immediately if another termination signal is
2026 * sent.
2027 */
2028 if (cancel_accept_thread)
2029 {
2030 #ifdef HAVE_PTHREAD_CANCEL
2031 int n = pthread_cancel (accept_tid);
2032 #else
2033 int n = pthread_kill (accept_tid, SIGUSR2);
2034 #endif
2035 if (!n)
2036 pthread_join (accept_tid, NULL);
2037 }
2038
2039 #ifdef WITH_GNUTLS
2040 start_stop_tls (1);
2041 #endif
2042 shutdown (sockfd, SHUT_RDWR);
2043 close (sockfd);
2044 unlink (*socketpath);
2045 xfree (*socketpath);
2046 *socketpath = NULL;
2047 MUTEX_LOCK (&cn_mutex);
2048 n = slist_length (cn_thread_list);
2049 MUTEX_UNLOCK (&cn_mutex);
2050
2051 if (n && !segv)
2052 {
2053 pthread_t tid;
2054
2055 rc = create_thread (waiting_for_exit, NULL, &tid, 0);
2056 if (!rc)
2057 {
2058 if (signal_loop (sigset))
2059 {
2060 log_write (_("Received second termination request. Exiting."));
2061 #ifdef HAVE_PTHREAD_CANCEL
2062 pthread_cancel (tid);
2063 #else
2064 pthread_kill (tid, SIGUSR2);
2065 #endif
2066 pthread_join (tid, NULL);
2067 }
2068 }
2069 else
2070 log_write ("%s(%i): pthread_create(): %s", __FILE__, __LINE__,
2071 pwmd_strerror (rc));
2072 }
2073
2074 if (cancel_timeout_thread)
2075 {
2076 #ifdef HAVE_PTHREAD_CANCEL
2077 pthread_cancel (cache_timeout_tid);
2078 #else
2079 pthread_kill (cache_timeout_tid, SIGUSR2);
2080 #endif
2081 pthread_join (cache_timeout_tid, NULL);
2082 }
2083
2084 if (cancel_keepalive_thread)
2085 {
2086 #ifdef HAVE_PTHREAD_CANCEL
2087 pthread_cancel (keepalive_tid);
2088 #else
2089 pthread_kill (keepalive_tid, SIGUSR2);
2090 #endif
2091 pthread_join (keepalive_tid, NULL);
2092 }
2093
2094 cleanup_all_clients (0);
2095 #ifdef WITH_GNUTLS
2096 start_stop_tls (1);
2097 #endif
2098 deinit_commands ();
2099 pthread_cond_destroy (&quit_cond);
2100 pthread_mutex_destroy (&quit_mutex);
2101 return segv ? EXIT_FAILURE : EXIT_SUCCESS;;
2102 }
2103
2104 static void
2105 startup_failure ()
2106 {
2107 log_write (_
2108 ("Failed to add a file to the cache. Use --ignore to force startup. Exiting."));
2109 cache_clear (NULL);
2110 }
2111
2112 /* This is called from cache.c:clear_once(). See
2113 * command.c:clearcache_command() for details about lock checking.
2114 */
2115 static gpg_error_t
2116 free_cache_data (file_cache_t * cache)
2117 {
2118 gpg_error_t rc = GPG_ERR_NO_DATA;
2119 int i, t;
2120 struct client_thread_s *found = NULL;
2121 int self = 0;
2122
2123 if (!cache->data)
2124 return 0;
2125
2126 cache_lock ();
2127 MUTEX_LOCK (&cn_mutex);
2128 pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
2129 t = slist_length (cn_thread_list);
2130
2131 for (i = 0; i < t; i++)
2132 {
2133 struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
2134
2135 if (!thd->cl)
2136 continue;
2137
2138 if (!memcmp (thd->cl->md5file, cache->filename,
2139 sizeof (cache->filename)))
2140 {
2141 if (pthread_equal (pthread_self (), thd->tid))
2142 {
2143 found = thd;
2144 self = 1;
2145 continue;
2146 }
2147
2148 /* Continue trying to find a client who has the same file open and
2149 * also has a lock. */
2150 rc = cache_lock_mutex (thd->cl->ctx, thd->cl->md5file, -1, 0, -1);
2151 if (!rc)
2152 {
2153 self = 0;
2154 found = thd;
2155 break;
2156 }
2157 }
2158 }
2159
2160 if (self && (!rc || rc == GPG_ERR_NO_DATA))
2161 rc = cache_lock_mutex (found->cl->ctx, found->cl->md5file, -1, 0, -1);
2162
2163 if (exiting || !rc || rc == GPG_ERR_NO_DATA)
2164 {
2165 free_cache_data_once (cache->data);
2166 cache->data = NULL;
2167 cache->defer_clear = 0;
2168 cache->timeout = -1;
2169
2170 if (found)
2171 cache_unlock_mutex (found->cl->md5file, 0);
2172
2173 rc = 0;
2174 }
2175
2176 if (rc)
2177 cache->defer_clear = 1;
2178
2179 pthread_cleanup_pop (1);
2180 cache_unlock ();
2181 return rc;
2182 }
2183
2184 static int
2185 convert_v2_datafile (const char *filename, const char *cipher,
2186 const char *keyfile, const char *keygrip,
2187 const char *sign_keygrip, int nopass,
2188 const char *outfile, const char *keyparam,
2189 unsigned long s2k_count, uint64_t iterations)
2190 {
2191 gpg_error_t rc;
2192 void *data = NULL;
2193 size_t datalen;
2194 struct crypto_s *crypto = NULL;
2195 uint16_t ver;
2196 int algo;
2197 void *key = NULL;
2198 size_t keylen = 0;
2199
2200 if (outfile[0] == '-' && outfile[1] == 0)
2201 outfile = NULL;
2202
2203 log_write (_("Converting version 2 data file \"%s\" ..."), filename);
2204 if (access (filename, R_OK) == -1)
2205 {
2206 log_write ("%s: %s", filename,
2207 pwmd_strerror (gpg_error_from_syserror ()));
2208 return 0;
2209 }
2210
2211 if (keyfile)
2212 {
2213 log_write (_("Using passphrase file \"%s\" for decryption ..."),
2214 keyfile);
2215 if (access (keyfile, R_OK) == -1)
2216 {
2217 log_write ("%s: %s", keyfile,
2218 pwmd_strerror (gpg_error_from_syserror ()));
2219 return 0;
2220 }
2221 }
2222
2223 rc = read_v2_datafile (filename, keyfile, &data, &datalen, &ver, &algo);
2224 if (rc)
2225 {
2226 log_write ("ERR %i: %s", rc, pwmd_strerror (rc));
2227 return 0;
2228 }
2229
2230 if (cipher)
2231 {
2232 algo = cipher_string_to_gcrypt (cipher);
2233 if (algo == -1)
2234 {
2235 rc = GPG_ERR_CIPHER_ALGO;
2236 goto fail;
2237 }
2238 }
2239
2240 if (ver < 0x212)
2241 {
2242 xmlDocPtr doc = parse_doc (data, datalen);
2243
2244 if (!doc)
2245 {
2246 rc = GPG_ERR_BAD_DATA;
2247 goto fail;
2248 }
2249
2250 rc = convert_pre_212_elements (doc);
2251 gcry_free (data);
2252 data = NULL;
2253 if (!rc)
2254 {
2255 xmlDocDumpFormatMemory (doc, (xmlChar **) & data, (int *) &datalen,
2256 0);
2257 if (!data)
2258 rc = GPG_ERR_ENOMEM;
2259 }
2260
2261 xmlFreeDoc (doc);
2262 if (rc)
2263 goto fail;
2264 }
2265
2266 rc = init_client_crypto (&crypto);
2267 if (!rc)
2268 {
2269 memcpy (&crypto->save.hdr, &crypto->hdr, sizeof (file_header_t));
2270 crypto->save.hdr.flags = set_cipher_flag (crypto->save.hdr.flags, algo);
2271 crypto->save.s2k_count = s2k_count;
2272 crypto->save.hdr.iterations = iterations;
2273
2274 if (!use_agent)
2275 {
2276 rc = export_common (NULL, 0, crypto, data, datalen, outfile, keyfile,
2277 &key, &keylen, 0, 0);
2278 }
2279 #ifdef WITH_AGENT
2280 else
2281 {
2282 rc = agent_set_pinentry_options (crypto->agent);
2283 if (!rc)
2284 rc = agent_export_common (crypto, keygrip, sign_keygrip, nopass,
2285 data, datalen, outfile, keyparam,
2286 no_passphrase_file ? NULL : keyfile);
2287 }
2288 #endif
2289 if (!rc)
2290 log_write (_("Output written to \"%s\"."), outfile);
2291 }
2292
2293 fail:
2294 if (ver < 0x212)
2295 xmlFree (data);
2296 else
2297 gcry_free (data);
2298
2299 gcry_free (key);
2300 cleanup_crypto (&crypto);
2301
2302 if (rc)
2303 log_write ("ERR %i: %s", rc, pwmd_strerror (rc));
2304 return rc ? 0 : 1;
2305 }
2306
2307 static void
2308 usage (const char *pn, int status)
2309 {
2310 FILE *fp = status == EXIT_FAILURE ? stderr : stdout;
2311
2312 fprintf (fp, _("Usage: %s [OPTIONS] [file1] [...]\n"
2313 " -f, --rcfile=filename load the specfied configuration file\n"
2314 " (~/.pwmd/config)\n"
2315 " --homedir alternate pwmd home directory (~/.pwmd)\n"
2316 #ifdef WITH_AGENT
2317 " --use-agent enable use of gpg-agent\n"
2318 #endif
2319 " -n, --no-fork run as a foreground process\n"
2320 " -D, --disable-dump disable the LIST, XPATH and DUMP commands\n"
2321 " --ignore ignore file errors during startup\n"
2322 " --debug-level=keywords log protocol output (see manual for details)\n"
2323 " -o, --outfile=filename output file when importing or converting\n"
2324 " -C, --convert=filename convert a version 2 data file to version 3\n"
2325 " -I, --import=filename import a pwmd DTD formatted XML file)\n"
2326 " -k, --passphrase-file=file for use when importing or converting\n"
2327 " --no-passphrase-file prompt instead of using --passphrase-file when\n"
2328 " converting\n"
2329 " --no-passphrase when importing or converting\n"
2330 " --keygrip=hex public key to use when encrypting\n"
2331 " --sign-keygrip=hex private key to use when signing\n"
2332 " --keyparam=s-exp custom key parameters to use (RSA-2048)\n"
2333 " --cipher=string encryption cipher (aes256)\n"
2334 " --iterations=N cipher iteration count (N+1)\n"
2335 " --s2k-count=N hash iteration count (>65536, calibrated)\n"
2336 " --help this help text\n"
2337 " --version show version and compile time features\n"),
2338 pn);
2339 exit (status);
2340 }
2341
2342 int
2343 main (int argc, char *argv[])
2344 {
2345 int opt;
2346 struct sockaddr_un addr;
2347 char buf[PATH_MAX];
2348 char *socketpath = NULL, *socketdir, *socketname = NULL;
2349 char *socketarg = NULL;
2350 char *datadir = NULL;
2351 int x;
2352 char *p;
2353 char **cache_push = NULL;
2354 char *import = NULL, *keygrip = NULL, *sign_keygrip = NULL;
2355 char *keyparam = NULL;
2356 int estatus = EXIT_FAILURE;
2357 int sockfd;
2358 char *outfile = NULL;
2359 int do_unlink = 0;
2360 int secure = 0;
2361 int show_version = 0;
2362 int force = 0;
2363 int no_passphrase = 0;
2364 gpg_error_t rc;
2365 char *convertfile = NULL;
2366 char *cipher = NULL;
2367 char *keyfile = NULL;
2368 unsigned long s2k_count = 0;
2369 uint64_t iterations = 0;
2370 int exists;
2371 char *debug_level_opt = NULL;
2372 int optindex;
2373 /* Must maintain the same order as longopts[] */
2374 enum
2375 { OPT_VERSION, OPT_HELP, OPT_AGENT,
2376 OPT_DEBUG_LEVEL, OPT_HOMEDIR, OPT_NO_FORK, OPT_DISABLE_DUMP, OPT_IGNORE,
2377 OPT_RCFILE, OPT_CONVERT, OPT_PASSPHRASE_FILE, OPT_IMPORT, OPT_OUTFILE,
2378 OPT_NO_PASSPHRASE_FILE, OPT_KEYGRIP, OPT_SIGN_KEYGRIP, OPT_KEYPARAM,
2379 OPT_CIPHER, OPT_ITERATIONS, OPT_S2K_COUNT, OPT_NO_PASSPHRASE
2380 };
2381 const char *optstring = "nf:C:k:I:o:";
2382 const struct option longopts[] = {
2383 {"version", no_argument, 0, 0},
2384 {"help", no_argument, 0, 0},
2385 {"use-agent", no_argument, 0, 0},
2386 {"debug-level", required_argument, 0, 0},
2387 {"homedir", required_argument, 0, 0},
2388 {"no-fork", no_argument, 0, 'n'},
2389 {"disable_dump", no_argument, 0, 0},
2390 {"ignore", no_argument, 0, 0},
2391 {"rcfile", required_argument, 0, 'f'},
2392 {"convert", required_argument, 0, 'C'},
2393 {"passphrase-file", required_argument, 0, 'k'},
2394 {"import", required_argument, 0, 'I'},
2395 {"outfile", required_argument, 0, 'o'},
2396 {"no-passphrase-file", no_argument, 0, 0},
2397 {"keygrip", required_argument, 0, 0},
2398 {"sign-keygrip", required_argument, 0, 0},
2399 {"keyparam", required_argument, 0, 0},
2400 {"cipher", required_argument, 0, 0},
2401 {"cipher-iterations", required_argument, 0, 0},
2402 {"s2k-count", required_argument, 0, 0},
2403 {"no-passphrase", no_argument, 0, 0},
2404 {0, 0, 0, 0}
2405 };
2406
2407 #ifndef DEBUG
2408 #ifdef HAVE_SETRLIMIT
2409 struct rlimit rl;
2410
2411 rl.rlim_cur = rl.rlim_max = 0;
2412
2413 if (setrlimit (RLIMIT_CORE, &rl) != 0)
2414 err (EXIT_FAILURE, "setrlimit()");
2415 #endif
2416 #endif
2417
2418 #ifdef ENABLE_NLS
2419 setlocale (LC_ALL, "");
2420 bindtextdomain ("pwmd", LOCALEDIR);
2421 textdomain ("pwmd");
2422 #endif
2423
2424 #ifndef MEM_DEBUG
2425 xmem_init ();
2426 #endif
2427 gpg_err_init ();
2428
2429 if (setup_crypto ())
2430 exit (EXIT_FAILURE);
2431
2432 #ifdef WITH_GNUTLS
2433 gnutls_global_set_mem_functions (xmalloc, xmalloc, secure_mem_check,
2434 xrealloc, xfree);
2435 gnutls_global_init ();
2436 gnutls_global_set_log_function (tls_log);
2437 gnutls_global_set_log_level (1);
2438 tls_fd = -1;
2439 tls6_fd = -1;
2440 #endif
2441 xmlMemSetup (xfree, xmalloc, xrealloc, str_dup);
2442 xmlInitMemory ();
2443 xmlInitGlobals ();
2444 xmlInitParser ();
2445 xmlXPathInit ();
2446 cmdline = 1;
2447 #ifdef WITH_AGENT
2448 use_agent = 0;
2449 #endif
2450
2451 while ((opt = getopt_long (argc, argv, optstring, longopts, &optindex))
2452 != -1)
2453 {
2454 switch (opt)
2455 {
2456 case 'I':
2457 import = optarg;
2458 break;
2459 case 'C':
2460 convertfile = optarg;
2461 break;
2462 case 'k':
2463 keyfile = optarg;
2464 break;
2465 case 'o':
2466 outfile = optarg;
2467 break;
2468 case 'D':
2469 secure = 1;
2470 break;
2471 case 'n':
2472 nofork = 1;
2473 break;
2474 case 'f':
2475 rcfile = str_dup (optarg);
2476 break;
2477 default:
2478 usage (argv[0], EXIT_FAILURE);
2479 break;
2480 case 0:
2481 switch (optindex)
2482 {
2483 case OPT_VERSION:
2484 show_version = 1;
2485 break;
2486 case OPT_HELP:
2487 usage (argv[0], 0);
2488 break;
2489 case OPT_AGENT:
2490 use_agent = 1;
2491 break;
2492 case OPT_DEBUG_LEVEL:
2493 debug_level_opt = optarg;
2494 break;
2495 case OPT_HOMEDIR:
2496 homedir = str_dup (optarg);
2497 break;
2498 case OPT_NO_FORK:
2499 nofork = 1;
2500 break;
2501 case OPT_DISABLE_DUMP:
2502 secure = 1;
2503 break;
2504 case OPT_IGNORE:
2505 force = 1;
2506 break;
2507 case OPT_RCFILE:
2508 rcfile = str_dup (optarg);
2509 break;
2510 case OPT_CONVERT:
2511 convertfile = optarg;
2512 break;
2513 case OPT_PASSPHRASE_FILE:
2514 keyfile = optarg;
2515 break;
2516 case OPT_IMPORT:
2517 import = optarg;
2518 break;
2519 case OPT_OUTFILE:
2520 outfile = optarg;
2521 break;
2522 case OPT_NO_PASSPHRASE_FILE:
2523 no_passphrase_file = 1;
2524 break;
2525 case OPT_KEYGRIP:
2526 keygrip = optarg;
2527 break;
2528 case OPT_SIGN_KEYGRIP:
2529 sign_keygrip = optarg;
2530 break;
2531 case OPT_KEYPARAM:
2532 keyparam = optarg;
2533 break;
2534 case OPT_CIPHER:
2535 cipher = optarg;
2536 break;
2537 case OPT_ITERATIONS:
2538 iterations = strtoull (optarg, NULL, 10);
2539 break;
2540 case OPT_S2K_COUNT:
2541 s2k_count = strtoul (optarg, NULL, 10);
2542 break;
2543 case OPT_NO_PASSPHRASE:
2544 no_passphrase = 1;
2545 break;
2546 default:
2547 usage (argv[0], 1);
2548 }
2549 }
2550 }
2551
2552 if (show_version)
2553 {
2554 printf (_("%s\n\n"
2555 "Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013\n"
2556 "%s\n"
2557 "Released under the terms of the GPL v2. Use at your own risk.\n\n"
2558 "Compile time features:\n%s"), PACKAGE_STRING,
2559 PACKAGE_BUGREPORT,
2560 #ifdef PWMD_HOMEDIR
2561 "+PWMD_HOMEDIR=" PWMD_HOMEDIR "\n"
2562 #endif
2563 #ifdef WITH_AGENT
2564 "+WITH_AGENT\n"
2565 #else
2566 "-WITH_AGENT\n"
2567 #endif
2568 #ifdef WITH_QUALITY
2569 "+WITH_QUALITY\n"
2570 #else
2571 "-WITH_QUALITY\n"
2572 #endif
2573 #ifdef WITH_GNUTLS
2574 "+WITH_GNUTLS\n"
2575 #else
2576 "-WITH_GNUTLS\n"
2577 #endif
2578 #ifdef WITH_LIBACL
2579 "+WITH_LIBACL\n"
2580 #else
2581 "-WITH_LIBACL\n"
2582 #endif
2583 #ifdef DEBUG
2584 "+DEBUG\n"
2585 #else
2586 "-DEBUG\n"
2587 #endif
2588 #ifdef MEM_DEBUG
2589 "+MEM_DEBUG\n"
2590 #else
2591 "-MEM_DEBUG\n"
2592 #endif
2593 #ifdef MUTEX_DEBUG
2594 "+MUTEX_DEBUG\n"
2595 #else
2596 "-MUTEX_DEBUG\n"
2597 #endif
2598 );
2599 exit (EXIT_SUCCESS);
2600 }
2601
2602 if (!homedir)
2603 #ifdef PWMD_HOMEDIR
2604 homedir = str_dup(PWMD_HOMEDIR);
2605 #else
2606 homedir = str_asprintf ("%s/.pwmd", get_home_dir ());
2607 #endif
2608
2609 if (mkdir (homedir, 0700) == -1 && errno != EEXIST)
2610 err (EXIT_FAILURE, "%s", homedir);
2611
2612 snprintf (buf, sizeof (buf), "%s/data", homedir);
2613 if (mkdir (buf, 0700) == -1 && errno != EEXIST)
2614 err (EXIT_FAILURE, "%s", buf);
2615
2616 datadir = str_dup (buf);
2617 pthread_mutexattr_t attr;
2618 pthread_mutexattr_init (&attr);
2619 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
2620 pthread_mutex_init (&rcfile_mutex, &attr);
2621 pthread_cond_init (&rcfile_cond, NULL);
2622 pthread_mutex_init (&cn_mutex, &attr);
2623 pthread_mutexattr_destroy (&attr);
2624 pthread_key_create (&last_error_key, free_key);
2625 #ifndef HAVE_PTHREAD_CANCEL
2626 pthread_key_create (&signal_thread_key, free_key);
2627 #endif
2628
2629 if (!rcfile)
2630 rcfile = str_asprintf ("%s/config", homedir);
2631
2632 global_config = config_parse (rcfile);
2633 if (!global_config)
2634 exit (EXIT_FAILURE);
2635
2636 if (!use_agent)
2637 use_agent = config_get_boolean ("global", "use_agent");
2638
2639 setup_logging ();
2640
2641 if (debug_level_opt)
2642 debug_level = str_split (debug_level_opt, ",", 0);
2643
2644 x = config_get_int_param (global_config, "global", "priority", &exists);
2645 if (exists && x != atoi(INVALID_PRIORITY))
2646 {
2647 errno = 0;
2648 if (setpriority (PRIO_PROCESS, 0, x) == -1)
2649 {
2650 log_write ("setpriority(): %s",
2651 pwmd_strerror (gpg_error_from_syserror ()));
2652 goto do_exit;
2653 }
2654 }
2655 #ifdef HAVE_MLOCKALL
2656 if (disable_mlock == 0 && mlockall (MCL_CURRENT | MCL_FUTURE) == -1)
2657 {
2658 log_write ("mlockall(): %s",
2659 pwmd_strerror (gpg_error_from_syserror ()));
2660 goto do_exit;
2661 }
2662 #endif
2663
2664 rc = cache_init (free_cache_data);
2665 if (rc)
2666 {
2667 log_write ("pwmd: ERR %i: %s", rc,
2668 gpg_err_code (rc) == GPG_ERR_UNKNOWN_VERSION
2669 ? _("incompatible version: 2.1.0 or later required")
2670 : pwmd_strerror (rc));
2671 goto do_exit;
2672 }
2673
2674 if (s2k_count == 0)
2675 s2k_count = config_get_ulong (NULL, "s2k_count");
2676
2677 if (convertfile)
2678 {
2679 if (!outfile)
2680 usage (argv[0], EXIT_FAILURE);
2681
2682 estatus = convert_v2_datafile (convertfile, cipher, keyfile, keygrip,
2683 sign_keygrip, no_passphrase, outfile,
2684 keyparam, s2k_count, iterations);
2685 config_free (global_config);
2686 xfree (rcfile);
2687 exit (!estatus);
2688 }
2689
2690 if (import)
2691 {
2692 if (!outfile || !*outfile)
2693 usage (argv[0], EXIT_FAILURE);
2694
2695 if (outfile && outfile[0] == '-' && outfile[1] == 0)
2696 outfile = NULL;
2697
2698 estatus = xml_import (import, outfile, keygrip, sign_keygrip, keyfile,
2699 no_passphrase, cipher, keyparam, s2k_count,
2700 iterations);
2701 config_free (global_config);
2702 xfree (rcfile);
2703 exit (!estatus);
2704 }
2705
2706 p = config_get_string ("global", "socket_path");
2707 if (!p)
2708 p = str_asprintf ("%s/socket", homedir);
2709
2710 socketarg = expand_homedir (p);
2711 xfree (p);
2712
2713 if (!secure)
2714 disable_list_and_dump = config_get_boolean ("global",
2715 "disable_list_and_dump");
2716 else
2717 disable_list_and_dump = secure;
2718
2719 cache_push = config_get_list ("global", "cache_push");
2720
2721 while (optind < argc)
2722 {
2723 if (strv_printf (&cache_push, "%s", argv[optind++]) == 0)
2724 errx (EXIT_FAILURE, "%s", pwmd_strerror (GPG_ERR_ENOMEM));
2725 }
2726
2727 if (strchr (socketarg, '/') == NULL)
2728 {
2729 socketdir = getcwd (buf, sizeof (buf));
2730 socketname = str_dup (socketarg);
2731 socketpath = str_asprintf ("%s/%s", socketdir, socketname);
2732 }
2733 else
2734 {
2735 socketname = str_dup (strrchr (socketarg, '/'));
2736 socketname++;
2737 socketarg[strlen (socketarg) - strlen (socketname) - 1] = 0;
2738 socketdir = str_dup (socketarg);
2739 socketpath = str_asprintf ("%s/%s", socketdir, socketname);
2740 }
2741
2742 if (chdir (datadir))
2743 {
2744 log_write ("%s: %s", datadir,
2745 pwmd_strerror (gpg_error_from_syserror ()));
2746 unlink (socketpath);
2747 goto do_exit;
2748 }
2749
2750 /*
2751 * Set the cache entry for a file. Prompts for the password.
2752 */
2753 if (cache_push)
2754 {
2755 struct crypto_s *crypto = NULL;
2756 gpg_error_t rc = init_client_crypto (&crypto);
2757
2758 if (rc)
2759 {
2760 estatus = EXIT_FAILURE;
2761 goto do_exit;
2762 }
2763
2764 #ifdef WITH_AGENT
2765 if (use_agent)
2766 {
2767 rc = agent_set_pinentry_options (crypto->agent);
2768 if (rc)
2769 {
2770 estatus = EXIT_FAILURE;
2771 goto do_exit;
2772 }
2773 }
2774 #endif
2775
2776 for (opt = 0; cache_push[opt]; opt++)
2777 {
2778 if (!do_cache_push (cache_push[opt], crypto) && !force)
2779 {
2780 strv_free (cache_push);
2781 startup_failure ();
2782 estatus = EXIT_FAILURE;
2783 cleanup_crypto (&crypto);
2784 goto do_exit;
2785 }
2786
2787 cleanup_crypto_stage1 (crypto);
2788 }
2789
2790 #ifdef WITH_AGENT
2791 if (use_agent)
2792 (void) kill_scd (crypto->agent);
2793 #endif
2794
2795 cleanup_crypto (&crypto);
2796 strv_free (cache_push);
2797 log_write (!nofork ? _("Done. Daemonizing...") :
2798 _("Done. Waiting for connections..."));
2799 }
2800
2801 config_clear_keys ();
2802
2803 /*
2804 * bind() doesn't like the full pathname of the socket or any non alphanum
2805 * characters so change to the directory where the socket is wanted then
2806 * create it then change to datadir.
2807 */
2808 if (chdir (socketdir))
2809 {
2810 log_write ("%s: %s", socketdir,
2811 pwmd_strerror (gpg_error_from_syserror ()));
2812 goto do_exit;
2813 }
2814
2815 xfree (socketdir);
2816
2817 if ((sockfd = socket (PF_UNIX, SOCK_STREAM, 0)) == -1)
2818 {
2819 log_write ("socket(): %s", pwmd_strerror (gpg_error_from_syserror ()));
2820 goto do_exit;
2821 }
2822
2823 addr.sun_family = AF_UNIX;
2824 snprintf (addr.sun_path, sizeof (addr.sun_path), "%s", socketname);
2825 do_unlink = 1;
2826 if (bind (sockfd, (struct sockaddr *) &addr, sizeof (struct sockaddr)) ==
2827 -1)
2828 {
2829 log_write ("bind(): %s", pwmd_strerror (gpg_error_from_syserror ()));
2830
2831 if (errno == EADDRINUSE)
2832 {
2833 do_unlink = 0;
2834 log_write (_("Either there is another pwmd running or '%s' is a \n"
2835 "stale socket. Please remove it manually."), socketpath);
2836 }
2837
2838 goto do_exit;
2839 }
2840
2841 {
2842 char *t = config_get_string ("global", "socket_perms");
2843 mode_t mode;
2844 mode_t mask;
2845
2846 if (t)
2847 {
2848 mode = strtol (t, NULL, 8);
2849 mask = umask (0);
2850 xfree (t);
2851
2852 if (chmod (socketname, mode) == -1)
2853 {
2854 log_write ("%s: %s", socketname,
2855 pwmd_strerror (gpg_error_from_syserror ()));
2856 close (sockfd);
2857 umask (mask);
2858 goto do_exit;
2859 }
2860
2861 umask (mask);
2862 }
2863 }
2864
2865 xfree (--socketname);
2866
2867 if (chdir (datadir))
2868 {
2869 log_write ("%s: %s", datadir,
2870 pwmd_strerror (gpg_error_from_syserror ()));
2871 close (sockfd);
2872 goto do_exit;
2873 }
2874
2875 xfree (datadir);
2876
2877 if (listen (sockfd, 0) == -1)
2878 {
2879 log_write ("listen(): %s", pwmd_strerror (gpg_error_from_syserror ()));
2880 goto do_exit;
2881 }
2882
2883 cmdline = 0;
2884
2885 if (!nofork)
2886 {
2887 switch (fork ())
2888 {
2889 case -1:
2890 log_write ("fork(): %s",
2891 pwmd_strerror (gpg_error_from_syserror ()));
2892 goto do_exit;
2893 case 0:
2894 close (0);
2895 close (1);
2896 close (2);
2897 setsid ();
2898 break;
2899 default:
2900 _exit (EXIT_SUCCESS);
2901 }
2902 }
2903
2904 pthread_key_create (&thread_name_key, free_key);
2905 pthread_setspecific (thread_name_key, str_dup ("main"));
2906 estatus = server_loop (sockfd, &socketpath);
2907
2908 do_exit:
2909 if (socketpath && do_unlink)
2910 {
2911 unlink (socketpath);
2912 xfree (socketpath);
2913 }
2914
2915 xfree (socketarg);
2916 #ifdef WITH_GNUTLS
2917 gnutls_global_deinit ();
2918 #endif
2919 if (rcfile_tid)
2920 {
2921 #ifdef HAVE_PTHREAD_CANCEL
2922 pthread_cancel (rcfile_tid);
2923 #else
2924 pthread_kill (rcfile_tid, SIGUSR2);
2925 pthread_cond_signal (&rcfile_cond);
2926 #endif
2927 pthread_join (rcfile_tid, NULL);
2928 }
2929
2930 pthread_cond_destroy (&rcfile_cond);
2931 pthread_mutex_destroy (&rcfile_mutex);
2932 pthread_key_delete (last_error_key);
2933 #ifndef HAVE_PTHREAD_CANCEL
2934 pthread_key_delete (signal_thread_key);
2935 #endif
2936
2937 if (global_config)
2938 config_free (global_config);
2939
2940 xfree (rcfile);
2941 xfree (home_directory);
2942 xfree (homedir);
2943 xmlCleanupParser ();
2944 xmlCleanupGlobals ();
2945
2946 if (estatus == EXIT_SUCCESS)
2947 log_write (_("pwmd exiting normally"));
2948
2949 pthread_key_delete (thread_name_key);
2950 closelog ();
2951 #if defined(DEBUG) && !defined(MEM_DEBUG)
2952 xdump ();
2953 #endif
2954 exit (estatus);
2955 }
A server for managing passphrases and anything else.