static void tear_down(FF_PKT **ff, struct conf ***confs)
{
fail_unless(e==NULL);
find_files_free(ff);
confs_free(confs);
strlists_free(&expected);
fail_unless(recursive_delete(BASE)==0);
alloc_check();
}
static void remove_locks(void)
{
int i=0;
// Remove locks.
for(i=0; i<lockcount; i++)
unlink(locklist[i]->path);
strlists_free(locklist, lockcount);
lockcount=0;
}
static int get_conf_val_args(const char *field, const char *value, const char *opt, struct strlist ***args, int *got_args, int *count, struct strlist ***list, int include)
{
char *tmp=NULL;
if(get_conf_val(field, value, opt, &tmp)) return -1;
if(tmp)
{
if(got_args && *got_args && args)
{
strlists_free(*args, *count);
*got_args=0;
*args=NULL;
*count=0;
}
if(strlist_add(list, count, tmp, include)) return -1;
free(tmp); tmp=NULL;
}
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;
}
/* Free only stuff related to includes/excludes.
This is so that the server can override them all on the client. */
static void free_incexcs(struct config *conf)
{
strlists_free(conf->startdir, conf->sdcount);
strlists_free(conf->incexcdir, conf->iecount);
strlists_free(conf->fschgdir, conf->fscount);
strlists_free(conf->nobackup, conf->nbcount);
strlists_free(conf->incext, conf->incount); // include extensions
strlists_free(conf->excext, conf->excount); // exclude extensions
strlists_free(conf->increg, conf->ircount); // include (regular expression)
strlists_free(conf->excreg, conf->ercount); // exclude (regular expression)
strlists_free(conf->excfs, conf->exfscount); // exclude filesystems
strlists_free(conf->excom, conf->excmcount); // exclude from compression
strlists_free(conf->fifos, conf->ffcount);
strlists_free(conf->blockdevs, conf->bdcount);
if(conf->backup) free(conf->backup);
if(conf->restoreprefix) free(conf->restoreprefix);
if(conf->regex) free(conf->regex);
init_incexcs(conf);
}
void free_config(struct config *conf)
{
if(!conf) return;
if(conf->port) free(conf->port);
if(conf->configfile) free(conf->configfile);
if(conf->clientconfdir) free(conf->clientconfdir);
if(conf->cname) free(conf->cname);
if(conf->directory) free(conf->directory);
if(conf->timestamp_format) free(conf->timestamp_format);
if(conf->ca_conf) free(conf->ca_conf);
if(conf->ca_name) free(conf->ca_name);
if(conf->ca_server_name) free(conf->ca_server_name);
if(conf->ca_burp_ca) free(conf->ca_burp_ca);
if(conf->ca_csr_dir) free(conf->ca_csr_dir);
if(conf->lockfile) free(conf->lockfile);
if(conf->password) free(conf->password);
if(conf->passwd) free(conf->passwd);
if(conf->server) free(conf->server);
if(conf->working_dir_recovery_method)
free(conf->working_dir_recovery_method);
if(conf->ssl_cert_ca) free(conf->ssl_cert_ca);
if(conf->ssl_cert) free(conf->ssl_cert);
if(conf->ssl_key) free(conf->ssl_key);
if(conf->ssl_key_password) free(conf->ssl_key_password);
if(conf->ssl_ciphers) free(conf->ssl_ciphers);
if(conf->ssl_dhfile) free(conf->ssl_dhfile);
if(conf->ssl_peer_cn) free(conf->ssl_peer_cn);
if(conf->user) free(conf->user);
if(conf->group) free(conf->group);
if(conf->encryption_password) free(conf->encryption_password);
if(conf->client_lockdir) free(conf->client_lockdir);
if(conf->autoupgrade_dir) free(conf->autoupgrade_dir);
if(conf->autoupgrade_os) free(conf->autoupgrade_os);
if(conf->timer_script) free(conf->timer_script);
strlists_free(conf->timer_arg, conf->tacount);
if(conf->notify_success_script) free(conf->notify_success_script);
strlists_free(conf->notify_success_arg, conf->nscount);
if(conf->notify_failure_script) free(conf->notify_failure_script);
strlists_free(conf->notify_failure_arg, conf->nfcount);
strlists_free(conf->rclients, conf->rccount);
if(conf->backup_script_pre) free(conf->backup_script_pre);
strlists_free(conf->backup_script_pre_arg, conf->bprecount);
if(conf->backup_script_post) free(conf->backup_script_post);
strlists_free(conf->backup_script_post_arg, conf->bpostcount);
if(conf->restore_script_pre) free(conf->restore_script_pre);
strlists_free(conf->restore_script_pre_arg, conf->rprecount);
if(conf->restore_script_post) free(conf->restore_script_post);
strlists_free(conf->restore_script_post_arg, conf->rpostcount);
if(conf->server_script_pre) free(conf->server_script_pre);
strlists_free(conf->server_script_pre_arg, conf->sprecount);
if(conf->server_script_post) free(conf->server_script_post);
strlists_free(conf->server_script_post_arg, conf->spostcount);
if(conf->backup_script) free(conf->backup_script);
if(conf->restore_script) free(conf->restore_script);
strlists_free(conf->backup_script_arg, conf->bscount);
strlists_free(conf->restore_script_arg, conf->rscount);
if(conf->server_script) free(conf->server_script);
strlists_free(conf->server_script_arg, conf->sscount);
strlists_free(conf->keep, conf->kpcount);
if(conf->dedup_group) free(conf->dedup_group);
if(conf->browsefile) free(conf->browsefile);
if(conf->browsedir) free(conf->browsedir);
if(conf->restore_client) free(conf->restore_client);
if(conf->restore_path) free(conf->restore_path);
if(conf->orig_client) free(conf->orig_client);
free_incexcs(conf);
init_config(conf);
}
int run_bedup(int argc, char *argv[])
{
int i=1;
int ret=0;
int option=0;
int nonburp=0;
unsigned int maxlinks=DEF_MAX_LINKS;
char *groups=NULL;
char ext[16]="";
int givenconfigfile=0;
const char *configfile=NULL;
configfile=get_config_path();
snprintf(ext, sizeof(ext), ".bedup.%d", getpid());
while((option=getopt(argc, argv, "c:dg:hlm:nvV?"))!=-1)
{
switch(option)
{
case 'c':
configfile=optarg;
givenconfigfile=1;
break;
case 'd':
deletedups=1;
break;
case 'g':
groups=optarg;
break;
case 'l':
makelinks=1;
break;
case 'm':
maxlinks=atoi(optarg);
break;
case 'n':
nonburp=1;
break;
case 'V':
printf("%s-%s\n", prog, VERSION);
return 0;
case 'v':
verbose=1;
break;
case 'h':
case '?':
return usage();
}
}
if(nonburp && givenconfigfile)
{
logp("-n and -c options are mutually exclusive\n");
return 1;
}
if(nonburp && groups)
{
logp("-n and -g options are mutually exclusive\n");
return 1;
}
if(!nonburp && maxlinks!=DEF_MAX_LINKS)
{
logp("-m option is specified via the configuration file in burp mode (max_hardlinks=)\n");
return 1;
}
if(deletedups && makelinks)
{
logp("-d and -l options are mutually exclusive\n");
return 1;
}
if(deletedups && !nonburp)
{
logp("-d option requires -n option\n");
return 1;
}
if(optind>=argc)
{
if(nonburp)
{
logp("No directories found after options\n");
return 1;
}
}
else
{
if(!nonburp)
{
logp("Do not specify extra arguments.\n");
return 1;
}
}
if(maxlinks<2)
{
logp("The argument to -m needs to be greater than 1.\n");
return 1;
}
if(nonburp)
{
// Read directories from command line.
for(i=optind; i<argc; i++)
{
// Strip trailing slashes, for tidiness.
if(argv[i][strlen(argv[i])-1]=='/')
argv[i][strlen(argv[i])-1]='\0';
if(process_dir("", argv[i], ext, maxlinks,
0 /* not burp mode */, 0 /* level */))
{
ret=1;
break;
}
}
}
else
{
struct conf **globalcs=NULL;
struct strlist *grouplist=NULL;
struct lock *globallock=NULL;
if(groups)
{
char *tok=NULL;
if((tok=strtok(groups, ",\n")))
{
do
{
if(strlist_add(&grouplist, tok, 1))
{
log_out_of_memory(__func__);
return -1;
}
} while((tok=strtok(NULL, ",\n")));
}
if(!grouplist)
{
logp("unable to read list of groups\n");
return -1;
}
}
// Read directories from config files, and get locks.
if(!(globalcs=confs_alloc())) return -1;
if(confs_init(globalcs)) return -1;
if(conf_load_global_only(configfile, globalcs)) return 1;
if(get_e_burp_mode(globalcs[OPT_BURP_MODE])!=BURP_MODE_SERVER)
{
logp("%s is not a server config file\n", configfile);
confs_free(&globalcs);
return 1;
}
logp("Dedup clients from %s\n",
get_string(globalcs[OPT_CLIENTCONFDIR]));
maxlinks=get_int(globalcs[OPT_MAX_HARDLINKS]);
if(grouplist)
{
struct strlist *g=NULL;
logp("in dedup groups:\n");
for(g=grouplist; g; g=g->next)
logp("%s\n", g->path);
}
else
{
char *lockpath=NULL;
// Only get the global lock when doing a global run.
// If you are doing individual groups, you are likely
// to want to do many different dedup jobs and a
// global lock would get in the way.
if(!(lockpath=prepend(
get_string(globalcs[OPT_LOCKFILE]),
".bedup", ""))
|| !(globallock=lock_alloc_and_init(lockpath)))
return 1;
lock_get(globallock);
if(globallock->status!=GET_LOCK_GOT)
{
logp("Could not get lock %s (%d)\n", lockpath,
globallock->status);
free_w(&lockpath);
return 1;
}
logp("Got %s\n", lockpath);
}
ret=iterate_over_clients(globalcs, grouplist, ext, maxlinks);
confs_free(&globalcs);
lock_release(globallock);
lock_free(&globallock);
strlists_free(&grouplist);
}
if(!nonburp)
{
logp("%d client storages scanned\n", ccount);
}
logp("%llu duplicate %s found\n",
count, count==1?"file":"files");
logp("%llu bytes %s%s\n",
savedbytes, (makelinks || deletedups)?"saved":"saveable",
bytes_to_human(savedbytes));
return ret;
}
