/**
* This functions process a service previously loaded with libsmbconf.
*/
static sbcErr import_process_service(struct net_context *c,
struct smbconf_ctx *conf_ctx,
struct smbconf_service *service)
{
sbcErr err = SBC_ERR_OK;
if (c->opt_testmode) {
uint32_t idx;
const char *indent = "";
if (service->name != NULL) {
d_printf("[%s]\n", service->name);
indent = "\t";
}
for (idx = 0; idx < service->num_params; idx++) {
d_printf("%s%s = %s\n", indent,
service->param_names[idx],
service->param_values[idx]);
}
d_printf("\n");
goto done;
}
if (smbconf_share_exists(conf_ctx, service->name)) {
err = smbconf_delete_share(conf_ctx, service->name);
if (!SBC_ERROR_IS_OK(err)) {
goto done;
}
}
err = smbconf_create_set_share(conf_ctx, service);
done:
return err;
}
/**
* This functions process a service previously loaded with libsmbconf.
*/
static WERROR import_process_service(struct net_context *c,
struct smbconf_ctx *conf_ctx,
struct smbconf_service *service)
{
uint32_t idx;
WERROR werr = WERR_OK;
uint32_t num_includes = 0;
char **includes = NULL;
TALLOC_CTX *mem_ctx = talloc_stackframe();
if (c->opt_testmode) {
const char *indent = "";
if (service->name != NULL) {
d_printf("[%s]\n", service->name);
indent = "\t";
}
for (idx = 0; idx < service->num_params; idx++) {
d_printf("%s%s = %s\n", indent,
service->param_names[idx],
service->param_values[idx]);
}
d_printf("\n");
goto done;
}
if (smbconf_share_exists(conf_ctx, service->name)) {
werr = smbconf_delete_share(conf_ctx, service->name);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
}
werr = smbconf_create_share(conf_ctx, service->name);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
for (idx = 0; idx < service->num_params; idx ++) {
if (strequal(service->param_names[idx], "include")) {
includes = TALLOC_REALLOC_ARRAY(mem_ctx,
includes,
char *,
num_includes+1);
if (includes == NULL) {
werr = WERR_NOMEM;
goto done;
}
includes[num_includes] = talloc_strdup(includes,
service->param_values[idx]);
if (includes[num_includes] == NULL) {
werr = WERR_NOMEM;
goto done;
}
num_includes++;
} else {
static NTSTATUS sc_smap_unexpose(struct messaging_context *msg_ctx,
struct fss_sc_smap *sc_smap, bool delete_all)
{
NTSTATUS ret;
struct smbconf_ctx *conf_ctx;
sbcErr cerr;
bool is_modified = false;
TALLOC_CTX *tmp_ctx = talloc_new(sc_smap);
if (tmp_ctx == NULL) {
return NT_STATUS_NO_MEMORY;
}
cerr = smbconf_init(tmp_ctx, &conf_ctx, "registry");
if (!SBC_ERROR_IS_OK(cerr)) {
DEBUG(0, ("failed registry smbconf init: %s\n",
sbcErrorString(cerr)));
ret = NT_STATUS_UNSUCCESSFUL;
goto err_tmp;
}
/* registry IO must be done as root */
become_root();
cerr = smbconf_transaction_start(conf_ctx);
if (!SBC_ERROR_IS_OK(cerr)) {
DEBUG(0, ("error starting transaction: %s\n",
sbcErrorString(cerr)));
ret = NT_STATUS_UNSUCCESSFUL;
goto err_conf;
}
while (sc_smap) {
struct fss_sc_smap *sc_map_next = sc_smap->next;
if (!smbconf_share_exists(conf_ctx, sc_smap->sc_share_name)) {
DEBUG(2, ("no such share: %s\n", sc_smap->sc_share_name));
if (!delete_all) {
ret = NT_STATUS_OK;
goto err_cancel;
}
sc_smap = sc_map_next;
continue;
}
cerr = smbconf_delete_share(conf_ctx, sc_smap->sc_share_name);
if (!SBC_ERROR_IS_OK(cerr)) {
DEBUG(0, ("error deleting share: %s\n",
sbcErrorString(cerr)));
ret = NT_STATUS_UNSUCCESSFUL;
goto err_cancel;
}
is_modified = true;
sc_smap->is_exposed = false;
if (delete_all) {
sc_smap = sc_map_next;
} else {
sc_smap = NULL; /* only process single sc_map entry */
}
}
if (is_modified) {
cerr = smbconf_transaction_commit(conf_ctx);
if (!SBC_ERROR_IS_OK(cerr)) {
DEBUG(0, ("error committing transaction: %s\n",
sbcErrorString(cerr)));
ret = NT_STATUS_UNSUCCESSFUL;
goto err_cancel;
}
message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
} else {
ret = NT_STATUS_OK;
goto err_cancel;
}
ret = NT_STATUS_OK;
err_conf:
talloc_free(conf_ctx);
unbecome_root();
err_tmp:
talloc_free(tmp_ctx);
return ret;
err_cancel:
smbconf_transaction_cancel(conf_ctx);
talloc_free(conf_ctx);
unbecome_root();
talloc_free(tmp_ctx);
return ret;
}
/**
* get the list of share names defined in the configuration.
* registry version.
*/
static sbcErr smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
TALLOC_CTX *mem_ctx,
uint32_t *num_shares,
char ***share_names)
{
uint32_t count;
uint32_t added_count = 0;
TALLOC_CTX *tmp_ctx = NULL;
WERROR werr;
sbcErr err = SBC_ERR_OK;
char *subkey_name = NULL;
char **tmp_share_names = NULL;
if ((num_shares == NULL) || (share_names == NULL)) {
return SBC_ERR_INVALID_PARAM;
}
tmp_ctx = talloc_stackframe();
/* if there are values in the base key, return NULL as share name */
if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
0, NULL);
if (!SBC_ERROR_IS_OK(err)) {
goto done;
}
added_count++;
}
/* make sure "global" is always listed first */
if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
added_count, GLOBAL_NAME);
if (!SBC_ERROR_IS_OK(err)) {
goto done;
}
added_count++;
}
for (count = 0;
werr = reg_enumkey(tmp_ctx, rpd(ctx)->base_key, count,
&subkey_name, NULL),
W_ERROR_IS_OK(werr);
count++)
{
if (strequal(subkey_name, GLOBAL_NAME)) {
continue;
}
err = smbconf_add_string_to_array(tmp_ctx,
&tmp_share_names,
added_count,
subkey_name);
if (!SBC_ERROR_IS_OK(err)) {
goto done;
}
added_count++;
}
if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
err = SBC_ERR_NO_MORE_ITEMS;
goto done;
}
err = SBC_ERR_OK;
*num_shares = added_count;
if (added_count > 0) {
*share_names = talloc_move(mem_ctx, &tmp_share_names);
} else {
*share_names = NULL;
}
done:
talloc_free(tmp_ctx);
return err;
}
static int net_conf_setparm(struct net_context *c, struct smbconf_ctx *conf_ctx,
int argc, const char **argv)
{
int ret = -1;
sbcErr err;
char *service = NULL;
char *param = NULL;
const char *value_str = NULL;
TALLOC_CTX *mem_ctx = talloc_stackframe();
if (argc != 3 || c->display_usage) {
net_conf_setparm_usage(c, argc, argv);
goto done;
}
/*
* NULL service name means "dangling parameters" to libsmbconf.
* We use the empty string from the command line for this purpose.
*/
if (strlen(argv[0]) != 0) {
service = talloc_strdup(mem_ctx, argv[0]);
if (service == NULL) {
d_printf(_("error: out of memory!\n"));
goto done;
}
}
param = strlower_talloc(mem_ctx, argv[1]);
if (param == NULL) {
d_printf(_("error: out of memory!\n"));
goto done;
}
value_str = argv[2];
if (!net_conf_param_valid(service,param, value_str)) {
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;
}
if (!smbconf_share_exists(conf_ctx, service)) {
err = smbconf_create_share(conf_ctx, service);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error creating share '%s': %s\n"),
service, sbcErrorString(err));
goto cancel;
}
}
err = smbconf_set_parameter(conf_ctx, service, param, value_str);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error setting value '%s': %s\n"),
param, sbcErrorString(err));
goto cancel;
}
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;
}
/**
* Add a share, with a couple of standard parameters, partly optional.
*
* This is a high level utility function of the net conf utility,
* not a direct frontend to the smbconf API.
*/
static int net_conf_addshare(struct net_context *c,
struct smbconf_ctx *conf_ctx, int argc,
const char **argv)
{
int ret = -1;
sbcErr err;
char *sharename = NULL;
const char *path = NULL;
const char *comment = NULL;
const char *guest_ok = "no";
const char *writeable = "no";
TALLOC_CTX *mem_ctx = talloc_stackframe();
if (c->display_usage) {
net_conf_addshare_usage(c, argc, argv);
ret = 0;
goto done;
}
switch (argc) {
case 0:
case 1:
default:
net_conf_addshare_usage(c, argc, argv);
goto done;
case 5:
comment = argv[4];
FALL_THROUGH;
case 4:
if (!strnequal(argv[3], "guest_ok=", 9)) {
net_conf_addshare_usage(c, argc, argv);
goto done;
}
switch (argv[3][9]) {
case 'y':
case 'Y':
guest_ok = "yes";
break;
case 'n':
case 'N':
guest_ok = "no";
break;
default:
net_conf_addshare_usage(c, argc, argv);
goto done;
}
FALL_THROUGH;
case 3:
if (!strnequal(argv[2], "writeable=", 10)) {
net_conf_addshare_usage(c, argc, argv);
goto done;
}
switch (argv[2][10]) {
case 'y':
case 'Y':
writeable = "yes";
break;
case 'n':
case 'N':
writeable = "no";
break;
default:
net_conf_addshare_usage(c, argc, argv);
goto done;
}
FALL_THROUGH;
case 2:
path = argv[1];
sharename = talloc_strdup(mem_ctx, argv[0]);
if (sharename == NULL) {
d_printf(_("error: out of memory!\n"));
goto done;
}
break;
}
/*
* validate arguments
*/
/* validate share name */
if (!validate_net_name(sharename, INVALID_SHARENAME_CHARS,
strlen(sharename)))
{
d_fprintf(stderr, _("ERROR: share name %s contains "
"invalid characters (any of %s)\n"),
sharename, INVALID_SHARENAME_CHARS);
goto done;
}
if (strequal(sharename, GLOBAL_NAME)) {
d_fprintf(stderr,
_("ERROR: 'global' is not a valid share name.\n"));
goto done;
}
if (smbconf_share_exists(conf_ctx, sharename)) {
d_fprintf(stderr, _("ERROR: share %s already exists.\n"),
sharename);
goto done;
}
/* validate path */
if (path[0] != '/') {
d_fprintf(stderr,
_("Error: path '%s' is not an absolute path.\n"),
path);
goto done;
}
/*
* start a transaction
*/
err = smbconf_transaction_start(conf_ctx);
if (!SBC_ERROR_IS_OK(err)) {
d_printf("error starting transaction: %s\n",
sbcErrorString(err));
goto done;
}
/*
* create the share
*/
err = smbconf_create_share(conf_ctx, sharename);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error creating share %s: %s\n"),
sharename, sbcErrorString(err));
goto cancel;
}
/*
* fill the share with parameters
*/
err = smbconf_set_parameter(conf_ctx, sharename, "path", path);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
"path", sbcErrorString(err));
goto cancel;
}
if (comment != NULL) {
err = smbconf_set_parameter(conf_ctx, sharename, "comment",
comment);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
"comment", sbcErrorString(err));
goto cancel;
}
}
err = smbconf_set_parameter(conf_ctx, sharename, "guest ok", guest_ok);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
"'guest ok'", sbcErrorString(err));
goto cancel;
}
err = smbconf_set_parameter(conf_ctx, sharename, "writeable",
writeable);
if (!SBC_ERROR_IS_OK(err)) {
d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
"writeable", sbcErrorString(err));
goto cancel;
}
/*
* commit the whole thing
*/
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;
}
/**
* get the list of share names defined in the configuration.
*/
static WERROR smbconf_txt_get_share_names(struct smbconf_ctx *ctx,
TALLOC_CTX *mem_ctx,
uint32_t *num_shares,
char ***share_names)
{
uint32_t count;
uint32_t added_count = 0;
TALLOC_CTX *tmp_ctx = NULL;
WERROR werr = WERR_OK;
char **tmp_share_names = NULL;
if ((num_shares == NULL) || (share_names == NULL)) {
werr = WERR_INVALID_PARAM;
goto done;
}
werr = smbconf_txt_load_file(ctx);
if (!W_ERROR_IS_OK(werr)) {
return werr;
}
tmp_ctx = talloc_stackframe();
/* make sure "global" is always listed first,
* possibly after NULL section */
if (smbconf_share_exists(ctx, NULL)) {
werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
0, NULL);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
added_count++;
}
if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
added_count, GLOBAL_NAME);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
added_count++;
}
for (count = 0; count < pd(ctx)->cache->num_shares; count++) {
if (strequal(pd(ctx)->cache->share_names[count], GLOBAL_NAME) ||
(pd(ctx)->cache->share_names[count] == NULL))
{
continue;
}
werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
added_count,
pd(ctx)->cache->share_names[count]);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
added_count++;
}
*num_shares = added_count;
if (added_count > 0) {
*share_names = talloc_move(mem_ctx, &tmp_share_names);
} else {
*share_names = NULL;
}
done:
talloc_free(tmp_ctx);
return werr;
}
