client_util.c

开源备份软件源码 AMANDA, the Advanced Maryland Automatic Network Disk Archiver, is a backup system that a

	else {
	    quoted = quote_string(filename);
	    dbprintf(_("Can't create include file %s (%s)\n"),
		      quoted, strerror(errno));
	    if(verbose) {
		g_printf(_("ERROR [Can't create include file %s (%s)]\n"),
			quoted, strerror(errno));
	    }
	    amfree(quoted);
	}
    }
	
    if(nb_exp == 0) {
	quoted = quote_string(disk);
	dbprintf(_("No include for %s\n"), quoted);
	if(verbose && options->include_optional == 0) {
	    g_printf(_("ERROR [No include for %s]\n"), quoted);
	}
	amfree(quoted);
    }

    return filename;
}


void
init_options(
    option_t *options)
{
    options->str = NULL;
    options->compress = COMP_NONE;
    options->srvcompprog = NULL;
    options->clntcompprog = NULL;
    options->encrypt = ENCRYPT_NONE;
    options->kencrypt = 0;
    options->srv_encrypt = NULL;
    options->clnt_encrypt = NULL;
    options->srv_decrypt_opt = NULL;
    options->clnt_decrypt_opt = NULL;
    options->no_record = 0;
    options->createindex = 0;
    options->auth = NULL;
    options->exclude_file = NULL;
    options->exclude_list = NULL;
    options->include_file = NULL;
    options->include_list = NULL;
    options->exclude_optional = 0;
    options->include_optional = 0;
}


