static sbcErr fss_conf_get_share_def(struct smbconf_ctx *fconf_ctx,
struct smbconf_ctx *rconf_ctx,
TALLOC_CTX *mem_ctx,
char *share,
struct smbconf_service **service_def)
{
sbcErr cerr;
struct smbconf_service *def;
*service_def = NULL;
cerr = smbconf_get_share(fconf_ctx, mem_ctx, share, &def);
if (SBC_ERROR_IS_OK(cerr)) {
*service_def = def;
return SBC_ERR_OK;
}
cerr = smbconf_get_share(rconf_ctx, mem_ctx, share, &def);
if (SBC_ERROR_IS_OK(cerr)) {
*service_def = def;
return SBC_ERR_OK;
}
return cerr;
}
static int net_conf_showshare(struct net_context *c,
struct smbconf_ctx *conf_ctx, int argc,
const char **argv)
{
int ret = -1;
sbcErr err;
const char *sharename = NULL;
TALLOC_CTX *mem_ctx;
uint32_t count;
struct smbconf_service *service = NULL;
mem_ctx = talloc_stackframe();
if (argc != 1 || c->display_usage) {
net_conf_showshare_usage(c, argc, argv);
goto done;
}
sharename = talloc_strdup(mem_ctx, argv[0]);
if (sharename == NULL) {
d_printf("error: out of memory!\n");
goto done;
}
err = smbconf_get_share(conf_ctx, mem_ctx, sharename, &service);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error getting share parameters: %s\n"),
sbcErrorString(err));
goto done;
}
d_printf("[%s]\n", service->name);
for (count = 0; count < service->num_params; count++) {
d_printf("\t%s = %s\n", service->param_names[count],
service->param_values[count]);
}
ret = 0;
done:
TALLOC_FREE(mem_ctx);
return ret;
}
static int net_conf_import(struct net_context *c, struct smbconf_ctx *conf_ctx,
int argc, const char **argv)
{
int ret = -1;
const char *filename = NULL;
const char *servicename = NULL;
char *conf_source = NULL;
TALLOC_CTX *mem_ctx;
struct smbconf_ctx *txt_ctx;
sbcErr err;
if (c->display_usage)
return net_conf_import_usage(c, argc, argv);
mem_ctx = talloc_stackframe();
switch (argc) {
case 0:
default:
net_conf_import_usage(c, argc, argv);
goto done;
case 2:
servicename = talloc_strdup(mem_ctx, argv[1]);
if (servicename == NULL) {
d_printf(_("error: out of memory!\n"));
goto done;
}
FALL_THROUGH;
case 1:
filename = argv[0];
break;
}
DEBUG(3,("net_conf_import: reading configuration from file %s.\n",
filename));
conf_source = talloc_asprintf(mem_ctx, "file:%s", filename);
if (conf_source == NULL) {
d_printf(_("error: out of memory!\n"));
goto done;
}
err = smbconf_init(mem_ctx, &txt_ctx, conf_source);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error loading file '%s': %s\n"), filename,
sbcErrorString(err));
goto done;
}
if (c->opt_testmode) {
d_printf(_("\nTEST MODE - "
"would import the following configuration:\n\n"));
}
if (servicename != NULL) {
struct smbconf_service *service = NULL;
err = smbconf_get_share(txt_ctx, mem_ctx,
servicename,
&service);
if (!SBC_ERROR_IS_OK(err)) {
goto cancel;
}
err = smbconf_transaction_start(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error starting transaction: %s\n"),
sbcErrorString(err));
goto done;
}
err = import_process_service(c, conf_ctx, service);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error importing service %s: %s\n"),
servicename, sbcErrorString(err));
goto cancel;
}
} else {
struct smbconf_service **services = NULL;
uint32_t num_shares, sidx;
err = smbconf_get_config(txt_ctx, mem_ctx,
&num_shares,
&services);
if (!SBC_ERROR_IS_OK(err)) {
goto cancel;
}
if (!c->opt_testmode) {
if (!SBC_ERROR_IS_OK(smbconf_drop(conf_ctx))) {
goto cancel;
}
}
/*
* Wrap the importing of shares into a transaction,
* but only 100 at a time, in order to save memory.
* The allocated memory accumulates across the actions
* within the transaction, and for me, some 1500
* imported shares, the MAX_TALLOC_SIZE of 256 MB
* was exceeded.
*/
err = smbconf_transaction_start(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error starting transaction: %s\n"),
sbcErrorString(err));
goto done;
}
for (sidx = 0; sidx < num_shares; sidx++) {
err = import_process_service(c, conf_ctx,
services[sidx]);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error importing service %s: %s\n"),
services[sidx]->name,
sbcErrorString(err));
goto cancel;
}
if (sidx % 100) {
continue;
}
err = smbconf_transaction_commit(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error committing transaction: "
"%s\n"),
sbcErrorString(err));
goto done;
}
err = smbconf_transaction_start(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error starting transaction: %s\n"),
sbcErrorString(err));
goto done;
}
}
}
err = smbconf_transaction_commit(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error committing transaction: %s\n"),
sbcErrorString(err));
} else {
ret = 0;
}
goto done;
cancel:
err = smbconf_transaction_cancel(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf(_("error cancelling transaction: %s\n"),
sbcErrorString(err));
}
done:
TALLOC_FREE(mem_ctx);
return ret;
}
