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;
}
/* local prototypes */
static struct loadparm_service *lpcfg_getservicebyname(struct loadparm_context *lp_ctx,
const char *pszServiceName);
-static bool lpcfg_service_ok(struct loadparm_service *service);
static bool do_section(const char *pszSectionName, void *);
static bool set_variable_helper(TALLOC_CTX *mem_ctx, int parmnum, void *parm_ptr,
const char *pszParmName, const char *pszParmValue);
+static bool lp_do_parameter_parametric(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service,
+ const char *pszParmName,
+ const char *pszParmValue, int flags);
/* The following are helper functions for parametrical options support. */
/* It returns a pointer to parametrical option value if it exists or NULL otherwise */
*/
struct parm_struct *lpcfg_parm_struct(struct loadparm_context *lp_ctx, const char *name)
{
- int parmnum;
+ int num = lpcfg_map_parameter(name);
- if (lp_ctx->s3_fns) {
- return lp_ctx->s3_fns->get_parm_struct(name);
+ if (num < 0) {
+ return NULL;
}
- parmnum = lpcfg_map_parameter(name);
- if (parmnum == -1) return NULL;
- return &parm_table[parmnum];
+ return &parm_table[num];
}
/**
{
int parmnum;
- if (lp_ctx->s3_fns) {
- struct parm_struct *parm = lp_ctx->s3_fns->get_parm_struct(name);
- if (parm) {
- return parm->flags & FLAG_CMDLINE;
- }
- return false;
- }
-
parmnum = lpcfg_map_parameter(name);
if (parmnum == -1) return false;
* Check a service for consistency. Return False if the service is in any way
* incomplete or faulty, else True.
*/
-static bool lpcfg_service_ok(struct loadparm_service *service)
+bool lpcfg_service_ok(struct loadparm_service *service)
{
bool bRetval;
service->browseable = false;
}
+ if (service->path[0] == '\0' &&
+ strwicmp(service->szService, HOMES_NAME) != 0 &&
+ service->msdfs_proxy[0] == '\0')
+ {
+ DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
+ service->szService));
+ service->bAvailable = false;
+ }
+
/* If a service is flagged unavailable, log the fact at level 0. */
if (!service->bAvailable)
DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
f->modtime = mod_time;
talloc_free(f->subfname);
f->subfname = talloc_strdup(f, n2);
+ TALLOC_FREE(n2);
return true;
}
+ TALLOC_FREE(n2);
}
return false;
}
Handle the "realm" parameter
***************************************************************************/
-bool handle_realm(struct loadparm_context *lp_ctx, int unused,
+bool handle_realm(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
char *upper;
return false;
}
- if (lp_ctx->s3_fns != NULL) {
- lp_ctx->s3_fns->lp_string_set(ptr, pszParmValue);
- lp_ctx->s3_fns->lp_string_set(&lp_ctx->globals->realm, upper);
- lp_ctx->s3_fns->lp_string_set(&lp_ctx->globals->dnsdomain, lower);
- } else {
- lpcfg_string_set(lp_ctx, ptr, pszParmValue);
- lpcfg_string_set(lp_ctx, &lp_ctx->globals->realm, upper);
- lpcfg_string_set(lp_ctx, &lp_ctx->globals->dnsdomain, lower);
- }
+ lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
+ lpcfg_string_set(lp_ctx->globals->ctx, &lp_ctx->globals->realm, upper);
+ lpcfg_string_set(lp_ctx->globals->ctx, &lp_ctx->globals->dnsdomain, lower);
return true;
}
Handle the include operation.
***************************************************************************/
-bool handle_include(struct loadparm_context *lp_ctx, int unused,
+bool handle_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
char *fname;
if (lp_ctx->s3_fns) {
- return lp_ctx->s3_fns->lp_include(lp_ctx, unused, pszParmValue, ptr);
+ return lp_ctx->s3_fns->lp_include(lp_ctx, service, pszParmValue, ptr);
}
fname = standard_sub_basic(lp_ctx, pszParmValue);
Handle the interpretation of the copy parameter.
***************************************************************************/
-bool handle_copy(struct loadparm_context *lp_ctx, int snum,
+bool handle_copy(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
bool bRetval;
struct loadparm_service *serviceTemp = NULL;
- struct loadparm_service *current = NULL;
bRetval = false;
DEBUG(3, ("Copying service from service %s\n", pszParmValue));
serviceTemp = lpcfg_getservicebyname(lp_ctx, pszParmValue);
- if (lp_ctx->s3_fns != NULL) {
- current = lp_ctx->s3_fns->get_servicebynum(snum);
- } else {
- current = lp_ctx->currentService;
- }
- if (current == NULL) {
- DEBUG(0, ("Unable to copy service - invalid service destination"));
+ if (service == NULL) {
+ DEBUG(0, ("Unable to copy service - invalid service destination.\n"));
return false;
}
if (serviceTemp != NULL) {
- if (serviceTemp == current) {
+ if (serviceTemp == service) {
DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
} else {
- copy_service(current,
+ copy_service(service,
serviceTemp,
- current->copymap);
- lpcfg_string_set(current, ptr, pszParmValue);
+ service->copymap);
+ lpcfg_string_set(service, ptr, pszParmValue);
bRetval = true;
}
return bRetval;
}
-bool handle_debug_list(struct loadparm_context *lp_ctx, int unused,
+bool handle_debug_list(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
- if (lp_ctx->s3_fns != NULL) {
- lp_ctx->s3_fns->lp_string_set(ptr, pszParmValue);
- } else {
- lpcfg_string_set(lp_ctx, ptr, pszParmValue);
- }
+ lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
return debug_parse_levels(pszParmValue);
}
-bool handle_logfile(struct loadparm_context *lp_ctx, int unused,
+bool handle_logfile(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
- if (lp_ctx->s3_fns != NULL) {
- lp_ctx->s3_fns->lp_string_set(ptr, pszParmValue);
- } else {
+ if (lp_ctx->s3_fns == NULL) {
debug_set_logfile(pszParmValue);
- lpcfg_string_set(lp_ctx, ptr, pszParmValue);
}
+ lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
+
return true;
}
* These special charset handling methods only run in the source3 code.
*/
-bool handle_charset(struct loadparm_context *lp_ctx, int snum,
+bool handle_charset(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
if (lp_ctx->s3_fns) {
if (*ptr == NULL || strcmp(*ptr, pszParmValue) != 0) {
- lp_ctx->s3_fns->lp_string_set(ptr, pszParmValue);
global_iconv_handle = smb_iconv_handle_reinit(NULL,
lpcfg_dos_charset(lp_ctx),
lpcfg_unix_charset(lp_ctx),
true, global_iconv_handle);
}
- return true;
}
- return lpcfg_string_set(lp_ctx, ptr, pszParmValue);
+ return lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
}
-bool handle_dos_charset(struct loadparm_context *lp_ctx, int snum,
+bool handle_dos_charset(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
bool is_utf8 = false;
DEFAULT_DOS_CHARSET));
pszParmValue = DEFAULT_DOS_CHARSET;
}
- lp_ctx->s3_fns->lp_string_set(ptr, pszParmValue);
global_iconv_handle = smb_iconv_handle_reinit(NULL,
lpcfg_dos_charset(lp_ctx),
lpcfg_unix_charset(lp_ctx),
true, global_iconv_handle);
}
- return true;
}
- return lpcfg_string_set(lp_ctx, ptr, pszParmValue);
+ return lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
}
-bool handle_printing(struct loadparm_context *lp_ctx, int snum,
+bool handle_printing(struct loadparm_context *lp_ctx, struct loadparm_service *service,
const char *pszParmValue, char **ptr)
{
static int parm_num = -1;
- struct loadparm_service *s;
if (parm_num == -1) {
parm_num = lpcfg_map_parameter("printing");
}
if (lp_ctx->s3_fns) {
- if ( snum < 0 ) {
- s = lp_ctx->sDefault;
- lp_ctx->s3_fns->init_printer_values(lp_ctx->globals->ctx, s);
+ if (service == NULL) {
+ init_printer_values(lp_ctx, lp_ctx->globals->ctx, lp_ctx->sDefault);
} else {
- s = lp_ctx->services[snum];
- lp_ctx->s3_fns->init_printer_values(s, s);
+ init_printer_values(lp_ctx, service, service);
}
}
return true;
}
-bool handle_ldap_debug_level(struct loadparm_context *lp_ctx, int snum, const char *pszParmValue, char **ptr)
+bool handle_ldap_debug_level(struct loadparm_context *lp_ctx, struct loadparm_service *service,
+ const char *pszParmValue, char **ptr)
{
lp_ctx->globals->ldap_debug_level = lp_int(pszParmValue);
return true;
}
-bool handle_netbios_aliases(struct loadparm_context *lp_ctx, int snum, const char *pszParmValue, char **ptr)
+bool handle_netbios_aliases(struct loadparm_context *lp_ctx, struct loadparm_service *service,
+ const char *pszParmValue, char **ptr)
{
TALLOC_FREE(lp_ctx->globals->netbios_aliases);
lp_ctx->globals->netbios_aliases = (const char **)str_list_make_v3(lp_ctx->globals->ctx,
* idmap related parameters
*/
-bool handle_idmap_backend(struct loadparm_context *lp_ctx, int snum, const char *pszParmValue, char **ptr)
+bool handle_idmap_backend(struct loadparm_context *lp_ctx, struct loadparm_service *service,
+ const char *pszParmValue, char **ptr)
{
if (lp_ctx->s3_fns) {
- return lp_ctx->s3_fns->lp_do_parameter(snum, "idmap config * : backend", pszParmValue);
+ lp_do_parameter_parametric(lp_ctx, service, "idmap config * : backend",
+ pszParmValue, 0);
}
- return lpcfg_string_set(lp_ctx, ptr, pszParmValue);
+ return lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
}
-bool handle_idmap_uid(struct loadparm_context *lp_ctx, int snum, const char *pszParmValue, char **ptr)
+bool handle_idmap_uid(struct loadparm_context *lp_ctx, struct loadparm_service *service,
+ const char *pszParmValue, char **ptr)
{
if (lp_ctx->s3_fns) {
- return lp_ctx->s3_fns->lp_do_parameter(snum, "idmap config * : range", pszParmValue);
+ lp_do_parameter_parametric(lp_ctx, service, "idmap config * : range",
+ pszParmValue, 0);
}
- return lpcfg_string_set(lp_ctx, ptr, pszParmValue);
+ return lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
}
-bool handle_idmap_gid(struct loadparm_context *lp_ctx, int snum, const char *pszParmValue, char **ptr)
+bool handle_idmap_gid(struct loadparm_context *lp_ctx, struct loadparm_service *service,
+ const char *pszParmValue, char **ptr)
{
if (lp_ctx->s3_fns) {
- return lp_ctx->s3_fns->lp_do_parameter(snum, "idmap config * : range", pszParmValue);
+ lp_do_parameter_parametric(lp_ctx, service, "idmap config * : range",
+ pszParmValue, 0);
}
- return lpcfg_string_set(lp_ctx, ptr, pszParmValue);
+ return lpcfg_string_set(lp_ctx->globals->ctx, ptr, pszParmValue);
}
-bool handle_smb_ports(struct loadparm_context *lp_ctx, int snum, const char *pszParmValue, char **ptr)
+bool handle_smb_ports(struct loadparm_context *lp_ctx, struct loadparm_service *service,
+ const char *pszParmValue, char **ptr)
{
static int parm_num = -1;
int i;
}
-bool set_variable(TALLOC_CTX *mem_ctx, int snum, int parmnum, void *parm_ptr,
+bool set_variable(TALLOC_CTX *mem_ctx, struct loadparm_service *service, int parmnum, void *parm_ptr,
const char *pszParmName, const char *pszParmValue,
struct loadparm_context *lp_ctx, bool on_globals)
{
/* if it is a special case then go ahead */
if (parm_table[parmnum].special) {
- ok = parm_table[parmnum].special(lp_ctx, snum, pszParmValue,
+ ok = parm_table[parmnum].special(lp_ctx, service, pszParmValue,
(char **)parm_ptr);
if (!ok) {
return false;
parm_ptr = lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
- return set_variable(lp_ctx->globals->ctx, -1, parmnum, parm_ptr,
+ return set_variable(lp_ctx->globals->ctx, NULL, parmnum, parm_ptr,
pszParmName, pszParmValue, lp_ctx, true);
}
parm_table[i].p_class == parm_table[parmnum].p_class)
bitmap_clear(service->copymap, i);
- return set_variable(service, -1, parmnum, parm_ptr, pszParmName,
+ return set_variable(service, service, parmnum, parm_ptr, pszParmName,
pszParmValue, lp_ctx, false);
}
/* reset the CMDLINE flag in case this has been called before */
lp_ctx->flags[parmnum] &= ~FLAG_CMDLINE;
- if (lp_ctx->s3_fns != NULL) {
- if (!lp_ctx->s3_fns->lp_do_parameter(-1, pszParmName, pszParmValue)) {
- return false;
- }
- } else {
- if (!lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
- return false;
- }
+ if (!lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
+ return false;
}
lp_ctx->flags[parmnum] |= FLAG_CMDLINE;
* Determine if a particular base parameter is currently set to the default value.
*/
-static bool is_default(struct loadparm_service *sDefault, int i)
+static bool is_default(void *base_structure, int i)
{
- void *def_ptr = ((char *)sDefault) + parm_table[i].offset;
+ void *def_ptr = ((char *)base_structure) + parm_table[i].offset;
switch (parm_table[i].type) {
case P_CMDLIST:
case P_LIST:
*Display the contents of the global structure.
*/
-static void dump_globals(struct loadparm_context *lp_ctx, FILE *f,
+void lpcfg_dump_globals(struct loadparm_context *lp_ctx, FILE *f,
bool show_defaults)
{
int i;
for (i = 0; parm_table[i].label; i++)
if (parm_table[i].p_class == P_GLOBAL &&
(i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
- if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT))
- continue;
+ if (!show_defaults) {
+ if (lp_ctx->flags && (lp_ctx->flags[i] & FLAG_DEFAULT)) {
+ continue;
+ }
+
+ if (is_default(lp_ctx->globals, i)) {
+ continue;
+ }
+ }
+
fprintf(f, "\t%s = ", parm_table[i].label);
lpcfg_print_parameter(&parm_table[i], lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
fprintf(f, "\n");
return;
}
+/***************************************************************************
+ Initialise the sDefault parameter structure for the printer values.
+***************************************************************************/
+
+void init_printer_values(struct loadparm_context *lp_ctx, TALLOC_CTX *ctx,
+ struct loadparm_service *pService)
+{
+ /* choose defaults depending on the type of printing */
+ switch (pService->printing) {
+ case PRINT_BSD:
+ case PRINT_AIX:
+ case PRINT_LPRNT:
+ case PRINT_LPROS2:
+ lpcfg_string_set(ctx, &pService->lpq_command, "lpq -P'%p'");
+ lpcfg_string_set(ctx, &pService->lprm_command, "lprm -P'%p' %j");
+ lpcfg_string_set(ctx, &pService->print_command, "lpr -r -P'%p' %s");
+ break;
+
+ case PRINT_LPRNG:
+ case PRINT_PLP:
+ lpcfg_string_set(ctx, &pService->lpq_command, "lpq -P'%p'");
+ lpcfg_string_set(ctx, &pService->lprm_command, "lprm -P'%p' %j");
+ lpcfg_string_set(ctx, &pService->print_command, "lpr -r -P'%p' %s");
+ lpcfg_string_set(ctx, &pService->queuepause_command, "lpc stop '%p'");
+ lpcfg_string_set(ctx, &pService->queueresume_command, "lpc start '%p'");
+ lpcfg_string_set(ctx, &pService->lppause_command, "lpc hold '%p' %j");
+ lpcfg_string_set(ctx, &pService->lpresume_command, "lpc release '%p' %j");
+ break;
+
+ case PRINT_CUPS:
+ case PRINT_IPRINT:
+ /* set the lpq command to contain the destination printer
+ name only. This is used by cups_queue_get() */
+ lpcfg_string_set(ctx, &pService->lpq_command, "%p");
+ lpcfg_string_set(ctx, &pService->lprm_command, "");
+ lpcfg_string_set(ctx, &pService->print_command, "");
+ lpcfg_string_set(ctx, &pService->lppause_command, "");
+ lpcfg_string_set(ctx, &pService->lpresume_command, "");
+ lpcfg_string_set(ctx, &pService->queuepause_command, "");
+ lpcfg_string_set(ctx, &pService->queueresume_command, "");
+ break;
+
+ case PRINT_SYSV:
+ case PRINT_HPUX:
+ lpcfg_string_set(ctx, &pService->lpq_command, "lpstat -o%p");
+ lpcfg_string_set(ctx, &pService->lprm_command, "cancel %p-%j");
+ lpcfg_string_set(ctx, &pService->print_command, "lp -c -d%p %s; rm %s");
+ lpcfg_string_set(ctx, &pService->queuepause_command, "disable %p");
+ lpcfg_string_set(ctx, &pService->queueresume_command, "enable %p");
+#ifndef HPUX
+ lpcfg_string_set(ctx, &pService->lppause_command, "lp -i %p-%j -H hold");
+ lpcfg_string_set(ctx, &pService->lpresume_command, "lp -i %p-%j -H resume");
+#endif /* HPUX */
+ break;
+
+ case PRINT_QNX:
+ lpcfg_string_set(ctx, &pService->lpq_command, "lpq -P%p");
+ lpcfg_string_set(ctx, &pService->lprm_command, "lprm -P%p %j");
+ lpcfg_string_set(ctx, &pService->print_command, "lp -r -P%p %s");
+ break;
+
+#if defined(DEVELOPER) || defined(ENABLE_SELFTEST)
+
+ case PRINT_TEST:
+ case PRINT_VLP: {
+ const char *tdbfile;
+ TALLOC_CTX *tmp_ctx = talloc_new(ctx);
+ const char *tmp;
+
+ tmp = lpcfg_parm_string(lp_ctx, NULL, "vlp", "tdbfile");
+ if (tmp == NULL) {
+ tmp = "/tmp/vlp.tdb";
+ }
+
+ tdbfile = talloc_asprintf(tmp_ctx, "tdbfile=%s", tmp);
+ if (tdbfile == NULL) {
+ tdbfile="tdbfile=/tmp/vlp.tdb";
+ }
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s print %%p %%s",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->print_command,
+ tmp ? tmp : "vlp print %p %s");
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s lpq %%p",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->lpq_command,
+ tmp ? tmp : "vlp lpq %p");
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s lprm %%p %%j",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->lprm_command,
+ tmp ? tmp : "vlp lprm %p %j");
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s lppause %%p %%j",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->lppause_command,
+ tmp ? tmp : "vlp lppause %p %j");
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s lpresume %%p %%j",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->lpresume_command,
+ tmp ? tmp : "vlp lpresume %p %j");
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s queuepause %%p",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->queuepause_command,
+ tmp ? tmp : "vlp queuepause %p");
+
+ tmp = talloc_asprintf(tmp_ctx, "vlp %s queueresume %%p",
+ tdbfile);
+ lpcfg_string_set(ctx, &pService->queueresume_command,
+ tmp ? tmp : "vlp queueresume %p");
+ TALLOC_FREE(tmp_ctx);
+
+ break;
+ }
+#endif /* DEVELOPER */
+
+ }
+}
/**
* Unload unused services.
lpcfg_do_global_parameter(lp_ctx, "winbind reconnect delay", "30");
+ lpcfg_do_global_parameter(lp_ctx, "winbind request timeout", "60");
+
lpcfg_do_global_parameter(lp_ctx, "nt acl support", "yes");
lpcfg_do_global_parameter(lp_ctx, "acl check permissions", "yes");
return;
}
- dump_globals(lp_ctx, f, show_defaults);
+ lpcfg_dump_globals(lp_ctx, f, show_defaults);
lpcfg_dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f, lp_ctx->flags, show_defaults);
git.samba.org / sfrench / samba-autobuild / .git / blobdiff