2 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014
3 Ben Kibbey <bjk@luxsci.net>
5 This file is part of pwmd.
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.
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.
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/>.
30 #include <sys/socket.h>
44 #include <netinet/in.h>
45 #include <arpa/inet.h>
48 #include <sys/resource.h>
62 #ifdef HAVE_GETOPT_LONG
67 #include "getopt_long.h"
70 #ifdef HAVE_PR_SET_NAME
71 #include <sys/prctl.h>
74 #include "pwmd-error.h"
77 #include "util-misc.h"
83 #include "util-string.h"
90 /* In tenths of a second. */
93 /* For (tcp_)accept_thread (usec). */
94 #define ACCEPT_TIMEOUT 30000
101 static pthread_cond_t quit_cond
;
102 static pthread_mutex_t quit_mutex
;
103 static int no_passphrase_file
= 0;
104 static pthread_t keepalive_tid
;
107 #ifndef HAVE_PTHREAD_CANCEL
108 static pthread_key_t signal_thread_key
;
114 static pthread_t tls_tid
;
115 static pthread_t tls6_tid
;
116 static int spawned_tls
;
117 static int spawned_tls6
;
119 static int start_stop_tls (int term
);
122 static int do_cache_push (const char *filename
, struct crypto_s
*crypto
);
123 static int signal_loop (sigset_t sigset
);
125 GCRY_THREAD_OPTION_PTHREAD_IMPL
;
127 #ifndef HAVE_PTHREAD_CANCEL
128 #define INIT_THREAD_SIGNAL do { \
129 struct sigaction act; \
131 sigemptyset (&sigset); \
132 sigaddset (&sigset, SIGUSR2); \
133 pthread_sigmask (SIG_UNBLOCK, &sigset, NULL); \
134 memset (&act, 0, sizeof(act)); \
135 act.sa_flags = SA_SIGINFO; \
136 act.sa_mask = sigset; \
137 act.sa_sigaction = catch_thread_signal; \
138 sigaction (SIGUSR2, &act, NULL); \
142 catch_thread_signal (int sig
, siginfo_t
*info
, void *ctx
)
144 int *n
= (int *) pthread_getspecific (signal_thread_key
);
147 pthread_setspecific (signal_thread_key
, n
);
152 cache_push_from_rcfile ()
154 struct crypto_s
*crypto
= NULL
;
156 gpg_error_t rc
= init_client_crypto (&crypto
);
160 log_write ("%s: %s", __FUNCTION__
, pwmd_strerror (rc
));
167 rc
= set_agent_option (crypto
->agent
, "pinentry-mode", "error");
170 log_write ("%s: %s", __FUNCTION__
, pwmd_strerror (rc
));
176 cache_push
= config_get_list ("global", "cache_push");
181 for (p
= cache_push
; *p
; p
++)
183 (void) do_cache_push (*p
, crypto
);
184 cleanup_crypto_stage1 (crypto
);
187 strv_free (cache_push
);
191 (void) kill_scd (crypto
->agent
);
193 cleanup_crypto (&crypto
);
199 int n
= config_get_boolean ("global", "enable_logging");
203 char *p
= config_get_string ("global", "log_path");
205 if (!p
|| (logfile
&& p
&& log_fd
!= -1 && strcmp(p
, logfile
)))
214 logfile
= expand_homedir (p
);
227 log_syslog
= config_get_boolean ("global", "syslog");
229 openlog ("pwmd", LOG_NDELAY
| LOG_PID
, LOG_DAEMON
);
233 reload_rcfile_thread (void *arg
)
235 #ifndef HAVE_PTHREAD_CANCEL
236 int *n
= xmalloc (sizeof (int));
239 pthread_setspecific (signal_thread_key
, n
);
243 #ifdef HAVE_PR_SET_NAME
244 prctl (PR_SET_NAME
, "reload rcfile");
246 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
247 MUTEX_LOCK (&rcfile_mutex
);
248 pthread_cleanup_push (cleanup_mutex_cb
, &rcfile_mutex
);
252 struct allowed_users_s
257 struct slist_s
*allowed_users
= NULL
;
258 struct slist_s
*config
;
259 int b
= disable_list_and_dump
;
260 uid_t invoking_uid_orig
= invoking_uid
;
261 gid_t invoking_gid_orig
= invoking_gid
;
262 char *invoking_tls_orig
;
264 int require_save_key
= config_get_bool_param (global_config
, "global",
268 int tcp_require_key
= config_get_bool_param (global_config
, "global",
273 pthread_cond_wait (&rcfile_cond
, &rcfile_mutex
);
274 #ifndef HAVE_PTHREAD_CANCEL
275 int *cancel
= (int *) pthread_getspecific (signal_thread_key
);
280 /* Keep the "allowed" parameter across rcfile reloads to prevent
282 int n
, t
= slist_length (global_config
);
283 for (n
= 0; n
< t
; n
++)
285 struct config_section_s
*section
;
288 section
= slist_nth_data (global_config
, n
);
289 users
= config_get_list_param (global_config
, section
->name
,
293 struct allowed_users_s
*allowed
;
295 allowed
= xmalloc (sizeof(struct allowed_users_s
));
296 allowed
->section
= str_dup (section
->name
);
297 allowed
->users
= users
;
298 allowed_users
= slist_append (allowed_users
, allowed
);
302 invoking_tls_orig
= invoking_tls
? str_dup (invoking_tls
) : NULL
;
303 xfree (invoking_tls
);
305 log_write (_("reloading configuration file '%s'"), rcfile
);
307 config
= config_parse (rcfile
);
310 config_free (global_config
);
311 global_config
= config
;
313 cache_push_from_rcfile ();
314 config_clear_keys ();
317 xfree (invoking_tls
);
318 invoking_tls
= invoking_tls_orig
;
319 invoking_uid
= invoking_uid_orig
;
320 invoking_gid
= invoking_gid_orig
;
321 disable_list_and_dump
= !disable_list_and_dump
? b
: 1;
322 config_set_bool_param (&global_config
, "global", "require_save_key",
323 require_save_key
? "true" : "false");
325 if (config_get_bool_param (global_config
, "global", "tcp_require_key",
329 config_set_bool_param (&global_config
, "global", "tcp_require_key",
330 tcp_require_key
? "true" : "false");
335 int n
, t
= slist_length (allowed_users
);
337 for (n
= 0; n
< t
; n
++)
339 struct allowed_users_s
*allowed
;
342 allowed
= slist_nth_data (allowed_users
, n
);
343 tmp
= strv_join (",", allowed
->users
);
344 config_set_list_param (&global_config
, allowed
->section
,
347 xfree (allowed
->section
);
348 strv_free (allowed
->users
);
352 slist_free (allowed_users
);
356 /* Kill existing listening threads since the configured listening
357 * protocols may have changed. */
363 pthread_cleanup_pop (1);
368 send_error (assuan_context_t ctx
, gpg_error_t e
)
370 struct client_s
*client
= assuan_get_pointer (ctx
);
372 if (gpg_err_source (e
) == GPG_ERR_SOURCE_UNKNOWN
)
379 return assuan_process_done (ctx
, 0);
383 log_write ("ERR %i: %s", e
, pwmd_strerror (e
));
387 if (client
&& client
->xml_error
)
389 log_write ("%s", client
->xml_error
->message
);
390 xfree (client
->last_error
);
391 client
->last_error
= NULL
;
392 if (client
->xml_error
->message
)
393 client
->last_error
= str_dup (client
->xml_error
->message
);
395 e
= assuan_process_done (ctx
,
396 assuan_set_error (ctx
, e
,
397 client
->xml_error
->message
? client
->xml_error
->message
: NULL
));
398 xmlResetLastError ();
399 xmlResetError (client
->xml_error
);
400 xfree (client
->xml_error
);
401 client
->xml_error
= NULL
;
405 return assuan_process_done (ctx
,
406 assuan_set_error (ctx
, e
, pwmd_strerror (e
)));
410 assuan_log_cb (assuan_context_t ctx
, void *data
, unsigned cat
,
413 static pthread_mutex_t m
= PTHREAD_MUTEX_INITIALIZER
;
417 pthread_mutex_lock (&m
);
418 pthread_cleanup_push ((void (*)(void *)) pthread_mutex_unlock
, &m
);
419 t
= strv_length (debug_level
);
421 for (i
= 0; i
< t
; i
++)
423 if (!strcasecmp (debug_level
[i
], (char *) "init")
424 && cat
== ASSUAN_LOG_INIT
)
430 if (!strcasecmp (debug_level
[i
], (char *) "ctx")
431 && cat
== ASSUAN_LOG_CTX
)
437 if (!strcasecmp (debug_level
[i
], (char *) "engine")
438 && cat
== ASSUAN_LOG_ENGINE
)
444 if (!strcasecmp (debug_level
[i
], (char *) "data")
445 && cat
== ASSUAN_LOG_DATA
)
451 if (!strcasecmp (debug_level
[i
], (char *) "sysio")
452 && cat
== ASSUAN_LOG_SYSIO
)
458 if (!strcasecmp (debug_level
[i
], (char *) "control")
459 && cat
== ASSUAN_LOG_CONTROL
)
473 open (logfile
, O_WRONLY
| O_CREAT
| O_APPEND
, 0600)) == -1)
474 warn ("%s", logfile
);
477 pthread_cleanup_push (cleanup_fd_cb
, &fd
);
478 write (fd
, msg
, strlen (msg
));
479 pthread_cleanup_pop (1);
485 fprintf (stderr
, "%s%s", data
? (char *) data
: "", msg
);
490 pthread_cleanup_pop (1);
495 log_write (const char *fmt
, ...)
501 pthread_t tid
= pthread_self ();
502 static pthread_mutex_t m
= PTHREAD_MUTEX_INITIALIZER
;
504 if ((!logfile
&& !isatty (STDERR_FILENO
) && !log_syslog
) || !fmt
)
507 pthread_mutex_lock (&m
);
508 pthread_cleanup_push ((void (*)(void *)) pthread_mutex_unlock
, &m
);
510 if (!cmdline
&& logfile
&& log_fd
== -1)
512 log_fd
= open (logfile
, O_WRONLY
| O_CREAT
| O_APPEND
, 0600);
514 warn ("%s", logfile
);
519 if (str_vasprintf (&args
, fmt
, ap
) != -1)
523 pthread_cleanup_push (xfree
, args
);
524 fprintf (stderr
, "pwmd: %s\n", args
);
526 pthread_cleanup_pop (1);
530 char *name
= pthread_getspecific (thread_name_key
);
533 pthread_cleanup_push (xfree
, args
);
534 snprintf (buf
, sizeof (buf
), "%s(%p): ", name
? name
: _("unknown"),
538 if (!cmdline
&& log_syslog
&& !nofork
)
539 syslog (LOG_INFO
, "%s%s", name
, args
);
542 struct tm
*tm
= localtime (&now
);
544 strftime (tbuf
, sizeof (tbuf
), "%b %d %Y %H:%M:%S ", tm
);
545 tbuf
[sizeof (tbuf
) - 1] = 0;
547 if (args
[strlen (args
) - 1] == '\n')
548 args
[strlen (args
) - 1] = 0;
550 line
= str_asprintf ("%s %i %s%s\n", tbuf
, getpid (), name
,
552 pthread_cleanup_pop (1);
555 pthread_cleanup_push (xfree
, line
);
556 if (logfile
&& log_fd
!= -1)
558 write (log_fd
, line
, strlen (line
));
564 fprintf (stdout
, "%s", line
);
568 pthread_cleanup_pop (1);
574 pthread_cleanup_pop (0);
576 if (log_fd
!= -1 && config_get_boolean (NULL
, "log_keepopen") <= 0)
582 pthread_mutex_unlock (&m
);
587 secure_mem_check (const void *arg
)
596 gcry_control (GCRYCTL_SET_THREAD_CBS
, &gcry_threads_pthread
);
598 if (!gcry_check_version (GCRYPT_VERSION
))
600 fprintf (stderr
, _("gcry_check_version(): Incompatible libgcrypt. "
601 "Wanted %s, got %s.\n"), GCRYPT_VERSION
,
602 gcry_check_version (NULL
));
603 return GPG_ERR_UNKNOWN_VERSION
;
606 gcry_set_allocation_handler (xmalloc
, xmalloc
, NULL
, xrealloc
, xfree
);
611 do_validate_peer (assuan_context_t ctx
, const char *section
,
612 assuan_peercred_t
* peer
)
617 struct client_s
*client
= assuan_get_pointer (ctx
);
620 if (client
&& client
->thd
->remote
)
621 return tls_validate_access (client
, section
);
624 rc
= assuan_get_peercred (ctx
, peer
);
628 users
= config_get_list (section
, "allowed");
631 for (char **p
= users
; *p
; p
++)
633 rc
= acl_check_common(client
, *p
, (*peer
)->uid
, (*peer
)->gid
,
640 return allowed
? 0 : rc
? rc
: GPG_ERR_EACCES
;
644 peer_is_invoker(struct client_s
*client
)
647 if (client
->thd
->remote
)
649 char *p
= invoking_tls
;
651 if (!p
|| !*p
|| *p
++ != '#')
652 return GPG_ERR_EACCES
;
654 if (!strcmp(client
->thd
->tls
->fp
, p
))
657 return GPG_ERR_EACCES
;
661 if (client
->thd
->peer
->uid
== invoking_uid
)
664 return GPG_ERR_EACCES
;
667 #ifdef HAVE_GETGRNAM_R
669 acl_check_common (struct client_s
*client
, const char *user
, uid_t uid
,
670 gid_t gid
, int *allowed
)
672 struct passwd pw
, *result
;
681 if (*user
== '-' || *user
== '!')
684 if (*user
== '+') // not implemented yet
687 if (*user
== '#') // TLS fingerprint hash
690 if (not || rw
|| tls
)
696 if (client
->thd
->remote
)
698 if (!strcasecmp (client
->thd
->tls
->fp
, user
))
708 else if (client
->thd
->remote
) // Remote client with no TLS in the ACL
712 if (*user
== '@') // all users in group
714 struct group gr
, *gresult
;
715 size_t len
= sysconf (_SC_GETGR_R_SIZE_MAX
);
722 return GPG_ERR_ENOMEM
;
725 if (!getgrnam_r (user
, &gr
, buf
, len
, &gresult
) && gresult
)
727 if (gresult
->gr_gid
== gid
)
734 len
= sysconf (_SC_GETPW_R_SIZE_MAX
);
738 char *tbuf
= xmalloc (len
);
739 for (char **t
= gresult
->gr_mem
; *t
; t
++)
741 if (!getpwnam_r (*t
, &pw
, tbuf
, len
, &result
) && result
)
743 if (result
->pw_uid
== uid
)
756 size_t len
= sysconf (_SC_GETPW_R_SIZE_MAX
);
763 return GPG_ERR_ENOMEM
;
765 if (!getpwnam_r (user
, &pw
, buf
, len
, &result
) && result
)
767 if (result
->pw_uid
== uid
)
778 acl_check_common (struct client_s
*client
, const char *user
, uid_t uid
,
779 gid_t gid
, int *allowed
)
781 struct passwd
*result
;
789 if (*user
== '-' || *user
== '!')
792 if (*user
== '+') // not implemented yet
795 if (*user
== '#') // TLS fingerprint hash
798 if (not || rw
|| tls
)
804 if (client
->thd
->remote
)
806 if (!strcasecmp (client
->thd
->tls
->fp
, user
))
816 if (*user
== '@') // all users in group
818 struct group
*gresult
;
821 gresult
= getgrnam (user
);
822 if (gresult
&& gresult
->gr_gid
== gid
)
828 for (char **t
= gresult
->gr_mem
; *t
; t
++)
830 result
= getpwnam (*t
);
831 if (result
&& result
->pw_uid
== uid
)
842 result
= getpwnam (user
);
843 if (result
&& result
->pw_uid
== uid
)
852 validate_peer (struct client_s
*cl
)
858 return tls_validate_access (cl
, NULL
);
861 rc
= do_validate_peer (cl
->ctx
, "global", &cl
->thd
->peer
);
862 if (!rc
|| gpg_err_code (rc
) == GPG_ERR_EACCES
)
863 log_write ("peer %s: uid=%i, gid=%i, pid=%i",
864 !rc
? _("accepted") : _("rejected"), cl
->thd
->peer
->uid
,
865 cl
->thd
->peer
->gid
, cl
->thd
->peer
->pid
);
867 log_write ("%s: %s", __FUNCTION__
, pwmd_strerror (rc
));
873 xml_error_cb (void *data
, xmlErrorPtr e
)
875 struct client_s
*client
= data
;
878 * Keep the first reported error as the one to show in the error
879 * description. Reset in send_error().
881 if (client
->xml_error
)
884 client
->xml_error
= xcalloc (1, sizeof(xmlError
));
885 xmlCopyError (e
, client
->xml_error
);
889 hook_waitpid (assuan_context_t ctx
, pid_t pid
, int action
,
890 int *status
, int options
)
892 return waitpid (pid
, status
, options
);
896 hook_read (assuan_context_t ctx
, assuan_fd_t fd
, void *data
, size_t len
)
899 struct client_s
*client
= assuan_get_pointer (ctx
);
901 if (client
->thd
->remote
)
902 return tls_read_hook (ctx
, (int) fd
, data
, len
);
905 return read ((int) fd
, data
, len
);
909 hook_write (assuan_context_t ctx
, assuan_fd_t fd
,
910 const void *data
, size_t len
)
913 struct client_s
*client
= assuan_get_pointer (ctx
);
915 if (client
->thd
->remote
)
916 return tls_write_hook (ctx
, (int) fd
, data
, len
);
919 return write ((int) fd
, data
, len
);
923 new_connection (struct client_s
*cl
)
926 static struct assuan_malloc_hooks mhooks
= { xmalloc
, xrealloc
, xfree
};
927 static struct assuan_system_hooks shooks
= {
928 ASSUAN_SYSTEM_HOOKS_VERSION
,
936 NULL
, //sendmsg both are used for FD passing
947 char *prio
= config_get_string ("global", "tls_cipher_suite");
949 cl
->thd
->timeout
= config_get_integer ("global", "tls_timeout");
950 fcntl (cl
->thd
->fd
, F_SETFL
, O_NONBLOCK
);
951 cl
->thd
->tls
= tls_init (cl
->thd
->fd
, cl
->thd
->timeout
, prio
);
958 rc
= assuan_new_ext (&cl
->ctx
, GPG_ERR_SOURCE_DEFAULT
, &mhooks
,
959 debug_level
? assuan_log_cb
: NULL
, NULL
);
963 assuan_ctx_set_system_hooks (cl
->ctx
, &shooks
);
964 rc
= assuan_init_socket_server (cl
->ctx
, cl
->thd
->fd
, 2);
968 assuan_set_pointer (cl
->ctx
, cl
);
969 assuan_set_hello_line (cl
->ctx
, PACKAGE_STRING
);
970 rc
= register_commands (cl
->ctx
);
974 rc
= assuan_accept (cl
->ctx
);
978 rc
= validate_peer (cl
);
979 /* May not be implemented on all platforms. */
980 if (rc
&& gpg_err_code (rc
) != GPG_ERR_ASS_GENERAL
)
983 rc
= init_client_crypto (&cl
->crypto
);
989 cl
->crypto
->agent
->client_ctx
= cl
->ctx
;
992 cl
->crypto
->client_ctx
= cl
->ctx
;
993 xmlSetStructuredErrorFunc (cl
, xml_error_cb
);
997 log_write ("%s", pwmd_strerror (rc
));
1002 * This is called after a client_thread() terminates. Set with
1003 * pthread_cleanup_push().
1006 cleanup_cb (void *arg
)
1008 struct client_thread_s
*cn
= arg
;
1009 struct client_s
*cl
= cn
->cl
;
1011 MUTEX_LOCK (&cn_mutex
);
1012 cn_thread_list
= slist_remove (cn_thread_list
, cn
);
1013 MUTEX_UNLOCK (&cn_mutex
);
1017 cleanup_client (cl
);
1019 xmlResetError (cl
->xml_error
);
1021 xfree (cl
->xml_error
);
1026 gnutls_deinit (cn
->tls
->ses
);
1027 xfree (cn
->tls
->fp
);
1032 if (!cn
->atfork
&& cl
->ctx
)
1033 assuan_release (cl
->ctx
);
1034 else if (!cn
->atfork
&& cl
->thd
&& cl
->thd
->fd
!= -1)
1035 close (cl
->thd
->fd
);
1038 cleanup_crypto (&cl
->crypto
);
1040 pinentry_free_opts (&cl
->pinentry_opts
);
1049 while (cn
->msg_queue
)
1051 struct status_msg_s
*msg
= cn
->msg_queue
;
1053 cn
->msg_queue
= msg
->next
;
1058 if (!cn
->atfork
&& cn
->status_msg_pipe
[0] != -1)
1059 close (cn
->status_msg_pipe
[0]);
1061 if (!cn
->atfork
&& cn
->status_msg_pipe
[1] != -1)
1062 close (cn
->status_msg_pipe
[1]);
1064 pthread_mutex_destroy (&cn
->status_mutex
);
1068 log_write (_("exiting, fd=%i"), cn
->fd
);
1069 send_status_all (STATUS_CLIENTS
, NULL
);
1073 pthread_cond_signal (&quit_cond
);
1077 cleanup_all_clients (int atfork
)
1079 /* This function may be called from pthread_atfork() which requires
1080 reinitialization. */
1083 pthread_mutexattr_t attr
;
1085 pthread_mutexattr_init (&attr
);
1086 pthread_mutexattr_settype (&attr
, PTHREAD_MUTEX_RECURSIVE
);
1087 pthread_mutex_init (&cn_mutex
, &attr
);
1088 pthread_mutexattr_destroy (&attr
);
1089 cache_mutex_init ();
1092 MUTEX_LOCK (&cn_mutex
);
1094 while (slist_length (cn_thread_list
))
1096 struct client_thread_s
*thd
= slist_nth_data (cn_thread_list
, 0);
1098 thd
->atfork
= atfork
;
1103 MUTEX_UNLOCK (&cn_mutex
);
1104 cache_deinit (atfork
);
1108 send_msg_queue (struct client_thread_s
*thd
)
1110 MUTEX_LOCK (&thd
->status_mutex
);
1114 read (thd
->status_msg_pipe
[0], &c
, 1);
1116 while (thd
->msg_queue
)
1118 struct status_msg_s
*msg
= thd
->msg_queue
;
1120 thd
->msg_queue
= thd
->msg_queue
->next
;
1121 MUTEX_UNLOCK (&thd
->status_mutex
);
1122 rc
= send_status (thd
->cl
->ctx
, msg
->s
, msg
->line
);
1123 MUTEX_LOCK (&thd
->status_mutex
);
1131 MUTEX_UNLOCK (&thd
->status_mutex
);
1132 if (rc
&& gpg_err_code (rc
) != GPG_ERR_EPIPE
)
1133 log_write ("%s: %s", __FUNCTION__
, pwmd_strerror (rc
));
1139 client_thread (void *data
)
1141 struct client_thread_s
*thd
= data
;
1142 struct client_s
*cl
= xcalloc (1, sizeof (struct client_s
));
1144 #ifdef HAVE_PR_SET_NAME
1145 prctl (PR_SET_NAME
, "client");
1147 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
1151 log_write ("%s(%i): %s", __FILE__
, __LINE__
,
1152 pwmd_strerror (GPG_ERR_ENOMEM
));
1156 MUTEX_LOCK (&cn_mutex
);
1157 pthread_cleanup_push (cleanup_cb
, thd
);
1160 MUTEX_UNLOCK (&cn_mutex
);
1162 if (new_connection (cl
))
1167 send_status_all (STATUS_CLIENTS
, NULL
);
1168 rc
= send_status (cl
->ctx
, STATUS_CACHE
, NULL
);
1171 log_write ("%s(%i): %s", __FILE__
, __LINE__
, pwmd_strerror (rc
));
1182 FD_SET (thd
->fd
, &rfds
);
1183 FD_SET (thd
->status_msg_pipe
[0], &rfds
);
1184 n
= thd
->fd
> thd
->status_msg_pipe
[0]
1185 ? thd
->fd
: thd
->status_msg_pipe
[0];
1187 n
= select (n
+ 1, &rfds
, NULL
, NULL
, NULL
);
1190 log_write ("%s", strerror (errno
));
1194 if (FD_ISSET (thd
->status_msg_pipe
[0], &rfds
))
1196 rc
= send_msg_queue (thd
);
1197 if (rc
&& gpg_err_code (rc
) != GPG_ERR_EPIPE
)
1201 if (!FD_ISSET (thd
->fd
, &rfds
))
1204 rc
= assuan_process_next (cl
->ctx
, &eof
);
1207 if (gpg_err_code (rc
) == GPG_ERR_EOF
|| eof
)
1210 log_write ("assuan_process_next(): rc=%i %s", rc
,
1211 pwmd_strerror (rc
));
1212 if (rc
== gpg_error (GPG_ERR_ETIMEDOUT
))
1215 rc
= send_error (cl
->ctx
, rc
);
1218 log_write ("assuan_process_done(): rc=%i %s", rc
,
1219 pwmd_strerror (rc
));
1224 /* Since the msg queue pipe fd's are non-blocking, check for
1225 * pending status msgs here. GPG_ERR_EPIPE can be seen when the
1226 * client has already disconnected and will be converted to
1227 * GPG_ERR_EOF during assuan_process_next().
1229 rc
= send_msg_queue (thd
);
1230 if (rc
&& gpg_err_code (rc
) != GPG_ERR_EPIPE
)
1235 pthread_cleanup_pop (1);
1240 xml_import (const char *filename
, const char *outfile
,
1241 const char *keygrip
, const char *sign_keygrip
,
1242 const char *keyfile
, int no_passphrase
, const char *cipher
,
1243 const char *params
, unsigned long s2k_count
, uint64_t iterations
)
1252 struct crypto_s
*crypto
= NULL
;
1255 int algo
= cipher
? cipher_string_to_gcrypt ((char *) cipher
) :
1260 log_write ("ERR %i: %s", gpg_error (GPG_ERR_CIPHER_ALGO
),
1261 pwmd_strerror (GPG_ERR_CIPHER_ALGO
));
1265 if (stat (filename
, &st
) == -1)
1267 log_write ("%s: %s", filename
,
1268 pwmd_strerror (gpg_error_from_errno (errno
)));
1272 rc
= init_client_crypto (&crypto
);
1276 memcpy (&crypto
->save
.hdr
, &crypto
->hdr
, sizeof (file_header_t
));
1277 crypto
->save
.hdr
.flags
= set_cipher_flag (crypto
->save
.hdr
.flags
, algo
);
1278 log_write (_("Importing XML from '%s'. Output will be written to '%s' ..."),
1281 if ((fd
= open (filename
, O_RDONLY
)) == -1)
1283 log_write ("%s: %s", filename
,
1284 pwmd_strerror (gpg_error_from_errno (errno
)));
1288 if ((xmlbuf
= xmalloc (st
.st_size
+ 1)) == NULL
)
1291 log_write ("%s(%i): %s", __FILE__
, __LINE__
,
1292 pwmd_strerror (GPG_ERR_ENOMEM
));
1296 if (read (fd
, xmlbuf
, st
.st_size
) == -1)
1298 rc
= gpg_error_from_errno (errno
);
1300 log_write ("%s: %s", filename
, pwmd_strerror (rc
));
1305 xmlbuf
[st
.st_size
] = 0;
1307 * Make sure the document validates.
1309 if ((doc
= xmlReadDoc (xmlbuf
, NULL
, "UTF-8", XML_PARSE_NOBLANKS
)) == NULL
)
1311 log_write ("xmlReadDoc() failed");
1317 xmlNodePtr n
= xmlDocGetRootElement (doc
);
1318 if (n
&& !xmlStrEqual (n
->name
, (xmlChar
*) "pwmd"))
1320 log_write (_("Could not find root \"pwmd\" element."));
1321 rc
= GPG_ERR_BAD_DATA
;
1325 rc
= validate_import (NULL
, n
? n
->children
: n
);
1329 log_write ("ERR %i: %s", rc
, pwmd_strerror (rc
));
1334 xmlDocDumpMemory (doc
, &xml
, &len
);
1336 crypto
->save
.s2k_count
= s2k_count
;
1337 crypto
->save
.hdr
.iterations
= iterations
;
1340 rc
= export_common (NULL
, 0, crypto
, xml
, len
, outfile
, keyfile
, &key
,
1341 &keylen
, 0, 0, no_passphrase
);
1343 log_write (_("Success!"));
1348 rc
= agent_set_pinentry_options (crypto
->agent
);
1350 rc
= agent_export_common (crypto
, keygrip
, sign_keygrip
, no_passphrase
,
1351 xml
, len
, outfile
, params
, keyfile
);
1359 send_error (NULL
, rc
);
1363 cleanup_crypto (&crypto
);
1367 cleanup_crypto (&crypto
);
1372 do_cache_push (const char *filename
, struct crypto_s
*crypto
)
1374 unsigned char md5file
[16];
1379 struct cache_data_s
*cdata
;
1383 log_write (_("Trying to add datafile '%s' to the file cache ..."),
1386 if (valid_filename (filename
) == 0)
1388 log_write (_("%s: Invalid characters in filename"), filename
);
1392 rc
= decrypt_common (NULL
, 0, crypto
, filename
, &key
, &keylen
);
1396 rc
= parse_doc ((char *) crypto
->plaintext
, crypto
->plaintext_len
, &doc
);
1399 log_write ("%s", pwmd_strerror (rc
));
1404 gcry_md_hash_buffer (GCRY_MD_MD5
, md5file
, filename
, strlen (filename
));
1405 cdata
= xcalloc (1, sizeof (struct cache_data_s
));
1409 log_write ("%s", pwmd_strerror (GPG_ERR_ENOMEM
));
1414 rc
= get_checksum (filename
, &crc
, &len
);
1417 log_write ("ERR %i: %s", rc
, pwmd_strerror (rc
));
1419 free_cache_data_once (cdata
);
1425 rc
= encrypt_xml (NULL
, cache_key
, cache_keysize
, GCRY_CIPHER_AES
,
1426 crypto
->plaintext
, crypto
->plaintext_len
, &cdata
->doc
,
1427 &cdata
->doclen
, &cache_iv
, &cache_blocksize
, 0);
1428 if (!rc
&& !IS_PKI (crypto
))
1431 cdata
->keylen
= keylen
;
1438 log_write ("ERR %i: %s", rc
, pwmd_strerror (rc
));
1440 free_cache_data_once (cdata
);
1445 if (use_agent
&& IS_PKI (crypto
))
1447 gcry_sexp_build ((gcry_sexp_t
*) & cdata
->pubkey
, NULL
, "%S",
1449 gcry_sexp_build ((gcry_sexp_t
*) & cdata
->sigkey
, NULL
, "%S",
1450 crypto
->sigpkey_sexp
);
1454 int timeout
= config_get_integer (filename
, "cache_timeout");
1455 cache_add_file (md5file
, crypto
->grip
, cdata
, timeout
);
1456 log_write (_("Successfully added '%s' to the cache."), filename
);
1461 init_client (int fd
, const char *addr
)
1464 struct client_thread_s
*new = xcalloc (1, sizeof (struct client_thread_s
));
1469 return GPG_ERR_ENOMEM
;
1472 MUTEX_LOCK (&cn_mutex
);
1473 pthread_cleanup_push (cleanup_mutex_cb
, &cn_mutex
);
1475 if (pipe (new->status_msg_pipe
) == -1)
1476 rc
= gpg_error_from_errno (errno
);
1480 fcntl (new->status_msg_pipe
[0], F_SETFL
, O_NONBLOCK
);
1481 fcntl (new->status_msg_pipe
[1], F_SETFL
, O_NONBLOCK
);
1482 pthread_mutex_init (&new->status_mutex
, NULL
);
1488 new->remote
= addr
? 1 : 0;
1491 rc
= create_thread (client_thread
, new, &new->tid
, 1);
1494 close (new->status_msg_pipe
[0]);
1495 close (new->status_msg_pipe
[1]);
1496 pthread_mutex_destroy (&new->status_mutex
);
1502 struct slist_s
*list
= slist_append (cn_thread_list
, new);
1506 cn_thread_list
= list
;
1508 log_write (_("new connection: tid=%p, fd=%i, addr=%s"),
1509 (pthread_t
*) new->tid
, fd
, addr
);
1511 log_write (_("new connection: tid=%p, fd=%i"),
1512 (pthread_t
*) new->tid
, fd
);
1515 rc
= GPG_ERR_ENOMEM
;
1518 pthread_cleanup_pop (1);
1524 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
1525 pwmd_strerror (rc
));
1531 keepalive_thread (void *arg
)
1533 #ifndef HAVE_PTHREAD_CANCEL
1534 int *n
= xmalloc (sizeof (int));
1537 pthread_setspecific (signal_thread_key
, n
);
1541 #ifdef HAVE_PR_SET_NAME
1542 prctl (PR_SET_NAME
, "keepalive");
1544 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
1548 int n
= config_get_integer ("global", "keepalive_interval");
1549 struct timeval tv
= { n
, 0 };
1550 #ifndef HAVE_PTHREAD_CANCEL
1553 sigusr2
= (int *) pthread_getspecific (signal_thread_key
);
1558 send_status_all (STATUS_KEEPALIVE
, NULL
);
1559 select (0, NULL
, NULL
, NULL
, &tv
);
1566 /* From Beej's Guide to Network Programming. It's a good tutorial. */
1568 get_in_addr (struct sockaddr
*sa
)
1570 if (sa
->sa_family
== AF_INET
)
1571 return &(((struct sockaddr_in
*) sa
)->sin_addr
);
1573 return &(((struct sockaddr_in6
*) sa
)->sin6_addr
);
1577 tcp_accept_thread (void *arg
)
1579 int sockfd
= *(int *) arg
;
1580 #ifndef HAVE_PTHREAD_CANCEL
1581 int *n
= xmalloc (sizeof (int));
1584 pthread_setspecific (signal_thread_key
, n
);
1586 fcntl (sockfd
, F_SETFL
, O_NONBLOCK
);
1589 #ifdef HAVE_PR_SET_NAME
1590 prctl (PR_SET_NAME
, "tcp_accept");
1592 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
1596 struct sockaddr_storage raddr
;
1597 socklen_t slen
= sizeof (raddr
);
1600 char s
[INET6_ADDRSTRLEN
];
1601 struct timeval tv
= { 0, ACCEPT_TIMEOUT
};
1602 #ifndef HAVE_PTHREAD_CANCEL
1605 sigusr2
= (int *) pthread_getspecific (signal_thread_key
);
1610 fd
= accept (sockfd
, (struct sockaddr
*) &raddr
, &slen
);
1613 if (errno
== EMFILE
|| errno
== ENFILE
)
1614 log_write ("accept(): %s",
1615 pwmd_strerror (gpg_error_from_errno (errno
)));
1616 else if (errno
!= EAGAIN
)
1618 if (!quit
) // probably EBADF
1619 log_write ("accept(): %s", strerror (errno
));
1624 #ifndef HAVE_PTHREAD_CANCEL
1625 select (0, NULL
, NULL
, NULL
, &tv
);
1633 inet_ntop (raddr
.ss_family
, get_in_addr ((struct sockaddr
*) &raddr
),
1635 (void) init_client (fd
, s
);
1636 n
= config_get_integer ("global", "tcp_wait");
1639 tv
.tv_sec
= (n
* 100000) / 100000;
1640 tv
.tv_usec
= (n
* 100000) % 100000;
1641 select (0, NULL
, NULL
, NULL
, &tv
);
1649 start_stop_tls_with_protocol (int ipv6
, int term
)
1651 struct addrinfo hints
, *servinfo
, *p
;
1652 int port
= config_get_integer ("global", "tcp_port");
1656 int *fd
= ipv6
? &tls6_fd
: &tls_fd
;
1658 if (term
|| config_get_boolean ("global", "enable_tcp") == 0)
1664 #ifdef HAVE_PTHREAD_CANCEL
1665 pthread_cancel (tls6_tid
);
1667 pthread_kill (tls6_tid
, SIGUSR2
);
1669 pthread_join (tls6_tid
, NULL
);
1672 shutdown (tls6_fd
, SHUT_RDWR
);
1682 #ifdef HAVE_PTHREAD_CANCEL
1683 pthread_cancel (tls_tid
);
1685 pthread_kill (tls_tid
, SIGUSR2
);
1687 pthread_join (tls_tid
, NULL
);
1690 shutdown (tls_fd
, SHUT_RDWR
);
1696 /* A client may still be connected. */
1697 if (!quit
&& x509_cred
!= NULL
)
1698 tls_deinit_params ();
1703 if ((ipv6
&& tls6_fd
!= -1) || (!ipv6
&& tls_fd
!= -1))
1706 memset (&hints
, 0, sizeof (hints
));
1707 hints
.ai_family
= ipv6
? AF_INET6
: AF_INET
;
1708 hints
.ai_socktype
= SOCK_STREAM
;
1709 hints
.ai_flags
= AI_PASSIVE
;
1710 snprintf (buf
, sizeof (buf
), "%i", port
);
1712 if ((n
= getaddrinfo (NULL
, buf
, &hints
, &servinfo
)) == -1)
1714 log_write ("getaddrinfo(): %s", gai_strerror (n
));
1718 for (n
= 0, p
= servinfo
; p
!= NULL
; p
= p
->ai_next
)
1722 if ((ipv6
&& p
->ai_family
!= AF_INET6
)
1723 || (!ipv6
&& p
->ai_family
!= AF_INET
))
1726 if ((*fd
= socket (p
->ai_family
, p
->ai_socktype
, p
->ai_protocol
)) == -1)
1728 log_write ("socket(): %s", strerror (errno
));
1732 if (setsockopt (*fd
, SOL_SOCKET
, SO_REUSEADDR
, &r
, sizeof (int)) == -1)
1734 log_write ("setsockopt(): %s",
1735 pwmd_strerror (gpg_error_from_errno (errno
)));
1736 freeaddrinfo (servinfo
);
1740 if (bind (*fd
, p
->ai_addr
, p
->ai_addrlen
) == -1)
1743 log_write ("bind(): %s",
1744 pwmd_strerror (gpg_error_from_errno (errno
)));
1752 freeaddrinfo (servinfo
);
1757 #if HAVE_DECL_SO_BINDTODEVICE != 0
1758 char *tmp
= config_get_string ("global", "tcp_interface");
1759 if (tmp
&& setsockopt (*fd
, SOL_SOCKET
, SO_BINDTODEVICE
, tmp
,
1760 strlen (tmp
)) == -1)
1762 log_write ("setsockopt(): %s",
1763 pwmd_strerror (gpg_error_from_errno (errno
)));
1771 if (x509_cred
== NULL
)
1773 rc
= tls_init_params ();
1778 if (listen (*fd
, 0) == -1)
1780 log_write ("listen(): %s", strerror (errno
));
1785 rc
= create_thread (tcp_accept_thread
, fd
, &tls6_tid
, 0);
1787 rc
= create_thread (tcp_accept_thread
, fd
, &tls_tid
, 0);
1791 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
1792 pwmd_strerror (rc
));
1804 start_stop_tls_with_protocol (0, 1);
1817 start_stop_tls (int term
)
1819 char *s
= config_get_string ("global", "tcp_bind");
1825 if (!strcmp (s
, "any"))
1827 b
= start_stop_tls_with_protocol (0, term
);
1829 b
= start_stop_tls_with_protocol (1, term
);
1831 else if (!strcmp (s
, "ipv4"))
1832 b
= start_stop_tls_with_protocol (0, term
);
1833 else if (!strcmp (s
, "ipv6"))
1834 b
= start_stop_tls_with_protocol (1, term
);
1844 accept_thread (void *arg
)
1846 int sockfd
= *(int *) arg
;
1847 #ifndef HAVE_PTHREAD_CANCEL
1848 int *n
= xmalloc (sizeof (int));
1851 pthread_setspecific (signal_thread_key
, n
);
1853 fcntl (sockfd
, F_SETFL
, O_NONBLOCK
);
1856 #ifdef HAVE_PR_SET_NAME
1857 prctl (PR_SET_NAME
, "accept");
1859 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
1863 socklen_t slen
= sizeof (struct sockaddr_un
);
1864 struct sockaddr_un raddr
;
1866 #ifndef HAVE_PTHREAD_CANCEL
1867 struct timeval tv
= { 0, ACCEPT_TIMEOUT
};
1868 int *sigusr2
= (int *) pthread_getspecific (signal_thread_key
);
1874 fd
= accept (sockfd
, (struct sockaddr
*) &raddr
, &slen
);
1877 if (errno
== EMFILE
|| errno
== ENFILE
)
1878 log_write ("accept(): %s",
1879 pwmd_strerror (gpg_error_from_errno (errno
)));
1880 else if (errno
!= EAGAIN
)
1882 if (!quit
) // probably EBADF
1883 log_write ("accept(): %s",
1884 pwmd_strerror (gpg_error_from_errno (errno
)));
1889 #ifndef HAVE_PTHREAD_CANCEL
1890 select (0, NULL
, NULL
, NULL
, &tv
);
1895 (void) init_client (fd
, NULL
);
1898 /* Just in case accept() failed for some reason other than EBADF */
1904 cache_timer_thread (void *arg
)
1906 #ifndef HAVE_PTHREAD_CANCEL
1907 int *n
= xmalloc (sizeof (int));
1910 pthread_setspecific (signal_thread_key
, n
);
1914 #ifdef HAVE_PR_SET_NAME
1915 prctl (PR_SET_NAME
, "cache timer");
1917 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
1921 struct timeval tv
= { 1, 0 };
1922 #ifndef HAVE_PTHREAD_CANCEL
1925 n
= (int *) pthread_getspecific (signal_thread_key
);
1930 select (0, NULL
, NULL
, NULL
, &tv
);
1931 cache_adjust_timeout ();
1938 signal_loop (sigset_t sigset
)
1947 sigwait (&sigset
, &sig
);
1950 log_write (_("caught signal %i (%s)"), sig
, strsignal (sig
));
1955 pthread_cond_signal (&rcfile_cond
);
1958 log_write (_("clearing file cache"));
1960 send_status_all (STATUS_CACHE
, NULL
);
1979 log_write (_ ("Caught signal %i (%s). Exiting."), sig
, strsignal (sig
));
1980 #ifdef HAVE_BACKTRACE
1981 BACKTRACE (__FUNCTION__
);
1987 waiting_for_exit (void *arg
)
1990 #ifndef HAVE_PTHREAD_CANCEL
1991 int *n
= xmalloc (sizeof (int));
1994 pthread_setspecific (signal_thread_key
, n
);
1998 #ifdef HAVE_PR_SET_NAME
1999 prctl (PR_SET_NAME
, "exiting");
2001 pthread_setspecific (thread_name_key
, str_dup (__FUNCTION__
));
2002 log_write (_("waiting for all clients to disconnect"));
2003 MUTEX_LOCK (&quit_mutex
);
2004 pthread_cleanup_push (cleanup_mutex_cb
, &quit_mutex
);
2011 MUTEX_LOCK (&cn_mutex
);
2012 n
= slist_length (cn_thread_list
);
2013 MUTEX_UNLOCK (&cn_mutex
);
2017 #ifndef HAVE_PTHREAD_CANCEL
2018 int *s
= (int *) pthread_getspecific (signal_thread_key
);
2025 log_write (_("%i clients remain"), n
);
2029 INIT_TIMESPEC (SIG_TIMEOUT
, ts
);
2030 pthread_cond_timedwait (&quit_cond
, &quit_mutex
, &ts
);
2033 kill (getpid (), SIGQUIT
);
2034 pthread_cleanup_pop (1);
2039 server_loop (int sockfd
, char **socketpath
)
2041 pthread_t accept_tid
;
2042 pthread_t cache_timeout_tid
;
2043 int cancel_timeout_thread
= 0, cancel_accept_thread
= 0;
2044 int cancel_keepalive_thread
= 0;
2051 sigemptyset (&sigset
);
2054 sigaddset (&sigset
, SIGTERM
);
2055 sigaddset (&sigset
, SIGINT
);
2057 /* Clears the file cache. */
2058 sigaddset (&sigset
, SIGUSR1
);
2060 /* Configuration file reloading. */
2061 sigaddset (&sigset
, SIGHUP
);
2063 /* For exiting cleanly. */
2064 sigaddset (&sigset
, SIGQUIT
);
2066 #ifndef HAVE_PTHREAD_CANCEL
2068 The socket, cache and rcfile threads use this signal when
2069 pthread_cancel() is unavailable. Prevent the main thread from
2070 catching this signal from another process.
2072 sigaddset (&sigset
, SIGUSR2
);
2075 /* When mem.c cannot find a pointer in the list (double free). */
2076 signal (SIGABRT
, catchsig
);
2077 sigaddset (&sigset
, SIGABRT
);
2078 sigprocmask (SIG_BLOCK
, &sigset
, NULL
);
2080 #ifndef HAVE_PTHREAD_CANCEL
2081 /* Remove this signal from the watched signals in signal_loop(). */
2082 sigdelset (&sigset
, SIGUSR2
);
2085 /* Ignored everywhere. When a client disconnects abnormally this signal
2086 * gets raised. It isn't needed though because client_thread() will check
2087 * for rcs even after the client disconnects. */
2088 signal (SIGPIPE
, SIG_IGN
);
2090 /* Can show a backtrace of the stack in the log. */
2091 signal (SIGSEGV
, catchsig
);
2094 /* Needs to be done after the fork(). */
2095 if (!start_stop_tls (0))
2102 pthread_mutex_init (&quit_mutex
, NULL
);
2103 pthread_cond_init (&quit_cond
, NULL
);
2104 char *p
= get_username (getuid());
2105 log_write (_("%s started for user %s"), PACKAGE_STRING
, p
);
2109 if (config_get_boolean ("global", "enable_tcp"))
2110 log_write (_("Listening on %s and TCP port %i as user %i"), *socketpath
,
2111 config_get_integer ("global", "tcp_port"), invoking_uid
);
2113 log_write (_("Listening on %s"), *socketpath
);
2115 log_write (_("Listening on %s"), *socketpath
);
2118 rc
= create_thread (keepalive_thread
, NULL
, &keepalive_tid
, 0);
2121 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
2122 pwmd_strerror (rc
));
2126 cancel_keepalive_thread
= 1;
2127 rc
= create_thread (reload_rcfile_thread
, NULL
, &rcfile_tid
, 0);
2130 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
2131 pwmd_strerror (rc
));
2135 rc
= create_thread (cache_timer_thread
, NULL
, &cache_timeout_tid
, 0);
2138 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
2139 pwmd_strerror (rc
));
2143 cancel_timeout_thread
= 1;
2144 rc
= create_thread (accept_thread
, &sockfd
, &accept_tid
, 0);
2147 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
2148 pwmd_strerror (rc
));
2152 cancel_accept_thread
= 1;
2154 signal_loop (sigset
);
2160 * We're out of the main server loop. This happens when a signal was sent
2161 * to terminate the daemon. We'll wait for all clients to disconnect
2162 * before exiting but exit immediately if another termination signal is
2165 if (cancel_accept_thread
)
2167 #ifdef HAVE_PTHREAD_CANCEL
2168 int n
= pthread_cancel (accept_tid
);
2170 int n
= pthread_kill (accept_tid
, SIGUSR2
);
2173 pthread_join (accept_tid
, NULL
);
2179 shutdown (sockfd
, SHUT_RDWR
);
2181 unlink (*socketpath
);
2182 xfree (*socketpath
);
2184 MUTEX_LOCK (&cn_mutex
);
2185 n
= slist_length (cn_thread_list
);
2186 MUTEX_UNLOCK (&cn_mutex
);
2192 rc
= create_thread (waiting_for_exit
, NULL
, &tid
, 0);
2195 if (signal_loop (sigset
))
2197 log_write (_("Received second termination request. Exiting."));
2198 #ifdef HAVE_PTHREAD_CANCEL
2199 pthread_cancel (tid
);
2201 pthread_kill (tid
, SIGUSR2
);
2203 pthread_join (tid
, NULL
);
2207 log_write ("%s(%i): pthread_create(): %s", __FILE__
, __LINE__
,
2208 pwmd_strerror (rc
));
2211 if (cancel_timeout_thread
)
2213 #ifdef HAVE_PTHREAD_CANCEL
2214 pthread_cancel (cache_timeout_tid
);
2216 pthread_kill (cache_timeout_tid
, SIGUSR2
);
2218 pthread_join (cache_timeout_tid
, NULL
);
2221 if (cancel_keepalive_thread
)
2223 #ifdef HAVE_PTHREAD_CANCEL
2224 pthread_cancel (keepalive_tid
);
2226 pthread_kill (keepalive_tid
, SIGUSR2
);
2228 pthread_join (keepalive_tid
, NULL
);
2231 cleanup_all_clients (0);
2236 pthread_cond_destroy (&quit_cond
);
2237 pthread_mutex_destroy (&quit_mutex
);
2238 return segv
? EXIT_FAILURE
: EXIT_SUCCESS
;;
2245 ("Failed to add a file to the cache. Use --ignore to force startup. Exiting."));
2249 /* This is called from cache.c:clear_once(). See
2250 * command.c:clearcache_command() for details about lock checking.
2253 free_cache_data (file_cache_t
* cache
)
2255 gpg_error_t rc
= GPG_ERR_NO_DATA
;
2257 struct client_thread_s
*found
= NULL
;
2264 MUTEX_LOCK (&cn_mutex
);
2265 pthread_cleanup_push (cleanup_mutex_cb
, &cn_mutex
);
2266 t
= slist_length (cn_thread_list
);
2268 for (i
= 0; i
< t
; i
++)
2270 struct client_thread_s
*thd
= slist_nth_data (cn_thread_list
, i
);
2275 if (!memcmp (thd
->cl
->md5file
, cache
->filename
,
2276 sizeof (cache
->filename
)))
2278 if (pthread_equal (pthread_self (), thd
->tid
))
2285 /* Continue trying to find a client who has the same file open and
2286 * also has a lock. */
2287 rc
= cache_lock_mutex (thd
->cl
->ctx
, thd
->cl
->md5file
, -1, 0, -1);
2297 if (self
&& (!rc
|| rc
== GPG_ERR_NO_DATA
))
2298 rc
= cache_lock_mutex (found
->cl
->ctx
, found
->cl
->md5file
, -1, 0, -1);
2300 if (exiting
|| !rc
|| rc
== GPG_ERR_NO_DATA
)
2302 free_cache_data_once (cache
->data
);
2304 cache
->defer_clear
= 0;
2305 cache
->timeout
= -1;
2308 cache_unlock_mutex (found
->cl
->md5file
, 0);
2314 cache
->defer_clear
= 1;
2316 pthread_cleanup_pop (1);
2322 convert_v2_datafile (const char *filename
, const char *cipher
,
2323 const char *keyfile
, const char *keygrip
,
2324 const char *sign_keygrip
, int nopass
,
2325 const char *outfile
, const char *keyparam
,
2326 unsigned long s2k_count
, uint64_t iterations
)
2331 struct crypto_s
*crypto
= NULL
;
2337 if (outfile
[0] == '-' && outfile
[1] == 0)
2340 log_write (_("Converting version 2 data file \"%s\" ..."), filename
);
2341 if (access (filename
, R_OK
) == -1)
2343 log_write ("%s: %s", filename
,
2344 pwmd_strerror (gpg_error_from_errno (errno
)));
2350 log_write (_("Using passphrase file \"%s\" for decryption ..."),
2352 if (access (keyfile
, R_OK
) == -1)
2354 log_write ("%s: %s", keyfile
,
2355 pwmd_strerror (gpg_error_from_errno (errno
)));
2360 rc
= read_v2_datafile (filename
, keyfile
, &data
, &datalen
, &ver
, &algo
);
2363 log_write ("ERR %i: %s", rc
, pwmd_strerror (rc
));
2369 algo
= cipher_string_to_gcrypt (cipher
);
2372 rc
= GPG_ERR_CIPHER_ALGO
;
2381 rc
= parse_doc (data
, datalen
, &doc
);
2385 rc
= convert_pre_212_elements (doc
);
2390 xmlDocDumpFormatMemory (doc
, (xmlChar
**) & data
, (int *) &datalen
,
2393 rc
= GPG_ERR_ENOMEM
;
2401 rc
= init_client_crypto (&crypto
);
2404 memcpy (&crypto
->save
.hdr
, &crypto
->hdr
, sizeof (file_header_t
));
2405 crypto
->save
.hdr
.flags
= set_cipher_flag (crypto
->save
.hdr
.flags
, algo
);
2406 crypto
->save
.s2k_count
= s2k_count
;
2407 crypto
->save
.hdr
.iterations
= iterations
;
2411 rc
= export_common (NULL
, 0, crypto
, data
, datalen
, outfile
, keyfile
,
2412 &key
, &keylen
, 0, 0, nopass
);
2417 rc
= agent_set_pinentry_options (crypto
->agent
);
2419 rc
= agent_export_common (crypto
, keygrip
, sign_keygrip
, nopass
,
2420 data
, datalen
, outfile
, keyparam
,
2421 no_passphrase_file
? NULL
: keyfile
);
2425 log_write (_("Output written to \"%s\"."), outfile
);
2435 cleanup_crypto (&crypto
);
2438 log_write ("ERR %i: %s", rc
, pwmd_strerror (rc
));
2443 usage (const char *pn
, int status
)
2445 FILE *fp
= status
== EXIT_FAILURE
? stderr
: stdout
;
2447 fprintf (fp
, _("Usage: %s [OPTIONS] [file1] [...]\n"
2448 " -f, --rcfile=filename load the specfied configuration file\n"
2449 " (~/.pwmd/config)\n"
2450 " --homedir alternate pwmd home directory (~/.pwmd)\n"
2452 " --use-agent enable use of gpg-agent\n"
2454 " -n, --no-fork run as a foreground process\n"
2455 " -D, --disable-dump disable the LIST, XPATH and DUMP commands\n"
2456 " --ignore, --force ignore file errors during startup\n"
2457 " --debug-level=keywords log protocol output (see manual for details)\n"
2458 " -o, --outfile=filename output file when importing or converting\n"
2459 " -C, --convert=filename convert a version 2 data file to version 3\n"
2460 " -I, --import=filename import a pwmd DTD formatted XML file)\n"
2461 " -k, --passphrase-file=file for use when importing or converting\n"
2462 " --no-passphrase-file prompt instead of using --passphrase-file when\n"
2464 " --no-passphrase when importing or converting\n"
2465 " --keygrip=hex public key to use when encrypting\n"
2466 " --sign-keygrip=hex private key to use when signing\n"
2467 " --keyparam=s-exp custom key parameters to use (RSA-2048)\n"
2468 " --cipher=string encryption cipher (aes256)\n"
2469 " --cipher-iterations=N cipher iteration count (N+1)\n"
2470 " --s2k-count=N hash iteration count (>65536, calibrated)\n"
2471 " --help this help text\n"
2472 " --version show version and compile time features\n"),
2478 unlink_stale_socket (const char *sock
, const char *pidfile
)
2480 log_write (_ ("removing stale socket %s"), sock
);
2486 test_pidfile (const char *path
, const char *sock
, char *buf
, size_t buflen
,
2487 char **pidfile
, int create
, mode_t mode
)
2495 snprintf (buf
, buflen
, "%s/%s.pid", homedir
, sock
);
2496 *pidfile
= str_dup (buf
);
2497 fd
= open (buf
, O_RDONLY
);
2500 fd
= open (*pidfile
, O_CREAT
|O_WRONLY
|O_TRUNC
, mode
);
2504 if (!create
&& errno
!= ENOENT
)
2506 log_write ("%s: %s", buf
, pwmd_strerror (errno
));
2514 log_write ("%s: %s", *pidfile
, strerror (errno
));
2520 snprintf (buf
, buflen
, "%i", getpid ());
2521 write (fd
, buf
, strlen (buf
));
2526 len
= read (fd
, buf
, sizeof(buf
));
2530 unlink_stale_socket (path
, *pidfile
);
2534 if (sscanf (buf
, "%5i", &pid
) != 1 || pid
== 0)
2536 unlink_stale_socket (path
, *pidfile
);
2540 if (kill (pid
, 0) == -1)
2542 unlink_stale_socket (path
, *pidfile
);
2546 log_write (_ ("an instance for socket %s is already running"), path
);
2553 main (int argc
, char *argv
[])
2556 struct sockaddr_un addr
;
2558 char *socketpath
= NULL
, *socketdir
, *socketname
= NULL
;
2559 char *socketarg
= NULL
;
2560 char *datadir
= NULL
;
2561 char *pidfile
= NULL
;
2565 char **cache_push
= NULL
;
2566 char *import
= NULL
, *keygrip
= NULL
, *sign_keygrip
= NULL
;
2567 char *keyparam
= NULL
;
2568 int estatus
= EXIT_FAILURE
;
2570 char *outfile
= NULL
;
2573 int show_version
= 0;
2575 int no_passphrase
= 0;
2577 char *convertfile
= NULL
;
2578 char *cipher
= NULL
;
2579 char *keyfile
= NULL
;
2580 unsigned long s2k_count
= 0;
2581 uint64_t iterations
= 0;
2583 char *debug_level_opt
= NULL
;
2585 /* Must maintain the same order as longopts[] */
2588 OPT_VERSION
, OPT_HELP
,
2592 OPT_DEBUG_LEVEL
, OPT_HOMEDIR
, OPT_NO_FORK
, OPT_DISABLE_DUMP
,
2593 OPT_IGNORE
, OPT_FORCE
, OPT_RCFILE
, OPT_CONVERT
,
2594 OPT_PASSPHRASE_FILE
, OPT_IMPORT
, OPT_OUTFILE
,
2595 OPT_NO_PASSPHRASE_FILE
, OPT_KEYGRIP
, OPT_SIGN_KEYGRIP
,
2596 OPT_KEYPARAM
, OPT_CIPHER
, OPT_ITERATIONS
, OPT_S2K_COUNT
,
2599 const char *optstring
= "nf:C:k:I:o:";
2600 const struct option longopts
[] = {
2601 {"version", no_argument
, 0, 0},
2602 {"help", no_argument
, 0, 0},
2604 {"use-agent", no_argument
, 0, 0},
2606 {"debug-level", required_argument
, 0, 0},
2607 {"homedir", required_argument
, 0, 0},
2608 {"no-fork", no_argument
, 0, 'n'},
2609 {"disable_dump", no_argument
, 0, 0},
2610 {"ignore", no_argument
, 0, 0},
2611 {"force", no_argument
, 0, 0},
2612 {"rcfile", required_argument
, 0, 'f'},
2613 {"convert", required_argument
, 0, 'C'},
2614 {"passphrase-file", required_argument
, 0, 'k'},
2615 {"import", required_argument
, 0, 'I'},
2616 {"outfile", required_argument
, 0, 'o'},
2617 {"no-passphrase-file", no_argument
, 0, 0},
2618 {"keygrip", required_argument
, 0, 0},
2619 {"sign-keygrip", required_argument
, 0, 0},
2620 {"keyparam", required_argument
, 0, 0},
2621 {"cipher", required_argument
, 0, 0},
2622 {"cipher-iterations", required_argument
, 0, 0},
2623 {"s2k-count", required_argument
, 0, 0},
2624 {"no-passphrase", no_argument
, 0, 0},
2631 #ifdef HAVE_SETRLIMIT
2634 rl
.rlim_cur
= rl
.rlim_max
= 0;
2636 if (setrlimit (RLIMIT_CORE
, &rl
) != 0)
2637 err (EXIT_FAILURE
, "setrlimit()");
2640 #ifdef HAVE_PR_SET_DUMPABLE
2641 prctl (PR_SET_DUMPABLE
, 0);
2646 setlocale (LC_ALL
, "");
2647 bindtextdomain ("pwmd", LOCALEDIR
);
2648 textdomain ("pwmd");
2656 if (setup_crypto ())
2657 exit (EXIT_FAILURE
);
2660 gnutls_global_set_mem_functions (xmalloc
, xmalloc
, secure_mem_check
,
2662 gnutls_global_init ();
2663 gnutls_global_set_log_function (tls_log
);
2664 gnutls_global_set_log_level (1);
2668 xmlMemSetup (xfree
, xmalloc
, xrealloc
, str_dup
);
2676 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, &optindex
))
2685 convertfile
= optarg
;
2700 rcfile
= str_dup (optarg
);
2703 usage (argv
[0], EXIT_FAILURE
);
2719 case OPT_DEBUG_LEVEL
:
2720 debug_level_opt
= optarg
;
2723 homedir
= str_dup (optarg
);
2728 case OPT_DISABLE_DUMP
:
2736 rcfile
= str_dup (optarg
);
2739 convertfile
= optarg
;
2741 case OPT_PASSPHRASE_FILE
:
2750 case OPT_NO_PASSPHRASE_FILE
:
2751 no_passphrase_file
= 1;
2756 case OPT_SIGN_KEYGRIP
:
2757 sign_keygrip
= optarg
;
2765 case OPT_ITERATIONS
:
2766 iterations
= strtoull (optarg
, NULL
, 10);
2769 s2k_count
= strtoul (optarg
, NULL
, 10);
2771 case OPT_NO_PASSPHRASE
:
2783 "Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014\n"
2785 "Released under the terms of the GPL v2. Use at your own risk.\n\n"
2786 "Compile time features:\n%s"), PACKAGE_STRING
,
2789 "+PWMD_HOMEDIR=" PWMD_HOMEDIR
"\n"
2822 exit (EXIT_SUCCESS
);
2827 homedir
= str_dup(PWMD_HOMEDIR
);
2829 homedir
= str_asprintf ("%s/.pwmd", get_home_dir());
2832 if (mkdir (homedir
, 0700) == -1 && errno
!= EEXIST
)
2833 err (EXIT_FAILURE
, "%s", homedir
);
2835 snprintf (buf
, sizeof (buf
), "%s/data", homedir
);
2836 if (mkdir (buf
, 0700) == -1 && errno
!= EEXIST
)
2837 err (EXIT_FAILURE
, "%s", buf
);
2839 datadir
= str_dup (buf
);
2840 pthread_mutexattr_t attr
;
2841 pthread_mutexattr_init (&attr
);
2842 pthread_mutexattr_settype (&attr
, PTHREAD_MUTEX_RECURSIVE
);
2843 pthread_mutex_init (&rcfile_mutex
, &attr
);
2844 pthread_cond_init (&rcfile_cond
, NULL
);
2845 pthread_mutex_init (&cn_mutex
, &attr
);
2846 pthread_mutexattr_destroy (&attr
);
2847 pthread_key_create (&last_error_key
, free_key
);
2848 #ifndef HAVE_PTHREAD_CANCEL
2849 pthread_key_create (&signal_thread_key
, free_key
);
2853 rcfile
= str_asprintf ("%s/config", homedir
);
2855 global_config
= config_parse (rcfile
);
2857 exit (EXIT_FAILURE
);
2861 use_agent
= config_get_boolean ("global", "use_agent");
2866 if (debug_level_opt
)
2867 debug_level
= str_split (debug_level_opt
, ",", 0);
2869 x
= config_get_int_param (global_config
, "global", "priority", &exists
);
2870 if (exists
&& x
!= atoi(INVALID_PRIORITY
))
2873 if (setpriority (PRIO_PROCESS
, 0, x
) == -1)
2875 log_write ("setpriority(): %s",
2876 pwmd_strerror (gpg_error_from_errno (errno
)));
2880 #ifdef HAVE_MLOCKALL
2881 if (disable_mlock
== 0 && mlockall (MCL_CURRENT
| MCL_FUTURE
) == -1)
2883 log_write ("mlockall(): %s",
2884 pwmd_strerror (gpg_error_from_errno (errno
)));
2889 rc
= cache_init (free_cache_data
);
2892 log_write ("pwmd: ERR %i: %s", rc
,
2893 gpg_err_code (rc
) == GPG_ERR_UNKNOWN_VERSION
2894 ? _("incompatible gpg-agent version: 2.1.0 or later required")
2895 : pwmd_strerror (rc
));
2900 s2k_count
= config_get_ulong (NULL
, "s2k_count");
2904 if (!outfile
|| !*outfile
|| argc
!= optind
)
2905 usage (argv
[0], EXIT_FAILURE
);
2907 estatus
= convert_v2_datafile (convertfile
, cipher
, keyfile
, keygrip
,
2908 sign_keygrip
, no_passphrase
, outfile
,
2909 keyparam
, s2k_count
, iterations
);
2910 config_free (global_config
);
2917 if (!outfile
|| !*outfile
|| argc
!= optind
)
2918 usage (argv
[0], EXIT_FAILURE
);
2920 if (outfile
&& outfile
[0] == '-' && outfile
[1] == 0)
2923 estatus
= xml_import (import
, outfile
, keygrip
, sign_keygrip
, keyfile
,
2924 no_passphrase
, cipher
, keyparam
, s2k_count
,
2926 config_free (global_config
);
2931 p
= config_get_string ("global", "socket_path");
2933 p
= str_asprintf ("%s/socket", homedir
);
2935 socketarg
= expand_homedir (p
);
2939 disable_list_and_dump
= config_get_boolean ("global",
2940 "disable_list_and_dump");
2942 disable_list_and_dump
= secure
;
2944 cache_push
= config_get_list ("global", "cache_push");
2946 while (optind
< argc
)
2948 if (strv_printf (&cache_push
, "%s", argv
[optind
++]) == 0)
2949 errx (EXIT_FAILURE
, "%s", pwmd_strerror (GPG_ERR_ENOMEM
));
2952 if (strchr (socketarg
, '/') == NULL
)
2954 socketdir
= getcwd (buf
, sizeof (buf
));
2955 socketname
= str_dup (socketarg
);
2956 socketpath
= str_asprintf ("%s/%s", socketdir
, socketname
);
2960 socketname
= str_dup (strrchr (socketarg
, '/'));
2962 socketarg
[strlen (socketarg
) - strlen (socketname
) - 1] = 0;
2963 socketdir
= str_dup (socketarg
);
2964 socketpath
= str_asprintf ("%s/%s", socketdir
, socketname
);
2967 if (chdir (datadir
))
2969 log_write ("%s: %s", datadir
,
2970 pwmd_strerror (gpg_error_from_errno (errno
)));
2971 unlink (socketpath
);
2975 if (test_pidfile (socketpath
, socketname
, buf
, sizeof(buf
), &pidfile
, 0,
2980 * bind() doesn't like the full pathname of the socket or any non alphanum
2981 * characters so change to the directory where the socket is wanted then
2982 * create it then change to datadir.
2984 if (chdir (socketdir
))
2986 log_write ("%s: %s", socketdir
,
2987 pwmd_strerror (gpg_error_from_errno (errno
)));
2993 if ((sockfd
= socket (PF_UNIX
, SOCK_STREAM
, 0)) == -1)
2995 log_write ("socket(): %s", pwmd_strerror (gpg_error_from_errno (errno
)));
2999 addr
.sun_family
= AF_UNIX
;
3000 snprintf (addr
.sun_path
, sizeof (addr
.sun_path
), "%s", socketname
);
3002 if (bind (sockfd
, (struct sockaddr
*) &addr
, sizeof (struct sockaddr
)) ==
3005 log_write ("bind(): %s", pwmd_strerror (gpg_error_from_errno (errno
)));
3007 if (errno
== EADDRINUSE
)
3010 log_write (_("Either there is another pwmd running or '%s' is a \n"
3011 "stale socket. Please remove it manually."), socketpath
);
3018 char *t
= config_get_string ("global", "socket_perms");
3023 mode
= strtol (t
, NULL
, 8);
3027 if (chmod (socketname
, mode
) == -1)
3029 log_write ("%s: %s", socketname
,
3030 pwmd_strerror (gpg_error_from_errno (errno
)));
3040 xfree (--socketname
);
3042 if (chdir (datadir
))
3044 log_write ("%s: %s", datadir
,
3045 pwmd_strerror (gpg_error_from_errno (errno
)));
3053 * Set the cache entry for a file. Prompts for the password.
3057 struct crypto_s
*crypto
= NULL
;
3058 gpg_error_t rc
= init_client_crypto (&crypto
);
3062 estatus
= EXIT_FAILURE
;
3069 rc
= agent_set_pinentry_options (crypto
->agent
);
3072 estatus
= EXIT_FAILURE
;
3078 for (opt
= 0; cache_push
[opt
]; opt
++)
3080 if (!do_cache_push (cache_push
[opt
], crypto
) && !force
)
3082 strv_free (cache_push
);
3084 estatus
= EXIT_FAILURE
;
3085 cleanup_crypto (&crypto
);
3089 cleanup_crypto_stage1 (crypto
);
3094 (void) kill_scd (crypto
->agent
);
3097 cleanup_crypto (&crypto
);
3098 strv_free (cache_push
);
3099 log_write (!nofork
? _("Done. Daemonizing...") :
3100 _("Done. Waiting for connections..."));
3103 config_clear_keys ();
3105 if (listen (sockfd
, 0) == -1)
3107 log_write ("listen(): %s", pwmd_strerror (gpg_error_from_errno (errno
)));
3116 log_write ("fork(): %s",
3117 pwmd_strerror (gpg_error_from_errno (errno
)));
3126 _exit (EXIT_SUCCESS
);
3130 (void)test_pidfile (socketpath
, socketname
, buf
, sizeof(buf
), &pidfile
, 1,
3133 pthread_key_create (&thread_name_key
, free_key
);
3134 pthread_setspecific (thread_name_key
, str_dup ("main"));
3135 estatus
= server_loop (sockfd
, &socketpath
);
3138 if (socketpath
&& do_unlink
)
3140 unlink (socketpath
);
3146 gnutls_global_deinit ();
3147 xfree (invoking_tls
);
3151 #ifdef HAVE_PTHREAD_CANCEL
3152 pthread_cancel (rcfile_tid
);
3154 pthread_kill (rcfile_tid
, SIGUSR2
);
3155 pthread_cond_signal (&rcfile_cond
);
3157 pthread_join (rcfile_tid
, NULL
);
3160 pthread_cond_destroy (&rcfile_cond
);
3161 pthread_mutex_destroy (&rcfile_mutex
);
3162 pthread_key_delete (last_error_key
);
3163 #ifndef HAVE_PTHREAD_CANCEL
3164 pthread_key_delete (signal_thread_key
);
3168 config_free (global_config
);
3171 xfree (home_directory
);
3173 xmlCleanupParser ();
3174 xmlCleanupGlobals ();
3180 if (estatus
== EXIT_SUCCESS
)
3181 log_write (_("pwmd exiting normally"));
3183 pthread_key_delete (thread_name_key
);
3185 #if defined(DEBUG) && !defined(MEM_DEBUG)