option_t *
parse_options(
    char *str,
    char *disk,
    char *device,
    am_feature_t *fs,
    int verbose)
{
    char *exc;
    char *inc;
    option_t *options;
    char *p, *tok;
    char *quoted;

    (void)disk;		/* Quiet unused parameter warning */
    (void)device;	/* Quiet unused parameter warning */

    options = alloc(SIZEOF(option_t));
    init_options(options);
    options->str = stralloc(str);

    p = stralloc(str);
    tok = strtok(p,";");

    while (tok != NULL) {
	if(am_has_feature(fs, fe_options_auth)
	   && BSTRNCMP(tok,"auth=") == 0) {
	    if(options->auth != NULL) {
		quoted = quote_string(tok + 5);
		dbprintf(_("multiple auth option %s\n"), quoted);
		if(verbose) {
		    g_printf(_("ERROR [multiple auth option %s]\n"), quoted);
		}
		amfree(quoted);
	    }
	    options->auth = stralloc(&tok[5]);
	}
	else if(am_has_feature(fs, fe_options_bsd_auth)
	   && BSTRNCMP(tok, "bsd-auth") == 0) {
	    if(options->auth != NULL) {
		dbprintf(_("multiple auth option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple auth option]\n"));
		}
	    }
	    options->auth = stralloc("bsd");
	}
	else if(am_has_feature(fs, fe_options_krb4_auth)
	   && BSTRNCMP(tok, "krb4-auth") == 0) {
	    if(options->auth != NULL) {
		dbprintf(_("multiple auth option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple auth option]\n"));
		}
	    }
	    options->auth = stralloc("krb4");
	}
	else if(BSTRNCMP(tok, "compress-fast") == 0) {
	    if(options->compress != COMP_NONE) {
		dbprintf(_("multiple compress option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple compress option]\n"));
		}
	    }
	    options->compress = COMP_FAST;
	}
	else if(BSTRNCMP(tok, "compress-best") == 0) {
	    if(options->compress != COMP_NONE) {
		dbprintf(_("multiple compress option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple compress option]\n"));
		}
	    }
	    options->compress = COMP_BEST;
	}
	else if(BSTRNCMP(tok, "srvcomp-fast") == 0) {
	    if(options->compress != COMP_NONE) {
		dbprintf(_("multiple compress option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple compress option]\n"));
		}
	    }
	    options->compress = COMP_SERVER_FAST;
	}
	else if(BSTRNCMP(tok, "srvcomp-best") == 0) {
	    if(options->compress != COMP_NONE) {
		dbprintf(_("multiple compress option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple compress option]\n"));
		}
	    }
	    options->compress = COMP_SERVER_BEST;
	}
	else if(BSTRNCMP(tok, "srvcomp-cust=") == 0) {
	    if(options->compress != COMP_NONE) {
		dbprintf(_("multiple compress option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple compress option]\n"));
		}
	    }
	    options->srvcompprog = stralloc(tok + SIZEOF("srvcomp-cust=") -1);
	    options->compress = COMP_SERVER_CUST;
	}
	else if(BSTRNCMP(tok, "comp-cust=") == 0) {
	    if(options->compress != COMP_NONE) {
		dbprintf(_("multiple compress option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple compress option]\n"));
		}
	    }
	    options->clntcompprog = stralloc(tok + SIZEOF("comp-cust=") -1);
	    options->compress = COMP_CUST;
	    /* parse encryption options */
	} 
	else if(BSTRNCMP(tok, "encrypt-serv-cust=") == 0) {
	    if(options->encrypt != ENCRYPT_NONE) {
		dbprintf(_("multiple encrypt option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple encrypt option]\n"));
		}
	    }
	    options->srv_encrypt = stralloc(tok + SIZEOF("encrypt-serv-cust=") -1);
	    options->encrypt = ENCRYPT_SERV_CUST;
	} 
	else if(BSTRNCMP(tok, "encrypt-cust=") == 0) {
	    if(options->encrypt != ENCRYPT_NONE) {
		dbprintf(_("multiple encrypt option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple encrypt option]\n"));
		}
	    }
	    options->clnt_encrypt= stralloc(tok + SIZEOF("encrypt-cust=") -1);
	    options->encrypt = ENCRYPT_CUST;
	} 
	else if(BSTRNCMP(tok, "server-decrypt-option=") == 0) {
	  options->srv_decrypt_opt = stralloc(tok + SIZEOF("server-decrypt-option=") -1);
	}
	else if(BSTRNCMP(tok, "client-decrypt-option=") == 0) {
	  options->clnt_decrypt_opt = stralloc(tok + SIZEOF("client-decrypt-option=") -1);
	}
	else if(BSTRNCMP(tok, "no-record") == 0) {
	    if(options->no_record != 0) {
		dbprintf(_("multiple no-record option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple no-record option]\n"));
		}
	    }
	    options->no_record = 1;
	}
	else if(BSTRNCMP(tok, "index") == 0) {
	    if(options->createindex != 0) {
		dbprintf(_("multiple index option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple index option]\n"));
		}
	    }
	    options->createindex = 1;
	}
	else if(BSTRNCMP(tok, "exclude-optional") == 0) {
	    if(options->exclude_optional != 0) {
		dbprintf(_("multiple exclude-optional option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple exclude-optional option]\n"));
		}
	    }
	    options->exclude_optional = 1;
	}
	else if(strcmp(tok, "include-optional") == 0) {
	    if(options->include_optional != 0) {
		dbprintf(_("multiple include-optional option\n"));
		if(verbose) {
		    g_printf(_("ERROR [multiple include-optional option]\n"));
		}
	    }
	    options->include_optional = 1;
	}
	else if(BSTRNCMP(tok,"exclude-file=") == 0) {
	    exc = unquote_string(&tok[13]);
	    options->exclude_file = append_sl(options->exclude_file, exc);
	    amfree(exc);
	}
	else if(BSTRNCMP(tok,"exclude-list=") == 0) {
	    exc = unquote_string(&tok[13]);
	    options->exclude_list = append_sl(options->exclude_list, exc);
	    amfree(exc);
	}
	else if(BSTRNCMP(tok,"include-file=") == 0) {
	    inc = unquote_string(&tok[13]);
	    options->include_file = append_sl(options->include_file, inc);
	    amfree(inc);
	}
	else if(BSTRNCMP(tok,"include-list=") == 0) {
	    inc = unquote_string(&tok[13]);
	    options->include_list = append_sl(options->include_list, inc);
	    amfree(inc);
	}
	else if(BSTRNCMP(tok,"kencrypt") == 0) {
	    options->kencrypt = 1;
	}
	else if(strcmp(tok,"|") != 0) {
	    quoted = quote_string(tok);
	    dbprintf(_("unknown option %s\n"), quoted);
	    if(verbose) {
		g_printf(_("ERROR [unknown option: %s]\n"), quoted);
	    }
	    amfree(quoted);
	}
	tok = strtok(NULL, ";");
    }
    amfree(p);
    return options;
}

void
output_tool_property(
    FILE     *tool,
    option_t *options)
{
    sle_t *sle;
    char *q;

    if (!is_empty_sl(options->exclude_file)) {
	for(sle = options->exclude_file->first ; sle != NULL; sle=sle->next) {
	    q = quote_string(sle->name);
	    g_fprintf(tool, "EXCLUDE-FILE %s\n", q);
	    amfree(q);
	}
    }

    if (!is_empty_sl(options->exclude_list)) {
	for(sle = options->exclude_list->first ; sle != NULL; sle=sle->next) {
	    q = quote_string(sle->name);
	    g_fprintf(tool, "EXCLUDE-LIST %s\n", q);
	    amfree(q);
	}
    }

    if (!is_empty_sl(options->include_file)) {
	for(sle = options->include_file->first ; sle != NULL; sle=sle->next) {
	    q = quote_string(sle->name);
	    g_fprintf(tool, "INCLUDE-FILE %s\n", q);
	    amfree(q);
	}
    }

    if (!is_empty_sl(options->include_list)) {
	for(sle = options->include_list->first ; sle != NULL; sle=sle->next) {
	    q = quote_string(sle->name);
	    g_fprintf(tool, "INCLUDE-LIST %s\n", q);
	    amfree(q);
	}
    }

    if (!is_empty_sl(options->exclude_file) ||
	!is_empty_sl(options->exclude_list)) {
	if (options->exclude_optional)
	    g_fprintf(tool, "EXCLUDE-OPTIONAL YES\n");
	else
	    g_fprintf(tool, "EXCLUDE-OPTIONAL NO\n");
    }

    if (!is_empty_sl(options->include_file) ||
	!is_empty_sl(options->include_list)) {
	if (options->include_optional)
	    g_fprintf(tool, "INCLUDE-OPTIONAL YES\n");
	else
	    g_fprintf(tool, "INCLUDE-OPTIONAL NO\n");
    }
}

