SCD changes for PC/SC under W32.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG 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 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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 this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <assert.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #include <sys/stat.h>
33 #ifndef HAVE_W32_SYSTEM
34 # include <sys/socket.h>
35 # include <sys/un.h>
36 #endif /*!HAVE_W32_SYSTEM*/
37 #include <unistd.h>
38 #include <signal.h>
39 #include <pth.h>
40
41 #define JNLIB_NEED_LOG_LOGV
42 #include "agent.h"
43 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
44
45 #include "i18n.h"
46 #include "mkdtemp.h" /* Gnulib replacement. */
47 #include "sysutils.h"
48 #include "setenv.h"
49 #include "gc-opt-flags.h"
50
51
52 enum cmd_and_opt_values 
53 { aNull = 0,
54   oCsh            = 'c',
55   oQuiet          = 'q',
56   oSh             = 's',
57   oVerbose        = 'v',
58
59   oNoVerbose = 500,
60   aGPGConfList,
61   aGPGConfTest,
62   oOptions,
63   oDebug,
64   oDebugAll,
65   oDebugLevel,
66   oDebugWait,
67   oNoGreeting,
68   oNoOptions,
69   oHomedir,
70   oNoDetach,
71   oNoGrab,
72   oLogFile,
73   oServer,
74   oDaemon,
75   oBatch,
76
77   oPinentryProgram,
78   oPinentryTouchFile,
79   oDisplay,
80   oTTYname,
81   oTTYtype,
82   oLCctype,
83   oLCmessages,
84   oXauthority,
85   oScdaemonProgram,
86   oDefCacheTTL,
87   oDefCacheTTLSSH,
88   oMaxCacheTTL,
89   oMaxCacheTTLSSH,
90   oEnforcePassphraseConstraints,
91   oMinPassphraseLen,
92   oMinPassphraseNonalpha,
93   oCheckPassphrasePattern,
94   oMaxPassphraseDays,
95   oEnablePassphraseHistory,
96   oUseStandardSocket,
97   oNoUseStandardSocket,
98   oFakedSystemTime,
99
100   oIgnoreCacheForSigning,
101   oAllowMarkTrusted,
102   oAllowPresetPassphrase,
103   oKeepTTY,
104   oKeepDISPLAY,
105   oSSHSupport,
106   oDisableScdaemon,
107   oWriteEnvFile
108 };
109
110
111
112 static ARGPARSE_OPTS opts[] = {
113
114   { aGPGConfList, "gpgconf-list", 256, "@" },
115   { aGPGConfTest, "gpgconf-test", 256, "@" },
116   
117   { 301, NULL, 0, N_("@Options:\n ") },
118
119   { oServer,   "server",     0, N_("run in server mode (foreground)") },
120   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
121   { oVerbose, "verbose",     0, N_("verbose") },
122   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
123   { oSh,        "sh",        0, N_("sh-style command output") },
124   { oCsh,       "csh",       0, N_("csh-style command output") },
125   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
126   { oDebug,     "debug"     ,4|16, "@"},
127   { oDebugAll, "debug-all"     ,0, "@"},
128   { oDebugLevel, "debug-level" ,2, "@"},
129   { oDebugWait,"debug-wait",1, "@"},
130   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
131   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
132   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
133   { oUseStandardSocket, "use-standard-socket", 0,
134                       N_("use a standard location for the socket")},
135   { oNoUseStandardSocket, "no-use-standard-socket", 0, "@"},
136   { oPinentryProgram, "pinentry-program", 2 ,
137                                N_("|PGM|use PGM as the PIN-Entry program") },
138   { oPinentryTouchFile, "pinentry-touch-file", 2 , "@" },
139   { oScdaemonProgram, "scdaemon-program", 2 ,
140                                N_("|PGM|use PGM as the SCdaemon program") },
141   { oDisableScdaemon, "disable-scdaemon", 0, N_("do not use the SCdaemon") },
142   { oFakedSystemTime, "faked-system-time", 2, "@" }, /* (epoch time) */
143
144   { oDisplay,    "display",     2, "@" },
145   { oTTYname,    "ttyname",     2, "@" },
146   { oTTYtype,    "ttytype",     2, "@" },
147   { oLCctype,    "lc-ctype",    2, "@" },
148   { oLCmessages, "lc-messages", 2, "@" },
149   { oXauthority, "xauthority",  2, "@" },
150   { oKeepTTY,    "keep-tty",    0,  N_("ignore requests to change the TTY")},
151   { oKeepDISPLAY, "keep-display",
152                           0, N_("ignore requests to change the X display")},
153
154   { oDefCacheTTL, "default-cache-ttl", 4,
155                                N_("|N|expire cached PINs after N seconds")},
156   { oDefCacheTTLSSH, "default-cache-ttl-ssh", 4, "@" },
157   { oMaxCacheTTL, "max-cache-ttl", 4, "@" },
158   { oMaxCacheTTLSSH, "max-cache-ttl-ssh", 4, "@" },
159
160   { oEnforcePassphraseConstraints, "enforce-passphrase-constraints", 0, "@"},
161   { oMinPassphraseLen, "min-passphrase-len", 4, "@" },
162   { oMinPassphraseNonalpha, "min-passphrase-nonalpha", 4, "@" },
163   { oCheckPassphrasePattern, "check-passphrase-pattern", 2, "@" },
164   { oMaxPassphraseDays, "max-passphrase-days", 4, "@" },
165   { oEnablePassphraseHistory, "enable-passphrase-history", 0, "@" },
166
167   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
168                                N_("do not use the PIN cache when signing")},
169   { oAllowMarkTrusted, "allow-mark-trusted", 0,
170                              N_("allow clients to mark keys as \"trusted\"")},
171   { oAllowPresetPassphrase, "allow-preset-passphrase", 0,
172                              N_("allow presetting passphrase")},
173   { oSSHSupport, "enable-ssh-support", 0, N_("enable ssh-agent emulation") },
174   { oWriteEnvFile, "write-env-file", 2|8,
175             N_("|FILE|write environment settings also to FILE")},
176   {0}
177 };
178
179
180 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
181 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
182 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
183 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
184 #define MIN_PASSPHRASE_LEN    (8)      
185 #define MIN_PASSPHRASE_NONALPHA (1)      
186 #define MAX_PASSPHRASE_DAYS   (0)
187
188 /* The timer tick used for housekeeping stuff.  For Windows we use a
189    longer period as the SetWaitableTimer seems to signal earlier than
190    the 2 seconds.  */
191 #ifdef HAVE_W32_SYSTEM
192 #define TIMERTICK_INTERVAL    (4)
193 #else
194 #define TIMERTICK_INTERVAL    (2)    /* Seconds.  */
195 #endif
196
197 /* flag to indicate that a shutdown was requested */
198 static int shutdown_pending;
199
200
201 /* It is possible that we are currently running under setuid permissions */
202 static int maybe_setuid = 1;
203
204 /* Name of the communication socket used for native gpg-agent requests.  */
205 static char *socket_name;
206
207 /* Name of the communication socket used for ssh-agent-emulation.  */
208 static char *socket_name_ssh;
209
210 /* We need to keep track of the server's nonces (these are dummies for
211    POSIX systems). */
212 static assuan_sock_nonce_t socket_nonce;
213 static assuan_sock_nonce_t socket_nonce_ssh;
214
215
216 /* Default values for options passed to the pinentry. */
217 static char *default_display;
218 static char *default_ttyname;
219 static char *default_ttytype;
220 static char *default_lc_ctype;
221 static char *default_lc_messages;
222 static char *default_xauthority;
223
224 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
225 static char *config_filename;
226
227 /* Helper to implement --debug-level */
228 static const char *debug_level;
229
230 /* Keep track of the current log file so that we can avoid updating
231    the log file after a SIGHUP if it didn't changed. Malloced. */
232 static char *current_logfile;
233
234 /* The handle_tick() function may test whether a parent is still
235    running.  We record the PID of the parent here or -1 if it should be
236    watched. */
237 static pid_t parent_pid = (pid_t)(-1);
238
239 \f
240 /*
241    Local prototypes. 
242  */
243
244 static char *create_socket_name (int use_standard_socket,
245                                  char *standard_name, char *template);
246 static gnupg_fd_t create_server_socket (int is_standard_name, char *name, 
247                                         int is_ssh, 
248                                         assuan_sock_nonce_t *nonce);
249 static void create_directories (void);
250
251 static void agent_init_default_ctrl (ctrl_t ctrl);
252 static void agent_deinit_default_ctrl (ctrl_t ctrl);
253
254 static void handle_connections (gnupg_fd_t listen_fd,
255                                 gnupg_fd_t listen_fd_ssh);
256 static int check_for_running_agent (int silent, int mode);
257
258 /* Pth wrapper function definitions. */
259 GCRY_THREAD_OPTION_PTH_IMPL;
260 static int fixed_gcry_pth_init (void)
261 {
262   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
263 }
264
265
266 #ifndef PTH_HAVE_PTH_THREAD_ID
267 static unsigned long pth_thread_id (void)
268 {
269   return (unsigned long)pth_self ();
270 }
271 #endif
272
273
274 \f
275 /*
276    Functions. 
277  */
278
279
280 static const char *
281 my_strusage (int level)
282 {
283   const char *p;
284   switch (level)
285     {
286     case 11: p = "gpg-agent (GnuPG)";
287       break;
288     case 13: p = VERSION; break;
289     case 17: p = PRINTABLE_OS_NAME; break;
290     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
291       break;
292     case 1:
293     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
294       break;
295     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
296                     "Secret key management for GnuPG\n");
297     break;
298     
299     default: p = NULL;
300     }
301   return p;
302 }
303
304
305
306 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
307    only the active debug flags are propagated to the subsystems.  With
308    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
309    all flags already set. Note that we don't fail here, because it is
310    important to keep gpg-agent running even after re-reading the
311    options due to a SIGHUP. */
312 static void
313 set_debug (void)
314 {
315   if (!debug_level)
316     ;
317   else if (!strcmp (debug_level, "none"))
318     opt.debug = 0;
319   else if (!strcmp (debug_level, "basic"))
320     opt.debug = DBG_ASSUAN_VALUE;
321   else if (!strcmp (debug_level, "advanced"))
322     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
323   else if (!strcmp (debug_level, "expert"))
324     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
325                  |DBG_CACHE_VALUE);
326   else if (!strcmp (debug_level, "guru"))
327     opt.debug = ~0;
328   else
329     {
330       log_error (_("invalid debug-level `%s' given\n"), debug_level);
331       opt.debug = 0; /* Reset debugging, so that prior debug
332                         statements won't have an undesired effect. */
333     }
334
335   if (opt.debug && !opt.verbose)
336     opt.verbose = 1;
337   if (opt.debug && opt.quiet)
338     opt.quiet = 0;
339
340   if (opt.debug & DBG_MPI_VALUE)
341     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
342   if (opt.debug & DBG_CRYPTO_VALUE )
343     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
344   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
345 }
346  
347
348 /* Helper for cleanup to remove one socket with NAME.  */
349 static void
350 remove_socket (char *name)
351 {
352   if (name && *name)
353     {
354       char *p;
355
356       remove (name);
357       p = strrchr (name, '/');
358       if (p)
359         {
360           *p = 0;
361           rmdir (name);
362           *p = '/';
363         }
364       *name = 0;
365     }
366 }  
367
368 static void
369 cleanup (void)
370 {
371   remove_socket (socket_name);
372   remove_socket (socket_name_ssh);
373 }
374
375
376
377 /* Handle options which are allowed to be reset after program start.
378    Return true when the current option in PARGS could be handled and
379    false if not.  As a special feature, passing a value of NULL for
380    PARGS, resets the options to the default.  REREAD should be set
381    true if it is not the initial option parsing. */
382 static int
383 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
384 {
385   if (!pargs)
386     { /* reset mode */
387       opt.quiet = 0;
388       opt.verbose = 0;
389       opt.debug = 0;
390       opt.no_grab = 0;
391       opt.pinentry_program = NULL;
392       opt.pinentry_touch_file = NULL;
393       opt.scdaemon_program = NULL;
394       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
395       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
396       opt.max_cache_ttl = MAX_CACHE_TTL;
397       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
398       opt.enforce_passphrase_constraints = 0;
399       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
400       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
401       opt.check_passphrase_pattern = NULL;
402       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
403       opt.enable_passhrase_history = 0;
404       opt.ignore_cache_for_signing = 0;
405       opt.allow_mark_trusted = 0;
406       opt.disable_scdaemon = 0;
407       return 1;
408     }
409
410   switch (pargs->r_opt)
411     {
412     case oQuiet: opt.quiet = 1; break;
413     case oVerbose: opt.verbose++; break;
414
415     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
416     case oDebugAll: opt.debug = ~0; break;
417     case oDebugLevel: debug_level = pargs->r.ret_str; break;
418
419     case oLogFile:
420       if (!reread)
421         return 0; /* not handeld */
422       if (!current_logfile || !pargs->r.ret_str
423           || strcmp (current_logfile, pargs->r.ret_str))
424         {
425           log_set_file (pargs->r.ret_str);
426           xfree (current_logfile);
427           current_logfile = xtrystrdup (pargs->r.ret_str);
428         }
429       break;
430
431     case oNoGrab: opt.no_grab = 1; break;
432       
433     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
434     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
435     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
436     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
437
438     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
439     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
440     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
441     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
442       
443     case oEnforcePassphraseConstraints: 
444       opt.enforce_passphrase_constraints=1;
445       break;
446     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
447     case oMinPassphraseNonalpha: 
448       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
449       break;
450     case oCheckPassphrasePattern:
451       opt.check_passphrase_pattern = pargs->r.ret_str;
452       break;
453     case oMaxPassphraseDays:
454       opt.max_passphrase_days = pargs->r.ret_ulong; 
455       break;
456     case oEnablePassphraseHistory:
457       opt.enable_passhrase_history = 1;
458       break;
459
460     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
461
462     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
463
464     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
465
466     default:
467       return 0; /* not handled */
468     }
469
470   return 1; /* handled */
471 }
472
473
474 /* The main entry point.  */
475 int
476 main (int argc, char **argv )
477 {
478   ARGPARSE_ARGS pargs;
479   int orig_argc;
480   int may_coredump;
481   char **orig_argv;
482   FILE *configfp = NULL;
483   char *configname = NULL;
484   const char *shell;
485   unsigned configlineno;
486   int parse_debug = 0;
487   int default_config =1;
488   int greeting = 0;
489   int nogreeting = 0;
490   int pipe_server = 0;
491   int is_daemon = 0;
492   int nodetach = 0;
493   int csh_style = 0;
494   char *logfile = NULL;
495   int debug_wait = 0;
496   int gpgconf_list = 0;
497   int use_standard_socket = 0;
498   gpg_error_t err;
499   const char *env_file_name = NULL;
500
501
502   set_strusage (my_strusage);
503   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
504   /* Please note that we may running SUID(ROOT), so be very CAREFUL
505      when adding any stuff between here and the call to INIT_SECMEM()
506      somewhere after the option parsing */
507   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID); 
508
509   /* Make sure that our subsystems are ready.  */
510   init_common_subsystems ();
511
512   i18n_init ();
513
514   /* Libgcrypt requires us to register the threading model first.
515      Note that this will also do the pth_init. */
516   gcry_threads_pth.init = fixed_gcry_pth_init;
517   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
518   if (err)
519     {
520       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
521                  gpg_strerror (err));
522     }
523
524
525   /* Check that the libraries are suitable.  Do it here because
526      the option parsing may need services of the library. */
527   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
528     {
529       log_fatal( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
530                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
531     }
532
533   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
534   assuan_set_assuan_log_stream (log_get_stream ());
535   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
536   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
537
538   setup_libgcrypt_logging ();
539   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
540
541   may_coredump = disable_core_dumps ();
542
543   /* Set default options.  */
544   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
545 #ifdef HAVE_W32_SYSTEM
546   use_standard_socket = 1;  /* Under Windows we always use a standard
547                                socket.  */
548 #endif
549   
550   shell = getenv ("SHELL");
551   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
552     csh_style = 1;
553
554   opt.homedir = default_homedir ();
555
556   /* Record some of the original environment strings. */
557   opt.startup_display = getenv ("DISPLAY");
558   if (opt.startup_display)
559     opt.startup_display = xstrdup (opt.startup_display);
560   opt.startup_ttyname = ttyname (0);
561   if (opt.startup_ttyname)
562     opt.startup_ttyname = xstrdup (opt.startup_ttyname);
563   opt.startup_ttytype = getenv ("TERM");
564   if (opt.startup_ttytype)
565     opt.startup_ttytype = xstrdup (opt.startup_ttytype);
566   /* Fixme: Better use the locale function here.  */
567   opt.startup_lc_ctype = getenv ("LC_CTYPE");
568   if (opt.startup_lc_ctype) 
569     opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
570   opt.startup_lc_messages = getenv ("LC_MESSAGES");
571   if (opt.startup_lc_messages)
572     opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
573   opt.startup_xauthority = getenv ("XAUTHORITY");
574   if (opt.startup_xauthority)
575     opt.startup_xauthority = xstrdup (opt.startup_xauthority);
576   opt.startup_pinentry_user_data = getenv ("PINENTRY_USER_DATA");
577   if (opt.startup_pinentry_user_data)
578     opt.startup_pinentry_user_data = xstrdup (opt.startup_pinentry_user_data);
579
580   /* Check whether we have a config file on the commandline */
581   orig_argc = argc;
582   orig_argv = argv;
583   pargs.argc = &argc;
584   pargs.argv = &argv;
585   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
586   while (arg_parse( &pargs, opts))
587     {
588       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
589         parse_debug++;
590       else if (pargs.r_opt == oOptions)
591         { /* yes there is one, so we do not try the default one, but
592              read the option file when it is encountered at the
593              commandline */
594           default_config = 0;
595         }
596         else if (pargs.r_opt == oNoOptions)
597           default_config = 0; /* --no-options */
598         else if (pargs.r_opt == oHomedir)
599           opt.homedir = pargs.r.ret_str;
600     }
601
602   /* Initialize the secure memory. */
603   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
604   maybe_setuid = 0;
605
606   /* 
607      Now we are now working under our real uid 
608   */
609
610   if (default_config)
611     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
612   
613   argc = orig_argc;
614   argv = orig_argv;
615   pargs.argc = &argc;
616   pargs.argv = &argv;
617   pargs.flags=  1;  /* do not remove the args */
618  next_pass:
619   if (configname)
620     {
621       configlineno = 0;
622       configfp = fopen (configname, "r");
623       if (!configfp)
624         {
625           if (default_config)
626             {
627               if( parse_debug )
628                 log_info (_("NOTE: no default option file `%s'\n"),
629                           configname );
630             }
631           else
632             {
633               log_error (_("option file `%s': %s\n"),
634                          configname, strerror(errno) );
635               exit(2);
636             }
637           xfree (configname); 
638           configname = NULL;
639         }
640       if (parse_debug && configname )
641         log_info (_("reading options from `%s'\n"), configname );
642       default_config = 0;
643     }
644
645   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
646     {
647       if (parse_rereadable_options (&pargs, 0))
648         continue; /* Already handled */
649       switch (pargs.r_opt)
650         {
651         case aGPGConfList: gpgconf_list = 1; break;
652         case aGPGConfTest: gpgconf_list = 2; break;
653         case oBatch: opt.batch=1; break;
654
655         case oDebugWait: debug_wait = pargs.r.ret_int; break;
656
657         case oOptions:
658           /* config files may not be nested (silently ignore them) */
659           if (!configfp)
660             {
661                 xfree(configname);
662                 configname = xstrdup(pargs.r.ret_str);
663                 goto next_pass;
664             }
665           break;
666         case oNoGreeting: nogreeting = 1; break;
667         case oNoVerbose: opt.verbose = 0; break;
668         case oNoOptions: break; /* no-options */
669         case oHomedir: opt.homedir = pargs.r.ret_str; break;
670         case oNoDetach: nodetach = 1; break;
671         case oLogFile: logfile = pargs.r.ret_str; break;
672         case oCsh: csh_style = 1; break;
673         case oSh: csh_style = 0; break;
674         case oServer: pipe_server = 1; break;
675         case oDaemon: is_daemon = 1; break;
676
677         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
678         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
679         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
680         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
681         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
682         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
683           break;
684
685         case oUseStandardSocket: use_standard_socket = 1; break;
686         case oNoUseStandardSocket: use_standard_socket = 0; break;
687
688         case oFakedSystemTime:
689           {
690             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
691             if (faked_time == (time_t)(-1))
692               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
693             gnupg_set_time (faked_time, 0);
694           }
695           break;
696
697         case oKeepTTY: opt.keep_tty = 1; break;
698         case oKeepDISPLAY: opt.keep_display = 1; break;
699
700         case oSSHSupport:  opt.ssh_support = 1; break;
701         case oWriteEnvFile:
702           if (pargs.r_type)
703             env_file_name = pargs.r.ret_str;
704           else
705             env_file_name = make_filename ("~/.gpg-agent-info", NULL);
706           break;
707
708         default : pargs.err = configfp? 1:2; break;
709         }
710     }
711   if (configfp)
712     {
713       fclose( configfp );
714       configfp = NULL;
715       /* Keep a copy of the name so that it can be read on SIGHUP. */
716       config_filename = configname;
717       configname = NULL;
718       goto next_pass;
719     }
720   xfree (configname);
721   configname = NULL;
722   if (log_get_errorcount(0))
723     exit(2);
724   if (nogreeting )
725     greeting = 0;
726
727   if (greeting)
728     {
729       fprintf (stderr, "%s %s; %s\n",
730                  strusage(11), strusage(13), strusage(14) );
731       fprintf (stderr, "%s\n", strusage(15) );
732     }
733 #ifdef IS_DEVELOPMENT_VERSION
734   /* We don't want to print it here because gpg-agent is useful of its
735      own and quite matured.  */
736   /*log_info ("NOTE: this is a development version!\n");*/
737 #endif
738
739   set_debug ();
740   
741   if (atexit (cleanup))
742     {
743       log_error ("atexit failed\n");
744       cleanup ();
745       exit (1);
746     }
747
748   initialize_module_call_pinentry ();
749   initialize_module_call_scd ();
750   initialize_module_trustlist ();
751   
752   /* Try to create missing directories. */
753   create_directories ();
754
755   if (debug_wait && pipe_server)
756     {
757       log_debug ("waiting for debugger - my pid is %u .....\n",
758                  (unsigned int)getpid());
759       gnupg_sleep (debug_wait);
760       log_debug ("... okay\n");
761     }
762   
763   if (gpgconf_list == 2)
764     agent_exit (0);
765   if (gpgconf_list)
766     {
767       char *filename;
768       char *filename_esc;
769
770       /* List options and default values in the GPG Conf format.  */
771       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
772       filename_esc = percent_escape (filename, NULL);
773
774       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
775               GC_OPT_FLAG_DEFAULT, filename_esc);
776       xfree (filename);
777       xfree (filename_esc);
778
779       printf ("verbose:%lu:\n"
780               "quiet:%lu:\n"
781               "debug-level:%lu:\"none:\n"
782               "log-file:%lu:\n",
783               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
784               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
785               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
786               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
787       printf ("default-cache-ttl:%lu:%d:\n",
788               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
789       printf ("default-cache-ttl-ssh:%lu:%d:\n",
790               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
791       printf ("max-cache-ttl:%lu:%d:\n",
792               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
793       printf ("max-cache-ttl-ssh:%lu:%d:\n",
794               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
795       printf ("enforce-passphrase-constraints:%lu:\n", 
796               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
797       printf ("min-passphrase-len:%lu:%d:\n",
798               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
799       printf ("min-passphrase-nonalpha:%lu:%d:\n",
800               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, 
801               MIN_PASSPHRASE_NONALPHA);
802       printf ("check-passphrase-pattern:%lu:\n",
803               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
804       printf ("max-passphrase-days:%lu:%d:\n",
805               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, 
806               MAX_PASSPHRASE_DAYS);
807       printf ("enable-passphrase-history:%lu:\n", 
808               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
809       printf ("no-grab:%lu:\n", 
810               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
811       printf ("ignore-cache-for-signing:%lu:\n",
812               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
813       printf ("allow-mark-trusted:%lu:\n",
814               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
815       printf ("disable-scdaemon:%lu:\n",
816               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
817
818       agent_exit (0);
819     }
820
821   /* If this has been called without any options, we merely check
822      whether an agent is already running.  We do this here so that we
823      don't clobber a logfile but print it directly to stderr. */
824   if (!pipe_server && !is_daemon)
825     {
826       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
827       check_for_running_agent (0, 0);
828       agent_exit (0);
829     }
830   
831 #ifdef ENABLE_NLS
832   /* gpg-agent usually does not output any messages because it runs in
833      the background.  For log files it is acceptable to have messages
834      always encoded in utf-8.  We switch here to utf-8, so that
835      commands like --help still give native messages.  It is far
836      easier to switch only once instead of for every message and it
837      actually helps when more then one thread is active (avoids an
838      extra copy step). */
839     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
840 #endif
841
842   /* Now start with logging to a file if this is desired. */
843   if (logfile)
844     {
845       log_set_file (logfile);
846       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
847                              |JNLIB_LOG_WITH_TIME
848                              |JNLIB_LOG_WITH_PID));
849       current_logfile = xstrdup (logfile);
850       assuan_set_assuan_log_stream (log_get_stream ());
851     }
852
853   /* Make sure that we have a default ttyname. */
854   if (!default_ttyname && ttyname (1))
855     default_ttyname = xstrdup (ttyname (1));
856   if (!default_ttytype && getenv ("TERM"))
857     default_ttytype = xstrdup (getenv ("TERM"));
858
859
860   if (pipe_server)
861     { 
862       /* This is the simple pipe based server */
863       ctrl_t ctrl;
864
865       ctrl = xtrycalloc (1, sizeof *ctrl);
866       if (!ctrl)
867         {
868           log_error ("error allocating connection control data: %s\n",
869                      strerror (errno) );
870           agent_exit (1);
871         }
872       agent_init_default_ctrl (ctrl);
873       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
874       agent_deinit_default_ctrl (ctrl);
875       xfree (ctrl);
876     }
877   else if (!is_daemon)
878     ; /* NOTREACHED */
879   else
880     { /* Regular server mode */
881       gnupg_fd_t fd;
882       gnupg_fd_t fd_ssh;
883       pid_t pid;
884
885       /* Remove the DISPLAY variable so that a pinentry does not
886          default to a specific display.  There is still a default
887          display when gpg-agent was started using --display or a
888          client requested this using an OPTION command.  Note, that we
889          don't do this when running in reverse daemon mode (i.e. when
890          exec the program given as arguments). */
891 #ifndef HAVE_W32_SYSTEM
892       if (!opt.keep_display && !argc)
893         unsetenv ("DISPLAY");
894 #endif
895
896
897       /* Create the sockets.  */
898       socket_name = create_socket_name (use_standard_socket,
899                                         "S.gpg-agent",
900                                         "/tmp/gpg-XXXXXX/S.gpg-agent");
901       if (opt.ssh_support)
902         socket_name_ssh = create_socket_name (use_standard_socket, 
903                                             "S.gpg-agent.ssh",
904                                             "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
905
906       fd = create_server_socket (use_standard_socket, socket_name, 0,
907                                  &socket_nonce);
908       if (opt.ssh_support)
909         fd_ssh = create_server_socket (use_standard_socket, socket_name_ssh, 1,
910                                        &socket_nonce_ssh);
911       else
912         fd_ssh = GNUPG_INVALID_FD;
913
914       /* If we are going to exec a program in the parent, we record
915          the PID, so that the child may check whether the program is
916          still alive. */
917       if (argc)
918         parent_pid = getpid ();
919
920       fflush (NULL);
921 #ifdef HAVE_W32_SYSTEM
922       pid = getpid ();
923       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
924 #else /*!HAVE_W32_SYSTEM*/
925       pid = fork ();
926       if (pid == (pid_t)-1) 
927         {
928           log_fatal ("fork failed: %s\n", strerror (errno) );
929           exit (1);
930         }
931       else if (pid) 
932         { /* We are the parent */
933           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
934           
935           close (fd);
936           
937           /* Create the info string: <name>:<pid>:<protocol_version> */
938           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
939                         socket_name, (ulong)pid ) < 0)
940             {
941               log_error ("out of core\n");
942               kill (pid, SIGTERM);
943               exit (1);
944             }
945           if (opt.ssh_support)
946             {
947               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
948                             socket_name_ssh) < 0)
949                 {
950                   log_error ("out of core\n");
951                   kill (pid, SIGTERM);
952                   exit (1);
953                 }
954               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
955                             pid) < 0)
956                 {
957                   log_error ("out of core\n");
958                   kill (pid, SIGTERM);
959                   exit (1);
960                 }
961             }
962
963           *socket_name = 0; /* Don't let cleanup() remove the socket -
964                                the child should do this from now on */
965           if (opt.ssh_support)
966             *socket_name_ssh = 0;
967
968           if (env_file_name)
969             {
970               FILE *fp;
971               
972               fp = fopen (env_file_name, "w");
973               if (!fp)
974                 log_error (_("error creating `%s': %s\n"),
975                              env_file_name, strerror (errno));
976               else
977                 {
978                   fputs (infostr, fp);
979                   putc ('\n', fp);
980                   if (opt.ssh_support)
981                     {
982                       fputs (infostr_ssh_sock, fp);
983                       putc ('\n', fp);
984                       fputs (infostr_ssh_pid, fp);
985                       putc ('\n', fp);
986                     }
987                   fclose (fp);
988                 }
989             }
990
991
992           if (argc) 
993             { /* Run the program given on the commandline.  */
994               if (putenv (infostr))
995                 {
996                   log_error ("failed to set environment: %s\n",
997                              strerror (errno) );
998                   kill (pid, SIGTERM );
999                   exit (1);
1000                 }
1001               if (opt.ssh_support && putenv (infostr_ssh_sock))
1002                 {
1003                   log_error ("failed to set environment: %s\n",
1004                              strerror (errno) );
1005                   kill (pid, SIGTERM );
1006                   exit (1);
1007                 }
1008               if (opt.ssh_support && putenv (infostr_ssh_pid))
1009                 {
1010                   log_error ("failed to set environment: %s\n",
1011                              strerror (errno) );
1012                   kill (pid, SIGTERM );
1013                   exit (1);
1014                 }
1015               execvp (argv[0], argv);
1016               log_error ("failed to run the command: %s\n", strerror (errno));
1017               kill (pid, SIGTERM);
1018               exit (1);
1019             }
1020           else
1021             {
1022               /* Print the environment string, so that the caller can use
1023                  shell's eval to set it */
1024               if (csh_style)
1025                 {
1026                   *strchr (infostr, '=') = ' ';
1027                   printf ("setenv %s\n", infostr);
1028                   if (opt.ssh_support)
1029                     {
1030                       *strchr (infostr_ssh_sock, '=') = ' ';
1031                       printf ("setenv %s\n", infostr_ssh_sock);
1032                       *strchr (infostr_ssh_pid, '=') = ' ';
1033                       printf ("setenv %s\n", infostr_ssh_pid);
1034                     }
1035                 }
1036               else
1037                 {
1038                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1039                   if (opt.ssh_support)
1040                     {
1041                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
1042                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
1043                     }
1044                 }
1045               xfree (infostr); 
1046               if (opt.ssh_support)
1047                 {
1048                   xfree (infostr_ssh_sock);
1049                   xfree (infostr_ssh_pid);
1050                 }
1051               exit (0); 
1052             }
1053           /*NOTREACHED*/
1054         } /* End parent */
1055
1056       /* 
1057          This is the child
1058        */
1059
1060       /* Detach from tty and put process into a new session */
1061       if (!nodetach )
1062         { 
1063           int i;
1064           unsigned int oldflags;
1065
1066           /* Close stdin, stdout and stderr unless it is the log stream */
1067           for (i=0; i <= 2; i++) 
1068             {
1069               if (!log_test_fd (i) && i != fd )
1070                 {
1071                   if ( ! close (i)
1072                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1073                     {
1074                       log_error ("failed to open `%s': %s\n",
1075                                  "/dev/null", strerror (errno));
1076                       cleanup ();
1077                       exit (1);
1078                     }
1079                 }
1080             }
1081           if (setsid() == -1)
1082             {
1083               log_error ("setsid() failed: %s\n", strerror(errno) );
1084               cleanup ();
1085               exit (1);
1086             }
1087
1088           log_get_prefix (&oldflags);
1089           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1090           opt.running_detached = 1;
1091         }
1092
1093       if (chdir("/"))
1094         {
1095           log_error ("chdir to / failed: %s\n", strerror (errno));
1096           exit (1);
1097         }
1098
1099       {
1100         struct sigaction sa;
1101         
1102         sa.sa_handler = SIG_IGN;
1103         sigemptyset (&sa.sa_mask);
1104         sa.sa_flags = 0;
1105         sigaction (SIGPIPE, &sa, NULL);
1106       }
1107 #endif /*!HAVE_W32_SYSTEM*/
1108
1109       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1110       assuan_sock_close (fd);
1111     }
1112   
1113   return 0;
1114 }
1115
1116
1117 void
1118 agent_exit (int rc)
1119 {
1120   /*FIXME: update_random_seed_file();*/
1121 #if 1
1122   /* at this time a bit annoying */
1123   if (opt.debug & DBG_MEMSTAT_VALUE)
1124     {
1125       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1126       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1127     }
1128   if (opt.debug)
1129     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1130 #endif
1131   gcry_control (GCRYCTL_TERM_SECMEM );
1132   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1133   exit (rc);
1134 }
1135
1136 static void
1137 agent_init_default_ctrl (ctrl_t ctrl)
1138 {
1139   /* Note we ignore malloc errors because we can't do much about it
1140      and the request will fail anyway shortly after this
1141      initialization. */
1142   if (ctrl->display)
1143     xfree (ctrl->display);
1144   ctrl->display = default_display? xtrystrdup (default_display) : NULL;
1145
1146   if (ctrl->ttyname)
1147     xfree (ctrl->ttyname);
1148   ctrl->ttyname = default_ttyname? xtrystrdup (default_ttyname) : NULL;
1149
1150   if (ctrl->ttytype)
1151     xfree (ctrl->ttytype);
1152   ctrl->ttytype = default_ttytype? xtrystrdup (default_ttytype) : NULL;
1153
1154   if (ctrl->lc_ctype)
1155     xfree (ctrl->lc_ctype);
1156   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1157
1158   if (ctrl->lc_messages)
1159     xfree (ctrl->lc_messages);
1160   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1161                                     /**/ : NULL;
1162
1163   if (ctrl->xauthority)
1164     xfree (ctrl->xauthority);
1165   ctrl->xauthority = default_xauthority? xtrystrdup (default_xauthority)
1166                                    /**/: NULL;
1167
1168   if (ctrl->pinentry_user_data)
1169     xfree (ctrl->pinentry_user_data);
1170   ctrl->pinentry_user_data = NULL;
1171 }
1172
1173
1174 static void
1175 agent_deinit_default_ctrl (ctrl_t ctrl)
1176 {
1177   if (ctrl->display)
1178     xfree (ctrl->display);
1179   if (ctrl->ttyname)
1180     xfree (ctrl->ttyname);
1181   if (ctrl->ttytype)
1182     xfree (ctrl->ttytype);
1183   if (ctrl->lc_ctype)
1184     xfree (ctrl->lc_ctype);
1185   if (ctrl->lc_messages)
1186     xfree (ctrl->lc_messages);
1187   if (ctrl->xauthority)
1188     xfree (ctrl->xauthority);
1189   if (ctrl->pinentry_user_data)
1190     xfree (ctrl->pinentry_user_data);
1191 }
1192
1193 /* Reread parts of the configuration.  Note, that this function is
1194    obviously not thread-safe and should only be called from the PTH
1195    signal handler. 
1196
1197    Fixme: Due to the way the argument parsing works, we create a
1198    memory leak here for all string type arguments.  There is currently
1199    no clean way to tell whether the memory for the argument has been
1200    allocated or points into the process' original arguments.  Unless
1201    we have a mechanism to tell this, we need to live on with this. */
1202 static void
1203 reread_configuration (void)
1204 {
1205   ARGPARSE_ARGS pargs;
1206   FILE *fp;
1207   unsigned int configlineno = 0;
1208   int dummy;
1209
1210   if (!config_filename)
1211     return; /* No config file. */
1212
1213   fp = fopen (config_filename, "r");
1214   if (!fp)
1215     {
1216       log_error (_("option file `%s': %s\n"),
1217                  config_filename, strerror(errno) );
1218       return;
1219     }
1220
1221   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1222
1223   memset (&pargs, 0, sizeof pargs);
1224   dummy = 0;
1225   pargs.argc = &dummy;
1226   pargs.flags = 1;  /* do not remove the args */
1227   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1228     {
1229       if (pargs.r_opt < -1)
1230         pargs.err = 1; /* Print a warning. */
1231       else /* Try to parse this option - ignore unchangeable ones. */
1232         parse_rereadable_options (&pargs, 1);
1233     }
1234   fclose (fp);
1235   set_debug ();
1236 }
1237
1238
1239 /* Return the file name of the socket we are using for native
1240    requests.  */
1241 const char *
1242 get_agent_socket_name (void)
1243 {
1244   const char *s = socket_name;
1245
1246   return (s && *s)? s : NULL;
1247 }
1248
1249 /* Return the file name of the socket we are using for SSH
1250    requests.  */
1251 const char *
1252 get_agent_ssh_socket_name (void)
1253 {
1254   const char *s = socket_name_ssh;
1255
1256   return (s && *s)? s : NULL;
1257 }
1258
1259
1260 /* Under W32, this function returns the handle of the scdaemon
1261    notification event.  Calling it the first time creates that
1262    event.  */
1263 #ifdef HAVE_W32_SYSTEM
1264 void *
1265 get_agent_scd_notify_event (void)
1266 {
1267   static HANDLE the_event;
1268
1269   if (!the_event)
1270     {
1271       HANDLE h, h2;
1272       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1273
1274       /* We need to use manual reset evet object due to the way our
1275          w32-pth wait function works: If we would use an automatic
1276          reset event we are not able to figure out which handle has
1277          been signaled because at the time we single out the signaled
1278          handles using WFSO the event has already been reset due to
1279          the WFMO.  */
1280       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1281       if (!h)
1282         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1283       else if (!DuplicateHandle (GetCurrentProcess(), h,
1284                                  GetCurrentProcess(), &h2,
1285                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0)) 
1286         {
1287           log_error ("setting syncronize for scd notify event failed: %s\n",
1288                      w32_strerror (-1) );
1289           CloseHandle (h);
1290         }
1291       else
1292         {
1293           CloseHandle (h);
1294           the_event = h2;
1295         }
1296     }
1297
1298   log_debug  ("returning notify handle %p\n", the_event);
1299   return the_event;
1300 }
1301 #endif /*HAVE_W32_SYSTEM*/
1302
1303
1304
1305 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1306    true using STANDARD_NAME in the home directory or if given as
1307    false from the mkdir type name TEMPLATE.  In the latter case a
1308    unique name in a unique new directory will be created.  In both
1309    cases check for valid characters as well as against a maximum
1310    allowed length for a unix domain socket is done.  The function
1311    terminates the process in case of an error.  Returns: Pointer to an
1312    allocated string with the absolute name of the socket used.  */
1313 static char *
1314 create_socket_name (int use_standard_socket,
1315                     char *standard_name, char *template)
1316 {
1317   char *name, *p;
1318
1319   if (use_standard_socket)
1320     name = make_filename (opt.homedir, standard_name, NULL);
1321   else
1322     {
1323       name = xstrdup (template);
1324       p = strrchr (name, '/');
1325       if (!p)
1326         BUG ();
1327       *p = 0;
1328       if (!mkdtemp (name))
1329         {
1330           log_error (_("can't create directory `%s': %s\n"),
1331                      name, strerror (errno));
1332           agent_exit (2);
1333         }
1334       *p = '/';
1335     }
1336
1337   if (strchr (name, PATHSEP_C))
1338     {
1339       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1340       agent_exit (2);
1341     }
1342   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1343     {
1344       log_error (_("name of socket too long\n"));
1345       agent_exit (2);
1346     }
1347   return name;
1348 }
1349
1350
1351
1352 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1353    whether a non-random socket is used.  Returns the file descriptor
1354    or terminates the process in case of an error.  Not that this
1355    function needs to be used for the regular socket first and only then
1356    for the ssh socket.  */
1357 static gnupg_fd_t
1358 create_server_socket (int is_standard_name, char *name, int is_ssh,
1359                       assuan_sock_nonce_t *nonce)
1360 {
1361   struct sockaddr_un *serv_addr;
1362   socklen_t len;
1363   gnupg_fd_t fd;
1364   int rc;
1365
1366   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1367   if (fd == ASSUAN_INVALID_FD)
1368     {
1369       log_error (_("can't create socket: %s\n"), strerror (errno));
1370       agent_exit (2);
1371     }
1372
1373   serv_addr = xmalloc (sizeof (*serv_addr)); 
1374   memset (serv_addr, 0, sizeof *serv_addr);
1375   serv_addr->sun_family = AF_UNIX;
1376   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1377     {
1378       log_error (_("socket name `%s' is too long\n"), name);
1379       agent_exit (2);
1380     }
1381   strcpy (serv_addr->sun_path, name);
1382   len = (offsetof (struct sockaddr_un, sun_path)
1383          + strlen (serv_addr->sun_path) + 1);
1384
1385   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1386   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1387     {
1388       /* Check whether a gpg-agent is already running on the standard
1389          socket.  We do this test only if this is not the ssh socket.
1390          For ssh we assume that a test for gpg-agent has already been
1391          done and reuse the requested ssh socket.  Testing the
1392          ssh-socket is not possible because at this point, though we
1393          know the new Assuan socket, the Assuan server and thus the
1394          ssh-agent server is not yet operational.  This would lead to
1395          a hang.  */
1396       if (!is_ssh && !check_for_running_agent (1, 1))
1397         {
1398           log_error (_("a gpg-agent is already running - "
1399                        "not starting a new one\n"));
1400           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1401           assuan_sock_close (fd);
1402           agent_exit (2);
1403         }
1404       remove (name);
1405       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1406     }
1407   if (rc != -1 
1408       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1409     log_error (_("error getting nonce for the socket\n"));
1410   if (rc == -1)
1411     {
1412       /* We use gpg_strerror here because it allows us to get strings
1413          for some W32 socket error codes.  */
1414       log_error (_("error binding socket to `%s': %s\n"),
1415                  serv_addr->sun_path, 
1416                  gpg_strerror (gpg_error_from_errno (errno)));
1417       
1418       assuan_sock_close (fd);
1419       if (is_standard_name)
1420         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1421       agent_exit (2);
1422     }
1423
1424   if (listen (FD2INT(fd), 5 ) == -1)
1425     {
1426       log_error (_("listen() failed: %s\n"), strerror (errno));
1427       assuan_sock_close (fd);
1428       agent_exit (2);
1429     }
1430           
1431   if (opt.verbose)
1432     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1433
1434   return fd;
1435 }
1436
1437
1438 /* Check that the directory for storing the private keys exists and
1439    create it if not.  This function won't fail as it is only a
1440    convenience function and not strictly necessary.  */
1441 static void
1442 create_private_keys_directory (const char *home)
1443 {
1444   char *fname;
1445   struct stat statbuf;
1446
1447   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1448   if (stat (fname, &statbuf) && errno == ENOENT)
1449     {
1450 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1451       if (!CreateDirectory (fname, NULL))
1452         log_error (_("can't create directory `%s': %s\n"),
1453                    fname, w32_strerror (-1) );
1454 #else
1455       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1456         log_error (_("can't create directory `%s': %s\n"),
1457                    fname, strerror (errno) );
1458 #endif
1459       else if (!opt.quiet)
1460         log_info (_("directory `%s' created\n"), fname);
1461     }
1462   xfree (fname);
1463 }
1464
1465 /* Create the directory only if the supplied directory name is the
1466    same as the default one.  This way we avoid to create arbitrary
1467    directories when a non-default home directory is used.  To cope
1468    with HOME, we compare only the suffix if we see that the default
1469    homedir does start with a tilde.  We don't stop here in case of
1470    problems because other functions will throw an error anyway.*/
1471 static void
1472 create_directories (void)
1473 {
1474   struct stat statbuf;
1475   const char *defhome = standard_homedir ();
1476   char *home;
1477
1478   home = make_filename (opt.homedir, NULL);
1479   if ( stat (home, &statbuf) )
1480     {
1481       if (errno == ENOENT)
1482         {
1483           if (
1484 #ifdef HAVE_W32_SYSTEM
1485               ( !compare_filenames (home, defhome) )
1486 #else
1487               (*defhome == '~'
1488                 && (strlen (home) >= strlen (defhome+1)
1489                     && !strcmp (home + strlen(home)
1490                                 - strlen (defhome+1), defhome+1)))
1491                || (*defhome != '~' && !strcmp (home, defhome) )
1492 #endif
1493                )
1494             {
1495 #ifdef HAVE_W32_SYSTEM
1496               if (!CreateDirectory (home, NULL))
1497                 log_error (_("can't create directory `%s': %s\n"),
1498                            home, w32_strerror (-1) );
1499 #else
1500               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1501                 log_error (_("can't create directory `%s': %s\n"),
1502                            home, strerror (errno) );
1503 #endif
1504               else 
1505                 {
1506                   if (!opt.quiet)
1507                     log_info (_("directory `%s' created\n"), home);
1508                   create_private_keys_directory (home);
1509                 }
1510             }
1511         }
1512       else
1513         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1514     }
1515   else if ( !S_ISDIR(statbuf.st_mode))
1516     {
1517       log_error (_("can't use `%s' as home directory\n"), home);
1518     }
1519   else /* exists and is a directory. */
1520     {
1521       create_private_keys_directory (home);
1522     }
1523   xfree (home);
1524 }
1525
1526
1527
1528 /* This is the worker for the ticker.  It is called every few seconds
1529    and may only do fast operations. */
1530 static void
1531 handle_tick (void)
1532 {
1533   /* Check whether the scdaemon has died and cleanup in this case. */
1534   agent_scd_check_aliveness ();
1535
1536   /* If we are running as a child of another process, check whether
1537      the parent is still alive and shutdown if not. */
1538 #ifndef HAVE_W32_SYSTEM
1539   if (parent_pid != (pid_t)(-1))
1540     {
1541       if (kill (parent_pid, 0))
1542         {
1543           shutdown_pending = 2;
1544           log_info ("parent process died - shutting down\n");
1545           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1546           cleanup ();
1547           agent_exit (0);
1548         }
1549     }
1550 #endif /*HAVE_W32_SYSTEM*/
1551 }
1552
1553
1554 /* A global function which allows us to call the reload stuff from
1555    other places too.  This is only used when build for W32.  */
1556 void
1557 agent_sighup_action (void)
1558 {
1559   log_info ("SIGHUP received - "
1560             "re-reading configuration and flushing cache\n");
1561   agent_flush_cache ();
1562   reread_configuration ();
1563   agent_reload_trustlist ();
1564 }
1565
1566
1567 static void
1568 agent_sigusr2_action (void)
1569 {
1570   if (opt.verbose)
1571     log_info ("SIGUSR2 received - checking smartcard status\n");
1572   /* Nothing to check right now.  We only increment a counter.  */
1573   bump_card_eventcounter ();
1574 }
1575
1576
1577 static void
1578 handle_signal (int signo)
1579 {
1580   switch (signo)
1581     {
1582 #ifndef HAVE_W32_SYSTEM
1583     case SIGHUP:
1584       agent_sighup_action ();
1585       break;
1586       
1587     case SIGUSR1:
1588       log_info ("SIGUSR1 received - printing internal information:\n");
1589       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1590       agent_query_dump_state ();
1591       agent_scd_dump_state ();
1592       break;
1593       
1594     case SIGUSR2:
1595       agent_sigusr2_action ();
1596       break;
1597
1598     case SIGTERM:
1599       if (!shutdown_pending)
1600         log_info ("SIGTERM received - shutting down ...\n");
1601       else
1602         log_info ("SIGTERM received - still %ld running threads\n",
1603                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1604       shutdown_pending++;
1605       if (shutdown_pending > 2)
1606         {
1607           log_info ("shutdown forced\n");
1608           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1609           cleanup ();
1610           agent_exit (0);
1611         }
1612       break;
1613         
1614     case SIGINT:
1615       log_info ("SIGINT received - immediate shutdown\n");
1616       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1617       cleanup ();
1618       agent_exit (0);
1619       break;
1620 #endif
1621     default:
1622       log_info ("signal %d received - no action defined\n", signo);
1623     }
1624 }
1625
1626
1627 /* Check the nonce on a new connection.  This is a NOP unless we we
1628    are using our Unix domain socket emulation under Windows.  */
1629 static int 
1630 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1631 {
1632   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1633     {
1634       log_info (_("error reading nonce on fd %d: %s\n"), 
1635                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1636       assuan_sock_close (ctrl->thread_startup.fd);
1637       xfree (ctrl);
1638       return -1;
1639     }
1640   else
1641     return 0;
1642 }
1643
1644
1645 /* This is the standard connection thread's main function.  */
1646 static void *
1647 start_connection_thread (void *arg)
1648 {
1649   ctrl_t ctrl = arg;
1650
1651   if (check_nonce (ctrl, &socket_nonce))
1652     return NULL;
1653
1654   agent_init_default_ctrl (ctrl);
1655   if (opt.verbose)
1656     log_info (_("handler 0x%lx for fd %d started\n"), 
1657               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1658
1659   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1660   if (opt.verbose)
1661     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1662               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1663   
1664   agent_deinit_default_ctrl (ctrl);
1665   xfree (ctrl);
1666   return NULL;
1667 }
1668
1669
1670 /* This is the ssh connection thread's main function.  */
1671 static void *
1672 start_connection_thread_ssh (void *arg)
1673 {
1674   ctrl_t ctrl = arg;
1675
1676   if (check_nonce (ctrl, &socket_nonce_ssh))
1677     return NULL;
1678
1679   agent_init_default_ctrl (ctrl);
1680   if (opt.verbose)
1681     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1682               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1683
1684   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1685   if (opt.verbose)
1686     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1687               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1688   
1689   agent_deinit_default_ctrl (ctrl);
1690   xfree (ctrl);
1691   return NULL;
1692 }
1693
1694
1695 /* Connection handler loop.  Wait for connection requests and spawn a
1696    thread after accepting a connection.  */
1697 static void
1698 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1699 {
1700   pth_attr_t tattr;
1701   pth_event_t ev, time_ev;
1702   sigset_t sigs;
1703   int signo;
1704   struct sockaddr_un paddr;
1705   socklen_t plen;
1706   fd_set fdset, read_fdset;
1707   int ret;
1708   gnupg_fd_t fd;
1709   int nfd;
1710
1711   tattr = pth_attr_new();
1712   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1713   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1714
1715 #ifndef HAVE_W32_SYSTEM /* fixme */
1716   /* Make sure that the signals we are going to handle are not blocked
1717      and create an event object for them. */
1718   sigemptyset (&sigs );
1719   sigaddset (&sigs, SIGHUP);
1720   sigaddset (&sigs, SIGUSR1);
1721   sigaddset (&sigs, SIGUSR2);
1722   sigaddset (&sigs, SIGINT);
1723   sigaddset (&sigs, SIGTERM);
1724   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1725   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1726 #else
1727 # ifdef PTH_EVENT_HANDLE
1728   sigs = 0;
1729   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1730   signo = 0;
1731 # else
1732   /* Use a dummy event. */
1733   sigs = 0;
1734   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1735 # endif
1736 #endif
1737   time_ev = NULL;
1738
1739   FD_ZERO (&fdset);
1740   FD_SET (FD2INT (listen_fd), &fdset);
1741   nfd = FD2INT (listen_fd);
1742   if (listen_fd_ssh != GNUPG_INVALID_FD)
1743     {
1744       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1745       if (FD2INT (listen_fd_ssh) > nfd)
1746         nfd = FD2INT (listen_fd_ssh);
1747     }
1748
1749   for (;;)
1750     {
1751       sigset_t oldsigs;
1752
1753       if (shutdown_pending)
1754         {
1755           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1756             break; /* ready */
1757
1758           /* Do not accept anymore connections and wait for existing
1759              connections to terminate */
1760           signo = 0;
1761           pth_wait (ev);
1762           if (pth_event_occurred (ev) && signo)
1763             handle_signal (signo);
1764           continue;
1765         }
1766
1767       /* Create a timeout event if needed. */
1768       if (!time_ev)
1769         time_ev = pth_event (PTH_EVENT_TIME, 
1770                              pth_timeout (TIMERTICK_INTERVAL, 0));
1771
1772       /* POSIX says that fd_set should be implemented as a structure,
1773          thus a simple assignment is fine to copy the entire set.  */
1774       read_fdset = fdset;
1775
1776       if (time_ev)
1777         pth_event_concat (ev, time_ev, NULL);
1778       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1779       if (time_ev)
1780         pth_event_isolate (time_ev);
1781
1782       if (ret == -1)
1783         {
1784           if (pth_event_occurred (ev)
1785               || (time_ev && pth_event_occurred (time_ev)))
1786             {
1787               if (pth_event_occurred (ev))
1788                 {
1789 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1790                   agent_sigusr2_action ();
1791 #else
1792                   handle_signal (signo);
1793 #endif
1794                 }
1795               if (time_ev && pth_event_occurred (time_ev))
1796                 {
1797                   pth_event_free (time_ev, PTH_FREE_ALL);
1798                   time_ev = NULL;
1799                   handle_tick ();
1800                 }
1801               continue;
1802             }
1803           log_error (_("pth_select failed: %s - waiting 1s\n"),
1804                      strerror (errno));
1805           pth_sleep (1);
1806           continue;
1807         }
1808
1809       if (pth_event_occurred (ev))
1810         {
1811 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1812           agent_sigusr2_action ();
1813 #else
1814           handle_signal (signo);
1815 #endif
1816         }
1817
1818       if (time_ev && pth_event_occurred (time_ev))
1819         {
1820           pth_event_free (time_ev, PTH_FREE_ALL);
1821           time_ev = NULL;
1822           handle_tick ();
1823         }
1824
1825       
1826       /* We now might create new threads and because we don't want any
1827          signals (as we are handling them here) to be delivered to a
1828          new thread.  Thus we need to block those signals. */
1829       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1830
1831       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
1832         {
1833           ctrl_t ctrl;
1834
1835           plen = sizeof paddr;
1836           fd = INT2FD (pth_accept (FD2INT(listen_fd),
1837                                    (struct sockaddr *)&paddr, &plen));
1838           if (fd == GNUPG_INVALID_FD)
1839             {
1840               log_error ("accept failed: %s\n", strerror (errno));
1841             }
1842           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1843             {
1844               log_error ("error allocating connection control data: %s\n",
1845                          strerror (errno) );
1846               assuan_sock_close (fd);
1847             }
1848           else 
1849             {
1850               char threadname[50];
1851
1852               snprintf (threadname, sizeof threadname-1,
1853                         "conn fd=%d (gpg)", FD2INT(fd));
1854               threadname[sizeof threadname -1] = 0;
1855               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1856               ctrl->thread_startup.fd = fd;
1857               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1858                 {
1859                   log_error ("error spawning connection handler: %s\n",
1860                              strerror (errno) );
1861                   assuan_sock_close (fd);
1862                   xfree (ctrl);
1863                 }
1864             }
1865           fd = GNUPG_INVALID_FD;
1866         }
1867
1868       if (listen_fd_ssh != GNUPG_INVALID_FD 
1869           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
1870         {
1871           ctrl_t ctrl;
1872
1873           plen = sizeof paddr;
1874           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
1875                                   (struct sockaddr *)&paddr, &plen));
1876           if (fd == GNUPG_INVALID_FD)
1877             {
1878               log_error ("accept failed for ssh: %s\n", strerror (errno));
1879             }
1880           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1881             {
1882               log_error ("error allocating connection control data: %s\n",
1883                          strerror (errno) );
1884               assuan_sock_close (fd);
1885             }
1886           else
1887             {
1888               char threadname[50];
1889
1890               agent_init_default_ctrl (ctrl);
1891               snprintf (threadname, sizeof threadname-1,
1892                         "conn fd=%d (ssh)", FD2INT(fd));
1893               threadname[sizeof threadname -1] = 0;
1894               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1895               ctrl->thread_startup.fd = fd;
1896               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
1897                 {
1898                   log_error ("error spawning ssh connection handler: %s\n",
1899                              strerror (errno) );
1900                   assuan_sock_close (fd);
1901                   xfree (ctrl);
1902                 }
1903             }
1904           fd = GNUPG_INVALID_FD;
1905         }
1906
1907       /* Restore the signal mask. */
1908       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1909
1910     }
1911
1912   pth_event_free (ev, PTH_FREE_ALL);
1913   if (time_ev)
1914     pth_event_free (time_ev, PTH_FREE_ALL);
1915   cleanup ();
1916   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1917 }
1918
1919
1920 /* Figure out whether an agent is available and running. Prints an
1921    error if not.  If SILENT is true, no messages are printed.  Usually
1922    started with MODE 0.  Returns 0 if the agent is running. */
1923 static int
1924 check_for_running_agent (int silent, int mode)
1925 {
1926   int rc;
1927   char *infostr, *p;
1928   assuan_context_t ctx;
1929   int prot, pid;
1930
1931   if (!mode)
1932     {
1933       infostr = getenv ("GPG_AGENT_INFO");
1934       if (!infostr || !*infostr)
1935         {
1936           if (!check_for_running_agent (silent, 1))
1937             return 0; /* Okay, its running on the standard socket. */
1938           if (!silent)
1939             log_error (_("no gpg-agent running in this session\n"));
1940           return -1;
1941         }
1942
1943       infostr = xstrdup (infostr);
1944       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1945         {
1946           xfree (infostr);
1947           if (!check_for_running_agent (silent, 1))
1948             return 0; /* Okay, its running on the standard socket. */
1949           if (!silent)
1950             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1951           return -1;
1952         }
1953
1954       *p++ = 0;
1955       pid = atoi (p);
1956       while (*p && *p != PATHSEP_C)
1957         p++;
1958       prot = *p? atoi (p+1) : 0;
1959       if (prot != 1)
1960         {
1961           xfree (infostr);
1962           if (!silent)
1963             log_error (_("gpg-agent protocol version %d is not supported\n"),
1964                        prot);
1965           if (!check_for_running_agent (silent, 1))
1966             return 0; /* Okay, its running on the standard socket. */
1967           return -1;
1968         }
1969     }
1970   else /* MODE != 0 */
1971     {
1972       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1973       pid = (pid_t)(-1);
1974     }
1975
1976
1977   rc = assuan_socket_connect (&ctx, infostr, pid);
1978   xfree (infostr);
1979   if (rc)
1980     {
1981       if (!mode && !check_for_running_agent (silent, 1))
1982         return 0; /* Okay, its running on the standard socket. */
1983
1984       if (!mode && !silent)
1985         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
1986       return -1;
1987     }
1988
1989   if (!opt.quiet && !silent)
1990     log_info ("gpg-agent running and available\n");
1991
1992   assuan_disconnect (ctx);
1993   return 0;
1994 }