static #endif int write_hook_header(struct fzp *fzp, const char *rmanifest, const char *msg) { int ret=0; char *tmp=NULL; if(!(tmp=prepend_s(rmanifest, msg)) || send_msg_fzp(fzp, CMD_MANIFEST, tmp, strlen(tmp))) ret=-1; free_w(&tmp); return ret; }
int sbuf_to_manifest(struct sbuf *sb, struct fzp *fzp) { if(!sb->path.buf) return 0; if(sb->protocol1) { if(sb->protocol1->datapth.buf && iobuf_send_msg_fzp(&(sb->protocol1->datapth), fzp)) return -1; if(iobuf_send_msg_fzp(&sb->attr, fzp)) return -1; } else { // Hackity hack: Strip the file index from the beginning of // the attribs so that manifests where nothing changed are // identical to each other. Better would be to preserve the // index. char *cp; if(!(cp=strchr(sb->attr.buf, ' '))) { logp("Strange attributes: %s\n", iobuf_to_printable(&sb->attr)); return -1; } if(send_msg_fzp(fzp, CMD_ATTRIBS, cp, sb->attr.len-(cp-sb->attr.buf))) return -1; } if(iobuf_send_msg_fzp(&sb->path, fzp)) return -1; if(sb->link.buf && iobuf_send_msg_fzp(&sb->link, fzp)) return -1; if(sb->endfile.buf && iobuf_send_msg_fzp(&sb->endfile, fzp)) return -1; return 0; }
static struct slist *build_manifest_phase1(const char *path, enum protocol protocol, int entries) { struct sbuf *sb; struct slist *slist=NULL; struct manio *manio=NULL; slist=build_slist_phase1(NULL /*prefix*/, protocol, entries); fail_unless((manio=manio_open_phase1(path, "wb", protocol))!=NULL); for(sb=slist->head; sb; sb=sb->next) { fail_unless(!manio_write_sbuf(manio, sb)); if(protocol==PROTO_2) hack_protocol2_attr(&sb->attr); } fail_unless(!send_msg_fzp(manio->fzp, CMD_GEN, "phase1end", strlen("phase1end"))); fail_unless(!manio_close(&manio)); return slist; }
void build_manifest_phase1_from_slist(const char *path, struct slist *slist, enum protocol protocol) { struct sbuf *sb; struct manio *manio=NULL; struct iobuf datapth; struct iobuf endfile; iobuf_init(&datapth); iobuf_init(&endfile); for(sb=slist->head; sb; sb=sb->next) set_sbuf(slist, sb, 0 /* with_data_files */); fail_unless((manio=manio_open_phase1(path, "wb", protocol))!=NULL); for(sb=slist->head; sb; sb=sb->next) { // Might be given an slist that has datapth or endfile set, // which should not go into a phase1 scan. Deal with it. if(sb->protocol1 && sb->protocol1->datapth.buf) iobuf_move(&datapth, &sb->protocol1->datapth); if(sb->endfile.buf) iobuf_move(&endfile, &sb->endfile); fail_unless(!manio_write_sbuf(manio, sb)); if(datapth.buf) iobuf_move(&sb->protocol1->datapth, &datapth); if(endfile.buf) iobuf_move(&sb->endfile, &endfile); } fail_unless(!send_msg_fzp(manio->fzp, CMD_GEN, "phase1end", strlen("phase1end"))); fail_unless(!manio_close(&manio)); }
int iobuf_send_msg_fzp(struct iobuf *iobuf, struct fzp *fzp) { return send_msg_fzp(fzp, iobuf->cmd, iobuf->buf, iobuf->len); }
int backup_phase1_server_all(struct async *as, struct sdirs *sdirs, struct conf **confs) { int ret=-1; struct sbuf *sb=NULL; char *phase1tmp=NULL; struct asfd *asfd=as->asfd; struct manio *manio=NULL; enum protocol protocol=get_protocol(confs); struct cntr *cntr=get_cntr(confs); logp("Begin phase1 (file system scan)\n"); if(!(phase1tmp=get_tmp_filename(sdirs->phase1data)) || !(manio=manio_open_phase1(phase1tmp, comp_level(get_int(confs[OPT_COMPRESSION])), protocol)) || !(sb=sbuf_alloc(protocol))) goto error; while(1) { sbuf_free_content(sb); switch(sbuf_fill_from_net(sb, asfd, NULL, NULL, cntr)) { case 0: break; case 1: // Last thing the client sends is // 'backupphase2', and it wants an 'ok' reply. if(asfd->write_str(asfd, CMD_GEN, "ok") || send_msg_fzp(manio->fzp, CMD_GEN, "phase1end", strlen("phase1end"))) goto error; goto end; case -1: default: goto error; } if(write_status(CNTR_STATUS_SCANNING, sb->path.buf, cntr) || manio_write_sbuf(manio, sb)) goto error; cntr_add_phase1(cntr, sb->path.cmd, 0); if(sbuf_is_filedata(sb)) { cntr_add_val(cntr, CMD_BYTES_ESTIMATED, (uint64_t)sb->statp.st_size, 0); } } end: if(manio_close(&manio)) { logp("error closing %s in backup_phase1_server\n", phase1tmp); goto error; } if(check_quota(as, cntr, get_uint64_t(confs[OPT_HARD_QUOTA]), get_uint64_t(confs[OPT_SOFT_QUOTA]))) goto error; // Possible rename race condition is of no consequence here, because // the working directory will always get deleted if phase1 is not // complete. if(do_rename(phase1tmp, sdirs->phase1data)) goto error; //cntr_print(p1cntr, cntr, ACTION_BACKUP); logp("End phase1 (file system scan)\n"); ret=0; error: free_w(&phase1tmp); manio_close(&manio); sbuf_free(&sb); return ret; }
static int write_sig_msg(struct manio *manio, const char *msg) { if(!manio->fzp && manio_open_next_fpath(manio)) return -1; if(send_msg_fzp(manio->fzp, CMD_SIG, msg, strlen(msg))) return -1; return check_sig_count(manio, msg); }