Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source4/param/loadparm.c

    r414 r740  
    6262#include "libcli/raw/signing.h"
    6363#include "../lib/util/dlinklist.h"
     64#include "../lib/util/parmlist.h"
    6465#include "param/param.h"
    6566#include "param/loadparm.h"
    … …  
    8081{
    8182        enum server_role server_role;
     83        enum sid_generator sid_generator;
    8284
    8385        const char **smb_ports;
    … …  
    8991        char *szModulesDir;
    9092        char *szPidDir;
    91         char *szSetupDir;
    9293        char *szServerString;
    9394        char *szAutoServices;
    … …  
    104105        char *szSocketOptions;
    105106        char *szRealm;
     107        char *szRealm_upper;
     108        char *szRealm_lower;
    106109        const char **szWINSservers;
    107110        const char **szInterfaces;
    … …  
    124127        int bWinbindSealedPipes;
    125128        int bIdmapTrustedOnly;
    126         char *swat_directory;
    127129        int tls_enabled;
    128130        char *tls_keyfile;
    … …  
    132134        char *tls_dhpfile;
    133135        char *logfile;
     136        char *loglevel;
    134137        char *panic_action;
    135138        int max_mux;
    … …  
    183186        int bRpcBigEndian;
    184187        char *szNTPSignDSocketDirectory;
     188        const char **szRNDCCommand;
     189        const char **szDNSUpdateCommand;
     190        const char **szSPNUpdateCommand;
     191        const char **szNSUpdateCommand;
    185192        struct parmlist_entry *param_opt;
    186193};
    … …  
    235242static bool handle_include(struct loadparm_context *lp_ctx,
    236243                           const char *pszParmValue, char **ptr);
     244static bool handle_realm(struct loadparm_context *lp_ctx,
     245                         const char *pszParmValue, char **ptr);
    237246static bool handle_copy(struct loadparm_context *lp_ctx,
    238247                        const char *pszParmValue, char **ptr);
    … …  
    325334};
    326335
     336static const struct enum_list enum_sid_generator[] = {
     337        {SID_GENERATOR_INTERNAL, "internal"},
     338        {SID_GENERATOR_BACKEND, "backend"},
     339        {-1, NULL}
     340};
    327341
    328342#define GLOBAL_VAR(name) offsetof(struct loadparm_global, name)
    … …  
    331345static struct parm_struct parm_table[] = {
    332346        {"server role", P_ENUM, P_GLOBAL, GLOBAL_VAR(server_role), NULL, enum_server_role},
     347        {"sid generator", P_ENUM, P_GLOBAL, GLOBAL_VAR(sid_generator), NULL, enum_sid_generator},
    333348
    334349        {"dos charset", P_STRING, P_GLOBAL, GLOBAL_VAR(dos_charset), NULL, NULL},
    … …  
    340355        {"directory", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
    341356        {"workgroup", P_USTRING, P_GLOBAL, GLOBAL_VAR(szWorkgroup), NULL, NULL},
    342         {"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), NULL, NULL},
     357        {"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), handle_realm, NULL},
    343358        {"netbios name", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosName), NULL, NULL},
    344359        {"netbios aliases", P_LIST, P_GLOBAL, GLOBAL_VAR(szNetbiosAliases), NULL, NULL},
    … …  
    383398        {"hosts deny", P_LIST, P_LOCAL, LOCAL_VAR(szHostsdeny), NULL, NULL},
    384399
    385         {"log level", P_INTEGER, P_GLOBAL, GLOBAL_VAR(debuglevel), handle_debuglevel, NULL},
    386         {"debuglevel", P_INTEGER, P_GLOBAL, GLOBAL_VAR(debuglevel), handle_debuglevel, NULL},
     400        {"log level", P_STRING, P_GLOBAL, GLOBAL_VAR(loglevel), handle_debuglevel, NULL},
     401        {"debuglevel", P_STRING, P_GLOBAL, GLOBAL_VAR(loglevel), handle_debuglevel, NULL},
    387402        {"log file", P_STRING, P_GLOBAL, GLOBAL_VAR(logfile), handle_logfile, NULL},
    388403
    … …  
    400415        {"tls crlfile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_crlfile), NULL, NULL},
    401416        {"tls dh params file", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_dhpfile), NULL, NULL},
    402         {"swat directory", P_STRING, P_GLOBAL, GLOBAL_VAR(swat_directory), NULL, NULL},
    403417        {"large readwrite", P_BOOL, P_GLOBAL, GLOBAL_VAR(bLargeReadwrite), NULL, NULL},
    404418        {"server max protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(srv_maxprotocol), NULL, enum_protocol},
    … …  
    469483        {"modules dir", P_STRING, P_GLOBAL, GLOBAL_VAR(szModulesDir), NULL, NULL},
    470484        {"pid directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szPidDir), NULL, NULL},
    471         {"setup directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szSetupDir), NULL, NULL},
    472485
    473486        {"socket address", P_STRING, P_GLOBAL, GLOBAL_VAR(szSocketAddress), NULL, NULL},
    … …  
    492505
    493506        {"ntp signd socket directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szNTPSignDSocketDirectory), NULL, NULL },
     507        {"rndc command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szRNDCCommand), NULL, NULL },
     508        {"dns update command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szDNSUpdateCommand), NULL, NULL },
     509        {"spn update command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szSPNUpdateCommand), NULL, NULL },
     510        {"nsupdate command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szNSUpdateCommand), NULL, NULL },
    494511
    495512        {NULL, P_BOOL, P_NONE, 0, NULL, NULL}
    … …  
    503520        struct loadparm_service **services;
    504521        struct loadparm_service *sDefault;
     522        struct smb_iconv_convenience *iconv_convenience;
    505523        int iNumServices;
    506524        struct loadparm_service *currentService;
    … …  
    513531        } *file_lists;
    514532        unsigned int flags[NUMPARAMETERS];
    515         struct smb_iconv_convenience *iconv_convenience;
     533        bool loaded;
     534        bool refuse_free;
    516535};
    517536
    518537
    519 struct loadparm_service *lp_default_service(struct loadparm_context *lp_ctx)
     538struct loadparm_service *lpcfg_default_service(struct loadparm_context *lp_ctx)
    520539{
    521540        return lp_ctx->sDefault;
    … …  
    525544  return the parameter table
    526545*/
    527 struct parm_struct *lp_parm_table(void)
     546struct parm_struct *lpcfg_parm_table(void)
    528547{
    529548        return parm_table;
    … …  
    584603*/
    585604
     605/*
     606 * the creation of separate lpcfg_*() and lp_*() functions is to allow
     607 * for code compatibility between existing Samba4 and Samba3 code.
     608 */
     609
     610/* this global context supports the lp_*() function varients */
     611static struct loadparm_context *global_loadparm_context;
     612
     613#define lpcfg_default_service global_loadparm_context->sDefault
     614#define lpcfg_global_service(i) global_loadparm_context->services[i]
     615
    586616#define FN_GLOBAL_STRING(fn_name,var_name) \
    587  const char *fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_string(lp_ctx->globals->var_name) : "";}
     617 _PUBLIC_ const char *lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_string(lp_ctx->globals->var_name) : "";}
     618
    588619#define FN_GLOBAL_CONST_STRING(fn_name,var_name) \
    589  const char *fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_ctx->globals->var_name : "";}
     620 _PUBLIC_ const char *lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_ctx->globals->var_name : "";}
     621
    590622#define FN_GLOBAL_LIST(fn_name,var_name) \
    591  const char **fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;}
     623 _PUBLIC_ const char **lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;}
     624
    592625#define FN_GLOBAL_BOOL(fn_name,var_name) \
    593  bool fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;}
    594 #if 0 /* unused */
    595 #define FN_GLOBAL_CHAR(fn_name,ptr) \
    596  char fn_name(void) {return(*(char *)(ptr));}
    597 #endif
     626 _PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;}
     627
    598628#define FN_GLOBAL_INTEGER(fn_name,var_name) \
    599  int fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;}
     629 _PUBLIC_ int lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;}
    600630
    601631#define FN_LOCAL_STRING(fn_name,val) \
    602  const char *fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault->val)));}
     632 _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)));}
     633
    603634#define FN_LOCAL_LIST(fn_name,val) \
    604  const char **fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(const char **)(service != NULL && service->val != NULL? service->val : sDefault->val);}
     635 _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);}
     636
    605637#define FN_LOCAL_BOOL(fn_name,val) \
    606  bool fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
     638 _PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
     639
    607640#define FN_LOCAL_INTEGER(fn_name,val) \
    608  int fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
    609 
    610 _PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, server_role)
    611 _PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, smb_ports)
    612 _PUBLIC_ FN_GLOBAL_INTEGER(lp_nbt_port, nbt_port)
    613 _PUBLIC_ FN_GLOBAL_INTEGER(lp_dgram_port, dgram_port)
    614 _PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, cldap_port)
    615 _PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, krb5_port)
    616 _PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, kpasswd_port)
    617 _PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, web_port)
    618 _PUBLIC_ FN_GLOBAL_STRING(lp_swat_directory, swat_directory)
    619 _PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, tls_enabled)
    620 _PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, szShareBackend)
    621 _PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, szSAM_URL)
    622 _PUBLIC_ FN_GLOBAL_STRING(lp_idmap_url, szIDMAP_URL)
    623 _PUBLIC_ FN_GLOBAL_STRING(lp_secrets_url, szSECRETS_URL)
    624 _PUBLIC_ FN_GLOBAL_STRING(lp_spoolss_url, szSPOOLSS_URL)
    625 _PUBLIC_ FN_GLOBAL_STRING(lp_wins_config_url, szWINS_CONFIG_URL)
    626 _PUBLIC_ FN_GLOBAL_STRING(lp_wins_url, szWINS_URL)
    627 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbind_separator, szWinbindSeparator)
    628 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_socket_directory, szWinbinddSocketDirectory)
    629 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
    630 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_shell, szTemplateShell)
    631 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_homedir, szTemplateHomedir)
    632 _PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, bWinbindSealedPipes)
    633 _PUBLIC_ FN_GLOBAL_BOOL(lp_idmap_trusted_only, bIdmapTrustedOnly)
    634 _PUBLIC_ FN_GLOBAL_STRING(lp_private_dir, szPrivateDir)
    635 _PUBLIC_ FN_GLOBAL_STRING(lp_serverstring, szServerString)
    636 _PUBLIC_ FN_GLOBAL_STRING(lp_lockdir, szLockDir)
    637 _PUBLIC_ FN_GLOBAL_STRING(lp_modulesdir, szModulesDir)
    638 _PUBLIC_ FN_GLOBAL_STRING(lp_setupdir, szSetupDir)
    639 _PUBLIC_ FN_GLOBAL_STRING(lp_ncalrpc_dir, ncalrpc_dir)
    640 _PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, dos_charset)
    641 _PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, unix_charset)
    642 _PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, display_charset)
    643 _PUBLIC_ FN_GLOBAL_STRING(lp_piddir, szPidDir)
    644 _PUBLIC_ FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, dcerpc_ep_servers)
    645 _PUBLIC_ FN_GLOBAL_LIST(lp_server_services, server_services)
    646 _PUBLIC_ FN_GLOBAL_STRING(lp_ntptr_providor, ntptr_providor)
    647 _PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, szAutoServices)
    648 _PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, szPasswdChat)
    649 _PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, szPasswordServers)
    650 _PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, szNameResolveOrder)
    651 _PUBLIC_ FN_GLOBAL_STRING(lp_realm, szRealm)
    652 _PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, socket_options)
    653 _PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, szWorkgroup)
    654 _PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, szNetbiosName)
    655 _PUBLIC_ FN_GLOBAL_STRING(lp_netbios_scope, szNetbiosScope)
    656 _PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, szWINSservers)
    657 _PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, szInterfaces)
    658 _PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, szSocketAddress)
    659 _PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, szNetbiosAliases)
    660 
    661 _PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
    662 _PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, bWINSsupport)
    663 _PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, bWINSdnsProxy)
    664 _PUBLIC_ FN_GLOBAL_STRING(lp_wins_hook, szWINSHook)
    665 _PUBLIC_ FN_GLOBAL_BOOL(lp_local_master, bLocalMaster)
    666 _PUBLIC_ FN_GLOBAL_BOOL(lp_readraw, bReadRaw)
    667 _PUBLIC_ FN_GLOBAL_BOOL(lp_large_readwrite, bLargeReadwrite)
    668 _PUBLIC_ FN_GLOBAL_BOOL(lp_writeraw, bWriteRaw)
    669 _PUBLIC_ FN_GLOBAL_BOOL(lp_null_passwords, bNullPasswords)
    670 _PUBLIC_ FN_GLOBAL_BOOL(lp_obey_pam_restrictions, bObeyPamRestrictions)
    671 _PUBLIC_ FN_GLOBAL_BOOL(lp_encrypted_passwords, bEncryptPasswords)
    672 _PUBLIC_ FN_GLOBAL_BOOL(lp_time_server, bTimeServer)
    673 _PUBLIC_ FN_GLOBAL_BOOL(lp_bind_interfaces_only, bBindInterfacesOnly)
    674 _PUBLIC_ FN_GLOBAL_BOOL(lp_unicode, bUnicode)
    675 _PUBLIC_ FN_GLOBAL_BOOL(lp_nt_status_support, bNTStatusSupport)
    676 _PUBLIC_ FN_GLOBAL_BOOL(lp_lanman_auth, bLanmanAuth)
    677 _PUBLIC_ FN_GLOBAL_BOOL(lp_ntlm_auth, bNTLMAuth)
    678 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_plaintext_auth, bClientPlaintextAuth)
    679 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_lanman_auth, bClientLanManAuth)
    680 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, bClientNTLMv2Auth)
    681 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_use_spnego_principal, client_use_spnego_principal)
    682 _PUBLIC_ FN_GLOBAL_BOOL(lp_host_msdfs, bHostMSDfs)
    683 _PUBLIC_ FN_GLOBAL_BOOL(lp_unix_extensions, bUnixExtensions)
    684 _PUBLIC_ FN_GLOBAL_BOOL(lp_use_spnego, bUseSpnego)
    685 _PUBLIC_ FN_GLOBAL_BOOL(lp_rpc_big_endian, bRpcBigEndian)
    686 _PUBLIC_ FN_GLOBAL_INTEGER(lp_max_wins_ttl, max_wins_ttl)
    687 _PUBLIC_ FN_GLOBAL_INTEGER(lp_min_wins_ttl, min_wins_ttl)
    688 _PUBLIC_ FN_GLOBAL_INTEGER(lp_maxmux, max_mux)
    689 _PUBLIC_ FN_GLOBAL_INTEGER(lp_max_xmit, max_xmit)
    690 _PUBLIC_ FN_GLOBAL_INTEGER(lp_passwordlevel, pwordlevel)
    691 _PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_maxprotocol, srv_maxprotocol)
    692 _PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_minprotocol, srv_minprotocol)
    693 _PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_maxprotocol, cli_maxprotocol)
    694 _PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, cli_minprotocol)
    695 _PUBLIC_ FN_GLOBAL_INTEGER(lp_security, security)
    696 _PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
    697 _PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, announce_as)
    698 const char *lp_servicename(const struct loadparm_service *service)
    699 {
    700         return lp_string((const char *)service->szService);
    701 }
    702 
    703 _PUBLIC_ FN_LOCAL_STRING(lp_pathname, szPath)
    704 static FN_LOCAL_STRING(_lp_printername, szPrintername)
    705 _PUBLIC_ FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
    706 _PUBLIC_ FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
    707 _PUBLIC_ FN_LOCAL_STRING(lp_comment, comment)
    708 _PUBLIC_ FN_LOCAL_STRING(lp_fstype, fstype)
    709 static FN_LOCAL_STRING(lp_volume, volume)
    710 _PUBLIC_ FN_LOCAL_LIST(lp_ntvfs_handler, ntvfs_handler)
    711 _PUBLIC_ FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
    712 _PUBLIC_ FN_LOCAL_BOOL(lp_browseable, bBrowseable)
    713 _PUBLIC_ FN_LOCAL_BOOL(lp_readonly, bRead_only)
    714 _PUBLIC_ FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
    715 _PUBLIC_ FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
    716 _PUBLIC_ FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
    717 _PUBLIC_ FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
    718 _PUBLIC_ FN_LOCAL_BOOL(lp_oplocks, bOplocks)
    719 _PUBLIC_ FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
    720 _PUBLIC_ FN_LOCAL_BOOL(lp_ci_filesystem, bCIFileSystem)
    721 _PUBLIC_ FN_LOCAL_BOOL(lp_map_system, bMap_system)
    722 _PUBLIC_ FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
    723 _PUBLIC_ FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
    724 _PUBLIC_ FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
    725 _PUBLIC_ FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
    726 _PUBLIC_ FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
    727 _PUBLIC_ FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
    728 _PUBLIC_ FN_GLOBAL_INTEGER(lp_server_signing, server_signing)
    729 _PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, client_signing)
    730 
    731 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_ntp_signd_socket_directory, szNTPSignDSocketDirectory)
     641 _PUBLIC_ int lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
     642
     643FN_GLOBAL_INTEGER(server_role, server_role)
     644FN_GLOBAL_INTEGER(sid_generator, sid_generator)
     645FN_GLOBAL_LIST(smb_ports, smb_ports)
     646FN_GLOBAL_INTEGER(nbt_port, nbt_port)
     647FN_GLOBAL_INTEGER(dgram_port, dgram_port)
     648FN_GLOBAL_INTEGER(cldap_port, cldap_port)
     649FN_GLOBAL_INTEGER(krb5_port, krb5_port)
     650FN_GLOBAL_INTEGER(kpasswd_port, kpasswd_port)
     651FN_GLOBAL_INTEGER(web_port, web_port)
     652FN_GLOBAL_BOOL(tls_enabled, tls_enabled)
     653FN_GLOBAL_STRING(share_backend, szShareBackend)
     654FN_GLOBAL_STRING(sam_url, szSAM_URL)
     655FN_GLOBAL_STRING(idmap_url, szIDMAP_URL)
     656FN_GLOBAL_STRING(secrets_url, szSECRETS_URL)
     657FN_GLOBAL_STRING(spoolss_url, szSPOOLSS_URL)
     658FN_GLOBAL_STRING(wins_config_url, szWINS_CONFIG_URL)
     659FN_GLOBAL_STRING(wins_url, szWINS_URL)
     660FN_GLOBAL_CONST_STRING(winbind_separator, szWinbindSeparator)
     661FN_GLOBAL_CONST_STRING(winbindd_socket_directory, szWinbinddSocketDirectory)
     662FN_GLOBAL_CONST_STRING(winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
     663FN_GLOBAL_CONST_STRING(template_shell, szTemplateShell)
     664FN_GLOBAL_CONST_STRING(template_homedir, szTemplateHomedir)
     665FN_GLOBAL_BOOL(winbind_sealed_pipes, bWinbindSealedPipes)
     666FN_GLOBAL_BOOL(idmap_trusted_only, bIdmapTrustedOnly)
     667FN_GLOBAL_STRING(private_dir, szPrivateDir)
     668FN_GLOBAL_STRING(serverstring, szServerString)
     669FN_GLOBAL_STRING(lockdir, szLockDir)
     670FN_GLOBAL_STRING(modulesdir, szModulesDir)
     671FN_GLOBAL_STRING(ncalrpc_dir, ncalrpc_dir)
     672FN_GLOBAL_STRING(dos_charset, dos_charset)
     673FN_GLOBAL_STRING(unix_charset, unix_charset)
     674FN_GLOBAL_STRING(display_charset, display_charset)
     675FN_GLOBAL_STRING(piddir, szPidDir)
     676FN_GLOBAL_LIST(rndc_command, szRNDCCommand)
     677FN_GLOBAL_LIST(dns_update_command, szDNSUpdateCommand)
     678FN_GLOBAL_LIST(spn_update_command, szSPNUpdateCommand)
     679FN_GLOBAL_LIST(nsupdate_command, szNSUpdateCommand)
     680FN_GLOBAL_LIST(dcerpc_endpoint_servers, dcerpc_ep_servers)
     681FN_GLOBAL_LIST(server_services, server_services)
     682FN_GLOBAL_STRING(ntptr_providor, ntptr_providor)
     683FN_GLOBAL_STRING(auto_services, szAutoServices)
     684FN_GLOBAL_STRING(passwd_chat, szPasswdChat)
     685FN_GLOBAL_LIST(passwordserver, szPasswordServers)
     686FN_GLOBAL_LIST(name_resolve_order, szNameResolveOrder)
     687FN_GLOBAL_STRING(realm, szRealm_upper)
     688FN_GLOBAL_STRING(dnsdomain, szRealm_lower)
     689FN_GLOBAL_STRING(socket_options, socket_options)
     690FN_GLOBAL_STRING(workgroup, szWorkgroup)
     691FN_GLOBAL_STRING(netbios_name, szNetbiosName)
     692FN_GLOBAL_STRING(netbios_scope, szNetbiosScope)
     693FN_GLOBAL_LIST(wins_server_list, szWINSservers)
     694FN_GLOBAL_LIST(interfaces, szInterfaces)
     695FN_GLOBAL_STRING(socket_address, szSocketAddress)
     696FN_GLOBAL_LIST(netbios_aliases, szNetbiosAliases)
     697FN_GLOBAL_BOOL(disable_netbios, bDisableNetbios)
     698FN_GLOBAL_BOOL(wins_support, bWINSsupport)
     699FN_GLOBAL_BOOL(wins_dns_proxy, bWINSdnsProxy)
     700FN_GLOBAL_STRING(wins_hook, szWINSHook)
     701FN_GLOBAL_BOOL(local_master, bLocalMaster)
     702FN_GLOBAL_BOOL(readraw, bReadRaw)
     703FN_GLOBAL_BOOL(large_readwrite, bLargeReadwrite)
     704FN_GLOBAL_BOOL(writeraw, bWriteRaw)
     705FN_GLOBAL_BOOL(null_passwords, bNullPasswords)
     706FN_GLOBAL_BOOL(obey_pam_restrictions, bObeyPamRestrictions)
     707FN_GLOBAL_BOOL(encrypted_passwords, bEncryptPasswords)
     708FN_GLOBAL_BOOL(time_server, bTimeServer)
     709FN_GLOBAL_BOOL(bind_interfaces_only, bBindInterfacesOnly)
     710FN_GLOBAL_BOOL(unicode, bUnicode)
     711FN_GLOBAL_BOOL(nt_status_support, bNTStatusSupport)
     712FN_GLOBAL_BOOL(lanman_auth, bLanmanAuth)
     713FN_GLOBAL_BOOL(ntlm_auth, bNTLMAuth)
     714FN_GLOBAL_BOOL(client_plaintext_auth, bClientPlaintextAuth)
     715FN_GLOBAL_BOOL(client_lanman_auth, bClientLanManAuth)
     716FN_GLOBAL_BOOL(client_ntlmv2_auth, bClientNTLMv2Auth)
     717FN_GLOBAL_BOOL(client_use_spnego_principal, client_use_spnego_principal)
     718FN_GLOBAL_BOOL(host_msdfs, bHostMSDfs)
     719FN_GLOBAL_BOOL(unix_extensions, bUnixExtensions)
     720FN_GLOBAL_BOOL(use_spnego, bUseSpnego)
     721FN_GLOBAL_BOOL(rpc_big_endian, bRpcBigEndian)
     722FN_GLOBAL_INTEGER(max_wins_ttl, max_wins_ttl)
     723FN_GLOBAL_INTEGER(min_wins_ttl, min_wins_ttl)
     724FN_GLOBAL_INTEGER(maxmux, max_mux)
     725FN_GLOBAL_INTEGER(max_xmit, max_xmit)
     726FN_GLOBAL_INTEGER(passwordlevel, pwordlevel)
     727FN_GLOBAL_INTEGER(srv_maxprotocol, srv_maxprotocol)
     728FN_GLOBAL_INTEGER(srv_minprotocol, srv_minprotocol)
     729FN_GLOBAL_INTEGER(cli_maxprotocol, cli_maxprotocol)
     730FN_GLOBAL_INTEGER(cli_minprotocol, cli_minprotocol)
     731FN_GLOBAL_INTEGER(security, security)
     732FN_GLOBAL_BOOL(paranoid_server_security, paranoid_server_security)
     733FN_GLOBAL_INTEGER(announce_as, announce_as)
     734
     735FN_LOCAL_STRING(pathname, szPath)
     736FN_LOCAL_LIST(hostsallow, szHostsallow)
     737FN_LOCAL_LIST(hostsdeny, szHostsdeny)
     738FN_LOCAL_STRING(comment, comment)
     739FN_LOCAL_STRING(fstype, fstype)
     740FN_LOCAL_LIST(ntvfs_handler, ntvfs_handler)
     741FN_LOCAL_BOOL(msdfs_root, bMSDfsRoot)
     742FN_LOCAL_BOOL(browseable, bBrowseable)
     743FN_LOCAL_BOOL(readonly, bRead_only)
     744FN_LOCAL_BOOL(print_ok, bPrint_ok)
     745FN_LOCAL_BOOL(map_hidden, bMap_hidden)
     746FN_LOCAL_BOOL(map_archive, bMap_archive)
     747FN_LOCAL_BOOL(strict_locking, bStrictLocking)
     748FN_LOCAL_BOOL(oplocks, bOplocks)
     749FN_LOCAL_BOOL(strict_sync, bStrictSync)
     750FN_LOCAL_BOOL(ci_filesystem, bCIFileSystem)
     751FN_LOCAL_BOOL(map_system, bMap_system)
     752FN_LOCAL_INTEGER(max_connections, iMaxConnections)
     753FN_LOCAL_INTEGER(csc_policy, iCSCPolicy)
     754FN_LOCAL_INTEGER(create_mask, iCreate_mask)
     755FN_LOCAL_INTEGER(force_create_mode, iCreate_force_mode)
     756FN_LOCAL_INTEGER(dir_mask, iDir_mask)
     757FN_LOCAL_INTEGER(force_dir_mode, iDir_force_mode)
     758FN_GLOBAL_INTEGER(server_signing, server_signing)
     759FN_GLOBAL_INTEGER(client_signing, client_signing)
     760
     761FN_GLOBAL_CONST_STRING(ntp_signd_socket_directory, szNTPSignDSocketDirectory)
    732762
    733763/* local prototypes */
    734764static int map_parameter(const char *pszParmName);
    735 static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx, 
     765static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
    736766                                        const char *pszServiceName);
    737767static void copy_service(struct loadparm_service *pserviceDest,
    … …  
    745775/* It returns a pointer to parametrical option value if it exists or NULL otherwise */
    746776/* Actual parametrical functions are quite simple */
    747 const char *lp_get_parametric(struct loadparm_context *lp_ctx,
     777const char *lpcfg_get_parametric(struct loadparm_context *lp_ctx,
    748778                              struct loadparm_service *service,
    749779                              const char *type, const char *option)
    750780{
    751         char *vfskey;
    752         struct parmlist_entry *data;
     781        char *vfskey = NULL;
     782        struct parmlist_entry *data;
    753783
    754784        if (lp_ctx == NULL)
    … …  
    758788
    759789        asprintf(&vfskey, "%s:%s", type, option);
     790        if (vfskey == NULL) return NULL;
    760791        strlower(vfskey);
    761792
    … …  
    855886 */
    856887
    857 const char *lp_parm_string(struct loadparm_context *lp_ctx,
    858                            struct loadparm_service *service, const char *type,
    859                            const char *option)
    860 {
    861         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     888const char *lpcfg_parm_string(struct loadparm_context *lp_ctx,
     889                              struct loadparm_service *service, const char *type,
     890                              const char *option)
     891{
     892        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    862893
    863894        if (value)
    … …  
    873904 */
    874905
    875 const char **lp_parm_string_list(TALLOC_CTX *mem_ctx,
    876                                  struct loadparm_context *lp_ctx,
    877                                  struct loadparm_service *service,
    878                                  const char *type,
    879                                  const char *option, const char *separator)
    880 {
    881         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     906const char **lpcfg_parm_string_list(TALLOC_CTX *mem_ctx,
     907                                    struct loadparm_context *lp_ctx,
     908                                    struct loadparm_service *service,
     909                                    const char *type,
     910                                    const char *option, const char *separator)
     911{
     912        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    882913
    883914        if (value != NULL)
    … …  
    892923 */
    893924
    894 int lp_parm_int(struct loadparm_context *lp_ctx,
    895                 struct loadparm_service *service, const char *type,
    896                 const char *option, int default_v)
    897 {
    898         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     925int lpcfg_parm_int(struct loadparm_context *lp_ctx,
     926                   struct loadparm_service *service, const char *type,
     927                   const char *option, int default_v)
     928{
     929        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    899930
    900931        if (value)
    … …  
    910941 */
    911942
    912 int lp_parm_bytes(struct loadparm_context *lp_ctx,
     943int lpcfg_parm_bytes(struct loadparm_context *lp_ctx,
    913944                  struct loadparm_service *service, const char *type,
    914945                  const char *option, int default_v)
    … …  
    916947        uint64_t bval;
    917948
    918         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     949        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    919950
    920951        if (value && conv_str_size(value, &bval)) {
    … …  
    932963 * Parametric option has following syntax: 'Type: option = value'
    933964 */
    934 unsigned long lp_parm_ulong(struct loadparm_context *lp_ctx,
     965unsigned long lpcfg_parm_ulong(struct loadparm_context *lp_ctx,
    935966                            struct loadparm_service *service, const char *type,
    936967                            const char *option, unsigned long default_v)
    937968{
    938         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     969        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    939970
    940971        if (value)
    … …  
    945976
    946977
    947 double lp_parm_double(struct loadparm_context *lp_ctx,
     978double lpcfg_parm_double(struct loadparm_context *lp_ctx,
    948979                      struct loadparm_service *service, const char *type,
    949980                      const char *option, double default_v)
    950981{
    951         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     982        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    952983
    953984        if (value != NULL)
    … …  
    962993 */
    963994
    964 bool lp_parm_bool(struct loadparm_context *lp_ctx,
    965                   struct loadparm_service *service, const char *type,
    966                   const char *option, bool default_v)
    967 {
    968         const char *value = lp_get_parametric(lp_ctx, service, type, option);
     995bool lpcfg_parm_bool(struct loadparm_context *lp_ctx,
     996                     struct loadparm_service *service, const char *type,
     997                     const char *option, bool default_v)
     998{
     999        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
    9691000
    9701001        if (value != NULL)
    … …  
    10141045 */
    10151046
    1016 struct loadparm_service *lp_add_service(struct loadparm_context *lp_ctx,
    1017                                      const struct loadparm_service *pservice,
    1018                                      const char *name)
     1047struct loadparm_service *lpcfg_add_service(struct loadparm_context *lp_ctx,
     1048                                           const struct loadparm_service *pservice,
     1049                                           const char *name)
    10191050{
    10201051        int i;
    … …  
    10221053        int num_to_alloc = lp_ctx->iNumServices + 1;
    10231054        struct parmlist_entry *data, *pdata;
     1055
     1056        if (pservice == NULL) {
     1057                pservice = lp_ctx->sDefault;
     1058        }
    10241059
    10251060        tservice = *pservice;
    … …  
    10551090
    10561091                if (!tsp) {
    1057                         DEBUG(0,("lp_add_service: failed to enlarge services!\n"));
     1092                        DEBUG(0,("lpcfg_add_service: failed to enlarge services!\n"));
    10581093                        return NULL;
    10591094                } else {
    … …  
    10671102        lp_ctx->services[i] = init_service(lp_ctx->services, lp_ctx->sDefault);
    10681103        if (lp_ctx->services[i] == NULL) {
    1069                 DEBUG(0,("lp_add_service: out of memory!\n"));
     1104                DEBUG(0,("lpcfg_add_service: out of memory!\n"));
    10701105                return NULL;
    10711106        }
    … …  
    10811116 */
    10821117
    1083 bool lp_add_home(struct loadparm_context *lp_ctx,
     1118bool lpcfg_add_home(struct loadparm_context *lp_ctx,
    10841119                 const char *pszHomename,
    10851120                 struct loadparm_service *default_service,
    … …  
    10881123        struct loadparm_service *service;
    10891124
    1090         service = lp_add_service(lp_ctx, default_service, pszHomename);
     1125        service = lpcfg_add_service(lp_ctx, default_service, pszHomename);
    10911126
    10921127        if (service == NULL)
    … …  
    10971132                service->szPath = talloc_strdup(service, pszHomedir);
    10981133        } else {
    1099                 service->szPath = string_sub_talloc(service, lp_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir);
     1134                service->szPath = string_sub_talloc(service, lpcfg_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir);
    11001135        }
    11011136
    … …  
    11081143        DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n",
    11091144                  pszHomename, user, service->szPath));
    1110 
    1111         return true;
    1112 }
    1113 
    1114 /**
    1115  * Add the IPC service.
    1116  */
    1117 
    1118 static bool lp_add_hidden(struct loadparm_context *lp_ctx, const char *name,
    1119                           const char *fstype)
    1120 {
    1121         struct loadparm_service *service = lp_add_service(lp_ctx, lp_ctx->sDefault, name);
    1122 
    1123         if (service == NULL)
    1124                 return false;
    1125 
    1126         string_set(service, &service->szPath, tmpdir());
    1127 
    1128         service->comment = talloc_asprintf(service, "%s Service (%s)",
    1129                                 fstype, lp_ctx->globals->szServerString);
    1130         string_set(service, &service->fstype, fstype);
    1131         service->iMaxConnections = -1;
    1132         service->bAvailable = true;
    1133         service->bRead_only = true;
    1134         service->bPrint_ok = false;
    1135         service->bBrowseable = false;
    1136 
    1137         if (strcasecmp(fstype, "IPC") == 0) {
    1138                 lp_do_service_parameter(lp_ctx, service, "ntvfs handler",
    1139                                         "default");
    1140         }
    1141 
    1142         DEBUG(3, ("adding hidden service %s\n", name));
    11431145
    11441146        return true;
    … …  
    11551157        const char *comment = "From Printcap";
    11561158        struct loadparm_service *service;
    1157         service = lp_add_service(lp_ctx, default_service, pszPrintername);
     1159        service = lpcfg_add_service(lp_ctx, default_service, pszPrintername);
    11581160
    11591161        if (service == NULL)
    … …  
    12081210  return the parameter structure for a parameter
    12091211*/
    1210 struct parm_struct *lp_parm_struct(const char *name)
     1212struct parm_struct *lpcfg_parm_struct(const char *name)
    12111213{
    12121214        int parmnum = map_parameter(name);
    … …  
    12181220  return the parameter pointer for a parameter
    12191221*/
    1220 void *lp_parm_ptr(struct loadparm_context *lp_ctx,
     1222void *lpcfg_parm_ptr(struct loadparm_context *lp_ctx,
    12211223                  struct loadparm_service *service, struct parm_struct *parm)
    12221224{
    … …  
    12361238 */
    12371239
    1238 static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx, 
     1240static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
    12391241                                        const char *pszServiceName)
    12401242{
    … …  
    13291331                }
    13301332                if (not_added) {
    1331                         paramo = talloc(pserviceDest, struct parmlist_entry);
     1333                        paramo = talloc_zero(pserviceDest, struct parmlist_entry);
    13321334                        if (paramo == NULL)
    13331335                                smb_panic("OOM");
    … …  
    14491451
    14501452/***************************************************************************
     1453 Handle the "realm" parameter
     1454***************************************************************************/
     1455
     1456static bool handle_realm(struct loadparm_context *lp_ctx,
     1457                         const char *pszParmValue, char **ptr)
     1458{
     1459        string_set(lp_ctx, ptr, pszParmValue);
     1460
     1461        talloc_free(lp_ctx->globals->szRealm_upper);
     1462        talloc_free(lp_ctx->globals->szRealm_lower);
     1463
     1464        lp_ctx->globals->szRealm_upper = strupper_talloc(lp_ctx, pszParmValue);
     1465        lp_ctx->globals->szRealm_lower = strlower_talloc(lp_ctx, pszParmValue);
     1466
     1467        return true;
     1468}
     1469
     1470/***************************************************************************
    14511471 Handle the include operation.
    14521472***************************************************************************/
    … …  
    15061526                        const char *pszParmValue, char **ptr)
    15071527{
    1508         DEBUGLEVEL = atoi(pszParmValue);
    1509 
    1510         return true;
     1528
     1529        string_set(lp_ctx, ptr, pszParmValue);
     1530        return debug_parse_levels(pszParmValue);
    15111531}
    15121532
    … …  
    15141534                        const char *pszParmValue, char **ptr)
    15151535{
    1516         logfile = pszParmValue;
     1536        debug_set_logfile(pszParmValue);
     1537        string_set(lp_ctx, ptr, pszParmValue);
    15171538        return true;
    15181539}
    … …  
    15841605        }
    15851606
    1586         paramo = talloc(mem_ctx, struct parmlist_entry);
     1607        paramo = talloc_zero(mem_ctx, struct parmlist_entry);
    15871608        if (!paramo)
    15881609                smb_panic("OOM");
    … …  
    16031624static bool set_variable(TALLOC_CTX *mem_ctx, int parmnum, void *parm_ptr,
    16041625                         const char *pszParmName, const char *pszParmValue,
    1605                          struct loadparm_context *lp_ctx)
     1626                         struct loadparm_context *lp_ctx, bool on_globals)
    16061627{
    16071628        int i;
    16081629        /* if it is a special case then go ahead */
    16091630        if (parm_table[parmnum].special) {
    1610                 parm_table[parmnum].special(lp_ctx, pszParmValue,
    1611                                             (char **)parm_ptr);
    1612                 return true;
     1631                bool ret;
     1632                ret = parm_table[parmnum].special(lp_ctx, pszParmValue,
     1633                                                  (char **)parm_ptr);
     1634                if (!ret) {
     1635                        return false;
     1636                }
     1637                goto mark_non_default;
    16131638        }
    16141639
    … …  
    16491674                }
    16501675
    1651                 case P_LIST:
     1676                case P_CMDLIST:
    16521677                        *(const char ***)parm_ptr = (const char **)str_list_make(mem_ctx,
    16531678                                                                  pszParmValue, NULL);
    16541679                        break;
    1655 
     1680                case P_LIST:
     1681                {
     1682                        char **new_list = str_list_make(mem_ctx,
     1683                                                        pszParmValue, NULL);
     1684                        for (i=0; new_list[i]; i++) {
     1685                                if (new_list[i][0] == '+' && new_list[i][1]) {
     1686                                        *(const char ***)parm_ptr = str_list_add(*(const char ***)parm_ptr,
     1687                                                                                 &new_list[i][1]);
     1688                                } else if (new_list[i][0] == '-' && new_list[i][1]) {
     1689                                        if (!str_list_check(*(const char ***)parm_ptr,
     1690                                                            &new_list[i][1])) {
     1691                                                DEBUG(0, ("Unsupported value for: %s = %s, %s is not in the original list\n",
     1692                                                          pszParmName, pszParmValue, new_list[i]));
     1693                                                return false;
     1694
     1695                                        }
     1696                                        str_list_remove(*(const char ***)parm_ptr,
     1697                                                        &new_list[i][1]);
     1698                                } else {
     1699                                        if (i != 0) {
     1700                                                DEBUG(0, ("Unsupported list syntax for: %s = %s\n",
     1701                                                          pszParmName, pszParmValue));
     1702                                                return false;
     1703                                        }
     1704                                        *(const char ***)parm_ptr = (const char **) new_list;
     1705                                        break;
     1706                                }
     1707                        }
     1708                        break;
     1709                }
    16561710                case P_STRING:
    16571711                        string_set(mem_ctx, (char **)parm_ptr, pszParmValue);
    … …  
    16821736        }
    16831737
    1684         if (lp_ctx->flags[parmnum] & FLAG_DEFAULT) {
     1738mark_non_default:
     1739        if (on_globals && (lp_ctx->flags[parmnum] & FLAG_DEFAULT)) {
    16851740                lp_ctx->flags[parmnum] &= ~FLAG_DEFAULT;
    16861741                /* we have to also unset FLAG_DEFAULT on aliases */
    … …  
    16961751
    16971752
    1698 bool lp_do_global_parameter(struct loadparm_context *lp_ctx,
    1699                             const char *pszParmName, const char *pszParmValue)
     1753bool lpcfg_do_global_parameter(struct loadparm_context *lp_ctx,
     1754                               const char *pszParmName, const char *pszParmValue)
    17001755{
    17011756        int parmnum = map_parameter(pszParmName);
    … …  
    17161771        }
    17171772
    1718         parm_ptr = lp_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
    1719 
    1720         return set_variable(lp_ctx, parmnum, parm_ptr,
    1721                             pszParmName, pszParmValue, lp_ctx);
    1722 }
    1723 
    1724 bool lp_do_service_parameter(struct loadparm_context *lp_ctx,
    1725                              struct loadparm_service *service,
    1726                              const char *pszParmName, const char *pszParmValue)
     1773        parm_ptr = lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
     1774
     1775        return set_variable(lp_ctx->globals, parmnum, parm_ptr,
     1776                            pszParmName, pszParmValue, lp_ctx, true);
     1777}
     1778
     1779bool lpcfg_do_service_parameter(struct loadparm_context *lp_ctx,
     1780                                struct loadparm_service *service,
     1781                                const char *pszParmName, const char *pszParmValue)
    17271782{
    17281783        void *parm_ptr;
    … …  
    17631818
    17641819        return set_variable(service, parmnum, parm_ptr, pszParmName,
    1765                             pszParmValue, lp_ctx);
     1820                            pszParmValue, lp_ctx, false);
    17661821}
    17671822
    … …  
    17761831
    17771832        if (lp_ctx->bInGlobalSection)
    1778                 return lp_do_global_parameter(lp_ctx, pszParmName,
     1833                return lpcfg_do_global_parameter(lp_ctx, pszParmName,
    17791834                                              pszParmValue);
    17801835        else
    1781                 return lp_do_service_parameter(lp_ctx, lp_ctx->currentService,
    1782                                                pszParmName, pszParmValue);
     1836                return lpcfg_do_service_parameter(lp_ctx, lp_ctx->currentService,
     1837                                                  pszParmName, pszParmValue);
    17831838}
    17841839
    … …  
    17861841  variable argument do parameter
    17871842*/
    1788 bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
    1789 bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx,
     1843bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
     1844bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx,
    17901845                                const char *pszParmName, const char *fmt, ...)
    17911846{
    … …  
    17971852        s = talloc_vasprintf(NULL, fmt, ap);
    17981853        va_end(ap);
    1799         ret = lp_do_global_parameter(lp_ctx, pszParmName, s);
     1854        ret = lpcfg_do_global_parameter(lp_ctx, pszParmName, s);
    18001855        talloc_free(s);
    18011856        return ret;
    … …  
    18081863  by smb.conf processing
    18091864*/
    1810 bool lp_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
    1811                     const char *pszParmValue)
     1865bool lpcfg_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
     1866                       const char *pszParmValue)
    18121867{
    18131868        int parmnum = map_parameter(pszParmName);
    … …  
    18311886        lp_ctx->flags[parmnum] &= ~FLAG_CMDLINE;
    18321887
    1833         if (!lp_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
     1888        if (!lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
    18341889                return false;
    18351890        }
    … …  
    18511906  set a option from the commandline in 'a=b' format. Use to support --option
    18521907*/
    1853 bool lp_set_option(struct loadparm_context *lp_ctx, const char *option)
     1908bool lpcfg_set_option(struct loadparm_context *lp_ctx, const char *option)
    18541909{
    18551910        char *p, *s;
    … …  
    18691924        *p = 0;
    18701925
    1871         ret = lp_set_cmdline(lp_ctx, s, p+1);
     1926        ret = lpcfg_set_cmdline(lp_ctx, s, p+1);
    18721927        free(s);
    18731928        return ret;
    … …  
    18841939{
    18851940        int i;
     1941        const char *list_sep = ", "; /* For the seperation of lists values that we print below */
    18861942        switch (p->type)
    18871943        {
    … …  
    19091965                        break;
    19101966
     1967                case P_CMDLIST:
     1968                        list_sep = " ";
     1969                        /* fall through */
    19111970                case P_LIST:
    19121971                        if ((char ***)ptr && *(char ***)ptr) {
    19131972                                char **list = *(char ***)ptr;
    19141973
    1915                                 for (; *list; list++)
    1916                                         fprintf(f, "%s%s", *list,
    1917                                                 ((*(list+1))?", ":""));
     1974                                for (; *list; list++) {
     1975                                        if (*(list+1) == NULL) {
     1976                                                /* last item, print no extra seperator after */
     1977                                                list_sep = "";
     1978                                        }
     1979                                        fprintf(f, "%s%s", *list, list_sep);
     1980                                }
    19181981                        }
    19191982                        break;
    … …  
    19442007                        return (*((int *)ptr1) == *((int *)ptr2));
    19452008
     2009                case P_CMDLIST:
    19462010                case P_LIST:
    19472011                        return str_list_equal((const char **)(*(char ***)ptr1),
    … …  
    19992063                DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
    20002064
    2001                 if ((lp_ctx->currentService = lp_add_service(lp_ctx, lp_ctx->sDefault,
    2002                                                              pszSectionName))
     2065                if ((lp_ctx->currentService = lpcfg_add_service(lp_ctx, lp_ctx->sDefault,
     2066                                                                   pszSectionName))
    20032067                    == NULL) {
    20042068                        DEBUG(0, ("Failed to add a new service\n"));
    … …  
    20212085                return false;
    20222086        switch (parm_table[i].type) {
     2087                case P_CMDLIST:
    20232088                case P_LIST:
    20242089                        return str_list_equal((const char **)parm_table[i].def.lvalue,
    … …  
    20572122                    parm_table[i].offset != -1 &&
    20582123                    (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
    2059                         if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT)) 
     2124                        if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT))
    20602125                                continue;
    20612126                        fprintf(f, "\t%s = ", parm_table[i].label);
    2062                         print_parameter(&parm_table[i], lp_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
     2127                        print_parameter(&parm_table[i], lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
    20632128                        fprintf(f, "\n");
    20642129        }
    … …  
    20662131                for (data = lp_ctx->globals->param_opt; data;
    20672132                     data = data->next) {
     2133                        if (!show_defaults && (data->priority & FLAG_DEFAULT)) {
     2134                                continue;
     2135                        }
    20682136                        fprintf(f, "\t%s = %s\n", data->key, data->value);
    20692137                }
    … …  
    20762144 */
    20772145
    2078 static void dump_a_service(struct loadparm_service * pService, struct loadparm_service *sDefault, FILE * f)
     2146static void dump_a_service(struct loadparm_service * pService, struct loadparm_service *sDefault, FILE * f,
     2147                           unsigned int *flags)
    20792148{
    20802149        int i;
    … …  
    20912160                {
    20922161                        if (pService == sDefault) {
    2093                                 if (defaults_saved && is_default(sDefault, i))
     2162                                if (flags && (flags[i] & FLAG_DEFAULT)) {
    20942163                                        continue;
     2164                                }
     2165                                if (defaults_saved) {
     2166                                        if (is_default(sDefault, i)) {
     2167                                                continue;
     2168                                        }
     2169                                }
    20952170                        } else {
    20962171                                if (equal_parameter(parm_table[i].type,
    … …  
    21152190}
    21162191
    2117 bool lp_dump_a_parameter(struct loadparm_context *lp_ctx,
    2118                          struct loadparm_service *service,
    2119                          const char *parm_name, FILE * f)
     2192bool lpcfg_dump_a_parameter(struct loadparm_context *lp_ctx,
     2193                            struct loadparm_service *service,
     2194                            const char *parm_name, FILE * f)
    21202195{
    21212196        struct parm_struct *parm;
    21222197        void *ptr;
    21232198
    2124         parm = lp_parm_struct(parm_name);
     2199        parm = lpcfg_parm_struct(parm_name);
    21252200        if (!parm) {
    21262201                return false;
    21272202        }
    21282203
    2129         ptr = lp_parm_ptr(lp_ctx, service,parm);
     2204        ptr = lpcfg_parm_ptr(lp_ctx, service,parm);
    21302205
    21312206        print_parameter(parm, ptr, f);
    … …  
    21402215 */
    21412216
    2142 struct parm_struct *lp_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
    2143                                       int allparameters)
     2217
     2218struct parm_struct *lpcfg_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
     2219                                         int allparameters)
    21442220{
    21452221        if (snum == -1) {
    … …  
    21882264 * Auto-load some home services.
    21892265 */
    2190 static void lp_add_auto_services(struct loadparm_context *lp_ctx,
    2191                                  const char *str)
     2266static void lpcfg_add_auto_services(struct loadparm_context *lp_ctx,
     2267                                    const char *str)
    21922268{
    21932269        return;
    … …  
    22192295{
    22202296        struct parmlist_entry *data;
     2297
     2298        if (lp_ctx->refuse_free) {
     2299                /* someone is trying to free the
     2300                   global_loadparm_context.
     2301                   We can't allow that. */
     2302                return -1;
     2303        }
    22212304
    22222305        if (lp_ctx->globals->param_opt != NULL) {
    … …  
    22352318/**
    22362319 * Initialise the global parameter structure.
     2320 *
     2321 * Note that most callers should use loadparm_init_global() instead
    22372322 */
    22382323struct loadparm_context *loadparm_init(TALLOC_CTX *mem_ctx)
    … …  
    22412326        char *myname;
    22422327        struct loadparm_context *lp_ctx;
     2328        struct parmlist_entry *parm;
    22432329
    22442330        lp_ctx = talloc_zero(mem_ctx, struct loadparm_context);
    … …  
    22802366        }
    22812367
    2282         lp_do_global_parameter(lp_ctx, "share backend", "classic");
    2283 
    2284         lp_do_global_parameter(lp_ctx, "server role", "standalone");
     2368
     2369        lpcfg_do_global_parameter(lp_ctx, "log level", "0");
     2370
     2371        lpcfg_do_global_parameter(lp_ctx, "share backend", "classic");
     2372
     2373        lpcfg_do_global_parameter(lp_ctx, "share backend", "classic");
     2374
     2375        lpcfg_do_global_parameter(lp_ctx, "server role", "standalone");
    22852376
    22862377        /* options that can be set on the command line must be initialised via
    2287            the slower lp_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
     2378           the slower lpcfg_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
    22882379#ifdef TCP_NODELAY
    2289         lp_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
     2380        lpcfg_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
    22902381#endif
    2291         lp_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
     2382        lpcfg_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
    22922383        myname = get_myname(lp_ctx);
    2293         lp_do_global_parameter(lp_ctx, "netbios name", myname);
     2384        lpcfg_do_global_parameter(lp_ctx, "netbios name", myname);
    22942385        talloc_free(myname);
    2295         lp_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
    2296 
    2297         lp_do_global_parameter(lp_ctx, "fstype", "NTFS");
    2298 
    2299         lp_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
    2300         lp_do_global_parameter(lp_ctx, "max connections", "-1");
    2301 
    2302         lp_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser");
    2303         lp_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd kcc");
    2304         lp_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
    2305         lp_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain");
    2306         lp_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
    2307         lp_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
    2308         lp_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
    2309         lp_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
    2310         lp_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
    2311         lp_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
    2312         lp_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
    2313         lp_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
    2314         lp_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
    2315         lp_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
     2386        lpcfg_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
     2387
     2388        lpcfg_do_global_parameter(lp_ctx, "fstype", "NTFS");
     2389
     2390        lpcfg_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
     2391        lpcfg_do_global_parameter(lp_ctx, "max connections", "-1");
     2392
     2393        lpcfg_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser eventlog6 backupkey");
     2394        lpcfg_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd kcc dnsupdate web");
     2395        lpcfg_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
     2396        /* the winbind method for domain controllers is for both RODC
     2397           auth forwarding and for trusted domains */
     2398        lpcfg_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain winbind");
     2399        lpcfg_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
     2400        lpcfg_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
     2401        lpcfg_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
     2402        lpcfg_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
     2403        lpcfg_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
     2404        lpcfg_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
     2405        lpcfg_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
     2406        lpcfg_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
     2407        lpcfg_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
     2408        lpcfg_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
    23162409
    23172410        /* This hive should be dynamically generated by Samba using
    23182411           data from the sam, but for the moment leave it in a tdb to
    23192412           keep regedt32 from popping up an annoying dialog. */
    2320         lp_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
     2413        lpcfg_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
    23212414
    23222415        /* using UTF8 by default allows us to support all chars */
    2323         lp_do_global_parameter(lp_ctx, "unix charset", "UTF8");
     2416        lpcfg_do_global_parameter(lp_ctx, "unix charset", "UTF8");
    23242417
    23252418        /* Use codepage 850 as a default for the dos character set */
    2326         lp_do_global_parameter(lp_ctx, "dos charset", "CP850");
     2419        lpcfg_do_global_parameter(lp_ctx, "dos charset", "CP850");
    23272420
    23282421        /*
    23292422         * Allow the default PASSWD_CHAT to be overridden in local.h.
    23302423         */
    2331         lp_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
    2332 
    2333         lp_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
    2334         lp_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
    2335         lp_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
    2336         lp_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
    2337 
    2338         lp_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
    2339         lp_do_global_parameter_var(lp_ctx, "server string",
     2424        lpcfg_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
     2425
     2426        lpcfg_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
     2427        lpcfg_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
     2428        lpcfg_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
     2429        lpcfg_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
     2430
     2431        lpcfg_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
     2432        lpcfg_do_global_parameter_var(lp_ctx, "server string",
    23402433                                   "Samba %s", SAMBA_VERSION_STRING);
    23412434
    2342         lp_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
     2435        lpcfg_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
    23432436                         DEFAULT_MAJOR_VERSION,
    23442437                         DEFAULT_MINOR_VERSION);
    23452438
    2346         lp_do_global_parameter(lp_ctx, "password server", "*");
    2347 
    2348         lp_do_global_parameter(lp_ctx, "max mux", "50");
    2349         lp_do_global_parameter(lp_ctx, "max xmit", "12288");
    2350         lp_do_global_parameter(lp_ctx, "password level", "0");
    2351         lp_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
    2352         lp_do_global_parameter(lp_ctx, "server min protocol", "CORE");
    2353         lp_do_global_parameter(lp_ctx, "server max protocol", "NT1");
    2354         lp_do_global_parameter(lp_ctx, "client min protocol", "CORE");
    2355         lp_do_global_parameter(lp_ctx, "client max protocol", "NT1");
    2356         lp_do_global_parameter(lp_ctx, "security", "USER");
    2357         lp_do_global_parameter(lp_ctx, "paranoid server security", "True");
    2358         lp_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
    2359         lp_do_global_parameter(lp_ctx, "ReadRaw", "True");
    2360         lp_do_global_parameter(lp_ctx, "WriteRaw", "True");
    2361         lp_do_global_parameter(lp_ctx, "NullPasswords", "False");
    2362         lp_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
    2363         lp_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
    2364 
    2365         lp_do_global_parameter(lp_ctx, "TimeServer", "False");
    2366         lp_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
    2367         lp_do_global_parameter(lp_ctx, "Unicode", "True");
    2368         lp_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
    2369         lp_do_global_parameter(lp_ctx, "LanmanAuth", "False");
    2370         lp_do_global_parameter(lp_ctx, "NTLMAuth", "True");
    2371         lp_do_global_parameter(lp_ctx, "client use spnego principal", "False");
    2372 
    2373         lp_do_global_parameter(lp_ctx, "UnixExtensions", "False");
    2374 
    2375         lp_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
    2376         lp_do_global_parameter(lp_ctx, "LocalMaster", "True");
    2377 
    2378         lp_do_global_parameter(lp_ctx, "wins support", "False");
    2379         lp_do_global_parameter(lp_ctx, "dns proxy", "True");
    2380 
    2381         lp_do_global_parameter(lp_ctx, "winbind separator", "\\");
    2382         lp_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
    2383         lp_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
    2384         lp_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
    2385         lp_do_global_parameter(lp_ctx, "template shell", "/bin/false");
    2386         lp_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
    2387         lp_do_global_parameter(lp_ctx, "idmap trusted only", "False");
    2388 
    2389         lp_do_global_parameter(lp_ctx, "client signing", "Yes");
    2390         lp_do_global_parameter(lp_ctx, "server signing", "auto");
    2391 
    2392         lp_do_global_parameter(lp_ctx, "use spnego", "True");
    2393 
    2394         lp_do_global_parameter(lp_ctx, "smb ports", "445 139");
    2395         lp_do_global_parameter(lp_ctx, "nbt port", "137");
    2396         lp_do_global_parameter(lp_ctx, "dgram port", "138");
    2397         lp_do_global_parameter(lp_ctx, "cldap port", "389");
    2398         lp_do_global_parameter(lp_ctx, "krb5 port", "88");
    2399         lp_do_global_parameter(lp_ctx, "kpasswd port", "464");
    2400         lp_do_global_parameter(lp_ctx, "web port", "901");
    2401         lp_do_global_parameter(lp_ctx, "swat directory", dyn_SWATDIR);
    2402 
    2403         lp_do_global_parameter(lp_ctx, "nt status support", "True");
    2404 
    2405         lp_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
    2406         lp_do_global_parameter(lp_ctx, "min wins ttl", "10");
    2407 
    2408         lp_do_global_parameter(lp_ctx, "tls enabled", "True");
    2409         lp_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
    2410         lp_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
    2411         lp_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
    2412         lp_do_global_parameter_var(lp_ctx, "setup directory", "%s",
    2413                                    dyn_SETUPDIR);
    2414 
    2415         lp_do_global_parameter(lp_ctx, "prefork children:smb", "4");
    2416 
    2417         lp_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
     2439        lpcfg_do_global_parameter(lp_ctx, "password server", "*");
     2440
     2441        lpcfg_do_global_parameter(lp_ctx, "max mux", "50");
     2442        lpcfg_do_global_parameter(lp_ctx, "max xmit", "12288");
     2443        lpcfg_do_global_parameter(lp_ctx, "password level", "0");
     2444        lpcfg_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
     2445        lpcfg_do_global_parameter(lp_ctx, "server min protocol", "CORE");
     2446        lpcfg_do_global_parameter(lp_ctx, "server max protocol", "NT1");
     2447        lpcfg_do_global_parameter(lp_ctx, "client min protocol", "CORE");
     2448        lpcfg_do_global_parameter(lp_ctx, "client max protocol", "NT1");
     2449        lpcfg_do_global_parameter(lp_ctx, "security", "USER");
     2450        lpcfg_do_global_parameter(lp_ctx, "paranoid server security", "True");
     2451        lpcfg_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
     2452        lpcfg_do_global_parameter(lp_ctx, "ReadRaw", "True");
     2453        lpcfg_do_global_parameter(lp_ctx, "WriteRaw", "True");
     2454        lpcfg_do_global_parameter(lp_ctx, "NullPasswords", "False");
     2455        lpcfg_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
     2456        lpcfg_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
     2457
     2458        lpcfg_do_global_parameter(lp_ctx, "TimeServer", "False");
     2459        lpcfg_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
     2460        lpcfg_do_global_parameter(lp_ctx, "Unicode", "True");
     2461        lpcfg_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
     2462        lpcfg_do_global_parameter(lp_ctx, "ClientNTLMv2Auth", "True");
     2463        lpcfg_do_global_parameter(lp_ctx, "LanmanAuth", "False");
     2464        lpcfg_do_global_parameter(lp_ctx, "NTLMAuth", "True");
     2465        lpcfg_do_global_parameter(lp_ctx, "client use spnego principal", "False");
     2466
     2467        lpcfg_do_global_parameter(lp_ctx, "UnixExtensions", "False");
     2468
     2469        lpcfg_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
     2470        lpcfg_do_global_parameter(lp_ctx, "LocalMaster", "True");
     2471
     2472        lpcfg_do_global_parameter(lp_ctx, "wins support", "False");
     2473        lpcfg_do_global_parameter(lp_ctx, "dns proxy", "True");
     2474
     2475        lpcfg_do_global_parameter(lp_ctx, "winbind separator", "\\");
     2476        lpcfg_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
     2477        lpcfg_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
     2478        lpcfg_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
     2479        lpcfg_do_global_parameter(lp_ctx, "template shell", "/bin/false");
     2480        lpcfg_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
     2481        lpcfg_do_global_parameter(lp_ctx, "idmap trusted only", "False");
     2482
     2483        lpcfg_do_global_parameter(lp_ctx, "client signing", "Yes");
     2484        lpcfg_do_global_parameter(lp_ctx, "server signing", "auto");
     2485
     2486        lpcfg_do_global_parameter(lp_ctx, "use spnego", "True");
     2487
     2488        lpcfg_do_global_parameter(lp_ctx, "smb ports", "445 139");
     2489        lpcfg_do_global_parameter(lp_ctx, "nbt port", "137");
     2490        lpcfg_do_global_parameter(lp_ctx, "dgram port", "138");
     2491        lpcfg_do_global_parameter(lp_ctx, "cldap port", "389");
     2492        lpcfg_do_global_parameter(lp_ctx, "krb5 port", "88");
     2493        lpcfg_do_global_parameter(lp_ctx, "kpasswd port", "464");
     2494        lpcfg_do_global_parameter(lp_ctx, "web port", "901");
     2495
     2496        lpcfg_do_global_parameter(lp_ctx, "nt status support", "True");
     2497
     2498        lpcfg_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
     2499        lpcfg_do_global_parameter(lp_ctx, "min wins ttl", "10");
     2500
     2501        lpcfg_do_global_parameter(lp_ctx, "tls enabled", "True");
     2502        lpcfg_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
     2503        lpcfg_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
     2504        lpcfg_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
     2505        lpcfg_do_global_parameter(lp_ctx, "prefork children:smb", "4");
     2506
     2507        lpcfg_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
     2508        lpcfg_do_global_parameter(lp_ctx, "rndc command", "/usr/sbin/rndc");
     2509        lpcfg_do_global_parameter_var(lp_ctx, "dns update command", "%s/samba_dnsupdate", dyn_SCRIPTSBINDIR);
     2510        lpcfg_do_global_parameter_var(lp_ctx, "spn update command", "%s/samba_spnupdate", dyn_SCRIPTSBINDIR);
     2511        lpcfg_do_global_parameter(lp_ctx, "nsupdate command", "/usr/bin/nsupdate -g");
    24182512
    24192513        for (i = 0; parm_table[i].label; i++) {
    … …  
    24232517        }
    24242518
     2519        for (parm=lp_ctx->globals->param_opt; parm; parm=parm->next) {
     2520                if (!(parm->priority & FLAG_CMDLINE)) {
     2521                        parm->priority |= FLAG_DEFAULT;
     2522                }
     2523        }
     2524
    24252525        return lp_ctx;
    24262526}
    24272527
    2428 const char *lp_configfile(struct loadparm_context *lp_ctx)
     2528/**
     2529 * Initialise the global parameter structure.
     2530 */
     2531struct loadparm_context *loadparm_init_global(bool load_default)
     2532{
     2533        if (global_loadparm_context == NULL) {
     2534                global_loadparm_context = loadparm_init(NULL);
     2535        }
     2536        if (load_default && !global_loadparm_context->loaded) {
     2537                lpcfg_load_default(global_loadparm_context);
     2538        }
     2539        global_loadparm_context->refuse_free = true;
     2540        return global_loadparm_context;
     2541}
     2542
     2543const char *lpcfg_configfile(struct loadparm_context *lp_ctx)
    24292544{
    24302545        return lp_ctx->szConfigFile;
    … …  
    24432558 * have changed.
    24442559 */
    2445 static bool lp_update(struct loadparm_context *lp_ctx)
    2446 {
    2447         lp_add_auto_services(lp_ctx, lp_auto_services(lp_ctx));
    2448 
    2449         lp_add_hidden(lp_ctx, "IPC$", "IPC");
    2450         lp_add_hidden(lp_ctx, "ADMIN$", "DISK");
     2560static bool lpcfg_update(struct loadparm_context *lp_ctx)
     2561{
     2562        struct debug_settings settings;
     2563        lpcfg_add_auto_services(lp_ctx, lpcfg_auto_services(lp_ctx));
    24512564
    24522565        if (!lp_ctx->globals->szWINSservers && lp_ctx->globals->bWINSsupport) {
    2453                 lp_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
     2566                lpcfg_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
    24542567        }
    24552568
    … …  
    24582571        reload_charcnv(lp_ctx);
    24592572
    2460         /* FIXME: ntstatus_check_dos_mapping = lp_nt_status_support(lp_ctx); */
     2573        ZERO_STRUCT(settings);
     2574        /* Add any more debug-related smb.conf parameters created in
     2575         * future here */
     2576        settings.timestamp_logs = true;
     2577        debug_set_settings(&settings);
     2578
     2579        /* FIXME: ntstatus_check_dos_mapping = lpcfg_nt_status_support(lp_ctx); */
    24612580
    24622581        /* FIXME: This is a bit of a hack, but we can't use a global, since
    24632582         * not everything that uses lp also uses the socket library */
    2464         if (lp_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
     2583        if (lpcfg_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
    24652584                setenv("SOCKET_TESTNONBLOCK", "1", 1);
    24662585        } else {
    … …  
    24692588
    24702589        /* FIXME: Check locale in environment for this: */
    2471         if (strcmp(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)) != 0)
    2472                 d_set_iconv(smb_iconv_open(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)));
     2590        if (strcmp(lpcfg_display_charset(lp_ctx), lpcfg_unix_charset(lp_ctx)) != 0)
     2591                d_set_iconv(smb_iconv_open(lpcfg_display_charset(lp_ctx), lpcfg_unix_charset(lp_ctx)));
    24732592        else
    24742593                d_set_iconv((smb_iconv_t)-1);
    … …  
    24772596}
    24782597
    2479 bool lp_load_default(struct loadparm_context *lp_ctx)
     2598bool lpcfg_load_default(struct loadparm_context *lp_ctx)
    24802599{
    24812600    const char *path;
    … …  
    24862605            /* We allow the default smb.conf file to not exist,
    24872606             * basically the equivalent of an empty file. */
    2488             return lp_update(lp_ctx);
     2607            return lpcfg_update(lp_ctx);
    24892608    }
    24902609
    2491     return lp_load(lp_ctx, path);
     2610    return lpcfg_load(lp_ctx, path);
    24922611}
    24932612
    … …  
    24972616 * Return True on success, False on failure.
    24982617 */
    2499 bool lp_load(struct loadparm_context *lp_ctx, const char *filename)
     2618bool lpcfg_load(struct loadparm_context *lp_ctx, const char *filename)
    25002619{
    25012620        char *n2;
    … …  
    25082627        lp_ctx->bInGlobalSection = true;
    25092628        n2 = standard_sub_basic(lp_ctx, lp_ctx->szConfigFile);
    2510         DEBUG(2, ("lp_load: refreshing parameters from %s\n", n2));
     2629        DEBUG(2, ("lpcfg_load: refreshing parameters from %s\n", n2));
    25112630
    25122631        add_to_file_list(lp_ctx, lp_ctx->szConfigFile, n2);
    … …  
    25222641                        bRetval = service_ok(lp_ctx->currentService);
    25232642
    2524         bRetval = bRetval && lp_update(lp_ctx);
     2643        bRetval = bRetval && lpcfg_update(lp_ctx);
     2644
     2645        /* we do this unconditionally, so that it happens even
     2646           for a missing smb.conf */
     2647        reload_charcnv(lp_ctx);
     2648
     2649        if (bRetval == true) {
     2650                /* set this up so that any child python tasks will
     2651                   find the right smb.conf */
     2652                setenv("SMB_CONF_PATH", filename, 1);
     2653
     2654                /* set the context used by the lp_*() function
     2655                   varients */
     2656                global_loadparm_context = lp_ctx;
     2657                lp_ctx->loaded = true;
     2658        }
    25252659
    25262660        return bRetval;
    … …  
    25312665 */
    25322666
    2533 int lp_numservices(struct loadparm_context *lp_ctx)
     2667int lpcfg_numservices(struct loadparm_context *lp_ctx)
    25342668{
    25352669        return lp_ctx->iNumServices;
    … …  
    25402674 */
    25412675
    2542 void lp_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
     2676void lpcfg_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
    25432677             int maxtoprint)
    25442678{
    25452679        int iService;
    25462680
    2547         if (show_defaults)
    2548                 defaults_saved = false;
     2681        defaults_saved = !show_defaults;
    25492682
    25502683        dump_globals(lp_ctx, f, show_defaults);
    25512684
    2552         dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f);
     2685        dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f, lp_ctx->flags);
    25532686
    25542687        for (iService = 0; iService < maxtoprint; iService++)
    2555                 lp_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
     2688                lpcfg_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
    25562689}
    25572690
    … …  
    25592692 * Display the contents of one service in human-readable form.
    25602693 */
    2561 void lp_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
     2694void lpcfg_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
    25622695{
    25632696        if (service != NULL) {
    25642697                if (service->szService[0] == '\0')
    25652698                        return;
    2566                 dump_a_service(service, sDefault, f);
    2567         }
    2568 }
    2569 
    2570 struct loadparm_service *lp_servicebynum(struct loadparm_context *lp_ctx,
     2699                dump_a_service(service, sDefault, f, NULL);
     2700        }
     2701}
     2702
     2703struct loadparm_service *lpcfg_servicebynum(struct loadparm_context *lp_ctx,
    25712704                                         int snum)
    25722705{
    … …  
    25742707}
    25752708
    2576 struct loadparm_service *lp_service(struct loadparm_context *lp_ctx,
     2709struct loadparm_service *lpcfg_service(struct loadparm_context *lp_ctx,
    25772710                                    const char *service_name)
    25782711{
    … …  
    25902723                                        lp_ctx->services[iService],
    25912724                                        lp_ctx->services[iService]->szService);
    2592                         if (strequal(serviceName, service_name))
     2725                        if (strequal(serviceName, service_name)) {
     2726                                talloc_free(serviceName);
    25932727                                return lp_ctx->services[iService];
    2594                 }
    2595         }
    2596 
    2597         DEBUG(7,("lp_servicenumber: couldn't find %s\n", service_name));
     2728                        }
     2729                        talloc_free(serviceName);
     2730                }
     2731        }
     2732
     2733        DEBUG(7,("lpcfg_servicenumber: couldn't find %s\n", service_name));
    25982734        return NULL;
    25992735}
    26002736
     2737const char *lpcfg_servicename(const struct loadparm_service *service)
     2738{
     2739        return lp_string((const char *)service->szService);
     2740}
    26012741
    26022742/**
    … …  
    26052745const char *volume_label(struct loadparm_service *service, struct loadparm_service *sDefault)
    26062746{
    2607         const char *ret = lp_volume(service, sDefault);
     2747        const char *ret;
     2748        ret = lp_string((const char *)((service != NULL && service->volume != NULL) ?
     2749                                       service->volume : sDefault->volume));
    26082750        if (!*ret)
    2609                 return lp_servicename(service);
     2751                return lpcfg_servicename(service);
    26102752        return ret;
    26112753}
    26122754
    2613 
    26142755/**
    26152756 * If we are PDC then prefer us as DMB
    26162757 */
    2617 const char *lp_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
    2618 {
    2619         const char *ret = _lp_printername(service, sDefault);
     2758const char *lpcfg_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
     2759{
     2760        const char *ret;
     2761        ret = lp_string((const char *)((service != NULL && service->szPrintername != NULL) ?
     2762                                       service->szPrintername : sDefault->szPrintername));
    26202763        if (ret == NULL || (ret != NULL && *ret == '\0'))
    2621                 ret = lp_servicename(service);
     2764                ret = lpcfg_servicename(service);
    26222765
    26232766        return ret;
    … …  
    26282771 * Return the max print jobs per queue.
    26292772 */
    2630 int lp_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
     2773int lpcfg_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
    26312774{
    26322775        int maxjobs = (service != NULL) ? service->iMaxPrintJobs : sDefault->iMaxPrintJobs;
    … …  
    26372780}
    26382781
    2639 struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx)
     2782struct smb_iconv_convenience *lpcfg_iconv_convenience(struct loadparm_context *lp_ctx)
    26402783{
    26412784        if (lp_ctx == NULL) {
    2642                 static struct smb_iconv_convenience *fallback_ic = NULL;
    2643                 if (fallback_ic == NULL)
    2644                         fallback_ic = smb_iconv_convenience_init(talloc_autofree_context(),
    2645                                                   "CP850", "UTF8", true);
    2646                 return fallback_ic;
     2785                return get_iconv_convenience();
    26472786        }
    26482787        return lp_ctx->iconv_convenience;
    … …  
    26512790_PUBLIC_ void reload_charcnv(struct loadparm_context *lp_ctx)
    26522791{
    2653         talloc_unlink(lp_ctx, lp_ctx->iconv_convenience);
    2654         global_iconv_convenience = lp_ctx->iconv_convenience = smb_iconv_convenience_init_lp(lp_ctx, lp_ctx);
    2655 }
    2656 
    2657 void lp_smbcli_options(struct loadparm_context *lp_ctx,
     2792        struct smb_iconv_convenience *old_ic = lp_ctx->iconv_convenience;
     2793        if (old_ic == NULL) {
     2794                old_ic = global_iconv_convenience;
     2795        }
     2796        lp_ctx->iconv_convenience = smb_iconv_convenience_reinit_lp(lp_ctx, lp_ctx, old_ic);
     2797        global_iconv_convenience = lp_ctx->iconv_convenience;
     2798}
     2799
     2800void lpcfg_smbcli_options(struct loadparm_context *lp_ctx,
    26582801                         struct smbcli_options *options)
    26592802{
    2660         options->max_xmit = lp_max_xmit(lp_ctx);
    2661         options->max_mux = lp_maxmux(lp_ctx);
    2662         options->use_spnego = lp_nt_status_support(lp_ctx) && lp_use_spnego(lp_ctx);
    2663         options->signing = lp_client_signing(lp_ctx);
     2803        options->max_xmit = lpcfg_max_xmit(lp_ctx);
     2804        options->max_mux = lpcfg_maxmux(lp_ctx);
     2805        options->use_spnego = lpcfg_nt_status_support(lp_ctx) && lpcfg_use_spnego(lp_ctx);
     2806        options->signing = lpcfg_client_signing(lp_ctx);
    26642807        options->request_timeout = SMB_REQUEST_TIMEOUT;
    2665         options->ntstatus_support = lp_nt_status_support(lp_ctx);
    2666         options->max_protocol = lp_cli_maxprotocol(lp_ctx);
    2667         options->unicode = lp_unicode(lp_ctx);
     2808        options->ntstatus_support = lpcfg_nt_status_support(lp_ctx);
     2809        options->max_protocol = lpcfg_cli_maxprotocol(lp_ctx);
     2810        options->unicode = lpcfg_unicode(lp_ctx);
    26682811        options->use_oplocks = true;
    26692812        options->use_level2_oplocks = true;
    26702813}
    26712814
    2672 void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
     2815void lpcfg_smbcli_session_options(struct loadparm_context *lp_ctx,
    26732816                                 struct smbcli_session_options *options)
    26742817{
    2675         options->lanman_auth = lp_client_lanman_auth(lp_ctx);
    2676         options->ntlmv2_auth = lp_client_ntlmv2_auth(lp_ctx);
    2677         options->plaintext_auth = lp_client_plaintext_auth(lp_ctx);
    2678 }
    2679 
    2680 _PUBLIC_ char *lp_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2818        options->lanman_auth = lpcfg_client_lanman_auth(lp_ctx);
     2819        options->ntlmv2_auth = lpcfg_client_ntlmv2_auth(lp_ctx);
     2820        options->plaintext_auth = lpcfg_client_plaintext_auth(lp_ctx);
     2821}
     2822
     2823_PUBLIC_ char *lpcfg_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    26812824{
    26822825        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_keyfile);
    26832826}
    26842827
    2685 _PUBLIC_ char *lp_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2828_PUBLIC_ char *lpcfg_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    26862829{
    26872830        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_certfile);
    26882831}
    26892832
    2690 _PUBLIC_ char *lp_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2833_PUBLIC_ char *lpcfg_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    26912834{
    26922835        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_cafile);
    26932836}
    26942837
    2695 _PUBLIC_ char *lp_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2838_PUBLIC_ char *lpcfg_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    26962839{
    26972840        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_crlfile);
    26982841}
    26992842
    2700 _PUBLIC_ char *lp_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2843_PUBLIC_ char *lpcfg_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    27012844{
    27022845        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_dhpfile);
    27032846}
    27042847
    2705 _PUBLIC_ struct dcerpc_server_info *lp_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2848_PUBLIC_ struct dcerpc_server_info *lpcfg_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    27062849{
    27072850        struct dcerpc_server_info *ret = talloc_zero(mem_ctx, struct dcerpc_server_info);
    27082851
    2709         ret->domain_name = talloc_reference(mem_ctx, lp_workgroup(lp_ctx));
    2710         ret->version_major = lp_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
    2711         ret->version_minor = lp_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
    2712         ret->version_build = lp_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
     2852        ret->domain_name = talloc_reference(mem_ctx, lpcfg_workgroup(lp_ctx));
     2853        ret->version_major = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
     2854        ret->version_minor = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
     2855        ret->version_build = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
    27132856
    27142857        return ret;
    27152858}
    27162859
    2717 struct gensec_settings *lp_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
     2860struct gensec_settings *lpcfg_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
    27182861{
    27192862        struct gensec_settings *settings = talloc(mem_ctx, struct gensec_settings);
    … …  
    27222865        SMB_ASSERT(lp_ctx != NULL);
    27232866        settings->lp_ctx = talloc_reference(settings, lp_ctx);
    2724         settings->iconv_convenience = lp_iconv_convenience(lp_ctx);
    2725         settings->target_hostname = lp_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
     2867        settings->target_hostname = lpcfg_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
    27262868        return settings;
    27272869}
Note: See TracChangeset for help on using the changeset viewer.