backup_support_option_t *
backup_support_option(
    char       *program,
    g_option_t *g_options,
    char       *disk,
    char       *amdevice)
{
    pid_t   supportpid;
    int     supportin, supportout, supporterr;
    char   *cmd;
    char  **argvchild;
    int     i;
    FILE   *streamout;
    char   *line;
    backup_support_option_t *bsu;

    cmd = vstralloc(DUMPER_DIR, "/", program, NULL);
    argvchild = malloc(5 * SIZEOF(char *));
    i = 0;
    argvchild[i++] = program;
    argvchild[i++] = "support";
    if (g_options->config) {
	argvchild[i++] = "--config";
	argvchild[i++] = g_options->config;
    }
    if (g_options->hostname) {
	argvchild[i++] = "--host";
	argvchild[i++] = g_options->hostname;
    }
    if (disk) {
	argvchild[i++] = "--disk";
	argvchild[i++] = disk;
    }
    if (amdevice) {
	argvchild[i++] = "--device";
	argvchild[i++] = amdevice;
    }
    argvchild[i++] = NULL;

    supporterr = fileno(stderr);
    supportpid = pipespawnv(cmd, STDIN_PIPE|STDOUT_PIPE, &supportin,
			    &supportout, &supporterr, argvchild);

    aclose(supportin);

    bsu = malloc(SIZEOF(*bsu));
    memset(bsu, '\0', SIZEOF(*bsu));
    streamout = fdopen(supportout, "r");
    while((line = agets(streamout)) != NULL) {
	dbprintf(_("support line: %s\n"), line);
	if (strncmp(line,"CONFIG ", 7) == 0) {
	    if (strcmp(line+7, "YES") == 0)
		bsu->config = 1;
	} else if (strncmp(line,"HOST ", 5) == 0) {
	    if (strcmp(line+5, "YES") == 0)
	    bsu->host = 1;
	} else if (strncmp(line,"DISK ", 5) == 0) {
	    if (strcmp(line+5, "YES") == 0)
		bsu->host = 1;
	} else if (strncmp(line,"INDEX-LINE ", 11) == 0) {
	    if (strcmp(line+11, "YES") == 0)
		bsu->index_line = 1;
	} else if (strncmp(line,"INDEX-XML ", 10) == 0) {
	    if (strcmp(line+10, "YES") == 0)
		bsu->index_xml = 1;
	} else if (strncmp(line,"MESSAGE-LINE ", 13) == 0) {
	    if (strcmp(line+13, "YES") == 0)
		bsu->message_line = 1;
	} else if (strncmp(line,"MESSAGE-XML ", 12) == 0) {
	    if (strcmp(line+12, "YES") == 0)
		bsu->message_xml = 1;
	} else if (strncmp(line,"RECORD ", 7) == 0) {
	    if (strcmp(line+7, "YES") == 0)
		bsu->record = 1;
	} else if (strncmp(line,"INCLUDE-FILE ", 13) == 0) {
	    if (strcmp(line+13, "YES") == 0)
		bsu->include_file = 1;
	} else if (strncmp(line,"INCLUDE-LIST ", 13) == 0) {
	    if (strcmp(line+13, "YES") == 0)
		bsu->include_list = 1;
	} else if (strncmp(line,"EXCLUDE-FILE ", 13) == 0) {
	    if (strcmp(line+13, "YES") == 0)
		bsu->exclude_file = 1;
	} else if (strncmp(line,"EXCLUDE-LIST ", 13) == 0) {
	    if (strcmp(line+13, "YES") == 0)
		bsu->exclude_list = 1;
	} else if (strncmp(line,"COLLECTION ", 11) == 0) {
	    if (strcmp(line+11, "YES") == 0)
		bsu->collection = 1;
	} else if (strncmp(line,"MAX-LEVEL ", 10) == 0) {
	    bsu->max_level  = atoi(line+10);
	} else {
	    dbprintf(_("Invalid support line: %s\n"), line);
	}
	amfree(line);
    }
    aclose(supportout);

    return NULL;
}