2002-06-04 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 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, 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 <sys/types.h>
32 #include <sys/wait.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35
36 #include "assuan-defs.h"
37
38 #ifdef _POSIX_OPEN_MAX
39 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
40 #else
41 #define MAX_OPEN_FDS 20
42 #endif
43
44 #ifdef HAVE_JNLIB_LOGGING
45 #include "../jnlib/logging.h"
46 #define LOGERROR1(a,b)   log_error ((a), (b))
47 #else
48 #define LOGERROR1(a,b)   fprintf (stderr, (a), (b))
49 #endif
50
51
52
53 static int
54 writen ( int fd, const char *buffer, size_t length )
55 {
56   while (length)
57     {
58       int nwritten = write (fd, buffer, length);
59       
60       if (nwritten < 0)
61         {
62           if (errno == EINTR)
63             continue;
64           return -1; /* write error */
65         }
66       length -= nwritten;
67       buffer += nwritten;
68     }
69   return 0;  /* okay */
70 }
71
72
73 static int
74 do_finish (ASSUAN_CONTEXT ctx)
75 {
76   if (ctx->inbound.fd != -1)
77     {
78       close (ctx->inbound.fd);
79       ctx->inbound.fd = -1;
80     }
81   if (ctx->outbound.fd != -1)
82     {
83       close (ctx->outbound.fd);
84       ctx->outbound.fd = -1;
85     }
86   if (ctx->pid != -1)
87     {
88       waitpid (ctx->pid, NULL, 0);  /* FIXME Check return value.  */
89       ctx->pid = -1;
90     }
91   return 0;
92 }
93
94 static void
95 do_deinit (ASSUAN_CONTEXT ctx)
96 {
97   do_finish (ctx);
98 }
99
100
101
102 /* Connect to a server over a pipe, creating the assuan context and
103    returning it in CTX.  The server filename is NAME, the argument
104    vector in ARGV.  FD_CHILD_LIST is a -1 terminated list of file
105    descriptors not to close in the child.  */
106 AssuanError
107 assuan_pipe_connect2 (ASSUAN_CONTEXT *ctx, const char *name,
108                       char *const argv[], int *fd_child_list,
109                       unsigned int connect_flags)
110 {
111   static int fixed_signals = 0;
112   AssuanError err;
113   int rp[2];
114   int wp[2];
115
116   if (!ctx || !name || !argv || !argv[0])
117     return ASSUAN_Invalid_Value;
118
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
135   if (pipe (rp) < 0)
136     return ASSUAN_General_Error;
137
138   if (pipe (wp) < 0)
139     {
140       close (rp[0]);
141       close (rp[1]);
142       return ASSUAN_General_Error;
143     }
144   
145   err = _assuan_new_context (ctx);
146   if (err)
147     {
148       close (rp[0]);
149       close (rp[1]);
150       close (wp[0]);
151       close (wp[1]);
152       return err;
153     }
154   (*ctx)->pipe_mode = 1;
155   (*ctx)->inbound.fd  = rp[0];  /* Our inbound is read end of read pipe. */
156   (*ctx)->outbound.fd = wp[1];  /* Our outbound is write end of write pipe. */
157   (*ctx)->deinit_handler = do_deinit;
158   (*ctx)->finish_handler = do_finish;
159
160   (*ctx)->pid = fork ();
161   if ((*ctx)->pid < 0)
162     {
163       close (rp[0]);
164       close (rp[1]);
165       close (wp[0]);
166       close (wp[1]);
167       _assuan_release_context (*ctx); 
168       return ASSUAN_General_Error;
169     }
170
171   if ((*ctx)->pid == 0)
172     {
173       int i, n;
174       char errbuf[512];
175 #ifdef HAVE_JNLIB_LOGGING
176       int log_fd = log_get_fd (); 
177 #endif
178       /* close all files which will not be duped but keep stderr
179          and log_stream for now */
180       n = sysconf (_SC_OPEN_MAX);
181       if (n < 0)
182         n = MAX_OPEN_FDS;
183       for (i=0; i < n; i++)
184         {
185           int *fdp = fd_child_list;
186
187           if (fdp)
188             {
189               while (*fdp != -1 && *fdp != i)
190                 fdp++;
191             }
192
193           if (!(fdp && *fdp != -1)
194               && i != fileno (stderr) 
195 #ifdef HAVE_JNLIB_LOGGING
196               && i != log_fd
197 #endif
198               && i != rp[1] && i != wp[0])
199             close(i);
200         }
201       errno = 0;
202
203       /* Dup handles and to stdin/stdout and exec */
204       if (rp[1] != STDOUT_FILENO)
205         {
206           if (dup2 (rp[1], STDOUT_FILENO) == -1)
207             {
208               LOGERROR1 ("dup2 failed in child: %s\n", strerror (errno));
209               _exit (4);
210             }
211           close (rp[1]);
212         }
213       if (wp[0] != STDIN_FILENO)
214         {
215           if (dup2 (wp[0], STDIN_FILENO) == -1)
216             {
217               LOGERROR1 ("dup2 failed in child: %s\n", strerror (errno));
218               _exit (4);
219             }
220           close (wp[0]);
221         }
222
223       if ((connect_flags & 1))
224         { /* dup stderr to /dev/null so that the application output
225              won't get clobbered with output from the backend */
226           int fdzero = open ("/dev/null", O_WRONLY);
227           if (fdzero == -1)
228             {
229               LOGERROR1 ("can't open `/dev/null': %s\n", strerror (errno));
230               _exit (4);
231             }
232           if (dup2 (fdzero, 2) == -1)
233             {
234               LOGERROR1 ("dup2(dev/null, 2) failed: %s\n", strerror (errno));
235               _exit (4);
236             }
237           close (fdzero);
238         }
239
240       execv (name, argv); 
241       /* oops - use the pipe to tell the parent about it */
242       snprintf (errbuf, sizeof(errbuf)-1, "ERR %d can't exec `%s': %.50s\n",
243                 ASSUAN_Problem_Starting_Server, name, strerror (errno));
244       errbuf[sizeof(errbuf)-1] = 0;
245       writen (1, errbuf, strlen (errbuf));
246       _exit (4);
247     }
248
249   close (rp[1]);
250   close (wp[0]);
251
252   /* initial handshake */
253   {
254     int okay, off;
255
256     err = _assuan_read_from_server (*ctx, &okay, &off);
257     if (err)
258       {
259         LOGERROR1 ("can't connect server: %s\n", assuan_strerror (err));
260       }
261     else if (okay != 1)
262       {
263         LOGERROR1 ("can't connect server: `%s'\n", (*ctx)->inbound.line);
264         err = ASSUAN_Connect_Failed;
265       }
266   }
267
268   if (err)
269     {
270       assuan_disconnect (*ctx);
271       *ctx = NULL;
272     }
273
274   return err;
275 }
276
277 AssuanError
278 assuan_pipe_connect (ASSUAN_CONTEXT *ctx, const char *name, char *const argv[],
279                      int *fd_child_list)
280 {
281   return assuan_pipe_connect2 (ctx, name, argv, fd_child_list, 0);
282 }
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298