X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/9e2409ab2213cf560264dcd34d8537b6a7be4e89..669e76717c64bf40a8626da779839420cbf4a068:/io.c diff --git a/io.c b/io.c index 7d44962f..f26b48da 100644 --- a/io.c +++ b/io.c @@ -51,7 +51,7 @@ extern int eol_nulls; extern int csum_length; extern int checksum_seed; extern int protocol_version; -extern char *remote_filesfrom_file; +extern char *filesfrom_host; extern struct stats stats; const char phase_unknown[] = "unknown"; @@ -76,9 +76,8 @@ int batch_gen_fd = -1; const char *io_write_phase = phase_unknown; const char *io_read_phase = phase_unknown; -/** Ignore EOF errors while reading a module listing if the remote - version is 24 or less. */ -int kludge_around_eof = False; +/* Ignore an EOF error if non-zero. See whine_about_eof(). */ +int kluge_around_eof = 0; int msg_fd_in = -1; int msg_fd_out = -1; @@ -99,16 +98,20 @@ static char io_filesfrom_buf[2048]; static char *io_filesfrom_bp; static char io_filesfrom_lastchar; static int io_filesfrom_buflen; +static size_t contiguous_write_len = 0; static void read_loop(int fd, char *buf, size_t len); -struct redo_list { - struct redo_list *next; - int num; +struct flist_ndx_item { + struct flist_ndx_item *next; + int ndx; }; -static struct redo_list *redo_list_head; -static struct redo_list *redo_list_tail; +struct flist_ndx_list { + struct flist_ndx_item *head, *tail; +}; + +static struct flist_ndx_list redo_list; struct msg_list { struct msg_list *next; @@ -119,19 +122,37 @@ struct msg_list { static struct msg_list *msg_list_head; static struct msg_list *msg_list_tail; -static void redo_list_add(int num) +static void flist_ndx_push(struct flist_ndx_list *lp, int ndx) { - struct redo_list *rl; - - if (!(rl = new(struct redo_list))) - exit_cleanup(RERR_MALLOC); - rl->next = NULL; - rl->num = num; - if (redo_list_tail) - redo_list_tail->next = rl; + struct flist_ndx_item *item; + + if (!(item = new(struct flist_ndx_item))) + out_of_memory("flist_ndx_push"); + item->next = NULL; + item->ndx = ndx; + if (lp->tail) + lp->tail->next = item; else - redo_list_head = rl; - redo_list_tail = rl; + lp->head = item; + lp->tail = item; +} + +static int flist_ndx_pop(struct flist_ndx_list *lp) +{ + struct flist_ndx_item *next; + int ndx; + + if (!lp->head) + return -1; + + ndx = lp->head->ndx; + next = lp->head->next; + free(lp->head); + lp->head = next; + if (!next) + lp->tail = NULL; + + return ndx; } static void check_timeout(void) @@ -188,10 +209,10 @@ static void msg_list_add(int code, char *buf, int len) struct msg_list *ml; if (!(ml = new(struct msg_list))) - exit_cleanup(RERR_MALLOC); + out_of_memory("msg_list_add"); ml->next = NULL; if (!(ml->buf = new_array(char, len+4))) - exit_cleanup(RERR_MALLOC); + out_of_memory("msg_list_add"); SIVAL(ml->buf, 0, ((code+MPLEX_BASE)<<24) | len); memcpy(ml->buf+4, buf, len); ml->len = len+4; @@ -224,7 +245,7 @@ static void read_msg_fd(void) int tag, len; /* Temporarily disable msg_fd_in. This is needed to avoid looping back - * to this routine from read_timeout() and writefd_unbuffered(). */ + * to this routine from writefd_unbuffered(). */ msg_fd_in = -1; read_loop(fd, buf, 4); @@ -239,7 +260,7 @@ static void read_msg_fd(void) rprintf(FERROR, "invalid message %d:%d\n", tag, len); exit_cleanup(RERR_STREAMIO); } - redo_list_add(-1); + flist_ndx_push(&redo_list, -1); break; case MSG_REDO: if (len != 4 || !am_generator) { @@ -247,7 +268,7 @@ static void read_msg_fd(void) exit_cleanup(RERR_STREAMIO); } read_loop(fd, buf, 4); - redo_list_add(IVAL(buf,0)); + flist_ndx_push(&redo_list, IVAL(buf,0)); break; case MSG_DELETED: if (len >= (int)sizeof buf || !am_generator) { @@ -327,20 +348,11 @@ int msg_list_push(int flush_it_all) int get_redo_num(void) { - struct redo_list *next; - int num; - - while (!redo_list_head) + while (!redo_list.head) { read_msg_fd(); + } - num = redo_list_head->num; - next = redo_list_head->next; - free(redo_list_head); - redo_list_head = next; - if (!next) - redo_list_tail = NULL; - - return num; + return flist_ndx_pop(&redo_list); } /** @@ -362,20 +374,28 @@ void io_set_filesfrom_fds(int f_in, int f_out) io_filesfrom_buflen = 0; } -/** - * It's almost always an error to get an EOF when we're trying to read - * from the network, because the protocol is self-terminating. +/* It's almost always an error to get an EOF when we're trying to read from the + * network, because the protocol is (for the most part) self-terminating. * - * However, there is one unfortunate cases where it is not, which is - * rsync <2.4.6 sending a list of modules on a server, since the list - * is terminated by closing the socket. So, for the section of the - * program where that is a problem (start_socket_client), - * kludge_around_eof is True and we just exit. - */ + * There is one case for the receiver when it is at the end of the transfer + * (hanging around reading any keep-alive packets that might come its way): if + * the sender dies before the generator's kill-signal comes through, we can end + * up here needing to loop until the kill-signal arrives. In this situation, + * kluge_around_eof will be < 0. + * + * There is another case for older protocol versions (< 24) where the module + * listing was not terminated, so we must ignore an EOF error in that case and + * exit. In this situation, kluge_around_eof will be > 0. */ static void whine_about_eof(int fd) { - if (kludge_around_eof && fd == sock_f_in) - exit_cleanup(0); + if (kluge_around_eof && fd == sock_f_in) { + int i; + if (kluge_around_eof > 0) + exit_cleanup(0); + /* If we're still here after 10 seconds, exit with an error. */ + for (i = 10*1000/20; i--; ) + msleep(20); + } rprintf(FERROR, RSYNC_NAME ": connection unexpectedly closed " "(%.0f bytes received so far) [%s]\n", @@ -412,11 +432,7 @@ static int read_timeout(int fd, char *buf, size_t len) FD_ZERO(&r_fds); FD_ZERO(&w_fds); FD_SET(fd, &r_fds); - if (msg_fd_in >= 0) { - FD_SET(msg_fd_in, &r_fds); - if (msg_fd_in > maxfd) - maxfd = msg_fd_in; - } else if (msg_list_head) { + if (msg_list_head) { FD_SET(msg_fd_out, &w_fds); if (msg_fd_out > maxfd) maxfd = msg_fd_out; @@ -453,9 +469,7 @@ static int read_timeout(int fd, char *buf, size_t len) continue; } - if (msg_fd_in >= 0 && FD_ISSET(msg_fd_in, &r_fds)) - read_msg_fd(); - else if (msg_list_head && FD_ISSET(msg_fd_out, &w_fds)) + if (msg_list_head && FD_ISSET(msg_fd_out, &w_fds)) msg_list_push(NORMAL_FLUSH); if (io_filesfrom_f_out >= 0) { @@ -559,7 +573,7 @@ int read_filesfrom_line(int fd, char *fname) { char ch, *s, *eob = fname + MAXPATHLEN - 1; int cnt; - int reading_remotely = remote_filesfrom_file != NULL; + int reading_remotely = filesfrom_host != NULL; int nulls = eol_nulls || reading_remotely; start: @@ -639,6 +653,8 @@ void maybe_send_keepalive(int allowed_lull, int ndx) { if (time(NULL) - last_io >= allowed_lull) { if (!iobuf_out || !iobuf_out_cnt) { + if (protocol_version < 29) + return; /* there's nothing we can do */ write_int(sock_f_out, ndx); write_shortint(sock_f_out, ITEM_IS_NEW); } @@ -836,7 +852,7 @@ void read_buf(int f,char *buf,size_t len) void read_sbuf(int f,char *buf,size_t len) { readfd(f, buf, len); - buf[len] = 0; + buf[len] = '\0'; } uchar read_byte(int f) @@ -846,6 +862,25 @@ uchar read_byte(int f) return c; } +int read_vstring(int f, char *buf, int bufsize) +{ + int len = read_byte(f); + + if (len & 0x80) + len = (len & ~0x80) * 0x100 + read_byte(f); + + if (len >= bufsize) { + rprintf(FERROR, "over-long vstring received (%d > %d)\n", + len, bufsize - 1); + exit_cleanup(RERR_PROTOCOL); + } + + if (len) + readfd(f, buf, len); + buf[len] = '\0'; + return len; +} + /* Populate a sum_struct with values from the socket. This is * called by both the sender and the receiver. */ void read_sum_head(int f, struct sum_struct *sum) @@ -946,8 +981,8 @@ static void sleep_for_bwlimit(int bytes_written) /* Write len bytes to the file descriptor fd, looping as necessary to get - * the job done and also (in the generator) reading any data on msg_fd_in - * (to avoid deadlock). + * the job done and also (in certain circumstnces) reading any data on + * msg_fd_in to avoid deadlock. * * This function underlies the multiplexing system. The body of the * application never calls this function directly. */ @@ -965,7 +1000,7 @@ static void writefd_unbuffered(int fd,char *buf,size_t len) FD_SET(fd,&w_fds); maxfd = fd; - if (msg_fd_in >= 0) { + if (msg_fd_in >= 0 && len-total >= contiguous_write_len) { FD_ZERO(&r_fds); FD_SET(msg_fd_in,&r_fds); if (msg_fd_in > maxfd) @@ -1059,6 +1094,13 @@ static void mplex_write(enum msgcode code, char *buf, size_t len) SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len); + /* When the generator reads messages from the msg_fd_in pipe, it can + * cause output to occur down the socket. Setting contiguous_write_len + * prevents the reading of msg_fd_in once we actually start to write + * this sequence of data (though we might read it before the start). */ + if (am_generator && msg_fd_in >= 0) + contiguous_write_len = len + 4; + if (n > sizeof buffer - 4) n = sizeof buffer - 4; @@ -1070,6 +1112,9 @@ static void mplex_write(enum msgcode code, char *buf, size_t len) if (len) writefd_unbuffered(sock_f_out, buf, len); + + if (am_generator && msg_fd_in >= 0) + contiguous_write_len = 0; } @@ -1178,19 +1223,37 @@ void write_buf(int f,char *buf,size_t len) writefd(f,buf,len); } - /** Write a string to the connection */ void write_sbuf(int f, char *buf) { writefd(f, buf, strlen(buf)); } - void write_byte(int f, uchar c) { writefd(f, (char *)&c, 1); } +void write_vstring(int f, char *str, int len) +{ + uchar lenbuf[3], *lb = lenbuf; + + if (len > 0x7F) { + if (len > 0x7FFF) { + rprintf(FERROR, + "attempting to send over-long vstring (%d > %d)\n", + len, 0x7FFF); + exit_cleanup(RERR_PROTOCOL); + } + *lb++ = len / 0x100 + 0x80; + } + *lb = len; + + writefd(f, (char*)lenbuf, lb - lenbuf + 1); + if (len) + writefd(f, str, len); +} + /** * Read a line of up to @p maxlen characters into @p buf (not counting