static enum cliret restore_wrapper(struct asfd *asfd, enum action action,
int vss_restore, struct conf **confs)
{
enum cliret ret=CLIENT_OK;
const char *r_script_pre=get_string(confs[OPT_R_SCRIPT_PRE]);
const char *r_script_post=get_string(confs[OPT_R_SCRIPT_POST]);
if(r_script_pre)
{
int a=0;
const char *args[12];
args[a++]=r_script_pre;
if(get_int(confs[OPT_R_SCRIPT_RESERVED_ARGS]))
{
args[a++]="pre";
args[a++]="reserved2";
args[a++]="reserved3";
args[a++]="reserved4";
args[a++]="reserved5";
}
args[a++]=NULL;
if(run_script(asfd,
args, get_strlist(confs[OPT_R_SCRIPT_PRE_ARG]),
confs, 1, 1, 1))
ret=CLIENT_ERROR;
}
if(ret==CLIENT_OK)
{
if(do_restore_client(asfd, confs,
action, vss_restore)) ret=CLIENT_ERROR;
}
if((ret==CLIENT_OK || get_int(confs[OPT_R_SCRIPT_POST_RUN_ON_FAIL]))
&& r_script_post)
{
int a=0;
const char *args[12];
args[a++]=r_script_pre;
if(get_int(confs[OPT_R_SCRIPT_RESERVED_ARGS]))
{
args[a++]="post";
// Tell post script whether the restore failed.
args[a++]=ret?"1":"0";
args[a++]="reserved3";
args[a++]="reserved4";
args[a++]="reserved5";
}
args[a++]=NULL;
if(run_script(asfd,
args, get_strlist(confs[OPT_R_SCRIPT_POST_ARG]),
confs, 1, 1, 1))
ret=CLIENT_ERROR;
}
// Return non-zero if there were warnings,
// so that the test script can easily check.
if(ret==CLIENT_OK && get_cntr(confs)->ent[CMD_WARNING]->count)
ret=CLIENT_RESTORE_WARNINGS;
return ret;
}
// Instead of adding onto the end of the list, this replaces the list.
static int conf_set_from_global_arg_list_overrides(struct conf **globalc,
struct conf **cc)
{
int i=0;
for(i=0; i<OPT_MAX; i++)
{
if(cc[i]->conf_type!=CT_STRLIST) continue;
if(!(cc[i]->flags & CONF_FLAG_CC_OVERRIDE)) continue;
if(cc[i]->flags & CONF_FLAG_STRLIST_REPLACE)
{
// If there was no cc[i] strlist set, use the global.
if(!get_strlist(cc[i])
&& append_strlist(cc[i], globalc[i]))
return -1;
}
else
{
struct conf tmpconf;
// A bit painful.
tmpconf.conf_type=cc[i]->conf_type;
tmpconf.flags=cc[i]->flags;
memset(&tmpconf.data, 0, sizeof(tmpconf.data));
if(append_strlist(&tmpconf, globalc[i])
|| append_strlist(&tmpconf, cc[i]))
return -1;
set_strlist(cc[i], get_strlist(&tmpconf));
}
}
return 0;
}
static int finalise_keep_args(struct conf **c)
{
struct strlist *k;
struct strlist *last=NULL;
uint64_t mult=1;
for(k=get_strlist(c[OPT_KEEP]); k; k=k->next)
{
if(!(k->flag=atoi(k->path)))
{
logp("'keep' value cannot be set to '%s'\n", k->path);
return -1;
}
mult*=k->flag;
// An error if you try to keep backups every second
// for 100 years.
if(mult>52560000)
{
logp("Your 'keep' values are far too high. High enough to keep a backup every second for 10 years. Please lower them to something sensible.\n");
return -1;
}
last=k;
}
// If more than one keep value is set, add one to the last one.
// This is so that, for example, having set 7, 4, 6, then
// a backup of age 7*4*6=168 or more is guaranteed to be kept.
// Otherwise, only 7*4*5=140 would be guaranteed to be kept.
k=get_strlist(c[OPT_KEEP]);
if(k && k->next) last->flag++;
return 0;
}
// When recursing into directories, do not want to check the include_ext list.
static int file_is_included_no_incext(struct conf **confs, const char *fname)
{
int ret=0;
int longest=0;
int matching=0;
struct strlist *l=NULL;
struct strlist *best=NULL;
if(in_exclude_ext(get_strlist(confs[OPT_EXCEXT]), fname)
|| in_exclude_regex(get_strlist(confs[OPT_EXCREG]), fname))
return 0;
// Check include/exclude directories.
for(l=get_strlist(confs[OPT_INCEXCDIR]); l; l=l->next)
{
matching=is_subdir(l->path, fname);
if(matching>longest)
{
longest=matching;
best=l;
}
}
if(!best) ret=0;
else ret=best->flag;
return ret;
}
static int finalise_incexc_dirs(struct conf **c)
{
struct strlist *s=NULL;
for(s=get_strlist(c[OPT_INCLUDE]); s; s=s->next)
if(incexc_munge(c, s)) return -1;
for(s=get_strlist(c[OPT_EXCLUDE]); s; s=s->next)
if(incexc_munge(c, s)) return -1;
return 0;
}
static
#endif
int conf_finalise(struct conf **c)
{
int s_script_notify=0;
if(finalise_fstypes(c)) return -1;
strlist_compile_regexes(get_strlist(c[OPT_INCREG]));
strlist_compile_regexes(get_strlist(c[OPT_EXCREG]));
set_max_ext(get_strlist(c[OPT_INCEXT]));
set_max_ext(get_strlist(c[OPT_EXCEXT]));
set_max_ext(get_strlist(c[OPT_EXCOM]));
if(get_e_burp_mode(c[OPT_BURP_MODE])==BURP_MODE_CLIENT
&& finalise_glob(c)) return -1;
if(finalise_incexc_dirs(c)
|| finalise_start_dirs(c)) return -1;
if(finalise_keep_args(c)) return -1;
if((s_script_notify=get_int(c[OPT_S_SCRIPT_NOTIFY])))
{
set_int(c[OPT_S_SCRIPT_PRE_NOTIFY], s_script_notify);
set_int(c[OPT_S_SCRIPT_POST_NOTIFY], s_script_notify);
}
// These override the specific pre/post script paths with the general
// one. For example, if 'server_script' is set, its value is used for
// 'server_script_pre' and 'server_script_post'.
if(pre_post_override(c[OPT_B_SCRIPT],
c[OPT_B_SCRIPT_PRE], c[OPT_B_SCRIPT_POST])
|| pre_post_override(c[OPT_R_SCRIPT],
c[OPT_R_SCRIPT_PRE], c[OPT_R_SCRIPT_POST])
|| pre_post_override(c[OPT_S_SCRIPT],
c[OPT_S_SCRIPT_PRE], c[OPT_S_SCRIPT_POST])
// And these do the same for the script arguments.
|| setup_script_arg_overrides(c[OPT_B_SCRIPT_ARG],
c[OPT_B_SCRIPT_PRE_ARG], c[OPT_B_SCRIPT_POST_ARG])
|| setup_script_arg_overrides(c[OPT_R_SCRIPT_ARG],
c[OPT_R_SCRIPT_PRE_ARG], c[OPT_R_SCRIPT_POST_ARG])
|| setup_script_arg_overrides(c[OPT_S_SCRIPT_ARG],
c[OPT_S_SCRIPT_PRE_ARG], c[OPT_S_SCRIPT_POST_ARG]))
return -1;
// We are now done with these. Clear them, otherwise they interfere.
set_string(c[OPT_S_SCRIPT], NULL);
set_strlist(c[OPT_S_SCRIPT_ARG], NULL);
return 0;
}
/* If OPT_HARDLINKED_ARCHIVE set, hardlink everything.
If unset and there is more than one 'keep' value, periodically hardlink,
based on the first 'keep' value. This is so that we have more choice
of backups to delete than just the oldest.
*/
static int need_hardlinked_archive(struct conf **cconfs, unsigned long bno)
{
int kp=0;
int ret=0;
struct strlist *keep=get_strlist(cconfs[OPT_KEEP]);
if(get_int(cconfs[OPT_HARDLINKED_ARCHIVE]))
{
logp("New backup is a hardlinked_archive\n");
return 1;
}
if(!keep || !keep->next)
{
logp("New backup is not a hardlinked_archive\n");
return 0;
}
// If they have specified more than one 'keep' value, need to
// periodically hardlink, based on the first 'keep' value.
kp=keep->flag;
logp("First keep value: %d, backup: %lu (%lu-1=%lu)\n",
kp, bno, bno, bno-1);
ret=(bno-1)%kp;
logp("New backup is %sa hardlinked_archive (%lu%%%d=%d)\n",
ret?"not ":"", bno-1, kp, ret);
return !ret;
}
void log_restore_settings(struct conf **cconfs, int srestore)
{
struct strlist *l;
logp("Restore settings:\n");
if(get_string(cconfs[OPT_ORIG_CLIENT]))
logp("orig_client = '%s'\n",
get_string(cconfs[OPT_ORIG_CLIENT]));
if(get_string(cconfs[OPT_BACKUP]))
logp("backup = '%s'\n",
get_string(cconfs[OPT_BACKUP]));
if(srestore)
{
// This are unknown unless doing a server initiated restore.
logp("overwrite = %d\n", get_int(cconfs[OPT_OVERWRITE]));
logp("strip = %d\n", get_int(cconfs[OPT_STRIP]));
}
if(get_string(cconfs[OPT_RESTOREPREFIX]))
logp("restoreprefix = '%s'\n",
get_string(cconfs[OPT_RESTOREPREFIX]));
if(get_string(cconfs[OPT_STRIP_FROM_PATH]))
logp("stripfrompath = '%s'\n",
get_string(cconfs[OPT_STRIP_FROM_PATH]));
if(get_string(cconfs[OPT_REGEX]))
logp("regex = '%s'\n", get_string(cconfs[OPT_REGEX]));
for(l=get_strlist(cconfs[OPT_INCLUDE]); l; l=l->next)
logp("include = '%s'\n", l->path);
}
static int setup_script_arg_overrides(struct conf *c,
struct conf *pre_args, struct conf *post_args)
{
if(!get_strlist(c)) return 0;
return setup_script_arg_override(c, pre_args)
|| setup_script_arg_override(c, post_args);
}
// The glob stuff should only run on the client side.
static int finalise_glob(struct conf **c)
{
int ret=-1;
#ifdef HAVE_WIN32
if(glob_windows(c)) goto end;
#else
int i;
glob_t globbuf;
struct strlist *l;
struct strlist *last=NULL;
memset(&globbuf, 0, sizeof(globbuf));
for(l=get_strlist(c[OPT_INCGLOB]); l; l=l->next)
{
glob(l->path, last?GLOB_APPEND:0, NULL, &globbuf);
last=l;
}
for(i=0; (unsigned int)i<globbuf.gl_pathc; i++)
if(add_to_strlist_include_uniq(c[OPT_INCLUDE], globbuf.gl_pathv[i]))
goto end;
globfree(&globbuf);
#endif
ret=0;
end:
return ret;
}
static
#endif
int cstat_permitted(struct cstat *cstat,
struct conf **parentconfs, struct conf **cconfs)
{
struct strlist *rclient;
const char *parentconf_cname;
parentconf_cname=get_string(parentconfs[OPT_CNAME]);
if(!parentconf_cname) return 0;
// Allow clients to look at themselves.
if(!strcmp(cstat->name, parentconf_cname)) return 1;
// Do not allow clients using the restore_client option to see more
// than the client that it is pretending to be.
if(get_string(parentconfs[OPT_RESTORE_CLIENT])) return 0;
// If we are listed in this restore_client list.
for(rclient=get_strlist(cconfs[OPT_RESTORE_CLIENTS]);
rclient; rclient=rclient->next)
if(!strcmp(get_string(parentconfs[OPT_CNAME]), rclient->path))
return 1;
return 0;
}
// This decides which directories to start backing up, and which
// are subdirectories which don't need to be started separately.
static int finalise_start_dirs(struct conf **c)
{
struct strlist *s=NULL;
struct strlist *last_ie=NULL;
struct strlist *last_sd=NULL;
// Make sure that the startdir list starts empty, or chaos will ensue.
conf_free_content(c[OPT_STARTDIR]);
for(s=get_strlist(c[OPT_INCLUDE]); s; s=s->next)
{
#ifdef HAVE_WIN32
convert_backslashes(&s->path);
#endif
if(path_checks(s->path,
"ERROR: Please use absolute include/exclude paths.\n"))
return -1;
// Ensure that we do not backup the same directory twice.
if(last_ie && !strcmp(s->path, last_ie->path))
{
logp("Directory appears twice in conf: %s\n",
s->path);
return -1;
}
// If it is not a subdirectory of the most recent start point,
// we have found another start point.
if(!get_strlist(c[OPT_STARTDIR])
|| !last_sd || !is_subdir(last_sd->path, s->path))
{
// Do not use strlist_add_sorted, because last_sd is
// relying on incexcdir already being sorted.
if(add_to_strlist(c[OPT_STARTDIR], s->path, s->flag))
return -1;
last_sd=s;
}
else
{
// If it is not a starting directory, it should at
// least be included as a cross_filesystem entry.
if(add_to_cross_filesystem(c, s->path))
return -1;
}
last_ie=s;
}
return 0;
}
static int append_strlist(struct conf *dst, struct conf *src)
{
struct strlist *s;
for(s=get_strlist(src); s; s=s->next)
if(add_to_strlist(dst, s->path, s->flag))
return -1;
return 0;
}
static int need_to_read_blockdev(struct conf **confs, const char *fname)
{
struct strlist *l;
if(get_int(confs[OPT_READ_ALL_BLOCKDEVS])) return 1;
for(l=get_strlist(confs[OPT_BLOCKDEVS]); l; l=l->next)
if(!strcmp(l->path, fname)) return 1;
return 0;
}
static int fs_change_is_allowed(struct conf **confs, const char *fname)
{
struct strlist *l;
if(get_int(confs[OPT_CROSS_ALL_FILESYSTEMS])) return 1;
for(l=get_strlist(confs[OPT_FSCHGDIR]); l; l=l->next)
if(!strcmp(l->path, fname)) return 1;
return 0;
}
int glob_windows(struct conf **confs)
{
struct strlist *ig;
for(ig=get_strlist(confs[OPT_INCGLOB]); ig; ig=ig->next)
if(process_entry(ig, confs)) return -1;
return 0;
}
static int setup_script_arg_override(struct conf *c, struct conf *args)
{
struct strlist *s;
set_strlist(args, NULL);
for(s=get_strlist(c); s; s=s->next)
if(add_to_strlist(args, s->path, s->flag))
return -1;
return 0;
}
static int check_client_and_password(struct conf **globalcs,
const char *password, struct conf **cconfs)
{
const char *cname;
int password_check;
// Cannot load it until here, because we need to have the name of the
// client.
if(conf_load_clientconfdir(globalcs, cconfs)) return -1;
cname=get_string(cconfs[OPT_CNAME]);
password_check=get_int(cconfs[OPT_PASSWORD_CHECK]);
if(!get_string(cconfs[OPT_SSL_PEER_CN]))
{
logp("ssl_peer_cn unset");
if(cname)
{
logp("Falling back to using '%s'\n", cname);
if(set_string(cconfs[OPT_SSL_PEER_CN], cname))
return -1;
}
}
cname=get_string(cconfs[OPT_CNAME]);
if(password_check)
{
const char *conf_passwd=get_string(cconfs[OPT_PASSWD]);
const char *conf_password=get_string(cconfs[OPT_PASSWORD]);
if(!conf_password && !conf_passwd)
{
logp("password rejected for client %s\n", cname);
return -1;
}
// check against plain text
if(conf_password && strcmp(conf_password, password))
{
logp("password rejected for client %s\n", cname);
return -1;
}
// check against encypted passwd
if(conf_passwd && !check_passwd(conf_passwd, password))
{
logp("password rejected for client %s\n", cname);
return -1;
}
}
if(!get_strlist(cconfs[OPT_KEEP]))
{
logp("%s: you cannot set the keep value for a client to 0!\n",
cname);
return -1;
}
return 0;
}
static int restore_client_allowed(struct conf **cconfs, struct conf **sconfs)
{
struct strlist *r;
for(r=get_strlist(sconfs[OPT_RESTORE_CLIENTS]); r; r=r->next)
if(!strcmp(r->path, get_string(cconfs[OPT_CNAME])))
return 1;
logp("Access to client is not allowed: %s",
get_string(sconfs[OPT_CNAME]));
return 0;
}
static void run_find(const char *buf, FF_PKT *ff, struct conf **confs)
{
struct strlist *l;
const char *conffile=CONFBASE "/burp.conf";
fail_unless(!recursive_delete(CONFBASE));
build_file(conffile, buf);
fail_unless(!conf_load_global_only(conffile, confs));
for(l=get_strlist(confs[OPT_STARTDIR]); l; l=l->next) if(l->flag)
fail_unless(!find_files_begin(NULL, ff, confs, l->path));
fail_unless(!recursive_delete(CONFBASE));
}
// Used when restore is initiated from the server.
static int check_srestore(struct conf **confs, const char *path)
{
struct strlist *l=get_strlist(confs[OPT_INCEXCDIR]);
// If no includes specified, restore everything.
if(!l) return 1;
for(; l; l=l->next)
if(srestore_matches(l, path))
return 1;
return 0;
}
static int run_server_script(struct asfd *asfd,
const char *pre_or_post,
const char *script, struct strlist *script_arg,
uint8_t notify, struct conf **cconfs, int backup_ret, int timer_ret)
{
int a=0;
int ret=0;
char *logbuf=NULL;
const char *args[12];
struct iobuf *rbuf=asfd->rbuf;
const char *cname=get_string(cconfs[OPT_CNAME]);
args[a++]=script;
args[a++]=pre_or_post;
args[a++]=rbuf->buf?rbuf->buf:"", // Action requested by client.
args[a++]=cname;
args[a++]=backup_ret?"1":"0", // Indicate success or failure.
// Indicate whether the timer script said OK or not.
args[a++]=timer_ret?"1":"0",
args[a++]=NULL;
// Do not have a client storage directory, so capture the
// output in a buffer to pass to the notification script.
if(run_script_to_buf(asfd, args, script_arg, cconfs, 1, 1, 0, &logbuf))
{
char msg[256];
snprintf(msg, sizeof(msg),
"server %s script %s returned an error",
pre_or_post, script);
log_and_send(asfd, msg);
ret=-1;
if(!notify) goto end;
a=0;
args[a++]=get_string(cconfs[OPT_N_FAILURE_SCRIPT]);
args[a++]=cname;
// magic - set basedir blank and the
// notify script will know to get the content
// from the next argument (usually storagedir)
args[a++]=""; // usually basedir
args[a++]=logbuf?logbuf:""; //usually storagedir
args[a++]=""; // usually file
args[a++]=""; // usually brv
args[a++]=""; // usually warnings
args[a++]=NULL;
run_script(asfd, args, get_strlist(cconfs[OPT_N_FAILURE_ARG]),
cconfs, 1, 1, 0);
}
end:
free_w(&logbuf);
return ret;
}
static int my_send_file(struct asfd *asfd, struct FF_PKT *ff, struct conf **confs)
{
static struct sbuf *sb=NULL;
struct cntr *cntr=get_cntr(confs);
if(!sb && !(sb=sbuf_alloc(get_protocol(confs)))) return -1;
#ifdef HAVE_WIN32
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED)
{
if(ff->type==FT_REG
|| ff->type==FT_DIR)
return to_server(asfd, confs, ff, sb, CMD_EFS_FILE);
return logw(asfd, cntr,
"EFS type %d not yet supported: %s\n",
ff->type, ff->fname);
}
#endif
switch(ff->type)
{
case FT_REG:
case FT_RAW:
case FT_FIFO:
return do_to_server(asfd, confs, ff, sb, filesymbol,
in_exclude_comp(get_strlist(confs[OPT_EXCOM]),
ff->fname, get_int(confs[OPT_COMPRESSION])));
case FT_DIR:
case FT_REPARSE:
case FT_JUNCTION:
return to_server(asfd, confs, ff, sb, dirsymbol);
case FT_LNK_S:
return to_server(asfd, confs, ff, sb, CMD_SOFT_LINK);
case FT_LNK_H:
return to_server(asfd, confs, ff, sb, CMD_HARD_LINK);
case FT_SPEC:
return to_server(asfd, confs, ff, sb, CMD_SPECIAL);
case FT_NOFSCHG:
return ft_err(asfd, confs, ff, "Will not descend: "
"file system change not allowed");
case FT_NOFOLLOW:
return ft_err(asfd, confs, ff, "Could not follow link");
case FT_NOSTAT:
return ft_err(asfd, confs, ff, "Could not stat");
case FT_NOOPEN:
return ft_err(asfd, confs, ff, "Could not open directory");
default:
return logw(asfd, cntr,
"Err: Unknown file type %d: %s\n",
ff->type, ff->fname);
}
}
static void maybe_do_notification(struct asfd *asfd,
int status, const char *clientdir,
const char *storagedir, const char *filename,
const char *brv, struct conf **cconfs)
{
int a=0;
const char *args[12];
struct cntr *cntr=get_cntr(cconfs);
args[a++]=NULL; // Fill in the script name later.
args[a++]=get_string(cconfs[OPT_CNAME]);
args[a++]=clientdir;
args[a++]=storagedir;
args[a++]=filename;
args[a++]=brv;
if(status)
{
args[0]=get_string(cconfs[OPT_N_FAILURE_SCRIPT]);
args[a++]="0";
args[a++]=NULL;
run_script(asfd, args, get_strlist(cconfs[OPT_N_FAILURE_ARG]),
cconfs, 1, 1, 1);
}
else if((get_int(cconfs[OPT_N_SUCCESS_WARNINGS_ONLY])
&& cntr->ent[CMD_WARNING]->count > 0)
|| (get_int(cconfs[OPT_N_SUCCESS_CHANGES_ONLY])
&& cntr->ent[CMD_TOTAL]->changed > 0)
|| (!get_int(cconfs[OPT_N_SUCCESS_WARNINGS_ONLY])
&& !get_int(cconfs[OPT_N_SUCCESS_CHANGES_ONLY])))
{
char warnings[32]="";
snprintf(warnings, sizeof(warnings), "%"PRIu64,
cntr->ent[CMD_WARNING]->count);
args[0]=get_string(cconfs[OPT_N_SUCCESS_SCRIPT]);
args[a++]=warnings;
args[a++]=NULL;
run_script(asfd, args, get_strlist(cconfs[OPT_N_SUCCESS_ARG]),
cconfs, 1, 1, 1);
}
}
// Return -1 for error, 0 to backup, 1 to not backup.
int run_timer(
struct asfd *asfd,
struct sdirs *sdirs,
struct conf **cconfs)
{
const char *cname=get_string(cconfs[OPT_CNAME]);
const char *timer_script=NULL;
struct strlist *timer_args=get_strlist(cconfs[OPT_TIMER_ARG]);
if((timer_script=get_string(cconfs[OPT_TIMER_SCRIPT])))
return run_timer_script(asfd, timer_script,
cname, sdirs, timer_args, cconfs);
return run_timer_internal_w(cname, sdirs, timer_args);
}
//---------------------------------------------------------------------------------
//load preference
void AppConf::Load()
{
for (cache_t::iterator p=cache.begin(); p!=cache.end(); ++p) {
std::pair<std::string, std::string> name = split(p->first);
p->second->load(*cf, name.first.c_str(), name.second.c_str());
}
const std::list<std::string> &list=
get_strlist("/apps/stardict/preferences/main_window/search_website_list");
if (list.empty()) {
cache_t::iterator p =
cache.find("/apps/stardict/preferences/main_window/search_website_list");
static_cast<confval< std::list<std::string> > *>(p->second)->val_ =
get_default_search_website_list();
}
}
static int file_is_included(struct conf **confs,
const char *fname, bool top_level)
{
// Always save the top level directory.
// This will help in the simulation of browsing backups because it
// will mean that there is always a directory before any files:
// d /home/graham
// f /home/graham/somefile.txt
// This means that we can use the stats of the directory (/home/graham
// in this example) as the stats of the parent directories (/home,
// for example). Trust me on this.
if(!top_level
&& !in_include_ext(get_strlist(confs[OPT_INCEXT]), fname)) return 0;
return file_is_included_no_incext(confs, fname);
}
static int fstype_excluded(struct asfd *asfd,
struct conf **confs, const char *fname)
{
#if defined(HAVE_LINUX_OS)
struct statfs buf;
struct strlist *l;
if(statfs(fname, &buf))
{
logw(asfd, get_cntr(confs), "Could not statfs %s: %s\n",
fname, strerror(errno));
return -1;
}
for(l=get_strlist(confs[OPT_EXCFS]); l; l=l->next)
if(l->flag==buf.f_type)
return -1;
#endif
return 0;
}
static int set_cstat_from_conf(struct cstat *cstat,
struct conf **parentconfs, struct conf **cconfs)
{
struct strlist *s=NULL;
// Make sure the permitted flag is set appropriately.
cstat->permitted=cstat_permitted(cstat, parentconfs, cconfs);
cstat->protocol=get_protocol(cconfs);
sdirs_free((struct sdirs **)&cstat->sdirs);
if(!(cstat->sdirs=sdirs_alloc())
|| sdirs_init_from_confs((struct sdirs *)cstat->sdirs, cconfs))
return -1;
strlists_free(&cstat->labels);
for(s=get_strlist(cconfs[OPT_LABEL]); s; s=s->next)
if(strlist_add_sorted(&cstat->labels, s->path, s->flag))
return -1;
return 0;
}
int backup_phase1_client(struct asfd *asfd, struct conf **confs)
{
int ret=-1;
struct FF_PKT *ff=NULL;
struct strlist *l=NULL;
enable_acl=get_int(confs[OPT_ACL]);
enable_xattr=get_int(confs[OPT_XATTR]);
// First, tell the server about everything that needs to be backed up.
logp("Phase 1 begin (file system scan)\n");
// Encryption not yet supported in protocol2.
if(get_protocol(confs)==PROTO_1
&& get_string(confs[OPT_ENCRYPTION_PASSWORD]))
{
encryption=ENCRYPTION_KEY_DERIVED;
filesymbol=CMD_ENC_FILE;
metasymbol=CMD_ENC_METADATA;
#ifdef HAVE_WIN32
metasymbol=CMD_ENC_VSS;
vss_trail_symbol=CMD_ENC_VSS_T;
#endif
}
#ifdef HAVE_WIN32
dirsymbol=filesymbol;
if(get_protocol(confs)==PROTO_1
&& get_int(confs[OPT_STRIP_VSS]))
dirsymbol=CMD_DIRECTORY;
#endif
if(!(ff=find_files_init(my_send_file))) goto end;
for(l=get_strlist(confs[OPT_STARTDIR]); l; l=l->next) if(l->flag)
if(find_files_begin(asfd, ff, confs, l->path)) goto end;
ret=0;
end:
cntr_print_end_phase1(get_cntr(confs));
if(ret) logp("Error in phase 1\n");
logp("Phase 1 end (file system scan)\n");
find_files_free(&ff);
return ret;
}
