Various changes.
[gnupg.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
34 #include "assuan-defs.h"
35
36 #ifdef _POSIX_OPEN_MAX
37 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
38 #else
39 #define MAX_OPEN_FDS 20
40 #endif
41
42 #ifdef HAVE_JNLIB_LOGGING
43 #include "../jnlib/logging.h"
44 #define LOGERROR1(a,b)   log_error ((a), (b))
45 #else
46 #define LOGERROR1(a,b)   fprintf (stderr, (a), (b))
47 #endif
48
49
50
51 static int
52 writen ( int fd, const char *buffer, size_t length )
53 {
54   while (length)
55     {
56       int nwritten = write (fd, buffer, length);
57       
58       if (nwritten < 0)
59         {
60           if (errno == EINTR)
61             continue;
62           return -1; /* write error */
63         }
64       length -= nwritten;
65       buffer += nwritten;
66     }
67   return 0;  /* okay */
68 }
69
70
71 static int
72 do_finish (ASSUAN_CONTEXT ctx)
73 {
74   if (ctx->inbound.fd != -1)
75     {
76       close (ctx->inbound.fd);
77       ctx->inbound.fd = -1;
78     }
79   if (ctx->outbound.fd != -1)
80     {
81       close (ctx->outbound.fd);
82       ctx->outbound.fd = -1;
83     }
84   if (ctx->pid != -1)
85     {
86       waitpid (ctx->pid, NULL, 0);  /* FIXME Check return value.  */
87       ctx->pid = -1;
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   static int fixed_signals = 0;
109   AssuanError err;
110   int rp[2];
111   int wp[2];
112
113   if (!ctx || !name || !argv || !argv[0])
114     return ASSUAN_Invalid_Value;
115
116   if (!fixed_signals)
117     { 
118       struct sigaction act;
119         
120       sigaction (SIGPIPE, NULL, &act);
121       if (act.sa_handler == SIG_DFL)
122         {
123           act.sa_handler = SIG_IGN;
124           sigemptyset (&act.sa_mask);
125           act.sa_flags = 0;
126           sigaction (SIGPIPE, &act, NULL);
127         }
128       fixed_signals = 1;
129       /* FIXME: This is not MT safe */
130     }
131
132   if (pipe (rp) < 0)
133     return ASSUAN_General_Error;
134
135   if (pipe (wp) < 0)
136     {
137       close (rp[0]);
138       close (rp[1]);
139       return ASSUAN_General_Error;
140     }
141   
142   err = _assuan_new_context (ctx);
143   if (err)
144     {
145       close (rp[0]);
146       close (rp[1]);
147       close (wp[0]);
148       close (wp[1]);
149       return err;
150     }
151   (*ctx)->pipe_mode = 1;
152   (*ctx)->inbound.fd  = rp[0];  /* Our inbound is read end of read pipe. */
153   (*ctx)->outbound.fd = wp[1];  /* Our outbound is write end of write pipe. */
154   (*ctx)->deinit_handler = do_deinit;
155   (*ctx)->finish_handler = do_finish;
156
157   (*ctx)->pid = fork ();
158   if ((*ctx)->pid < 0)
159     {
160       close (rp[0]);
161       close (rp[1]);
162       close (wp[0]);
163       close (wp[1]);
164       _assuan_release_context (*ctx); 
165       return ASSUAN_General_Error;
166     }
167
168   if ((*ctx)->pid == 0)
169     {
170       int i, n;
171       char errbuf[512];
172 #ifdef HAVE_JNLIB_LOGGING
173       int log_fd = log_get_fd (); 
174 #endif
175       /* close all files which will not be duped but keep stderr
176          and log_stream for now */
177       n = sysconf (_SC_OPEN_MAX);
178       if (n < 0)
179         n = MAX_OPEN_FDS;
180       for (i=0; i < n; i++)
181         {
182           int *fdp = fd_child_list;
183
184           if (fdp)
185             {
186               while (*fdp != -1 && *fdp != i)
187                 fdp++;
188             }
189
190           if (!(fdp && *fdp != -1)
191               && i != fileno (stderr) 
192 #ifdef HAVE_JNLIB_LOGGING
193               && i != log_fd
194 #endif
195               && i != rp[1] && i != wp[0])
196             close(i);
197         }
198       errno = 0;
199
200       /* Dup handles and to stdin/stdout and exec */
201       if (rp[1] != STDOUT_FILENO)
202         {
203           if (dup2 (rp[1], STDOUT_FILENO) == -1)
204             {
205               LOGERROR1 ("dup2 failed in child: %s\n", strerror (errno));
206               _exit (4);
207             }
208           close (rp[1]);
209         }
210       if (wp[0] != STDIN_FILENO)
211         {
212           if (dup2 (wp[0], STDIN_FILENO) == -1)
213             {
214               LOGERROR1 ("dup2 failed in child: %s\n", strerror (errno));
215               _exit (4);
216             }
217           close (wp[0]);
218         }
219
220       execv (name, argv); 
221       /* oops - use the pipe to tell the parent about it */
222       snprintf (errbuf, sizeof(errbuf)-1, "ERR %d can't exec `%s': %.50s\n",
223                 ASSUAN_Problem_Starting_Server, name, strerror (errno));
224       errbuf[sizeof(errbuf)-1] = 0;
225       writen (1, errbuf, strlen (errbuf));
226       _exit (4);
227     }
228
229   close (rp[1]);
230   close (wp[0]);
231
232   /* initial handshake */
233   {
234     int okay, off;
235
236     err = _assuan_read_from_server (*ctx, &okay, &off);
237     if (err)
238       {
239         LOGERROR1 ("can't connect server: %s\n", assuan_strerror (err));
240       }
241     else if (okay != 1)
242       {
243         LOGERROR1 ("can't connect server: `%s'\n", (*ctx)->inbound.line);
244         err = ASSUAN_Connect_Failed;
245       }
246   }
247
248   if (err)
249     {
250       assuan_disconnect (*ctx);
251       *ctx = NULL;
252     }
253
254   return err;
255 }
256
257
258
259
260
261
262
263
264
265
266
267
268
269