#include "printing.h"
#include "lib/smbconf/smbconf.h"
#include "lib/smbconf/smbconf_init.h"
+#include "lib/param/loadparm.h"
#include "ads.h"
#include "../librpc/gen_ndr/svcctl.h"
#include "intl.h"
-#include "smb_signing.h"
-#include "dbwrap.h"
+#include "../libcli/smb/smb_signing.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_rbt.h"
#include "smbldap.h"
+#include "../lib/util/bitmap.h"
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
extern userdom_struct current_user_info;
-#ifndef GLOBAL_NAME
-#define GLOBAL_NAME "global"
-#endif
-
-#ifndef PRINTERS_NAME
-#define PRINTERS_NAME "printers"
-#endif
-
-#ifndef HOMES_NAME
-#define HOMES_NAME "homes"
-#endif
-
/* the special value for the include parameter
* to be interpreted not as a file name but to
* trigger loading of the global smb.conf options
static bool defaults_saved = false;
-struct param_opt_struct {
- struct param_opt_struct *prev, *next;
- char *key;
- char *value;
- char **list;
- unsigned flags;
-};
-
-/*
- * This structure describes global (ie., server-wide) parameters.
- */
-struct loadparm_global {
- int ConfigBackend;
- char *smb_ports;
- char *dos_charset;
- char *unix_charset;
- char *szPrintcapname;
- char *szAddPortCommand;
- char *szEnumPortsCommand;
- char *szAddPrinterCommand;
- char *szDeletePrinterCommand;
- char *szOs2DriverMap;
- char *szLockDir;
- char *szStateDir;
- char *szCacheDir;
- char *szPidDir;
- char *szRootdir;
- char *szDefaultService;
- char *szGetQuota;
- char *szSetQuota;
- char *szMsgCommand;
- char *szServerString;
- char *szAutoServices;
- char *szPasswdProgram;
- char *szPasswdChat;
- char *szLogFile;
- char *szConfigFile;
- char *szSMBPasswdFile;
- char *szPrivateDir;
- char *szPassdbBackend;
- char **szPreloadModules;
- char *szPasswordServer;
- char *szSocketOptions;
- char *szRealm;
- char *szRealmUpper;
- char *szDnsDomain;
- char *szAfsUsernameMap;
- int iAfsTokenLifetime;
- char *szLogNtTokenCommand;
- char *szUsernameMap;
- char *szLogonScript;
- char *szLogonPath;
- char *szLogonDrive;
- char *szLogonHome;
- char **szWINSservers;
- char **szInterfaces;
- char *szRemoteAnnounce;
- char *szRemoteBrowseSync;
- char *szSocketAddress;
- bool bNmbdBindExplicitBroadcast;
- char *szNISHomeMapName;
- char *szWorkgroup;
- char *szNetbiosName;
- char **szNetbiosAliases;
- char *szNetbiosScope;
- char *szNameResolveOrder;
- char *szPanicAction;
- char *szAddUserScript;
- char *szRenameUserScript;
- char *szDelUserScript;
- char *szAddGroupScript;
- char *szDelGroupScript;
- char *szAddUserToGroupScript;
- char *szDelUserFromGroupScript;
- char *szSetPrimaryGroupScript;
- char *szAddMachineScript;
- char *szShutdownScript;
- char *szAbortShutdownScript;
- char *szUsernameMapScript;
- int iUsernameMapCacheTime;
- char *szCheckPasswordScript;
- char *szWINSHook;
- char *szUtmpDir;
- char *szWtmpDir;
- bool bUtmp;
- char *szIdmapUID;
- char *szIdmapGID;
- bool bPassdbExpandExplicit;
- int AlgorithmicRidBase;
- char *szTemplateHomedir;
- char *szTemplateShell;
- char *szWinbindSeparator;
- bool bWinbindEnumUsers;
- bool bWinbindEnumGroups;
- bool bWinbindUseDefaultDomain;
- bool bWinbindTrustedDomainsOnly;
- bool bWinbindNestedGroups;
- int winbind_expand_groups;
- bool bWinbindRefreshTickets;
- bool bWinbindOfflineLogon;
- bool bWinbindNormalizeNames;
- bool bWinbindRpcOnly;
- bool bCreateKrb5Conf;
- int winbindMaxDomainConnections;
- char *szIdmapBackend;
- bool bIdmapReadOnly;
- char *szAddShareCommand;
- char *szChangeShareCommand;
- char *szDeleteShareCommand;
- char **szEventLogs;
- char *szGuestaccount;
- char *szManglingMethod;
- char **szServicesList;
- char *szUsersharePath;
- char *szUsershareTemplateShare;
- char **szUsersharePrefixAllowList;
- char **szUsersharePrefixDenyList;
- int mangle_prefix;
- int max_log_size;
- char *szLogLevel;
- int max_xmit;
- int max_mux;
- int max_open_files;
- int open_files_db_hash_size;
- int pwordlevel;
- int unamelevel;
- int deadtime;
- bool getwd_cache;
- int maxprotocol;
- int minprotocol;
- int security;
- char **AuthMethods;
- bool paranoid_server_security;
- int maxdisksize;
- int lpqcachetime;
- int iMaxSmbdProcesses;
- bool bDisableSpoolss;
- int syslog;
- int os_level;
- bool enhanced_browsing;
- int max_ttl;
- int max_wins_ttl;
- int min_wins_ttl;
- int lm_announce;
- int lm_interval;
- int machine_password_timeout;
- int map_to_guest;
- int oplock_break_wait_time;
- int winbind_cache_time;
- int winbind_reconnect_delay;
- int winbind_max_clients;
- char **szWinbindNssInfo;
- int iLockSpinTime;
- char *szLdapMachineSuffix;
- char *szLdapUserSuffix;
- char *szLdapIdmapSuffix;
- char *szLdapGroupSuffix;
- int ldap_ssl;
- bool ldap_ssl_ads;
- int ldap_deref;
- int ldap_follow_referral;
- char *szLdapSuffix;
- char *szLdapAdminDn;
- int ldap_debug_level;
- int ldap_debug_threshold;
- int iAclCompat;
- char *szCupsServer;
- int CupsEncrypt;
- char *szIPrintServer;
- char *ctdbdSocket;
- char **szClusterAddresses;
- bool clustering;
- int ctdb_timeout;
- int ctdb_locktime_warn_threshold;
- int ldap_passwd_sync;
- int ldap_replication_sleep;
- int ldap_timeout; /* This is initialised in init_globals */
- int ldap_connection_timeout;
- int ldap_page_size;
- bool ldap_delete_dn;
- bool bMsAddPrinterWizard;
- bool bDNSproxy;
- bool bWINSsupport;
- bool bWINSproxy;
- bool bLocalMaster;
- int iPreferredMaster;
- int iDomainMaster;
- bool bDomainLogons;
- char **szInitLogonDelayedHosts;
- int InitLogonDelay;
- bool bEncryptPasswords;
- bool bUpdateEncrypt;
- int clientSchannel;
- int serverSchannel;
- bool bNullPasswords;
- bool bObeyPamRestrictions;
- bool bLoadPrinters;
- int PrintcapCacheTime;
- bool bLargeReadwrite;
- bool bReadRaw;
- bool bWriteRaw;
- bool bSyslogOnly;
- bool bBrowseList;
- bool bNISHomeMap;
- bool bTimeServer;
- bool bBindInterfacesOnly;
- bool bPamPasswordChange;
- bool bUnixPasswdSync;
- bool bPasswdChatDebug;
- int iPasswdChatTimeout;
- bool bTimestampLogs;
- bool bNTSmbSupport;
- bool bNTPipeSupport;
- bool bNTStatusSupport;
- bool bStatCache;
- int iMaxStatCacheSize;
- bool bKernelOplocks;
- bool bAllowTrustedDomains;
- bool bLanmanAuth;
- bool bNTLMAuth;
- bool bUseSpnego;
- bool bClientLanManAuth;
- bool bClientNTLMv2Auth;
- bool bClientPlaintextAuth;
- bool bClientUseSpnego;
- bool client_use_spnego_principal;
- bool send_spnego_principal;
- bool bDebugPrefixTimestamp;
- bool bDebugHiresTimestamp;
- bool bDebugPid;
- bool bDebugUid;
- bool bDebugClass;
- bool bEnableCoreFiles;
- bool bHostMSDfs;
- bool bUseMmap;
- bool bHostnameLookups;
- bool bUnixExtensions;
- bool bDisableNetbios;
- char * szDedicatedKeytabFile;
- int iKerberosMethod;
- bool bDeferSharingViolations;
- bool bEnablePrivileges;
- bool bASUSupport;
- bool bUsershareOwnerOnly;
- bool bUsershareAllowGuests;
- bool bRegistryShares;
- int restrict_anonymous;
- int name_cache_timeout;
- int client_signing;
- int server_signing;
- int client_ldap_sasl_wrapping;
- int iUsershareMaxShares;
- int iIdmapCacheTime;
- int iIdmapNegativeCacheTime;
- bool bResetOnZeroVC;
- bool bLogWriteableFilesOnExit;
- int iKeepalive;
- int iminreceivefile;
- struct param_opt_struct *param_opt;
- int cups_connection_timeout;
- char *szSMBPerfcountModule;
- bool bMapUntrustedToDomain;
- bool bAsyncSMBEchoHandler;
- bool bMulticastDnsRegister;
- int ismb2_max_read;
- int ismb2_max_write;
- int ismb2_max_trans;
+#define LOADPARM_EXTRA_GLOBALS \
+ struct parmlist_entry *param_opt; \
+ char *szRealm; \
+ char *szLogLevel; \
+ int iminreceivefile; \
+ char *szPrintcapname; \
+ int CupsEncrypt; \
+ int iPreferredMaster; \
+ int iDomainMaster; \
+ char *szLdapMachineSuffix; \
+ char *szLdapUserSuffix; \
+ char *szLdapIdmapSuffix; \
+ char *szLdapGroupSuffix; \
+ char *szStateDir; \
+ char *szCacheDir; \
+ char *szSocketAddress; \
+ char *szUsershareTemplateShare; \
+ char *szIdmapUID; \
+ char *szIdmapGID; \
+ int winbindMaxDomainConnections; \
int ismb2_max_credits;
- char *ncalrpc_dir;
-};
-
-static struct loadparm_global Globals;
-/*
- * This structure describes a single service.
- */
-struct loadparm_service {
- bool valid;
- bool autoloaded;
- int usershare;
- struct timespec usershare_last_mod;
- char *szService;
- char *szPath;
- char *szUsername;
- char **szInvalidUsers;
- char **szValidUsers;
- char **szAdminUsers;
- char *szCopy;
- char *szInclude;
- char *szPreExec;
- char *szPostExec;
- char *szRootPreExec;
- char *szRootPostExec;
- char *szCupsOptions;
- char *szPrintcommand;
- char *szLpqcommand;
- char *szLprmcommand;
- char *szLppausecommand;
- char *szLpresumecommand;
- char *szQueuepausecommand;
- char *szQueueresumecommand;
- char *szPrintername;
- char *szPrintjobUsername;
- char *szDontdescend;
- char **szHostsallow;
- char **szHostsdeny;
- char *szMagicScript;
- char *szMagicOutput;
- char *szVetoFiles;
- char *szHideFiles;
- char *szVetoOplockFiles;
- char *comment;
- char *force_user;
- char *force_group;
- char **readlist;
- char **writelist;
- char **printer_admin;
- char *volume;
- char *fstype;
- char **szVfsObjects;
- char *szMSDfsProxy;
- char *szAioWriteBehind;
- char *szDfree;
- int iMinPrintSpace;
- int iMaxPrintJobs;
- int iMaxReportedPrintJobs;
- int iWriteCacheSize;
- int iCreate_mask;
- int iCreate_force_mode;
- int iSecurity_mask;
- int iSecurity_force_mode;
- int iDir_mask;
- int iDir_force_mode;
- int iDir_Security_mask;
- int iDir_Security_force_mode;
- int iMaxConnections;
- int iDefaultCase;
- int iPrinting;
- int iOplockContentionLimit;
- int iCSCPolicy;
- int iBlock_size;
- int iDfreeCacheTime;
- bool bPreexecClose;
- bool bRootpreexecClose;
- int iCaseSensitive;
- bool bCasePreserve;
- bool bShortCasePreserve;
- bool bHideDotFiles;
- bool bHideSpecialFiles;
- bool bHideUnReadable;
- bool bHideUnWriteableFiles;
- bool bBrowseable;
- bool bAccessBasedShareEnum;
- bool bAvailable;
- bool bRead_only;
- bool bNo_set_dir;
- bool bGuest_only;
- bool bAdministrative_share;
- bool bGuest_ok;
- bool bPrint_ok;
- bool bPrintNotifyBackchannel;
- bool bMap_system;
- bool bMap_hidden;
- bool bMap_archive;
- bool bStoreDosAttributes;
- bool bDmapiSupport;
- bool bLocking;
- int iStrictLocking;
- bool bPosixLocking;
- bool bShareModes;
- bool bOpLocks;
- bool bLevel2OpLocks;
- bool bOnlyUser;
- bool bMangledNames;
- bool bWidelinks;
- bool bSymlinks;
- bool bSyncAlways;
- bool bStrictAllocate;
- bool bStrictSync;
- char magic_char;
- struct bitmap *copymap;
- bool bDeleteReadonly;
- bool bFakeOplocks;
- bool bDeleteVetoFiles;
- bool bDosFilemode;
- bool bDosFiletimes;
- bool bDosFiletimeResolution;
- bool bFakeDirCreateTimes;
- bool bBlockingLocks;
- bool bInheritPerms;
- bool bInheritACLS;
- bool bInheritOwner;
- bool bMSDfsRoot;
- bool bUseClientDriver;
- bool bDefaultDevmode;
- bool bForcePrintername;
- bool bNTAclSupport;
- bool bForceUnknownAclUser;
- bool bUseSendfile;
- bool bProfileAcls;
- bool bMap_acl_inherit;
- bool bAfs_Share;
- bool bEASupport;
- bool bAclCheckPermissions;
- bool bAclMapFullControl;
- bool bAclGroupControl;
- bool bChangeNotify;
- bool bKernelChangeNotify;
- int iallocation_roundup_size;
- int iAioReadSize;
- int iAioWriteSize;
- int iMap_readonly;
- int iDirectoryNameCacheSize;
- int ismb_encrypt;
- struct param_opt_struct *param_opt;
-
- char dummy[3]; /* for alignment */
-};
+#include "param/param_global.h"
+static struct loadparm_global Globals;
/* This is a default service used to prime a services structure */
static struct loadparm_service sDefault =
static int num_invalid_services = 0;
static bool bInGlobalSection = true;
static bool bGlobalOnly = false;
-static int default_server_announce;
#define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
static bool handle_printing(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
static bool handle_ldap_debug_level(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
-static void set_default_server_announce_type(void);
static void set_allowed_client_auth(void);
static void add_to_file_list(const char *fname, const char *subfname);
static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue, bool store_values);
+static void free_param_opts(struct parmlist_entry **popts);
static const struct enum_list enum_protocol[] = {
- {PROTOCOL_SMB2, "SMB2"},
+ {PROTOCOL_SMB2_02, "SMB2"}, /* for now keep PROTOCOL_SMB2_02 */
+ {PROTOCOL_SMB2_10, "SMB2_10"},
+ {PROTOCOL_SMB2_02, "SMB2_02"},
{PROTOCOL_NT1, "NT1"},
{PROTOCOL_LANMAN2, "LANMAN2"},
{PROTOCOL_LANMAN1, "LANMAN1"},
/* SMB signing types. */
static const struct enum_list enum_smb_signing_vals[] = {
- {false, "No"},
- {false, "False"},
- {false, "0"},
- {false, "Off"},
- {false, "disabled"},
- {true, "Yes"},
- {true, "True"},
- {true, "1"},
- {true, "On"},
- {true, "enabled"},
- {Auto, "auto"},
- {Required, "required"},
- {Required, "mandatory"},
- {Required, "force"},
- {Required, "forced"},
- {Required, "enforced"},
+ {SMB_SIGNING_DEFAULT, "default"},
+ {SMB_SIGNING_OFF, "No"},
+ {SMB_SIGNING_OFF, "False"},
+ {SMB_SIGNING_OFF, "0"},
+ {SMB_SIGNING_OFF, "Off"},
+ {SMB_SIGNING_OFF, "disabled"},
+ {SMB_SIGNING_IF_REQUIRED, "if_required"},
+ {SMB_SIGNING_IF_REQUIRED, "Yes"},
+ {SMB_SIGNING_IF_REQUIRED, "True"},
+ {SMB_SIGNING_IF_REQUIRED, "1"},
+ {SMB_SIGNING_IF_REQUIRED, "On"},
+ {SMB_SIGNING_IF_REQUIRED, "enabled"},
+ {SMB_SIGNING_IF_REQUIRED, "auto"},
+ {SMB_SIGNING_REQUIRED, "required"},
+ {SMB_SIGNING_REQUIRED, "mandatory"},
+ {SMB_SIGNING_REQUIRED, "force"},
+ {SMB_SIGNING_REQUIRED, "forced"},
+ {SMB_SIGNING_REQUIRED, "enforced"},
{-1, NULL}
};
{-1, NULL}
};
+/* Server role options */
+static const struct enum_list enum_server_role[] = {
+ {ROLE_AUTO, "auto"},
+ {ROLE_STANDALONE, "standalone"},
+ {ROLE_DOMAIN_MEMBER, "member server"},
+ {ROLE_DOMAIN_MEMBER, "member"},
+ /* note that currently
+ ROLE_DOMAIN_CONTROLLER == ROLE_DOMAIN_BDC */
+ {ROLE_DOMAIN_CONTROLLER, "domain controller"},
+ {ROLE_DOMAIN_BDC, "backup domain controller"},
+ {ROLE_DOMAIN_BDC, "bdc"},
+ {ROLE_DOMAIN_BDC, "dc"},
+ {ROLE_DOMAIN_PDC, "primary domain controller"},
+ {ROLE_DOMAIN_PDC, "pdc"},
+ {-1, NULL}
+};
+
/* Note: We do not initialise the defaults union - it is not allowed in ANSI C
*
* The FLAG_HIDE is explicit. Parameters set this way do NOT appear in any edit
.enum_list = enum_config_backend,
.flags = FLAG_HIDE|FLAG_ADVANCED|FLAG_META,
},
+ {
+ .label = "server role",
+ .type = P_ENUM,
+ .p_class = P_GLOBAL,
+ .offset = GLOBAL_VAR(ServerRole),
+ .special = NULL,
+ .enum_list = enum_server_role,
+ .flags = FLAG_BASIC | FLAG_ADVANCED,
+ },
{N_("Security Options"), P_SEP, P_SEPARATOR},
.offset = LOCAL_VAR(bAclCheckPermissions),
.special = NULL,
.enum_list = NULL,
- .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
+ .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE | FLAG_DEPRECATED,
},
{
.label = "acl group control",
.enum_list = NULL,
.flags = FLAG_ADVANCED | FLAG_SHARE,
},
+ {
+ .label = "allow insecure wide links",
+ .type = P_BOOL,
+ .p_class = P_GLOBAL,
+ .offset = GLOBAL_VAR(bAllowInsecureWidelinks),
+ .special = NULL,
+ .enum_list = NULL,
+ .flags = FLAG_ADVANCED,
+ },
{
.label = "wide links",
.type = P_BOOL,
*/
static void free_global_parameters(void)
{
+ free_param_opts(&Globals.param_opt);
free_parameters_by_snum(GLOBAL_SECTION_SNUM);
}
* wipe out smb.conf options set with lp_set_cmdline(). The
* apply_lp_set_cmdline() call puts these values back in the
* table once the defaults are set */
- memset((void *)&Globals, '\0', sizeof(Globals));
+ ZERO_STRUCT(Globals);
for (i = 0; parm_table[i].label; i++) {
if ((parm_table[i].type == P_STRING ||
parm_table[i].type == P_USTRING))
{
- string_set(lp_parm_ptr(NULL, &parm_table[i]), "");
+ string_set((char **)lp_parm_ptr(NULL, &parm_table[i]), "");
}
}
*/
string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
- string_set(&Globals.szWorkgroup, WORKGROUP);
+ string_set(&Globals.szWorkgroup, DEFAULT_WORKGROUP);
string_set(&Globals.szPasswdProgram, "");
string_set(&Globals.szLockDir, get_dyn_LOCKDIR());
Globals.PrintcapCacheTime = 750; /* 12.5 minutes */
Globals.ConfigBackend = config_backend;
+ Globals.ServerRole = ROLE_STANDALONE;
/* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
/* Discovered by 2 days of pain by Don McCall @ HP :-). */
Globals.security = SEC_USER;
Globals.paranoid_server_security = true;
Globals.bEncryptPasswords = true;
- Globals.bUpdateEncrypt = false;
Globals.clientSchannel = Auto;
Globals.serverSchannel = Auto;
Globals.bReadRaw = true;
Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
- Globals.lm_announce = 2; /* = Auto: send only if LM clients found */
+ Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
Globals.lm_interval = 60;
#if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
Globals.bNISHomeMap = false;
Globals.bAllowTrustedDomains = true;
string_set(&Globals.szIdmapBackend, "tdb");
- Globals.bIdmapReadOnly = false;
string_set(&Globals.szTemplateShell, "/bin/false");
string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
Globals.bWinbindTrustedDomainsOnly = false;
Globals.bWinbindNestedGroups = true;
Globals.winbind_expand_groups = 1;
- Globals.szWinbindNssInfo = str_list_make_v3(NULL, "template", NULL);
+ Globals.szWinbindNssInfo = (const char **)str_list_make_v3(NULL, "template", NULL);
Globals.bWinbindRefreshTickets = false;
Globals.bWinbindOfflineLogon = false;
Globals.bUseSpnego = true;
Globals.bClientUseSpnego = true;
- Globals.client_signing = Auto;
- Globals.server_signing = false;
+ Globals.client_signing = SMB_SIGNING_DEFAULT;
+ Globals.server_signing = SMB_SIGNING_DEFAULT;
Globals.bDeferSharingViolations = true;
string_set(&Globals.smb_ports, SMB_PORTS);
int fn_name(void) {return(*(int *)(&Globals.ptr));}
#define FN_LOCAL_STRING(fn_name,val) \
- char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
+ char *lp_ ## fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
#define FN_LOCAL_CONST_STRING(fn_name,val) \
- const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
+ const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
#define FN_LOCAL_LIST(fn_name,val) \
- const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
+ const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
#define FN_LOCAL_BOOL(fn_name,val) \
- bool fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
+ bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
#define FN_LOCAL_INTEGER(fn_name,val) \
- int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
+ int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
#define FN_LOCAL_PARM_BOOL(fn_name,val) \
- bool fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
+ bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
#define FN_LOCAL_PARM_INTEGER(fn_name,val) \
- int fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
+ int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
#define FN_LOCAL_CHAR(fn_name,val) \
- char fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
+ char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
FN_GLOBAL_CONST_STRING(lp_smb_ports, smb_ports)
FN_GLOBAL_CONST_STRING(lp_dos_charset, dos_charset)
FN_GLOBAL_BOOL(lp_usershare_owner_only, bUsershareOwnerOnly)
FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
FN_GLOBAL_BOOL(lp_reset_on_zero_vc, bResetOnZeroVC)
-FN_GLOBAL_BOOL(lp_log_writeable_files_on_exit,
- bLogWriteableFilesOnExit)
+FN_GLOBAL_BOOL(lp_log_writeable_files_on_exit, bLogWriteableFilesOnExit)
FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, bMsAddPrinterWizard)
FN_GLOBAL_BOOL(lp_dns_proxy, bDNSproxy)
-FN_GLOBAL_BOOL(lp_wins_support, bWINSsupport)
FN_GLOBAL_BOOL(lp_we_are_a_wins_server, bWINSsupport)
FN_GLOBAL_BOOL(lp_wins_proxy, bWINSproxy)
FN_GLOBAL_BOOL(lp_local_master, bLocalMaster)
FN_GLOBAL_BOOL(lp_client_use_spnego_principal, client_use_spnego_principal)
FN_GLOBAL_BOOL(lp_send_spnego_principal, send_spnego_principal)
FN_GLOBAL_BOOL(lp_hostname_lookups, bHostnameLookups)
-FN_LOCAL_PARM_BOOL(lp_change_notify, bChangeNotify)
-FN_LOCAL_PARM_BOOL(lp_kernel_change_notify, bKernelChangeNotify)
FN_GLOBAL_CONST_STRING(lp_dedicated_keytab_file, szDedicatedKeytabFile)
FN_GLOBAL_INTEGER(lp_kerberos_method, iKerberosMethod)
FN_GLOBAL_BOOL(lp_defer_sharing_violations, bDeferSharingViolations)
int lp_maxprotocol(void)
{
int ret = _lp_maxprotocol();
- if ((ret == PROTOCOL_SMB2) && (lp_security() == SEC_SHARE)) {
+ if ((ret >= PROTOCOL_SMB2_02) && (lp_security() == SEC_SHARE)) {
DEBUG(2,("WARNING!!: \"security = share\" is incompatible "
"with the SMB2 protocol. Resetting to SMB1.\n" ));
lp_do_parameter(-1, "max protocol", "NT1");
FN_GLOBAL_INTEGER(lp_usershare_max_shares, iUsershareMaxShares)
FN_GLOBAL_CONST_STRING(lp_socket_options, szSocketOptions)
FN_GLOBAL_INTEGER(lp_config_backend, ConfigBackend)
+FN_GLOBAL_INTEGER(lp_server_role, ServerRole)
FN_GLOBAL_INTEGER(lp_smb2_max_read, ismb2_max_read)
FN_GLOBAL_INTEGER(lp_smb2_max_write, ismb2_max_write)
FN_GLOBAL_INTEGER(lp_smb2_max_trans, ismb2_max_trans)
}
return Globals.ismb2_max_credits;
}
-FN_LOCAL_STRING(lp_preexec, szPreExec)
-FN_LOCAL_STRING(lp_postexec, szPostExec)
-FN_LOCAL_STRING(lp_rootpreexec, szRootPreExec)
-FN_LOCAL_STRING(lp_rootpostexec, szRootPostExec)
-FN_LOCAL_STRING(lp_servicename, szService)
-FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
-FN_LOCAL_STRING(lp_pathname, szPath)
-FN_LOCAL_STRING(lp_dontdescend, szDontdescend)
-FN_LOCAL_STRING(lp_username, szUsername)
-FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
-FN_LOCAL_LIST(lp_valid_users, szValidUsers)
-FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
FN_GLOBAL_LIST(lp_svcctl_list, szServicesList)
-FN_LOCAL_STRING(lp_cups_options, szCupsOptions)
FN_GLOBAL_STRING(lp_cups_server, szCupsServer)
int lp_cups_encrypt(void)
{
FN_GLOBAL_BOOL(lp_clustering, clustering)
FN_GLOBAL_INTEGER(lp_ctdb_timeout, ctdb_timeout)
FN_GLOBAL_INTEGER(lp_ctdb_locktime_warn_threshold, ctdb_locktime_warn_threshold)
-FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
-FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
-FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
-FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
-FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
-FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
-FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
-static FN_LOCAL_STRING(_lp_printername, szPrintername)
-FN_LOCAL_CONST_STRING(lp_printjob_username, szPrintjobUsername)
-FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
-FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
-FN_LOCAL_STRING(lp_magicscript, szMagicScript)
-FN_LOCAL_STRING(lp_magicoutput, szMagicOutput)
-FN_LOCAL_STRING(lp_comment, comment)
-FN_LOCAL_STRING(lp_force_user, force_user)
-FN_LOCAL_STRING(lp_force_group, force_group)
-FN_LOCAL_LIST(lp_readlist, readlist)
-FN_LOCAL_LIST(lp_writelist, writelist)
-FN_LOCAL_LIST(lp_printer_admin, printer_admin)
-FN_LOCAL_STRING(lp_fstype, fstype)
-FN_LOCAL_LIST(lp_vfs_objects, szVfsObjects)
-FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
-static FN_LOCAL_STRING(lp_volume, volume)
-FN_LOCAL_STRING(lp_veto_files, szVetoFiles)
-FN_LOCAL_STRING(lp_hide_files, szHideFiles)
-FN_LOCAL_STRING(lp_veto_oplocks, szVetoOplockFiles)
-FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
-FN_LOCAL_STRING(lp_aio_write_behind, szAioWriteBehind)
-FN_LOCAL_STRING(lp_dfree_command, szDfree)
-FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
-FN_LOCAL_BOOL(lp_preexec_close, bPreexecClose)
-FN_LOCAL_BOOL(lp_rootpreexec_close, bRootpreexecClose)
-FN_LOCAL_INTEGER(lp_casesensitive, iCaseSensitive)
-FN_LOCAL_BOOL(lp_preservecase, bCasePreserve)
-FN_LOCAL_BOOL(lp_shortpreservecase, bShortCasePreserve)
-FN_LOCAL_BOOL(lp_hide_dot_files, bHideDotFiles)
-FN_LOCAL_BOOL(lp_hide_special_files, bHideSpecialFiles)
-FN_LOCAL_BOOL(lp_hideunreadable, bHideUnReadable)
-FN_LOCAL_BOOL(lp_hideunwriteable_files, bHideUnWriteableFiles)
-FN_LOCAL_BOOL(lp_browseable, bBrowseable)
-FN_LOCAL_BOOL(lp_access_based_share_enum, bAccessBasedShareEnum)
-FN_LOCAL_BOOL(lp_readonly, bRead_only)
-FN_LOCAL_BOOL(lp_no_set_dir, bNo_set_dir)
-FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
-FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
-FN_LOCAL_BOOL(lp_administrative_share, bAdministrative_share)
-FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
-FN_LOCAL_BOOL(lp_print_notify_backchannel, bPrintNotifyBackchannel)
-FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
-FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
-FN_LOCAL_BOOL(lp_store_dos_attributes, bStoreDosAttributes)
-FN_LOCAL_BOOL(lp_dmapi_support, bDmapiSupport)
-FN_LOCAL_PARM_BOOL(lp_locking, bLocking)
-FN_LOCAL_PARM_INTEGER(lp_strict_locking, iStrictLocking)
-FN_LOCAL_PARM_BOOL(lp_posix_locking, bPosixLocking)
-FN_LOCAL_BOOL(lp_share_modes, bShareModes)
-FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
-FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
-FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
-FN_LOCAL_PARM_BOOL(lp_manglednames, bMangledNames)
-FN_LOCAL_BOOL(lp_symlinks, bSymlinks)
-FN_LOCAL_BOOL(lp_syncalways, bSyncAlways)
-FN_LOCAL_BOOL(lp_strict_allocate, bStrictAllocate)
-FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
-FN_LOCAL_BOOL(lp_map_system, bMap_system)
-FN_LOCAL_BOOL(lp_delete_readonly, bDeleteReadonly)
-FN_LOCAL_BOOL(lp_fake_oplocks, bFakeOplocks)
-FN_LOCAL_BOOL(lp_recursive_veto_delete, bDeleteVetoFiles)
-FN_LOCAL_BOOL(lp_dos_filemode, bDosFilemode)
-FN_LOCAL_BOOL(lp_dos_filetimes, bDosFiletimes)
-FN_LOCAL_BOOL(lp_dos_filetime_resolution, bDosFiletimeResolution)
-FN_LOCAL_BOOL(lp_fake_dir_create_times, bFakeDirCreateTimes)
FN_GLOBAL_BOOL(lp_async_smb_echo_handler, bAsyncSMBEchoHandler)
FN_GLOBAL_BOOL(lp_multicast_dns_register, bMulticastDnsRegister)
-FN_LOCAL_BOOL(lp_blocking_locks, bBlockingLocks)
-FN_LOCAL_BOOL(lp_inherit_perms, bInheritPerms)
-FN_LOCAL_BOOL(lp_inherit_acls, bInheritACLS)
-FN_LOCAL_BOOL(lp_inherit_owner, bInheritOwner)
-FN_LOCAL_BOOL(lp_use_client_driver, bUseClientDriver)
-FN_LOCAL_BOOL(lp_default_devmode, bDefaultDevmode)
-FN_LOCAL_BOOL(lp_force_printername, bForcePrintername)
-FN_LOCAL_BOOL(lp_nt_acl_support, bNTAclSupport)
-FN_LOCAL_BOOL(lp_force_unknown_acl_user, bForceUnknownAclUser)
-FN_LOCAL_BOOL(lp_ea_support, bEASupport)
-FN_LOCAL_BOOL(_lp_use_sendfile, bUseSendfile)
-FN_LOCAL_BOOL(lp_profile_acls, bProfileAcls)
-FN_LOCAL_BOOL(lp_map_acl_inherit, bMap_acl_inherit)
-FN_LOCAL_BOOL(lp_afs_share, bAfs_Share)
-FN_LOCAL_BOOL(lp_acl_check_permissions, bAclCheckPermissions)
-FN_LOCAL_BOOL(lp_acl_group_control, bAclGroupControl)
-FN_LOCAL_BOOL(lp_acl_map_full_control, bAclMapFullControl)
-FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
-FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
-FN_LOCAL_INTEGER(lp_security_mask, iSecurity_mask)
-FN_LOCAL_INTEGER(lp_force_security_mode, iSecurity_force_mode)
-FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
-FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
-FN_LOCAL_INTEGER(lp_dir_security_mask, iDir_Security_mask)
-FN_LOCAL_INTEGER(lp_force_dir_security_mode, iDir_Security_force_mode)
-FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
-FN_LOCAL_INTEGER(lp_defaultcase, iDefaultCase)
-FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
-FN_LOCAL_INTEGER(lp_printing, iPrinting)
-FN_LOCAL_INTEGER(lp_max_reported_jobs, iMaxReportedPrintJobs)
-FN_LOCAL_INTEGER(lp_oplock_contention_limit, iOplockContentionLimit)
-FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
-FN_LOCAL_INTEGER(lp_write_cache_size, iWriteCacheSize)
-FN_LOCAL_INTEGER(lp_block_size, iBlock_size)
-FN_LOCAL_INTEGER(lp_dfree_cache_time, iDfreeCacheTime)
-FN_LOCAL_INTEGER(lp_allocation_roundup_size, iallocation_roundup_size)
-FN_LOCAL_INTEGER(lp_aio_read_size, iAioReadSize)
-FN_LOCAL_INTEGER(lp_aio_write_size, iAioWriteSize)
-FN_LOCAL_INTEGER(lp_map_readonly, iMap_readonly)
-FN_LOCAL_INTEGER(lp_directory_name_cache_size, iDirectoryNameCacheSize)
-FN_LOCAL_INTEGER(lp_smb_encrypt, ismb_encrypt)
-FN_LOCAL_CHAR(lp_magicchar, magic_char)
+FN_GLOBAL_BOOL(lp_allow_insecure_widelinks, bAllowInsecureWidelinks)
FN_GLOBAL_INTEGER(lp_winbind_cache_time, winbind_cache_time)
FN_GLOBAL_INTEGER(lp_winbind_reconnect_delay, winbind_reconnect_delay)
FN_GLOBAL_INTEGER(lp_winbind_max_clients, winbind_max_clients)
FN_GLOBAL_CONST_STRING(lp_ncalrpc_dir, ncalrpc_dir)
+#include "lib/param/param_functions.c"
+
+FN_LOCAL_STRING(servicename, szService)
+FN_LOCAL_CONST_STRING(const_servicename, szService)
+
/* local prototypes */
static int map_parameter_canonical(const char *pszParmName, bool *inverse);
static void init_copymap(struct loadparm_service *pservice);
static bool hash_a_service(const char *name, int number);
static void free_service_byindex(int iService);
-static void free_param_opts(struct param_opt_struct **popts);
static void show_parameter(int parmIndex);
static bool is_synonym_of(int parm1, int parm2, bool *inverse);
* pointer to parametrical option value if it exists or NULL otherwise. Actual
* parametrical functions are quite simple
*/
-static struct param_opt_struct *get_parametrics(int snum, const char *type,
- const char *option)
+static struct parmlist_entry *get_parametrics_by_service(struct loadparm_service *service, const char *type,
+ const char *option)
{
bool global_section = false;
char* param_key;
- struct param_opt_struct *data;
+ struct parmlist_entry *data;
- if (snum >= iNumServices) return NULL;
-
- if (snum < 0) {
+ if (service == NULL) {
data = Globals.param_opt;
global_section = true;
} else {
- data = ServicePtrs[snum]->param_opt;
+ data = service->param_opt;
}
if (asprintf(¶m_key, "%s:%s", type, option) == -1) {
return NULL;
}
+/*
+ * This is a helper function for parametrical options support. It returns a
+ * pointer to parametrical option value if it exists or NULL otherwise. Actual
+ * parametrical functions are quite simple
+ */
+static struct parmlist_entry *get_parametrics(int snum, const char *type,
+ const char *option)
+{
+ if (snum >= iNumServices) return NULL;
+
+ if (snum < 0) {
+ return get_parametrics_by_service(NULL, type, option);
+ } else {
+ return get_parametrics_by_service(ServicePtrs[snum], type, option);
+ }
+}
+
#define MISSING_PARAMETER(name) \
DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
/* the returned value is talloced on the talloc_tos() */
char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data == NULL||data->value==NULL) {
if (def) {
/* Parametric option has following syntax: 'Type: option = value' */
const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data == NULL||data->value==NULL)
return def;
return data->value;
}
+const char *lp_parm_const_string_service(struct loadparm_service *service, const char *type, const char *option)
+{
+ struct parmlist_entry *data = get_parametrics_by_service(service, type, option);
+
+ if (data == NULL||data->value==NULL)
+ return NULL;
+
+ return data->value;
+}
+
+
/* Return parametric option from a given service. Type is a part of option before ':' */
/* Parametric option has following syntax: 'Type: option = value' */
const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data == NULL||data->value==NULL)
return (const char **)def;
int lp_parm_int(int snum, const char *type, const char *option, int def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data && data->value && *data->value)
return lp_int(data->value);
unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data && data->value && *data->value)
return lp_ulong(data->value);
bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data && data->value && *data->value)
return lp_bool(data->value);
int lp_parm_enum(int snum, const char *type, const char *option,
const struct enum_list *_enum, int def)
{
- struct param_opt_struct *data = get_parametrics(snum, type, option);
+ struct parmlist_entry *data = get_parametrics(snum, type, option);
if (data && data->value && *data->value && _enum)
return lp_enum(data->value, _enum);
* then this whole functions reduces to a TALLOC_FREE().
*/
-static void free_param_opts(struct param_opt_struct **popts)
+static void free_param_opts(struct parmlist_entry **popts)
{
- struct param_opt_struct *opt, *next_opt;
+ struct parmlist_entry *opt, *next_opt;
if (popts == NULL) {
return;
i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
if (i < 0)
- return (false);
+ return false;
if (!(*(ServicePtrs[iDefaultService]->szPath))
|| strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
user, ServicePtrs[i]->szPath ));
- return (true);
+ return true;
}
/***************************************************************************
int i = add_a_service(&sDefault, ipc_name);
if (i < 0)
- return (false);
+ return false;
if (asprintf(&comment, "IPC Service (%s)",
Globals.szServerString) < 0) {
- return (false);
+ return false;
}
string_set(&ServicePtrs[i]->szPath, tmpdir());
DEBUG(3, ("adding IPC service\n"));
SAFE_FREE(comment);
- return (true);
+ return true;
}
/***************************************************************************
int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
if (i < 0)
- return (false);
+ return false;
/* note that we do NOT default the availability flag to true - */
/* we take it from the default service passed. This allows all */
DEBUG(3, ("adding printer service %s\n", pszPrintername));
- return (true);
+ return true;
}
static bool is_synonym_of(int parm1, int parm2, bool *inverse)
{
if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
+ (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
(parm_table[parm1].flags & FLAG_HIDE) &&
!(parm_table[parm2].flags & FLAG_HIDE))
{
int iService = -1;
char *canon_name;
TDB_DATA data;
+ NTSTATUS status;
if (ServiceHash == NULL) {
return -1;
canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
- data = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name);
+ status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
+ &data);
- if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
+ if (NT_STATUS_IS_OK(status) &&
+ (data.dptr != NULL) &&
+ (data.dsize == sizeof(iService)))
+ {
iService = *(int *)data.dptr;
}
return (iService);
}
+/* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
+struct loadparm_service *lp_service(const char *pszServiceName)
+{
+ int iService = getservicebyname(pszServiceName, NULL);
+ if (iService == -1 || !LP_SNUM_OK(iService)) {
+ return NULL;
+ }
+ return ServicePtrs[iService];
+}
+
+struct loadparm_service *lp_servicebynum(int snum)
+{
+ if ((snum == -1) || !LP_SNUM_OK(snum)) {
+ return NULL;
+ }
+ return ServicePtrs[snum];
+}
+
+struct loadparm_service *lp_default_loadparm_service()
+{
+ return &sDefault;
+}
+
+
/***************************************************************************
Copy a service structure to another.
If pcopymapDest is NULL then copy all fields
***************************************************************************/
/**
- * Add a parametric option to a param_opt_struct,
+ * Add a parametric option to a parmlist_entry,
* replacing old value, if already present.
*/
-static void set_param_opt(struct param_opt_struct **opt_list,
+static void set_param_opt(struct parmlist_entry **opt_list,
const char *opt_name,
const char *opt_value,
- unsigned flags)
+ unsigned priority)
{
- struct param_opt_struct *new_opt, *opt;
+ struct parmlist_entry *new_opt, *opt;
bool not_added;
if (opt_list == NULL) {
while (opt) {
/* If we already have same option, override it */
if (strwicmp(opt->key, opt_name) == 0) {
- if ((opt->flags & FLAG_CMDLINE) &&
- !(flags & FLAG_CMDLINE)) {
+ if ((opt->priority & FLAG_CMDLINE) &&
+ !(priority & FLAG_CMDLINE)) {
/* it's been marked as not to be
overridden */
return;
string_free(&opt->value);
TALLOC_FREE(opt->list);
opt->value = SMB_STRDUP(opt_value);
- opt->flags = flags;
+ opt->priority = priority;
not_added = false;
break;
}
opt = opt->next;
}
if (not_added) {
- new_opt = SMB_XMALLOC_P(struct param_opt_struct);
+ new_opt = SMB_XMALLOC_P(struct parmlist_entry);
new_opt->key = SMB_STRDUP(opt_name);
new_opt->value = SMB_STRDUP(opt_value);
new_opt->list = NULL;
- new_opt->flags = flags;
+ new_opt->priority = priority;
DLIST_ADD(*opt_list, new_opt);
}
}
{
int i;
bool bcopyall = (pcopymapDest == NULL);
- struct param_opt_struct *data;
+ struct parmlist_entry *data;
for (i = 0; parm_table[i].label; i++)
if (parm_table[i].p_class == P_LOCAL &&
data = pserviceSource->param_opt;
while (data) {
- set_param_opt(&pserviceDest->param_opt, data->key, data->value, data->flags);
+ set_param_opt(&pserviceDest->param_opt, data->key, data->value, data->priority);
data = data->next;
}
}
return ret;
}
+/**
+ * reload those shares from registry that are already
+ * activated in the services array.
+ */
+static bool reload_registry_shares(void)
+{
+ int i;
+ bool ret = true;
+
+ for (i = 0; i < iNumServices; i++) {
+ if (!VALID(i)) {
+ continue;
+ }
+
+ if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
+ continue;
+ }
+
+ ret = process_registry_service(ServicePtrs[i]->szService);
+ if (!ret) {
+ goto done;
+ }
+ }
+
+done:
+ return ret;
+}
+
+
#define MAX_INCLUDE_DEPTH 100
static uint8_t include_depth;
}
f = f->next;
}
- return (false);
+ return false;
}
if (len == 4 || len == 5) {
/* Don't use StrCaseCmp here as we don't want to
initialize iconv. */
- if ((toupper_ascii(pszParmValue[0]) == 'U') &&
- (toupper_ascii(pszParmValue[1]) == 'T') &&
- (toupper_ascii(pszParmValue[2]) == 'F')) {
+ if ((toupper_m(pszParmValue[0]) == 'U') &&
+ (toupper_m(pszParmValue[1]) == 'T') &&
+ (toupper_m(pszParmValue[2]) == 'F')) {
if (len == 4) {
if (pszParmValue[3] == '8') {
is_utf8 = true;
static bool handle_netbios_aliases(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
{
TALLOC_FREE(Globals.szNetbiosAliases);
- Globals.szNetbiosAliases = str_list_make_v3(NULL, pszParmValue, NULL);
- return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
+ Globals.szNetbiosAliases = (const char **)str_list_make_v3(NULL, pszParmValue, NULL);
+ return set_netbios_aliases(Globals.szNetbiosAliases);
}
/***************************************************************************
{
int parmnum, i;
void *parm_ptr = NULL; /* where we are going to store the result */
- struct param_opt_struct **opt_list;
+ struct parmlist_entry **opt_list;
parmnum = map_parameter(pszParmName);
if (strchr(pszParmName, ':') == NULL) {
DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",
pszParmName));
- return (true);
+ return true;
}
/*
? &Globals.param_opt : &ServicePtrs[snum]->param_opt;
set_param_opt(opt_list, pszParmName, pszParmValue, 0);
- return (true);
+ return true;
}
/* if it's already been set by the command line, then we don't
DEBUG(0,
("Global parameter %s found in service section!\n",
pszParmName));
- return (true);
+ return true;
}
parm_ptr = lp_local_ptr_by_snum(snum, &parm_table[parmnum]);
}
/* this handles the aliases - set the copymap for other entries with
the same data pointer */
- for (i = 0; parm_table[i].label; i++)
- if (parm_table[i].offset == parm_table[parmnum].offset)
+ for (i = 0; parm_table[i].label; i++) {
+ if ((parm_table[i].offset == parm_table[parmnum].offset)
+ && (parm_table[i].p_class == parm_table[parmnum].p_class)) {
bitmap_clear(ServicePtrs[snum]->copymap, i);
+ }
+ }
}
/* if it is a special case then go ahead */
}
break;
+ case P_BYTES:
+ {
+ uint64_t val;
+ if (conv_str_size_error(pszParmValue, &val)) {
+ if (val <= INT_MAX) {
+ *(int *)parm_ptr = (int)val;
+ break;
+ }
+ }
+
+ DEBUG(0,("lp_do_parameter(%s): value is not "
+ "a valid size specifier!\n", pszParmValue));
+ return false;
+ }
+
case P_LIST:
+ case P_CMDLIST:
TALLOC_FREE(*((char ***)parm_ptr));
*(char ***)parm_ptr = str_list_make_v3(
NULL, pszParmValue, NULL);
break;
}
- return (true);
+ return true;
}
/***************************************************************************
/* we have to also set FLAG_CMDLINE on aliases. Aliases must
* be grouped in the table, so we don't have to search the
* whole table */
- for (i=parmnum-1;i>=0 && parm_table[i].offset == parm_table[parmnum].offset;i--) {
+ for (i=parmnum-1;
+ i>=0 && parm_table[i].offset == parm_table[parmnum].offset
+ && parm_table[i].p_class == parm_table[parmnum].p_class;
+ i--) {
parm_table[i].flags |= FLAG_CMDLINE;
}
- for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].offset == parm_table[parmnum].offset;i++) {
+ for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].offset == parm_table[parmnum].offset
+ && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
parm_table[i].flags |= FLAG_CMDLINE;
}
void *userdata)
{
if (!bInGlobalSection && bGlobalOnly)
- return (true);
+ return true;
DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
{
+ /* For the seperation of lists values that we print below */
+ const char *list_sep = ", ";
int i;
switch (p->type)
{
break;
case P_INTEGER:
+ case P_BYTES:
fprintf(f, "%d", *(int *)ptr);
break;
break;
case P_OCTAL: {
- char *o = octal_string(*(int *)ptr);
- fprintf(f, "%s", o);
- TALLOC_FREE(o);
+ int val = *(int *)ptr;
+ if (val == -1) {
+ fprintf(f, "-1");
+ } else {
+ fprintf(f, "0%o", val);
+ }
break;
}
+ case P_CMDLIST:
+ list_sep = " ";
+ /* fall through */
case P_LIST:
if ((char ***)ptr && *(char ***)ptr) {
char **list = *(char ***)ptr;
for (; *list; list++) {
/* surround strings with whitespace in double quotes */
- if ( strchr_m( *list, ' ' ) )
- fprintf(f, "\"%s\"%s", *list, ((*(list+1))?", ":""));
- else
- fprintf(f, "%s%s", *list, ((*(list+1))?", ":""));
+ if (*(list+1) == NULL) {
+ /* last item, no extra separator */
+ list_sep = "";
+ }
+ if ( strchr_m( *list, ' ' ) ) {
+ fprintf(f, "\"%s\"%s", *list, list_sep);
+ } else {
+ fprintf(f, "%s%s", *list, list_sep);
+ }
}
}
break;
case P_INTEGER:
case P_ENUM:
case P_OCTAL:
+ case P_BYTES:
return (*((int *)ptr1) == *((int *)ptr2));
case P_CHAR:
return (*((char *)ptr1) == *((char *)ptr2));
case P_LIST:
+ case P_CMDLIST:
return str_list_equal(*(const char ***)ptr1, *(const char ***)ptr2);
case P_STRING:
case P_SEP:
break;
}
- return (false);
+ return false;
}
/***************************************************************************
/* check for multiple global sections */
if (bInGlobalSection) {
DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
- return (true);
+ return true;
}
if (!bInGlobalSection && bGlobalOnly)
- return (true);
+ return true;
/* if we have a current service, tidy it up before moving on */
bRetval = true;
/* issued by the post-processing of a previous section. */
DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
- if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
- < 0) {
+ iServiceIndex = add_a_service(&sDefault, pszSectionName);
+ if (iServiceIndex < 0) {
DEBUG(0, ("Failed to add a new service\n"));
- return (false);
+ return false;
}
/* Clean all parametric options for service */
/* They will be added during parsing again */
free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
}
- return (bRetval);
+ return bRetval;
}
return false;
switch (parm_table[i].type) {
case P_LIST:
+ case P_CMDLIST:
return str_list_equal((const char **)parm_table[i].def.lvalue,
*(const char ***)lp_parm_ptr(NULL,
&parm_table[i]));
case P_INTEGER:
case P_OCTAL:
case P_ENUM:
+ case P_BYTES:
return parm_table[i].def.ivalue ==
*(int *)lp_parm_ptr(NULL,
&parm_table[i]);
static void dump_globals(FILE *f)
{
int i;
- struct param_opt_struct *data;
+ struct parmlist_entry *data;
fprintf(f, "[global]\n");
static void dump_a_service(struct loadparm_service *pService, FILE * f)
{
int i;
- struct param_opt_struct *data;
+ struct parmlist_entry *data;
if (pService != &sDefault)
fprintf(f, "[%s]\n", pService->szService);
if ((*i) > 0
&& (parm_table[*i].offset ==
- parm_table[(*i) - 1].offset))
+ parm_table[(*i) - 1].offset)
+ && (parm_table[*i].p_class ==
+ parm_table[(*i) - 1].p_class))
continue;
if (is_default(*i) && !allparameters)
{
int i;
for (i = 0; parm_table[i].label; i++) {
- if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset)
+ if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
+ && parm_table[i].p_class == parm_table[i - 1].p_class)
continue;
switch (parm_table[i].type) {
case P_LIST:
+ case P_CMDLIST:
parm_table[i].def.lvalue = str_list_copy(
NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
break;
case P_INTEGER:
case P_OCTAL:
case P_ENUM:
+ case P_BYTES:
parm_table[i].def.ivalue =
*(int *)lp_parm_ptr(NULL, &parm_table[i]);
break;
}
{
- TDB_DATA data = dbwrap_fetch_bystring(
- ServiceHash, canon_name, canon_name);
+ TDB_DATA data;
+ NTSTATUS status;
+
+ status = dbwrap_fetch_bystring(ServiceHash, canon_name,
+ canon_name, &data);
iService = -1;
- if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
+ if (NT_STATUS_IS_OK(status) &&
+ (data.dptr != NULL) &&
+ (data.dsize == sizeof(iService)))
+ {
iService = *(int *)data.dptr;
}
}
/***************************************************************************
Allow client apps to specify that they are a client
***************************************************************************/
-void lp_set_in_client(bool b)
+static void lp_set_in_client(bool b)
{
in_client = b;
}
/***************************************************************************
Determine if we're running in a client app
***************************************************************************/
-bool lp_is_in_client(void)
+static bool lp_is_in_client(void)
{
return in_client;
}
bool add_ipc,
bool initialize_globals,
bool allow_include_registry,
- bool allow_registry_shares)
+ bool load_all_shares)
{
char *n2 = NULL;
bool bRetval;
lp_save_defaults();
}
- free_param_opts(&Globals.param_opt);
+ if (!initialize_globals) {
+ free_param_opts(&Globals.param_opt);
+ apply_lp_set_cmdline();
+ }
lp_do_parameter(-1, "idmap config * : backend", Globals.szIdmapBackend);
return lp_load_ex(pszFname, global_only, save_defaults,
add_ipc, initialize_globals,
allow_include_registry,
- allow_registry_shares);
+ load_all_shares);
}
} else if (lp_config_backend_is_registry()) {
bRetval = process_registry_globals();
bRetval = false;
}
- if (bRetval && lp_registry_shares() && allow_registry_shares) {
- bRetval = process_registry_shares();
+ if (bRetval && lp_registry_shares()) {
+ if (load_all_shares) {
+ bRetval = process_registry_shares();
+ } else {
+ bRetval = reload_registry_shares();
+ }
}
lp_add_auto_services(lp_auto_services());
}
set_server_role();
- set_default_server_announce_type();
set_allowed_client_auth();
if (lp_security() == SEC_SHARE) {
add_ipc,
initialize_globals,
true, /* allow_include_registry */
- false); /* allow_registry_shares*/
+ false); /* load_all_shares*/
}
bool lp_load_initial_only(const char *pszFname)
false, /* add_ipc */
true, /* initialize_globals */
false, /* allow_include_registry */
- false); /* allow_registry_shares*/
+ false); /* load_all_shares*/
+}
+
+/**
+ * most common lp_load wrapper, loading only the globals
+ */
+bool lp_load_global(const char *file_name)
+{
+ return lp_load_ex(file_name,
+ true, /* global_only */
+ false, /* save_defaults */
+ false, /* add_ipc */
+ true, /* initialize_globals */
+ true, /* allow_include_registry */
+ false); /* load_all_shares*/
+}
+
+/**
+ * lp_load wrapper, especially for clients
+ */
+bool lp_load_client(const char *file_name)
+{
+ lp_set_in_client(true);
+
+ return lp_load_global(file_name);
+}
+
+/**
+ * lp_load wrapper, loading only globals, but intended
+ * for subsequent calls, not reinitializing the globals
+ * to default values
+ */
+bool lp_load_global_no_reinit(const char *file_name)
+{
+ return lp_load_ex(file_name,
+ true, /* global_only */
+ false, /* save_defaults */
+ false, /* add_ipc */
+ false, /* initialize_globals */
+ true, /* allow_include_registry */
+ false); /* load_all_shares*/
+}
+
+/**
+ * lp_load wrapper, especially for clients, no reinitialization
+ */
+bool lp_load_client_no_reinit(const char *file_name)
+{
+ lp_set_in_client(true);
+
+ return lp_load_global_no_reinit(file_name);
}
bool lp_load_with_registry_shares(const char *pszFname,
add_ipc,
initialize_globals,
true, /* allow_include_registry */
- true); /* allow_registry_shares*/
+ true); /* load_all_shares*/
}
/***************************************************************************
}
/*******************************************************************
- Set the server type we will announce as via nmbd.
+ Get the default server type we will announce as via nmbd.
********************************************************************/
-static void set_default_server_announce_type(void)
+int lp_default_server_announce(void)
{
- default_server_announce = 0;
+ int default_server_announce = 0;
default_server_announce |= SV_TYPE_WORKSTATION;
default_server_announce |= SV_TYPE_SERVER;
default_server_announce |= SV_TYPE_SERVER_UNIX;
if (lp_host_msdfs())
default_server_announce |= SV_TYPE_DFS_SERVER;
+
+ return default_server_announce;
}
/***********************************************************
}
-/*******************************************************************
- Get the default server type we will announce as via nmbd.
-********************************************************************/
-
-int lp_default_server_announce(void)
-{
- return default_server_announce;
-}
-
/***********************************************************
Set the global name resolution order (used in smbclient).
************************************************************/
const char *lp_printername(int snum)
{
- const char *ret = _lp_printername(snum);
+ const char *ret = lp__printername(snum);
if (ret == NULL || (ret != NULL && *ret == '\0'))
ret = lp_const_servicename(snum);
if (signing_state) {
sign_active = smb_signing_is_active(signing_state);
}
- return (_lp_use_sendfile(snum) &&
+ return (lp__use_sendfile(snum) &&
(get_remote_arch() != RA_WIN95) &&
!sign_active);
}
return Globals.szSocketAddress;
}
-void lp_set_passdb_backend(const char *backend)
-{
- string_set(&Globals.szPassdbBackend, backend);
-}
-
/*******************************************************************
Safe wide links checks.
This helper function always verify the validity of wide links,
void widelinks_warning(int snum)
{
+ if (lp_allow_insecure_widelinks()) {
+ return;
+ }
+
if (lp_unix_extensions() && lp_widelinks_internal(snum)) {
DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
"These parameters are incompatible. "
{
/* wide links is always incompatible with unix extensions */
if (lp_unix_extensions()) {
- return false;
+ /*
+ * Unless we have "allow insecure widelinks"
+ * turned on.
+ */
+ if (!lp_allow_insecure_widelinks()) {
+ return false;
+ }
}
return lp_widelinks_internal(snum);
}
return _lp_readraw();
}
+
+void _lp_set_server_role(int server_role)
+{
+ Globals.ServerRole = server_role;
+}
git.samba.org / ira / wip.git / blobdiff