+/* This function converts the characters in the "in" xbuf into characters
+ * in the "out" xbuf. The "len" of the "in" xbuf is used starting from its
+ * "pos". The "size" of the "out" xbuf restricts how many characters can be
+ * stored, starting at its "pos+len" position. Note that the last byte of
+ * the buffer is never used, which reserves space for a terminating '\0'.
+ * We return a 0 on success or a -1 on error. An error also sets errno to
+ * E2BIG, EILSEQ, or EINVAL (see below); otherwise errno will be set to 0.
+ * The "in" xbuf is altered to update "pos" and "len". The "out" xbuf has
+ * data appended, and its "len" incremented. If ICB_EXPAND_OUT is set in
+ * "flags", the "out" xbuf will also be allocated if empty, and expanded if
+ * too small (so E2BIG will not be returned). If ICB_INCLUDE_BAD is set in
+ * "flags", any badly-encoded chars are included verbatim in the "out" xbuf,
+ * so EILSEQ will not be returned. Likewise for ICB_INCLUDE_INCOMPLETE with
+ * respect to an incomplete multi-byte char at the end, which ensures that
+ * EINVAL is not returned. Anytime "in.pos" is 0 we will reset the iconv()
+ * state prior to processing the characters. */
+int iconvbufs(iconv_t ic, xbuf *in, xbuf *out, int flags)
+{
+ ICONV_CONST char *ibuf;
+ size_t icnt, ocnt;
+ char *obuf;
+
+ if (!out->size && flags & ICB_EXPAND_OUT)
+ alloc_xbuf(out, 1024);
+
+ if (!in->pos)
+ iconv(ic, NULL, 0, NULL, 0);
+
+ ibuf = in->buf + in->pos;
+ icnt = in->len;
+
+ obuf = out->buf + (out->pos + out->len);
+ ocnt = out->size - (out->pos + out->len) - 1;
+
+ while (icnt) {
+ while (iconv(ic, &ibuf, &icnt, &obuf, &ocnt) == (size_t)-1) {
+ if (errno == EINTR)
+ continue;
+ if (errno == EINVAL) {
+ if (!(flags & ICB_INCLUDE_INCOMPLETE))
+ goto finish;
+ } else if (errno == EILSEQ) {
+ if (!(flags & ICB_INCLUDE_BAD))
+ goto finish;
+ } else {
+ size_t opos = obuf - out->buf;
+ if (!(flags & ICB_EXPAND_OUT)) {
+ errno = E2BIG;
+ goto finish;
+ }
+ realloc_xbuf(out, out->size + 1024);
+ obuf = out->buf + opos;
+ ocnt += 1024;
+ continue;
+ }
+ *obuf++ = *ibuf++;
+ ocnt--, icnt--;
+ }
+ }
+
+ errno = 0;
+
+ finish:
+ in->len = icnt;
+ in->pos = ibuf - in->buf;
+ out->len = obuf - out->buf - out->pos;
+
+ return errno ? -1 : 0;
+}
+#endif
+
+void send_protected_args(int fd, char *args[])
+{
+ int i;
+#ifdef ICONV_OPTION
+ int convert = ic_send != (iconv_t)-1;
+ xbuf outbuf, inbuf;
+
+ if (convert)
+ alloc_xbuf(&outbuf, 1024);
+#endif
+
+ for (i = 0; args[i]; i++) {} /* find first NULL */
+ args[i] = "rsync"; /* set a new arg0 */
+ if (DEBUG_GTE(CMD, 1))
+ print_child_argv("protected args:", args + i + 1);
+ do {
+#ifdef ICONV_OPTION
+ if (convert) {
+ INIT_XBUF_STRLEN(inbuf, args[i]);
+ iconvbufs(ic_send, &inbuf, &outbuf,
+ ICB_EXPAND_OUT | ICB_INCLUDE_BAD | ICB_INCLUDE_INCOMPLETE);
+ outbuf.buf[outbuf.len] = '\0';
+ write_buf(fd, outbuf.buf, outbuf.len + 1);
+ outbuf.len = 0;
+ } else
+#endif
+ write_buf(fd, args[i], strlen(args[i]) + 1);
+ } while (args[++i]);
+ write_byte(fd, 0);
+
+#ifdef ICONV_OPTION
+ if (convert)
+ free(outbuf.buf);
+#endif
+}
+
+int read_ndx_and_attrs(int f_in, int *iflag_ptr, uchar *type_ptr,
+ char *buf, int *len_ptr)
+{
+ int len, iflags = 0;
+ struct file_list *flist;
+ uchar fnamecmp_type = FNAMECMP_FNAME;
+ int ndx;
+
+ read_loop:
+ while (1) {
+ ndx = read_ndx(f_in);
+
+ if (ndx >= 0)
+ break;
+ if (ndx == NDX_DONE)
+ return ndx;
+ if (!inc_recurse || am_sender) {
+ int last;
+ if (first_flist)
+ last = first_flist->prev->ndx_start + first_flist->prev->used - 1;
+ else
+ last = -1;
+ rprintf(FERROR,
+ "Invalid file index: %d (%d - %d) [%s]\n",
+ ndx, NDX_DONE, last, who_am_i());
+ exit_cleanup(RERR_PROTOCOL);
+ }
+ if (ndx == NDX_FLIST_EOF) {
+ flist_eof = 1;
+ send_msg(MSG_FLIST_EOF, "", 0, 0);