#include "smb_server/smb_server.h"
#include "libcli/raw/signing.h"
#include "../lib/util/dlinklist.h"
-#include "../lib/util/parmlist.h"
#include "param/param.h"
#include "param/loadparm.h"
#include "libcli/raw/libcliraw.h"
#include "lib/socket/socket.h"
#include "auth/gensec/gensec.h"
#include "s3_param.h"
+#include "../lib/util/bitmap.h"
#define standard_sub_basic talloc_strdup
char *panic_action; \
int bPreferredMaster;
-#define LOADPARM_EXTRA_LOCALS \
- struct parmlist_entry *param_opt; \
- char *szService; \
- char *szCopy; \
- char *szInclude; \
- char *szPrintername; \
- int bAvailable; \
- int iMaxPrintJobs; \
- char *volume; \
- int *copymap; \
- char dummy[3]; /* for alignment */
-
#include "param_global.h"
-#include "param_local.h"
#define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
.label = "strict locking",
.type = P_BOOL,
.p_class = P_LOCAL,
- .offset = LOCAL_VAR(bStrictLocking),
+ .offset = LOCAL_VAR(iStrictLocking),
.special = NULL,
.enum_list = NULL
},
.label = "oplocks",
.type = P_BOOL,
.p_class = P_LOCAL,
- .offset = LOCAL_VAR(bOplocks),
+ .offset = LOCAL_VAR(bOpLocks),
.special = NULL,
.enum_list = NULL
},
.special = NULL,
.enum_list = NULL
},
+ {
+ .label = "state directory",
+ .type = P_STRING,
+ .p_class = P_GLOBAL,
+ .offset = GLOBAL_VAR(szStateDir),
+ .special = NULL,
+ .enum_list = NULL
+ },
+ {
+ .label = "cache directory",
+ .type = P_STRING,
+ .p_class = P_GLOBAL,
+ .offset = GLOBAL_VAR(szCacheDir),
+ .special = NULL,
+ .enum_list = NULL
+ },
{
.label = "pid directory",
.type = P_STRING,
struct loadparm_service *lpcfg_default_service(struct loadparm_context *lp_ctx)
{
+ if (lp_ctx->s3_fns) {
+ return lp_ctx->s3_fns->get_default_loadparm_service();
+ }
return lp_ctx->sDefault;
}
return lp_ctx->globals->var_name; \
}
+/* Local parameters don't need the ->s3_fns because the struct
+ * loadparm_service is shared and lpcfg_service() checks the ->s3_fns
+ * hook */
#define FN_LOCAL_STRING(fn_name,val) \
_PUBLIC_ const char *lpcfg_ ## fn_name(struct loadparm_service *service, \
struct loadparm_service *sDefault) { \
return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault->val))); \
}
+#define FN_LOCAL_CONST_STRING(fn_name,val) FN_LOCAL_STRING(fn_name, val)
+
#define FN_LOCAL_LIST(fn_name,val) \
_PUBLIC_ const char **lpcfg_ ## fn_name(struct loadparm_service *service, \
struct loadparm_service *sDefault) {\
return(const char **)(service != NULL && service->val != NULL? service->val : sDefault->val); \
}
+#define FN_LOCAL_PARM_BOOL(fn_name, val) FN_LOCAL_BOOL(fn_name, val)
+
#define FN_LOCAL_BOOL(fn_name,val) \
_PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_service *service, \
struct loadparm_service *sDefault) { \
return((service != NULL)? service->val : sDefault->val); \
}
+#define FN_LOCAL_PARM_INTEGER(fn_name, val) FN_LOCAL_INTEGER(fn_name, val)
+
+#define FN_LOCAL_PARM_CHAR(fn_name, val) FN_LOCAL_CHAR(fn_name, val)
+
+#define FN_LOCAL_CHAR(fn_name,val) \
+ _PUBLIC_ char lpcfg_ ## fn_name(struct loadparm_service *service, \
+ struct loadparm_service *sDefault) { \
+ return((service != NULL)? service->val : sDefault->val); \
+ }
+
+#include "lib/param/param_functions.c"
+
FN_GLOBAL_INTEGER(server_role, server_role)
FN_GLOBAL_LIST(smb_ports, smb_ports)
FN_GLOBAL_INTEGER(nbt_port, nbt_port)
FN_GLOBAL_STRING(private_dir, szPrivateDir)
FN_GLOBAL_STRING(serverstring, szServerString)
FN_GLOBAL_STRING(lockdir, szLockDir)
+FN_GLOBAL_STRING(statedir, szStateDir)
+FN_GLOBAL_STRING(cachedir, szCacheDir)
FN_GLOBAL_STRING(ncalrpc_dir, ncalrpc_dir)
FN_GLOBAL_STRING(dos_charset, dos_charset)
FN_GLOBAL_STRING(unix_charset, unix_charset)
FN_GLOBAL_INTEGER(security, security)
FN_GLOBAL_BOOL(paranoid_server_security, paranoid_server_security)
-FN_LOCAL_STRING(pathname, szPath)
-FN_LOCAL_LIST(hostsallow, szHostsallow)
-FN_LOCAL_LIST(hostsdeny, szHostsdeny)
-FN_LOCAL_STRING(comment, comment)
-FN_LOCAL_STRING(fstype, fstype)
-FN_LOCAL_LIST(ntvfs_handler, ntvfs_handler)
-FN_LOCAL_BOOL(msdfs_root, bMSDfsRoot)
-FN_LOCAL_BOOL(browseable, bBrowseable)
-FN_LOCAL_BOOL(readonly, bRead_only)
-FN_LOCAL_BOOL(print_ok, bPrint_ok)
-FN_LOCAL_BOOL(map_hidden, bMap_hidden)
-FN_LOCAL_BOOL(map_archive, bMap_archive)
-FN_LOCAL_BOOL(strict_locking, bStrictLocking)
-FN_LOCAL_BOOL(oplocks, bOplocks)
-FN_LOCAL_BOOL(strict_sync, bStrictSync)
-FN_LOCAL_BOOL(ci_filesystem, bCIFileSystem)
-FN_LOCAL_BOOL(map_system, bMap_system)
-FN_LOCAL_INTEGER(max_connections, iMaxConnections)
-FN_LOCAL_INTEGER(csc_policy, iCSCPolicy)
-FN_LOCAL_INTEGER(create_mask, iCreate_mask)
-FN_LOCAL_INTEGER(force_create_mode, iCreate_force_mode)
-FN_LOCAL_INTEGER(dir_mask, iDir_mask)
-FN_LOCAL_INTEGER(force_dir_mode, iDir_force_mode)
FN_GLOBAL_INTEGER(server_signing, server_signing)
FN_GLOBAL_INTEGER(client_signing, client_signing)
const char *pszServiceName);
static void copy_service(struct loadparm_service *pserviceDest,
struct loadparm_service *pserviceSource,
- int *pcopymapDest);
+ struct bitmap *pcopymapDest);
static bool service_ok(struct loadparm_service *service);
static bool do_section(const char *pszSectionName, void *);
static void init_copymap(struct loadparm_service *pservice);
{
int iService;
+ if (lp_ctx->s3_fns) {
+ return lp_ctx->s3_fns->get_service(pszServiceName);
+ }
+
for (iService = lp_ctx->iNumServices - 1; iService >= 0; iService--)
if (lp_ctx->services[iService] != NULL &&
strwicmp(lp_ctx->services[iService]->szService, pszServiceName) == 0) {
static void copy_service(struct loadparm_service *pserviceDest,
struct loadparm_service *pserviceSource,
- int *pcopymapDest)
+ struct bitmap *pcopymapDest)
{
int i;
bool bcopyall = (pcopymapDest == NULL);
bool not_added;
for (i = 0; parm_table[i].label; i++)
- if (parm_table[i].offset != -1 && parm_table[i].p_class == P_LOCAL &&
- (bcopyall || pcopymapDest[i])) {
+ if (parm_table[i].p_class == P_LOCAL &&
+ (bcopyall || bitmap_query(pcopymapDest, i))) {
void *src_ptr =
((char *)pserviceSource) + parm_table[i].offset;
void *dest_ptr =
if (bcopyall) {
init_copymap(pserviceDest);
if (pserviceSource->copymap)
- memcpy((void *)pserviceDest->copymap,
- (void *)pserviceSource->copymap,
- sizeof(int) * NUMPARAMETERS);
+ bitmap_copy(pserviceDest->copymap,
+ pserviceSource->copymap);
}
data = pserviceSource->param_opt;
static void init_copymap(struct loadparm_service *pservice)
{
int i;
- talloc_free(pservice->copymap);
- pservice->copymap = talloc_array(pservice, int, NUMPARAMETERS);
- if (pservice->copymap == NULL) {
+
+ TALLOC_FREE(pservice->copymap);
+
+ pservice->copymap = bitmap_talloc(NULL, NUMPARAMETERS);
+ if (!pservice->copymap)
DEBUG(0,
("Couldn't allocate copymap!! (size %d)\n",
(int)NUMPARAMETERS));
- return;
- }
- for (i = 0; i < NUMPARAMETERS; i++)
- pservice->copymap[i] = true;
+ else
+ for (i = 0; i < NUMPARAMETERS; i++)
+ bitmap_set(pservice->copymap, i);
}
/**
*(int *)parm_ptr = atoi(pszParmValue);
break;
+ case P_CHAR:
+ *(char *)parm_ptr = *pszParmValue;
+ break;
+
case P_OCTAL:
*(int *)parm_ptr = strtol(pszParmValue, NULL, 8);
break;
for (i = 0; parm_table[i].label; i++)
if (parm_table[i].offset == parm_table[parmnum].offset &&
parm_table[i].p_class == parm_table[parmnum].p_class)
- service->copymap[i] = false;
+ bitmap_clear(service->copymap, i);
return set_variable(service, parmnum, parm_ptr, pszParmName,
pszParmValue, lp_ctx, false);
bool lpcfg_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
const char *pszParmValue)
{
- int parmnum = map_parameter(pszParmName);
+ int parmnum;
int i;
+ if (lp_ctx->s3_fns) {
+ return lp_ctx->s3_fns->set_cmdline(pszParmName, pszParmValue);
+ }
+
+ parmnum = map_parameter(pszParmName);
+
while (isspace((unsigned char)*pszParmValue)) pszParmValue++;
fprintf(f, "%d", *(int *)ptr);
break;
+ case P_CHAR:
+ fprintf(f, "%c", *(char *)ptr);
+ break;
+
case P_OCTAL:
fprintf(f, "0%o", *(int *)ptr);
break;
case P_ENUM:
return (*((int *)ptr1) == *((int *)ptr2));
+ case P_CHAR:
+ return (*((char *)ptr1) == *((char *)ptr2));
+
case P_CMDLIST:
case P_LIST:
return str_list_equal((const char **)(*(char ***)ptr1),
return parm_table[i].def.bvalue ==
*(int *)def_ptr;
case P_INTEGER:
+ case P_CHAR:
case P_OCTAL:
case P_BYTES:
case P_ENUM:
for (i = 0; parm_table[i].label; i++)
if (parm_table[i].p_class == P_GLOBAL &&
- parm_table[i].offset != -1 &&
(i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT))
continue;
for (i = 0; parm_table[i].label; i++) {
if (parm_table[i].p_class == P_LOCAL &&
- parm_table[i].offset != -1 &&
(*parm_table[i].label != '-') &&
(i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
{
if (snum == -1) {
/* do the globals */
for (; parm_table[*i].label; (*i)++) {
- if (parm_table[*i].offset == -1
- || (*parm_table[*i].label == '-'))
+ if ((*parm_table[*i].label == '-'))
continue;
if ((*i) > 0
for (; parm_table[*i].label; (*i)++) {
if (parm_table[*i].p_class == P_LOCAL &&
- parm_table[*i].offset != -1 &&
(*parm_table[*i].label != '-') &&
((*i) == 0 ||
(parm_table[*i].offset !=
lp_ctx->sDefault->bBrowseable = true;
lp_ctx->sDefault->bRead_only = true;
lp_ctx->sDefault->bMap_archive = true;
- lp_ctx->sDefault->bStrictLocking = true;
- lp_ctx->sDefault->bOplocks = true;
+ lp_ctx->sDefault->iStrictLocking = true;
+ lp_ctx->sDefault->bOpLocks = true;
lp_ctx->sDefault->iCreate_mask = 0744;
lp_ctx->sDefault->iCreate_force_mode = 0000;
lp_ctx->sDefault->iDir_mask = 0755;
for (i = 0; parm_table[i].label; i++) {
if ((parm_table[i].type == P_STRING ||
parm_table[i].type == P_USTRING) &&
- parm_table[i].offset != -1 &&
!(lp_ctx->flags[i] & FLAG_CMDLINE)) {
char **r;
if (parm_table[i].p_class == P_LOCAL) {
lpcfg_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
lpcfg_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
+ lpcfg_do_global_parameter(lp_ctx, "state directory", dyn_STATEDIR);
+ lpcfg_do_global_parameter(lp_ctx, "cache directory", dyn_CACHEDIR);
lpcfg_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
lpcfg_do_global_parameter(lp_ctx, "socket address", "");
lp_ctx->szConfigFile = filename;
+ if (lp_ctx->s3_fns) {
+ return lp_ctx->s3_fns->load(filename);
+ }
+
lp_ctx->bInGlobalSection = true;
n2 = standard_sub_basic(lp_ctx, lp_ctx->szConfigFile);
DEBUG(2, ("lpcfg_load: refreshing parameters from %s\n", n2));
int lpcfg_numservices(struct loadparm_context *lp_ctx)
{
+ if (lp_ctx->s3_fns) {
+ return lp_ctx->s3_fns->get_numservices();
+ }
+
return lp_ctx->iNumServices;
}
}
struct loadparm_service *lpcfg_servicebynum(struct loadparm_context *lp_ctx,
- int snum)
+ int snum)
{
+ if (lp_ctx->s3_fns) {
+ return lp_ctx->s3_fns->get_servicebynum(snum);
+ }
+
return lp_ctx->services[snum];
}