Annotation of embedaddon/rsync/pipe.c, revision 1.1.1.3

1.1       misho       1: /*
                      2:  * Routines used to setup various kinds of inter-process pipes.
                      3:  *
                      4:  * Copyright (C) 1996-2000 Andrew Tridgell
                      5:  * Copyright (C) 1996 Paul Mackerras
                      6:  * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
1.1.1.3 ! misho       7:  * Copyright (C) 2004-2015 Wayne Davison
1.1       misho       8:  *
                      9:  * This program is free software; you can redistribute it and/or modify
                     10:  * it under the terms of the GNU General Public License as published by
                     11:  * the Free Software Foundation; either version 3 of the License, or
                     12:  * (at your option) any later version.
                     13:  *
                     14:  * This program is distributed in the hope that it will be useful,
                     15:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                     16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     17:  * GNU General Public License for more details.
                     18:  *
                     19:  * You should have received a copy of the GNU General Public License along
                     20:  * with this program; if not, visit the http://fsf.org website.
                     21:  */
                     22: 
                     23: #include "rsync.h"
                     24: 
                     25: extern int am_sender;
                     26: extern int am_server;
                     27: extern int blocking_io;
                     28: extern int filesfrom_fd;
1.1.1.2   misho      29: extern int munge_symlinks;
1.1       misho      30: extern char *logfile_name;
1.1.1.2   misho      31: extern int remote_option_cnt;
                     32: extern const char **remote_options;
