+ amfree(include_file);
+ amfree(include_list);
+ amfree(exc);
+ amfree(decrypt_opt);
+ amfree(encrypt_opt);
+
+ /* result contains at least 'auth=...' */
+ if ( err ) {
+ amfree(result);
+ return NULL;
+ } else {
+ return result;
+ }
+}
+
+
+char *
+xml_optionstr(
+ disk_t * dp,
+ am_feature_t * their_features,
+ FILE * fdout,
+ int to_server)
+{
+ char *auth_opt = stralloc("");
+ char *kencrypt_opt = stralloc("");
+ char *compress_opt = stralloc("");
+ char *encrypt_opt = stralloc("");
+ char *decrypt_opt = stralloc("");
+ char *record_opt = stralloc("");
+ char *index_opt = stralloc("");
+ char *exclude = stralloc("");
+ char *exclude_file = NULL;
+ char *exclude_list = NULL;
+ char *include = stralloc("");
+ char *include_file = NULL;
+ char *include_list = NULL;
+ char *excl_opt = "";
+ char *incl_opt = "";
+ char *exc = NULL;
+ char *script_opt;
+ char *result = NULL;
+ sle_t *excl;
+ int nb_exclude_file;
+ int nb_include_file;
+ char *qdpname;
+ char *q64name;
+ int err=0;
+
+ assert(dp != NULL);
+ assert(dp->host != NULL);
+
+ qdpname = quote_string(dp->name);
+ if(am_has_feature(dp->host->features, fe_options_auth)) {
+ auth_opt = vstralloc(" <auth>", dp->security_driver, "</auth>\n", NULL);
+ } else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support auth\n"),
+ dp->host->hostname, qdpname);
+ }
+
+ switch(dp->compress) {
+ case COMP_FAST:
+ if(am_has_feature(their_features, fe_options_compress_fast)) {
+ compress_opt = " <compress>FAST</compress>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support fast compression\n"),
+ dp->host->hostname, qdpname);
+ }
+ break;
+ case COMP_BEST:
+ if(am_has_feature(their_features, fe_options_compress_best)) {
+ compress_opt = " <compress>BEST</compress>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support best compression\n"),
+ dp->host->hostname, qdpname);
+ }
+ break;
+ case COMP_CUST:
+ if(am_has_feature(their_features, fe_options_compress_cust)) {
+ if (dp->clntcompprog == NULL) {
+ if(fdout) {
+ fprintf(fdout,
+ _("ERROR: %s:%s client custom compression with no compression program specified\n"),
+ dp->host->hostname, qdpname);
+ }
+ err++;
+ } else {
+
+ compress_opt = vstralloc(" <compress>CUSTOM"
+ "<custom-compress-program>",
+ dp->clntcompprog,
+ "</custom-compress-program>\n"
+ " </compress>\n", NULL);
+ }
+ }
+ else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support client custom compression\n"),
+ dp->host->hostname, qdpname);
+ }
+ break;
+ case COMP_SERVER_FAST:
+ compress_opt = " <compress>SERVER-FAST</compress>\n";
+ break;
+ case COMP_SERVER_BEST:
+ compress_opt = " <compress>SERVER-BEST</compress>\n";
+ break;
+ case COMP_SERVER_CUST:
+ compress_opt = " <compress>SERVER-CUSTOM</compress>\n";
+ if (dp->srvcompprog == NULL) {
+ if(fdout) {
+ fprintf(fdout,
+ _("ERROR: %s:%s server custom compression with no compression program specified\n"),
+ dp->host->hostname, qdpname);
+ }
+ err++;
+ } else {
+ compress_opt = vstralloc(" <compress>SERVER-CUSTOM"
+ "<custom-compress-program>",
+ dp->srvcompprog,
+ "</custom-compress-program>\n"
+ " </compress>\n", NULL);
+ }
+ break;
+ }
+
+ switch(dp->encrypt) {
+ case ENCRYPT_CUST:
+ if(am_has_feature(their_features, fe_options_encrypt_cust)) {
+ if(dp->clnt_decrypt_opt) {
+ if(am_has_feature(their_features, fe_options_client_decrypt_option)) {
+ decrypt_opt = newvstralloc(decrypt_opt,
+ " <decrypt-option>",
+ dp->clnt_decrypt_opt,
+ "</decrypt-option>\n", NULL);
+ } else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support client decrypt option\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+ if (dp->clnt_encrypt == NULL) {
+ if(fdout) {
+ fprintf(fdout,
+ _("ERROR: %s:%s encrypt client with no encryption program specified\n"),
+ dp->host->hostname, qdpname);
+ }
+ err++;
+ } else if (decrypt_opt) {
+ encrypt_opt = newvstralloc(encrypt_opt,
+ " <encrypt>CUSTOM"
+ "<custom-encrypt-program>",
+ dp->clnt_encrypt,
+ "</custom-encrypt-program>\n",
+ decrypt_opt,
+ " </encrypt>\n", NULL);
+ }
+ if (dp->compress == COMP_SERVER_FAST ||
+ dp->compress == COMP_SERVER_BEST ||
+ dp->compress == COMP_SERVER_CUST ) {
+ if(fdout) {
+ fprintf(fdout,
+ _("ERROR: %s:Client encryption with server compression is "
+ "not supported. See amanda.conf(5) for detail.\n"),
+ dp->host->hostname);
+ }
+ err++;
+ }
+ } else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support client data encryption\n"),
+ dp->host->hostname, qdpname);
+ }
+ break;
+ case ENCRYPT_SERV_CUST:
+ if (dp->srv_encrypt != NULL && to_server) {
+ decrypt_opt = newvstralloc(decrypt_opt,
+ " <decrypt-option>",
+ dp->srv_decrypt_opt,
+ "</decrypt-option>\n", NULL);
+ encrypt_opt = newvstralloc(encrypt_opt,
+ " <encrypt>SERVER-CUSTOM"
+ "<custom-encrypt-program>",
+ dp->srv_encrypt,
+ "</custom-encrypt-program>\n",
+ decrypt_opt,
+ " </encrypt>\n", NULL);
+ } else if (dp->srv_encrypt == NULL) {
+ if(fdout) {
+ fprintf(fdout,
+ _("ERROR: %s:%s No encryption program specified in dumptypes\n"),
+ dp->host->hostname, qdpname);
+ fprintf(fdout,
+ _("Change the dumptype in the disklist or mention "
+ "the encryption program to use in the dumptypes file\n"));
+ }
+ err++;
+ }
+ break;
+ }
+
+ if(!dp->record) {
+ if(am_has_feature(their_features, fe_options_no_record)) {
+ record_opt = " <record>NO</record>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support no record\n"),
+ dp->host->hostname, qdpname);
+ }
+ } else {
+ record_opt = " <record>YES</record>\n";
+ }
+
+ if(dp->index) {
+ if(am_has_feature(their_features, fe_options_index)) {
+ index_opt = " <index>YES</index>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support index\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+
+ if(dp->kencrypt) {
+ if(am_has_feature(their_features, fe_options_kencrypt)) {
+ kencrypt_opt = " <kencrypt>YES</kencrypt>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support kencrypt\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+
+ exclude_file = stralloc("");
+ nb_exclude_file = 0;
+ if(dp->exclude_file != NULL && dp->exclude_file->nb_element > 0) {
+ nb_exclude_file = dp->exclude_file->nb_element;
+ if(am_has_feature(their_features, fe_options_exclude_file)) {
+ if(am_has_feature(their_features, fe_options_multiple_exclude) ||
+ dp->exclude_file->nb_element == 1) {
+ for(excl = dp->exclude_file->first; excl != NULL;
+ excl = excl->next) {
+ q64name = amxml_format_tag("file", excl->name);
+ exc = newvstralloc( exc, " ", q64name, "\n", NULL);
+ strappend(exclude_file, exc);
+ amfree(q64name);
+ }
+ } else {
+ q64name = amxml_format_tag("file", dp->exclude_file->last->name);
+ exc = newvstralloc(exc, " ", q64name, "\n", NULL);
+ strappend(exclude_file, exc);
+ if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support multiple exclude\n"),
+ dp->host->hostname, qdpname);
+ }
+ amfree(q64name);
+ }
+ } else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support exclude file\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+ exclude_list = stralloc("");
+ if(dp->exclude_list != NULL && dp->exclude_list->nb_element > 0) {
+ if(am_has_feature(their_features, fe_options_exclude_list)) {
+ if(am_has_feature(their_features, fe_options_multiple_exclude) ||
+ (dp->exclude_list->nb_element == 1 && nb_exclude_file == 0)) {
+ for(excl = dp->exclude_list->first; excl != NULL;
+ excl = excl->next) {
+ q64name = amxml_format_tag("list", excl->name);
+ exc = newvstralloc(exc, " ", q64name, "\n", NULL);
+ strappend(exclude_list, exc);
+ amfree(q64name);
+ }
+ } else {
+ q64name = amxml_format_tag("list", dp->exclude_list->last->name);
+ exc = newvstralloc(exc, " ", q64name, "\n", NULL);
+ strappend(exclude_list, exc);
+ if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support multiple exclude\n"),
+ dp->host->hostname, qdpname);
+ }
+ amfree(q64name);
+ }
+ } else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support exclude list\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+
+ include_file = stralloc("");
+ nb_include_file = 0;
+ if(dp->include_file != NULL && dp->include_file->nb_element > 0) {
+ nb_include_file = dp->include_file->nb_element;
+ if(am_has_feature(their_features, fe_options_include_file)) {
+ if(am_has_feature(their_features, fe_options_multiple_include) ||
+ dp->include_file->nb_element == 1) {
+ for(excl = dp->include_file->first; excl != NULL;
+ excl = excl->next) {
+ q64name = amxml_format_tag("file", excl->name);
+ exc = newvstralloc( exc, " ", q64name, "\n", NULL);
+ strappend(include_file, exc);
+ amfree(q64name);
+ }
+ } else {
+ q64name = amxml_format_tag("file", dp->include_file->last->name);
+ exc = newvstralloc(exc, " ", q64name, "\n", NULL);
+ strappend(include_file, exc);
+ if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support multiple include\n"),
+ dp->host->hostname, qdpname);
+ }
+ amfree(q64name);
+ }
+ } else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support include file\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+ include_list = stralloc("");
+ if(dp->include_list != NULL && dp->include_list->nb_element > 0) {
+ if(am_has_feature(their_features, fe_options_include_list)) {
+ if(am_has_feature(their_features, fe_options_multiple_include) ||
+ (dp->include_list->nb_element == 1 && nb_include_file == 0)) {
+ for(excl = dp->include_list->first; excl != NULL;
+ excl = excl->next) {
+ q64name = amxml_format_tag("list", excl->name);
+ exc = newvstralloc( exc, " ", q64name, "\n", NULL);
+ strappend(include_list, exc);
+ amfree(q64name);
+ }
+ } else {
+ q64name = amxml_format_tag("list", dp->include_list->last->name);
+ exc = newvstralloc(exc, " ", q64name, "\n", NULL);
+ strappend(include_list, exc);
+ if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support multiple include\n"),
+ dp->host->hostname, qdpname);
+ }
+ amfree(q64name);
+ }
+ } else if(fdout) {
+ fprintf(fdout, _("WARNING: %s:%s does not support include list\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+
+ if(dp->exclude_optional) {
+ if(am_has_feature(their_features, fe_options_optional_exclude)) {
+ excl_opt = " <optional>YES</optional>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support optional exclude\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+ if(dp->include_optional) {
+ if(am_has_feature(their_features, fe_options_optional_include)) {
+ incl_opt = " <optional>YES</optional>\n";
+ }
+ else if(fdout) {
+ fprintf(fdout,
+ _("WARNING: %s:%s does not support optional include\n"),
+ dp->host->hostname, qdpname);
+ }
+ }
+
+ if (dp->exclude_file || dp->exclude_list)
+ exclude = newvstralloc(exclude,
+ " <exclude>\n",
+ exclude_file,
+ exclude_list,
+ excl_opt,
+ " </exclude>\n", NULL);
+ if (dp->include_file || dp->include_list)
+ include = newvstralloc(include,
+ " <include>\n",
+ include_file,
+ include_list,
+ incl_opt,
+ " </include>\n", NULL);
+ script_opt = xml_scripts(dp->pp_scriptlist, their_features);
+ result = vstralloc(auth_opt,
+ kencrypt_opt,
+ compress_opt,
+ encrypt_opt,
+ record_opt,
+ index_opt,
+ exclude,
+ include,
+ script_opt,
+ NULL);
+
+ amfree(qdpname);
+ amfree(auth_opt);
+ amfree(exclude);