static int conf_set_from_global(struct conf **globalc, struct conf **cc)
{
int i=0;
for(i=0; i<OPT_MAX; i++)
{
if(!(cc[i]->flags & CONF_FLAG_CC_OVERRIDE))
continue;
switch(cc[i]->conf_type)
{
case CT_STRING:
set_string(cc[i], get_string(globalc[i]));
break;
case CT_UINT:
set_int(cc[i], get_int(globalc[i]));
break;
case CT_FLOAT:
set_float(cc[i], get_float(globalc[i]));
break;
case CT_MODE_T:
set_mode_t(cc[i], get_mode_t(globalc[i]));
break;
case CT_SSIZE_T:
set_uint64_t(cc[i], get_uint64_t(globalc[i]));
break;
case CT_E_BURP_MODE:
set_e_burp_mode(cc[i], get_e_burp_mode(globalc[i]));
break;
case CT_E_PROTOCOL:
set_e_protocol(cc[i], get_e_protocol(globalc[i]));
break;
case CT_E_RECOVERY_METHOD:
set_e_recovery_method(cc[i], get_e_recovery_method(globalc[i]));
break;
case CT_E_RSHASH:
set_e_rshash(cc[i], get_e_rshash(globalc[i]));
break;
case CT_STRLIST:
// Done later.
break;
case CT_CNTR:
break;
// No default so that there are warnings if anything
// was missed.
}
}
// If ssl_peer_cn is not set, default it to the client name.
if(!get_string(globalc[OPT_SSL_PEER_CN])
&& set_string(cc[OPT_SSL_PEER_CN], get_string(cc[OPT_CNAME])))
return -1;
return 0;
}
static void check_default(struct conf **c, enum conf_opt o)
{
switch(o)
{
case OPT_BURP_MODE:
fail_unless(get_e_burp_mode(c[o])==BURP_MODE_UNSET);
break;
case OPT_LOCKFILE:
case OPT_PIDFILE:
case OPT_ADDRESS:
case OPT_PORT:
case OPT_STATUS_ADDRESS:
case OPT_STATUS_PORT:
case OPT_SSL_CERT_CA:
case OPT_SSL_CERT:
case OPT_SSL_KEY:
case OPT_SSL_KEY_PASSWORD:
case OPT_SSL_PEER_CN:
case OPT_SSL_CIPHERS:
case OPT_SSL_DHFILE:
case OPT_CA_CONF:
case OPT_CA_NAME:
case OPT_CA_SERVER_NAME:
case OPT_CA_BURP_CA:
case OPT_CA_CSR_DIR:
case OPT_CA_CRL:
case OPT_PEER_VERSION:
case OPT_CLIENT_LOCKDIR:
case OPT_MONITOR_LOGFILE:
case OPT_CNAME:
case OPT_PASSWORD:
case OPT_PASSWD:
case OPT_SERVER:
case OPT_ENCRYPTION_PASSWORD:
case OPT_AUTOUPGRADE_OS:
case OPT_AUTOUPGRADE_DIR:
case OPT_BACKUP:
case OPT_BACKUP2:
case OPT_RESTOREPREFIX:
case OPT_RESTORE_SPOOL:
case OPT_BROWSEFILE:
case OPT_BROWSEDIR:
case OPT_B_SCRIPT_PRE:
case OPT_B_SCRIPT_POST:
case OPT_R_SCRIPT_PRE:
case OPT_R_SCRIPT_POST:
case OPT_B_SCRIPT:
case OPT_R_SCRIPT:
case OPT_RESTORE_PATH:
case OPT_ORIG_CLIENT:
case OPT_CONFFILE:
case OPT_USER:
case OPT_GROUP:
case OPT_DIRECTORY:
case OPT_TIMESTAMP_FORMAT:
case OPT_CLIENTCONFDIR:
case OPT_S_SCRIPT_PRE:
case OPT_S_SCRIPT_POST:
case OPT_MANUAL_DELETE:
case OPT_S_SCRIPT:
case OPT_TIMER_SCRIPT:
case OPT_N_SUCCESS_SCRIPT:
case OPT_N_FAILURE_SCRIPT:
case OPT_DEDUP_GROUP:
case OPT_VSS_DRIVES:
case OPT_REGEX:
case OPT_RESTORE_CLIENT:
fail_unless(get_string(c[o])==NULL);
break;
case OPT_RATELIMIT:
fail_unless(get_float(c[o])==0);
break;
case OPT_CLIENT_IS_WINDOWS:
case OPT_RANDOMISE:
case OPT_B_SCRIPT_POST_RUN_ON_FAIL:
case OPT_R_SCRIPT_POST_RUN_ON_FAIL:
case OPT_SEND_CLIENT_CNTR:
case OPT_BREAKPOINT:
case OPT_SYSLOG:
case OPT_PROGRESS_COUNTER:
case OPT_MONITOR_BROWSE_CACHE:
case OPT_S_SCRIPT_PRE_NOTIFY:
case OPT_S_SCRIPT_POST_RUN_ON_FAIL:
case OPT_S_SCRIPT_POST_NOTIFY:
case OPT_S_SCRIPT_NOTIFY:
case OPT_HARDLINKED_ARCHIVE:
case OPT_N_SUCCESS_WARNINGS_ONLY:
case OPT_N_SUCCESS_CHANGES_ONLY:
case OPT_CROSS_ALL_FILESYSTEMS:
case OPT_READ_ALL_FIFOS:
case OPT_READ_ALL_BLOCKDEVS:
case OPT_SPLIT_VSS:
case OPT_STRIP_VSS:
case OPT_ATIME:
case OPT_SCAN_PROBLEM_RAISES_ERROR:
case OPT_OVERWRITE:
case OPT_STRIP:
case OPT_MESSAGE:
case OPT_CA_CRL_CHECK:
fail_unless(get_int(c[o])==0);
break;
case OPT_DAEMON:
case OPT_STDOUT:
case OPT_FORK:
case OPT_ENABLED:
case OPT_DIRECTORY_TREE:
case OPT_PASSWORD_CHECK:
case OPT_LIBRSYNC:
case OPT_VERSION_WARN:
case OPT_PATH_LENGTH_WARN:
case OPT_CLIENT_CAN_DELETE:
case OPT_CLIENT_CAN_DIFF:
case OPT_CLIENT_CAN_FORCE_BACKUP:
case OPT_CLIENT_CAN_LIST:
case OPT_CLIENT_CAN_RESTORE:
case OPT_CLIENT_CAN_VERIFY:
case OPT_SERVER_CAN_RESTORE:
case OPT_SERVER_CAN_OVERRIDE_INCLUDES:
case OPT_B_SCRIPT_RESERVED_ARGS:
case OPT_R_SCRIPT_RESERVED_ARGS:
case OPT_GLOB_AFTER_SCRIPT_PRE:
case OPT_ACL:
case OPT_XATTR:
fail_unless(get_int(c[o])==1);
break;
case OPT_NETWORK_TIMEOUT:
fail_unless(get_int(c[o])==60*60*2);
break;
case OPT_SSL_COMPRESSION:
case OPT_MAX_CHILDREN:
case OPT_MAX_STATUS_CHILDREN:
fail_unless(get_int(c[o])==5);
break;
case OPT_COMPRESSION:
fail_unless(get_int(c[o])==9);
break;
case OPT_MAX_STORAGE_SUBDIRS:
fail_unless(get_int(c[o])==30000);
break;
case OPT_MAX_HARDLINKS:
fail_unless(get_int(c[o])==10000);
break;
case OPT_UMASK:
fail_unless(get_mode_t(c[o])==0022);
break;
case OPT_STARTDIR:
case OPT_B_SCRIPT_PRE_ARG:
case OPT_B_SCRIPT_POST_ARG:
case OPT_R_SCRIPT_PRE_ARG:
case OPT_R_SCRIPT_POST_ARG:
case OPT_B_SCRIPT_ARG:
case OPT_R_SCRIPT_ARG:
case OPT_S_SCRIPT_PRE_ARG:
case OPT_S_SCRIPT_POST_ARG:
case OPT_S_SCRIPT_ARG:
case OPT_TIMER_ARG:
case OPT_N_SUCCESS_ARG:
case OPT_N_FAILURE_ARG:
case OPT_RESTORE_CLIENTS:
case OPT_KEEP:
case OPT_INCEXCDIR:
case OPT_INCLUDE:
case OPT_EXCLUDE:
case OPT_FSCHGDIR:
case OPT_NOBACKUP:
case OPT_INCEXT:
case OPT_EXCEXT:
case OPT_INCREG:
case OPT_EXCREG:
case OPT_EXCFS:
case OPT_EXCOM:
case OPT_INCGLOB:
case OPT_FIFOS:
case OPT_BLOCKDEVS:
case OPT_LABEL:
fail_unless(get_strlist(c[o])==NULL);
break;
case OPT_PROTOCOL:
fail_unless(get_e_protocol(c[o])==PROTO_AUTO);
break;
case OPT_HARD_QUOTA:
case OPT_SOFT_QUOTA:
case OPT_MIN_FILE_SIZE:
case OPT_MAX_FILE_SIZE:
fail_unless(get_uint64_t(c[o])==0);
break;
case OPT_WORKING_DIR_RECOVERY_METHOD:
fail_unless(get_e_recovery_method(c[o])==
RECOVERY_METHOD_DELETE);
break;
case OPT_RSHASH:
fail_unless(get_e_rshash(c[o])==RSHASH_UNSET);
break;
case OPT_CNTR:
fail_unless(get_cntr(c)==NULL);
break;
case OPT_MAX:
break;
// No default, so we get compiler warnings if something was
// missed.
}
}
static int recover_working(struct async *as,
struct sdirs *sdirs, const char *incexc,
int *resume, struct conf **cconfs)
{
int ret=-1;
char msg[256]="";
char *logpath=NULL;
struct stat statp;
char *phase1datatmp=NULL;
enum recovery_method recovery_method=get_e_recovery_method(
cconfs[OPT_WORKING_DIR_RECOVERY_METHOD]);
// The working directory has not finished being populated.
// Check what to do.
if(get_fullrealwork(as->asfd, sdirs, cconfs)) goto end;
if(!sdirs->rworking) goto end;
log_recovery_method(sdirs, recovery_method);
if(!(phase1datatmp=get_tmp_filename(sdirs->phase1data)))
goto end;
// If there is still a phase1 tmp file...
if(!lstat(phase1datatmp, &statp)
||
// ...or phase1 has not even got underway yet...
(lstat(phase1datatmp, &statp)
&& lstat(sdirs->phase1data, &statp)
&& lstat(sdirs->changed, &statp)
&& lstat(sdirs->unchanged, &statp)))
{
// ...phase 1 did not complete - delete everything.
logp("Phase 1 has not completed.\n");
recovery_method=RECOVERY_METHOD_DELETE;
}
if(recovery_method==RECOVERY_METHOD_DELETE)
{
ret=working_delete(as, sdirs, cconfs);
goto end;
}
// We are not deleting the old working directory - open the log inside
// for appending.
if(!(logpath=prepend_s(sdirs->rworking, "log"))
|| log_fzp_set(logpath, cconfs))
goto end;
switch(recovery_method)
{
case RECOVERY_METHOD_DELETE:
// Dealt with above.
break;
case RECOVERY_METHOD_RESUME:
ret=working_resume(as, sdirs, incexc, resume, cconfs);
break;
case RECOVERY_METHOD_UNSET:
default:
snprintf(msg, sizeof(msg),
"Unknown working_dir_recovery_method: %d\n",
(int)recovery_method);
log_and_send(as->asfd, msg);
break;
}
end:
free_w(&logpath);
free_w(&phase1datatmp);
log_fzp_set(NULL, cconfs); // fclose the logfzp
return ret;
}
static int server_conf_checks(struct conf **c, const char *path, int *r)
{
// FIX THIS: Most of this could be done by flags.
if(!get_string(c[OPT_ADDRESS])
&& set_string(c[OPT_ADDRESS], DEFAULT_ADDRESS_MAIN))
return -1;
if(!get_string(c[OPT_DIRECTORY]))
conf_problem(path, "directory unset", r);
if(!get_string(c[OPT_DEDUP_GROUP]))
conf_problem(path, "dedup_group unset", r);
if(!get_string(c[OPT_CLIENTCONFDIR]))
conf_problem(path, "clientconfdir unset", r);
if(get_e_recovery_method(c[OPT_WORKING_DIR_RECOVERY_METHOD])==RECOVERY_METHOD_UNSET)
conf_problem(path, "working_dir_recovery_method unset", r);
if(!get_string(c[OPT_SSL_DHFILE]))
conf_problem(path, "ssl_dhfile unset", r);
if(get_string(c[OPT_ENCRYPTION_PASSWORD]))
conf_problem(path,
"encryption_password should not be set on the server!", r);
if(!get_string(c[OPT_STATUS_ADDRESS])
&& set_string(c[OPT_STATUS_ADDRESS], DEFAULT_ADDRESS_STATUS))
return -1;
if(!get_string(c[OPT_STATUS_PORT])) // carry on if not set.
logp("%s: status_port unset", path);
if(!get_int(c[OPT_MAX_CHILDREN]))
conf_problem(path, "max_children unset", r);
if(!get_int(c[OPT_MAX_STATUS_CHILDREN]))
conf_problem(path, "max_status_children unset", r);
if(!get_strlist(c[OPT_KEEP]))
conf_problem(path, "keep unset", r);
if(get_int(c[OPT_MAX_HARDLINKS])<2)
conf_problem(path, "max_hardlinks too low", r);
if(get_int(c[OPT_MAX_CHILDREN])<=0)
conf_problem(path, "max_children too low", r);
if(get_int(c[OPT_MAX_STATUS_CHILDREN])<=0)
conf_problem(path, "max_status_children too low", r);
if(get_int(c[OPT_MAX_STORAGE_SUBDIRS])<=1000)
conf_problem(path, "max_storage_subdirs too low", r);
if(!get_string(c[OPT_TIMESTAMP_FORMAT])
&& set_string(c[OPT_TIMESTAMP_FORMAT], DEFAULT_TIMESTAMP_FORMAT))
return -1;
if(get_string(c[OPT_CA_CONF]))
{
int ca_err=0;
if(!get_string(c[OPT_CA_NAME]))
{
logp("ca_conf set, but ca_name not set\n");
ca_err++;
}
if(!get_string(c[OPT_CA_SERVER_NAME]))
{
logp("ca_conf set, but ca_server_name not set\n");
ca_err++;
}
if(!get_string(c[OPT_CA_BURP_CA]))
{
logp("ca_conf set, but ca_burp_ca not set\n");
ca_err++;
}
if(!get_string(c[OPT_SSL_DHFILE]))
{
logp("ca_conf set, but ssl_dhfile not set\n");
ca_err++;
}
if(!get_string(c[OPT_SSL_CERT_CA]))
{
logp("ca_conf set, but ssl_cert_ca not set\n");
ca_err++;
}
if(!get_string(c[OPT_SSL_CERT]))
{
logp("ca_conf set, but ssl_cert not set\n");
ca_err++;
}
if(!get_string(c[OPT_SSL_KEY]))
{
logp("ca_conf set, but ssl_key not set\n");
ca_err++;
}
if(ca_err) return -1;
}
if(get_string(c[OPT_MANUAL_DELETE]))
{
if(path_checks(get_string(c[OPT_MANUAL_DELETE]),
"ERROR: Please use an absolute manual_delete path.\n"))
return -1;
}
return 0;
}