1.1       misho      33: extern struct chmod_mode_struct *chmod_modes;
                     34: 
                     35: /**
                     36:  * Create a child connected to us via its stdin/stdout.
                     37:  *
                     38:  * This is derived from CVS code
                     39:  *
                     40:  * Note that in the child STDIN is set to blocking and STDOUT
                     41:  * is set to non-blocking. This is necessary as rsh relies on stdin being blocking
                     42:  *  and ssh relies on stdout being non-blocking
                     43:  *
                     44:  * If blocking_io is set then use blocking io on both fds. That can be
                     45:  * used to cope with badly broken rsh implementations like the one on
                     46:  * Solaris.
                     47:  **/
                     48: pid_t piped_child(char **command, int *f_in, int *f_out)
                     49: {
                     50:        pid_t pid;
                     51:        int to_child_pipe[2];
                     52:        int from_child_pipe[2];
                     53: 
1.1.1.2   misho      54:        if (DEBUG_GTE(CMD, 1))
1.1       misho      55:                print_child_argv("opening connection using:", command);
                     56: 
                     57:        if (fd_pair(to_child_pipe) < 0 || fd_pair(from_child_pipe) < 0) {
                     58:                rsyserr(FERROR, errno, "pipe");
                     59:                exit_cleanup(RERR_IPC);
                     60:        }
                     61: 
                     62:        pid = do_fork();
                     63:        if (pid == -1) {
                     64:                rsyserr(FERROR, errno, "fork");
                     65:                exit_cleanup(RERR_IPC);
                     66:        }
                     67: 
                     68:        if (pid == 0) {
                     69:                if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
                     70:                    close(to_child_pipe[1]) < 0 ||
                     71:                    close(from_child_pipe[0]) < 0 ||
                     72:                    dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
                     73:                        rsyserr(FERROR, errno, "Failed to dup/close");
                     74:                        exit_cleanup(RERR_IPC);
                     75:                }
                     76:                if (to_child_pipe[0] != STDIN_FILENO)
                     77:                        close(to_child_pipe[0]);
                     78:                if (from_child_pipe[1] != STDOUT_FILENO)
                     79:                        close(from_child_pipe[1]);
                     80:                set_blocking(STDIN_FILENO);
                     81:                if (blocking_io > 0)
                     82:                        set_blocking(STDOUT_FILENO);
                     83:                execvp(command[0], command);
                     84:                rsyserr(FERROR, errno, "Failed to exec %s", command[0]);
                     85:                exit_cleanup(RERR_IPC);
                     86:        }
                     87: 
                     88:        if (close(from_child_pipe[1]) < 0 || close(to_child_pipe[0]) < 0) {
                     89:                rsyserr(FERROR, errno, "Failed to close");
                     90:                exit_cleanup(RERR_IPC);
                     91:        }
                     92: 
                     93:        *f_in = from_child_pipe[0];
                     94:        *f_out = to_child_pipe[1];
                     95: 
                     96:        return pid;
                     97: }
                     98: 
                     99: /* This function forks a child which calls child_main().  First,
                    100:  * however, it has to establish communication paths to and from the
                    101:  * newborn child.  It creates two socket pairs -- one for writing to
                    102:  * the child (from the parent) and one for reading from the child
                    103:  * (writing to the parent).  Since that's four socket ends, each
                    104:  * process has to close the two ends it doesn't need.  The remaining
                    105:  * two socket ends are retained for reading and writing.  In the
                    106:  * child, the STDIN and STDOUT file descriptors refer to these
                    107:  * sockets.  In the parent, the function arguments f_in and f_out are
                    108:  * set to refer to these sockets. */
                    109: pid_t local_child(int argc, char **argv, int *f_in, int *f_out,
                    110:                  int (*child_main)(int, char*[]))
                    111: {
                    112:        pid_t pid;
                    113:        int to_child_pipe[2];
                    114:        int from_child_pipe[2];
                    115: 
                    116:        /* The parent process is always the sender for a local rsync. */
                    117:        assert(am_sender);
                    118: 
                    119:        if (fd_pair(to_child_pipe) < 0 ||
                    120:            fd_pair(from_child_pipe) < 0) {
                    121:                rsyserr(FERROR, errno, "pipe");
                    122:                exit_cleanup(RERR_IPC);
                    123:        }
                    124: 
                    125:        pid = do_fork();
                    126:        if (pid == -1) {
                    127:                rsyserr(FERROR, errno, "fork");
                    128:                exit_cleanup(RERR_IPC);
                    129:        }
                    130: 
                    131:        if (pid == 0) {
                    132:                am_sender = 0;
                    133:                am_server = 1;
                    134:                filesfrom_fd = -1;
1.1.1.2   misho     135:                munge_symlinks = 0; /* Each side needs its own option. */
1.1       misho     136:                chmod_modes = NULL; /* Let the sending side handle this. */
                    137: 
                    138:                /* Let the client side handle this. */
                    139:                if (logfile_name) {
                    140:                        logfile_name = NULL;
                    141:                        logfile_close();
                    142:                }
                    143: 
1.1.1.2   misho     144:                if (remote_option_cnt) {
                    145:                        int rc = remote_option_cnt + 1;
                    146:                        const char **rv = remote_options;
                    147:                        if (!parse_arguments(&rc, &rv)) {
                    148:                                option_error();
                    149:                                exit_cleanup(RERR_SYNTAX);
                    150:                        }
                    151:                }
                    152: 
1.1       misho     153:                if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
                    154:                    close(to_child_pipe[1]) < 0 ||
                    155:                    close(from_child_pipe[0]) < 0 ||
                    156:                    dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
                    157:                        rsyserr(FERROR, errno, "Failed to dup/close");
                    158:                        exit_cleanup(RERR_IPC);
                    159:                }
                    160:                if (to_child_pipe[0] != STDIN_FILENO)
                    161:                        close(to_child_pipe[0]);
                    162:                if (from_child_pipe[1] != STDOUT_FILENO)
                    163:                        close(from_child_pipe[1]);
                    164: #ifdef ICONV_CONST
                    165:                setup_iconv();
                    166: #endif
                    167:                child_main(argc, argv);
                    168:        }
                    169: 
                    170:        if (close(from_child_pipe[1]) < 0 ||
                    171:            close(to_child_pipe[0]) < 0) {
                    172:                rsyserr(FERROR, errno, "Failed to close");
                    173:                exit_cleanup(RERR_IPC);
                    174:        }
                    175: 
                    176:        *f_in = from_child_pipe[0];
                    177:        *f_out = to_child_pipe[1];
                    178: 
                    179:        return pid;
                    180: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>