2004-12-16 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / assuan / assuan-pipe-connect.c
1 /* assuan-pipe-connect.c - Establish a pipe connection (client) 
2  *      Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Assuan.
5  *
6  * Assuan is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Assuan is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA 
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <signal.h>
29 #include <unistd.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <sys/types.h>
33 #include <sys/wait.h>
34
35 #include "assuan-defs.h"
36
37 #ifdef _POSIX_OPEN_MAX
38 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
39 #else
40 #define MAX_OPEN_FDS 20
41 #endif
42
43 #define LOG(format, args...) \
44         fprintf (assuan_get_assuan_log_stream (), \
45                  assuan_get_assuan_log_prefix (), \
46                  "%s" format , ## args)
47
48 static int
49 writen (int fd, const char *buffer, size_t length)
50 {
51   while (length)
52     {
53       int nwritten = write (fd, buffer, length);
54       
55       if (nwritten < 0)
56         {
57           if (errno == EINTR)
58             continue;
59           return -1; /* write error */
60         }
61       length -= nwritten;
62       buffer += nwritten;
63     }
64   return 0;  /* okay */
65 }
66
67
68 static int
69 do_finish (ASSUAN_CONTEXT ctx)
70 {
71   if (ctx->inbound.fd != -1)
72     {
73       close (ctx->inbound.fd);
74       ctx->inbound.fd = -1;
75     }
76   if (ctx->outbound.fd != -1)
77     {
78       close (ctx->outbound.fd);
79       ctx->outbound.fd = -1;
80     }
81   if (ctx->pid != -1)
82     {
83 #if 0
84       /* This is already done by the double fork.  */
85       waitpid (ctx->pid, NULL, 0);  /* FIXME Check return value.  */
86       ctx->pid = -1;
87 #endif
88     }
89   return 0;
90 }
91
92 static void
93 do_deinit (ASSUAN_CONTEXT ctx)
94 {
95   do_finish (ctx);
96 }
97
98
99
100 /* Connect to a server over a pipe, creating the assuan context and
101    returning it in CTX.  The server filename is NAME, the argument
102    vector in ARGV.  FD_CHILD_LIST is a -1 terminated list of file
103    descriptors not to close in the child.  */
104 AssuanError
105 assuan_pipe_connect (ASSUAN_CONTEXT *ctx, const char *name, char *const argv[],
106                      int *fd_child_list)
107 {
108 #ifndef _ASSUAN_IN_GPGME
109   static int fixed_signals = 0;
110 #endif
111   AssuanError err;
112   int rp[2];
113   int wp[2];
114
115   if (!ctx || !name || !argv || !argv[0])
116     return ASSUAN_Invalid_Value;
117
118 #ifndef _ASSUAN_IN_GPGME
119   if (!fixed_signals)
120     { 
121       struct sigaction act;
122         
123       sigaction (SIGPIPE, NULL, &act);
124       if (act.sa_handler == SIG_DFL)
125         {
126           act.sa_handler = SIG_IGN;
127           sigemptyset (&act.sa_mask);
128           act.sa_flags = 0;
129           sigaction (SIGPIPE, &act, NULL);
130         }
131       fixed_signals = 1;
132       /* FIXME: This is not MT safe */
133     }
134 #endif
135
136   if (pipe (rp) < 0)
137     return ASSUAN_General_Error;
138
139   if (pipe (wp) < 0)
140     {
141       close (rp[0]);
142       close (rp[1]);
143       return ASSUAN_General_Error;
144     }
145   
146   err = _assuan_new_context (ctx);
147   if (err)
148     {
149       close (rp[0]);
150       close (rp[1]);
151       close (wp[0]);
152       close (wp[1]);
153       return err;
154     }
155   (*ctx)->pipe_mode = 1;
156   (*ctx)->inbound.fd  = rp[0];  /* Our inbound is read end of read pipe. */
157   (*ctx)->outbound.fd = wp[1];  /* Our outbound is write end of write pipe. */
158   (*ctx)->deinit_handler = do_deinit;
159   (*ctx)->finish_handler = do_finish;
160
161   /* FIXME: Use _gpgme_io_spawn.  The PID stored here is actually
162      soon useless.  */
163   (*ctx)->pid = fork ();
164   if ((*ctx)->pid < 0)
165     {
166       close (rp[0]);
167       close (rp[1]);
168       close (wp[0]);
169       close (wp[1]);
170       _assuan_release_context (*ctx); 
171       return ASSUAN_General_Error;
172     }
173
174   if ((*ctx)->pid == 0)
175     {
176       /* Intermediate child to prevent zombie processes.  */
177       pid_t pid;
178
179       if ((pid = fork ()) == 0)
180         {
181           /* Child.  */
182
183           int i, n;
184           char errbuf[512];
185           int *fdp;
186
187           /* Dup handles to stdin/stdout. */
188           if (rp[1] != STDOUT_FILENO)
189             {
190               if (dup2 (rp[1], STDOUT_FILENO) == -1)
191                 {
192                   LOG ("dup2 failed in child: %s\n", strerror (errno));
193                   _exit (4);
194                 }
195             }
196           if (wp[0] != STDIN_FILENO)
197             {
198               if (dup2 (wp[0], STDIN_FILENO) == -1)
199                 {
200                   LOG ("dup2 failed in child: %s\n", strerror (errno));
201                   _exit (4);
202                 }
203             }
204           
205           /* Dup stderr to /dev/null unless it is in the list of FDs to be
206              passed to the child. */
207           fdp = fd_child_list;
208           if (fdp)
209             {
210               for (; *fdp != -1 && *fdp != STDERR_FILENO; fdp++)
211                 ;
212             }
213           if (!fdp || *fdp == -1)
214             {
215               int fd = open ("/dev/null", O_WRONLY);
216               if (fd == -1)
217                 {
218                   LOG ("can't open `/dev/null': %s\n", strerror (errno));
219                   _exit (4);
220                 }
221               if (dup2 (fd, STDERR_FILENO) == -1)
222                 {
223                   LOG ("dup2(dev/null, 2) failed: %s\n", strerror (errno));
224                   _exit (4);
225                 }
226             }
227
228
229           /* Close all files which will not be duped and are not in the
230              fd_child_list. */
231           n = sysconf (_SC_OPEN_MAX);
232           if (n < 0)
233             n = MAX_OPEN_FDS;
234           for (i=0; i < n; i++)
235             {
236               if ( i == STDIN_FILENO || i == STDOUT_FILENO || i == STDERR_FILENO)
237                 continue;
238               fdp = fd_child_list;
239               if (fdp)
240                 {
241                   while (*fdp != -1 && *fdp != i)
242                     fdp++;
243                 }
244               
245               if (!(fdp && *fdp != -1))
246                 close(i);
247             }
248
249           errno = 0;
250
251           execv (name, argv); 
252           /* oops - use the pipe to tell the parent about it */
253           snprintf (errbuf, sizeof(errbuf)-1, "ERR %d can't exec `%s': %.50s\n",
254                     ASSUAN_Problem_Starting_Server, name, strerror (errno));
255           errbuf[sizeof(errbuf)-1] = 0;
256           writen (1, errbuf, strlen (errbuf));
257           _exit (4);
258         } /* End child.  */
259       if (pid == -1)
260         _exit (1);
261       else
262         _exit (0);
263     }
264
265   waitpid ((*ctx)->pid, NULL, 0);
266   (*ctx)->pid = -1;
267
268   close (rp[1]);
269   close (wp[0]);
270
271   /* initial handshake */
272   {
273     int okay, off;
274
275     err = _assuan_read_from_server (*ctx, &okay, &off);
276     if (err)
277       LOG ("can't connect server: %s\n", assuan_strerror (err));
278     else if (okay != 1)
279       {
280         LOG ("can't connect server: `%s'\n", (*ctx)->inbound.line);
281         err = ASSUAN_Connect_Failed;
282       }
283   }
284
285   if (err)
286     {
287       assuan_disconnect (*ctx);
288       *ctx = NULL;
289     }
290
291   return err;
292 }
293
294
295
296
297
298
299
300
301
302
303
304
305
306