1 2 /* 3 * server.c Set up and handle communications with a server process. 4 * 5 * Server Handling copyright 1992-1999, 2004 The Free Software Foundation 6 * 7 * Server Handling is free software. 8 * You may redistribute it and/or modify it under the terms of the 9 * GNU General Public License, as published by the Free Software 10 * Foundation; either version 2, or (at your option) any later version. 11 * 12 * Server Handling 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 Server Handling. See the file "COPYING". If not, 19 * write to: The Free Software Foundation, Inc., 20 * 51 Franklin Street, Fifth Floor, 21 * Boston, MA 02110-1301, USA. 22 * 23 * As a special exception, The Free Software Foundation gives 24 * permission for additional uses of the text contained in his release 25 * of ServerHandler. 26 * 27 * The exception is that, if you link the ServerHandler library with other 28 * files to produce an executable, this does not by itself cause the 29 * resulting executable to be covered by the GNU General Public License. 30 * Your use of that executable is in no way restricted on account of 31 * linking the ServerHandler library code into it. 32 * 33 * This exception does not however invalidate any other reasons why 34 * the executable file might be covered by the GNU General Public License. 35 * 36 * This exception applies only to the code released by The Free 37 * Software Foundation under the name ServerHandler. If you copy code 38 * from other sources under the General Public License into a copy of 39 * ServerHandler, as the General Public License permits, the exception 40 * does not apply to the code that you add in this way. To avoid 41 * misleading anyone as to the status of such modified files, you must 42 * delete this exception notice from them. 43 * 44 * If you write modifications of your own for ServerHandler, it is your 45 * choice whether to permit this exception to apply to your modifications. 46 * If you do not wish that, delete this exception notice. 47 */ 48 49 #include "fixlib.h" 50 #include "server.h" 51 52 STATIC const char* def_args[] = 53 { (char *) NULL, (char *) NULL }; 54 55 /* 56 * chain_open 57 * 58 * Given an FD for an inferior process to use as stdin, 59 * start that process and return a NEW FD that that process 60 * will use for its stdout. Requires the argument vector 61 * for the new process and, optionally, a pointer to a place 62 * to store the child's process id. 63 */ 64 int 65 chain_open (int stdin_fd, tCC** pp_args, pid_t* p_child) 66 { 67 t_fd_pair stdout_pair; 68 pid_t ch_id; 69 tCC *pz_cmd; 70 71 stdout_pair.read_fd = stdout_pair.write_fd = -1; 72 73 /* 74 * Create a pipe it will be the child process' stdout, 75 * and the parent will read from it. 76 */ 77 if (pipe ((int *) &stdout_pair) < 0) 78 { 79 if (p_child != (pid_t *) NULL) 80 *p_child = NOPROCESS; 81 return -1; 82 } 83 84 /* 85 * If we did not get an arg list, use the default 86 */ 87 if (pp_args == (tCC **) NULL) 88 pp_args = def_args; 89 90 /* 91 * If the arg list does not have a program, 92 * assume the "SHELL" from the environment, or, failing 93 * that, then sh. Set argv[0] to whatever we decided on. 94 */ 95 if (pz_cmd = *pp_args, 96 (pz_cmd == (char *) NULL) || (*pz_cmd == '\0')) 97 { 98 99 pz_cmd = getenv ("SHELL"); 100 if (pz_cmd == (char *) NULL) 101 pz_cmd = "sh"; 102 } 103 104 #ifdef DEBUG_PRINT 105 printf ("START: %s\n", pz_cmd); 106 { 107 int idx = 0; 108 109 while (pp_args[++idx] != (char *) NULL) 110 printf (" ARG %2d: %s\n", idx, pp_args[idx]); 111 } 112 #endif 113 114 /* 115 * Call fork() and see which process we become 116 */ 117 ch_id = fork (); 118 switch (ch_id) 119 { 120 case NOPROCESS: /* parent - error in call */ 121 close (stdout_pair.read_fd); 122 close (stdout_pair.write_fd); 123 if (p_child != (pid_t *) NULL) 124 *p_child = NOPROCESS; 125 return -1; 126 127 default: /* parent - return opposite FD's */ 128 if (p_child != (pid_t *) NULL) 129 *p_child = ch_id; 130 #ifdef DEBUG_PRINT 131 printf ("for pid %d: stdin from %d, stdout to %d\n" 132 "for parent: read from %d\n", 133 ch_id, stdin_fd, stdout_pair.write_fd, stdout_pair.read_fd); 134 #endif 135 close (stdin_fd); 136 close (stdout_pair.write_fd); 137 return stdout_pair.read_fd; 138 139 case NULLPROCESS: /* child - continue processing */ 140 break; 141 } 142 143 /* 144 * Close the pipe end handed back to the parent process 145 */ 146 close (stdout_pair.read_fd); 147 148 /* 149 * Close our current stdin and stdout 150 */ 151 close (STDIN_FILENO); 152 close (STDOUT_FILENO); 153 154 /* 155 * Make the fd passed in the stdin, and the write end of 156 * the new pipe become the stdout. 157 */ 158 dup2 (stdout_pair.write_fd, STDOUT_FILENO); 159 dup2 (stdin_fd, STDIN_FILENO); 160 161 if (*pp_args == (char *) NULL) 162 *pp_args = pz_cmd; 163 164 execvp (pz_cmd, (char**)pp_args); 165 fprintf (stderr, "Error %d: Could not execvp( '%s', ... ): %s\n", 166 errno, pz_cmd, xstrerror (errno)); 167 exit (EXIT_PANIC); 168 } 169 170 171 /* 172 * proc2_open 173 * 174 * Given a pointer to an argument vector, start a process and 175 * place its stdin and stdout file descriptors into an fd pair 176 * structure. The "write_fd" connects to the inferior process 177 * stdin, and the "read_fd" connects to its stdout. The calling 178 * process should write to "write_fd" and read from "read_fd". 179 * The return value is the process id of the created process. 180 */ 181 pid_t 182 proc2_open (t_fd_pair* p_pair, tCC** pp_args) 183 { 184 pid_t ch_id; 185 186 /* Create a bi-directional pipe. Writes on 0 arrive on 1 and vice 187 versa, so the parent and child processes will read and write to 188 opposite FD's. */ 189 if (pipe ((int *) p_pair) < 0) 190 return NOPROCESS; 191 192 p_pair->read_fd = chain_open (p_pair->read_fd, pp_args, &ch_id); 193 if (ch_id == NOPROCESS) 194 close (p_pair->write_fd); 195 196 return ch_id; 197 } 198 199 200 /* 201 * proc2_fopen 202 * 203 * Identical to "proc2_open()", except that the "fd"'s are 204 * "fdopen(3)"-ed into file pointers instead. 205 */ 206 pid_t 207 proc2_fopen (t_pf_pair* pf_pair, tCC** pp_args) 208 { 209 t_fd_pair fd_pair; 210 pid_t ch_id = proc2_open (&fd_pair, pp_args); 211 212 if (ch_id == NOPROCESS) 213 return ch_id; 214 215 pf_pair->pf_read = fdopen (fd_pair.read_fd, "r"); 216 pf_pair->pf_write = fdopen (fd_pair.write_fd, "w"); 217 return ch_id; 218 } 219