size_t push_string_base(const char *base, uint16 flags2,
void *dest, const char *src,
size_t dest_len, int flags);
-size_t pull_string_fn(const void *base_ptr,
- uint16 smb_flags2,
- char *dest,
- const void *src,
- size_t dest_len,
- size_t src_len,
- int flags);
size_t pull_string_talloc(TALLOC_CTX *ctx,
const void *base_ptr,
uint16 smb_flags2,
int flags);
size_t align_string(const void *base_ptr, const char *p, int flags);
size_t dos_PutUniCode(char *dst,const char *src, size_t len, bool null_terminate);
-int rpcstr_push(void *dest, const char *src, size_t dest_len, int flags);
int rpcstr_push_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src);
-/* The following definitions come from lib/conn_tdb.c */
-
-struct db_record *connections_fetch_entry(TALLOC_CTX *mem_ctx,
- connection_struct *conn,
- const char *name);
-int connections_traverse(int (*fn)(struct db_record *rec,
- void *private_data),
- void *private_data);
-int connections_forall(int (*fn)(struct db_record *rec,
- const struct connections_key *key,
- const struct connections_data *data,
- void *private_data),
- void *private_data);
-int connections_forall_read(int (*fn)(const struct connections_key *key,
- const struct connections_data *data,
- void *private_data),
- void *private_data);
-bool connections_init(bool rw);
-
/* The following definitions come from lib/dmallocmsg.c */
void register_dmalloc_msgs(struct messaging_context *msg_ctx);
/* The following definitions come from lib/file_id.c */
struct file_id vfs_file_id_from_sbuf(connection_struct *conn, const SMB_STRUCT_STAT *sbuf);
-bool file_id_equal(const struct file_id *id1, const struct file_id *id2);
-const char *file_id_string_tos(const struct file_id *id);
-void push_file_id_16(char *buf, const struct file_id *id);
-void push_file_id_24(char *buf, const struct file_id *id);
-void pull_file_id_24(char *buf, struct file_id *id);
/* The following definitions come from lib/gencache.c */
char *escape_ldap_string(TALLOC_CTX *mem_ctx, const char *s);
char *escape_rdn_val_string_alloc(const char *s);
-/* The following definitions come from lib/module.c */
-
-NTSTATUS smb_load_module(const char *module_name);
-int smb_load_modules(const char **modules);
-NTSTATUS smb_probe_module(const char *subsystem, const char *module);
-NTSTATUS smb_load_module(const char *module_name);
-int smb_load_modules(const char **modules);
-NTSTATUS smb_probe_module(const char *subsystem, const char *module);
-void init_modules(void);
-
/* The following definitions come from lib/ms_fnmatch.c */
int ms_fnmatch(const char *pattern, const char *string, bool translate_pattern,
ssize_t sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count);
ssize_t sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count);
ssize_t drain_socket(int sockfd, size_t count);
/* The following definitions come from lib/sendfile.c */
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count);
/* The following definitions come from lib/server_mutex.c */
const char *connectpath, gid_t gid,
const char *smb_name, const char *domain_name,
char *str, size_t len);
-char *standard_sub_conn(TALLOC_CTX *ctx, connection_struct *conn, const char *str);
-
-/* The following definitions come from lib/sysacls.c */
-
-int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
-int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
-int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
-SMB_ACL_T sys_acl_init(int count);
-int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
-int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
-int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T acl_d) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_valid(SMB_ACL_T acl_d);
-SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
- const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp);
-int sys_acl_set_file(vfs_handle_struct *handle,
- const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
-int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
- SMB_ACL_T acl_d);
-int sys_acl_delete_def_file(vfs_handle_struct *handle,
- const char *path);
-int no_acl_syscall_error(int err);
/* The following definitions come from lib/sysquotas.c */
/* The following definitions come from lib/system.c */
-int sys_usleep(long usecs);
ssize_t sys_read(int fd, void *buf, size_t count);
ssize_t sys_write(int fd, const void *buf, size_t count);
ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt);
-ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off);
-ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off);
+ssize_t sys_pread(int fd, void *buf, size_t count, off_t off);
+ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off);
ssize_t sys_send(int s, const void *msg, size_t len, int flags);
-ssize_t sys_sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
-ssize_t sys_recv(int fd, void *buf, size_t count, int flags);
ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
int sys_fcntl_ptr(int fd, int cmd, void *arg);
int sys_fcntl_long(int fd, int cmd, long arg);
bool fake_dir_create_times);
int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
bool fake_dir_create_times);
-int sys_ftruncate(int fd, SMB_OFF_T offset);
-int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len);
-int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len);
-SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence);
-int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence);
-SMB_OFF_T sys_ftell(FILE *fp);
-int sys_creat(const char *path, mode_t mode);
-int sys_open(const char *path, int oflag, mode_t mode);
-FILE *sys_fopen(const char *path, const char *type);
+int sys_posix_fallocate(int fd, off_t offset, off_t len);
+int sys_fallocate(int fd, enum vfs_fallocate_mode mode, off_t offset, off_t len);
void kernel_flock(int fd, uint32 share_mode, uint32 access_mask);
-SMB_STRUCT_DIR *sys_opendir(const char *name);
-SMB_STRUCT_DIR *sys_fdopendir(int fd);
-SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp);
-void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset);
-long sys_telldir(SMB_STRUCT_DIR *dirp);
-void sys_rewinddir(SMB_STRUCT_DIR *dirp);
-int sys_closedir(SMB_STRUCT_DIR *dirp);
+DIR *sys_fdopendir(int fd);
int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev);
int sys_waitpid(pid_t pid,int *status,int options);
char *sys_getwd(void);
int sys_popen(const char *command);
int sys_pclose(int fd);
ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size);
-ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size);
ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size);
ssize_t sys_listxattr (const char *path, char *list, size_t size);
-ssize_t sys_llistxattr (const char *path, char *list, size_t size);
ssize_t sys_flistxattr (int filedes, char *list, size_t size);
int sys_removexattr (const char *path, const char *name);
-int sys_lremovexattr (const char *path, const char *name);
int sys_fremovexattr (int filedes, const char *name);
int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags);
-int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags);
int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags);
uint32 unix_dev_major(SMB_DEV_T dev);
uint32 unix_dev_minor(SMB_DEV_T dev);
+#if 0
+int sys_get_number_of_cores(void);
+#endif
int sys_aio_read(SMB_STRUCT_AIOCB *aiocb);
int sys_aio_write(SMB_STRUCT_AIOCB *aiocb);
ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb);
int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb);
int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout);
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
-struct stat64;
-void init_stat_ex_from_stat (struct stat_ex *dst,
- const struct stat64 *src,
- bool fake_dir_create_times);
-#else
struct stat;
void init_stat_ex_from_stat (struct stat_ex *dst,
const struct stat *src,
bool fake_dir_create_times);
-#endif
/* The following definitions come from lib/system_smbd.c */
bool fake_dir_create_times);
bool socket_exist(const char *fname);
uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf);
-SMB_OFF_T get_file_size(char *file_name);
+bool check_same_dev_ino(const SMB_STRUCT_STAT *sbuf1,
+ const SMB_STRUCT_STAT *sbuf2);
+bool check_same_stat(const SMB_STRUCT_STAT *sbuf1,
+ const SMB_STRUCT_STAT *sbuf2);
void show_msg(const char *buf);
-void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num);
-void smb_setlen(char *buf,int len);
int set_message_bcc(char *buf,int num_bytes);
ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob);
char *unix_clean_name(TALLOC_CTX *ctx, const char *s);
char *clean_name(TALLOC_CTX *ctx, const char *s);
-ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos);
+ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, off_t pos);
int set_blocking(int fd, bool set);
+NTSTATUS init_before_fork(void);
NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
struct event_context *ev_ctx,
- struct server_id id,
bool parent_longlived);
void *malloc_(size_t size);
-void *memalign_array(size_t el_size, size_t align, unsigned int count);
-void *calloc_array(size_t size, size_t nmemb);
void *Realloc(void *p, size_t size, bool free_old_on_error);
void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
void *element, void *_array, uint32 *num_elements,
char *automount_lookup(TALLOC_CTX *ctx, const char *user_name);
char *automount_lookup(TALLOC_CTX *ctx, const char *user_name);
bool process_exists(const struct server_id pid);
+bool processes_exist(const struct server_id *pids, int num_pids,
+ bool *results);
const char *uidtoname(uid_t uid);
char *gidtoname(gid_t gid);
uid_t nametouid(const char *name);
gid_t nametogid(const char *name);
void smb_panic_s3(const char *why);
void log_stack_trace(void);
-const char *readdirname(SMB_STRUCT_DIR *p);
+const char *readdirname(DIR *p);
bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive);
void set_namearray(name_compare_entry **ppname_array, const char *namelist);
void free_namearray(name_compare_entry *name_array);
-bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
-bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid);
+bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type);
+bool fcntl_getlock(int fd, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid);
bool is_myname(const char *s);
-bool is_myworkgroup(const char *s);
void ra_lanman_string( const char *native_lanman );
const char *get_remote_arch_str(void);
void set_remote_arch(enum remote_arch_types type);
char *myhostname(void);
char *myhostname_upper(void);
char *lock_path(const char *name);
-char *pid_path(const char *name);
char *state_path(const char *name);
char *cache_path(const char *name);
bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
void set_my_unique_id(uint64_t unique_id);
struct server_id pid_to_procid(pid_t pid);
struct server_id procid_self(void);
-bool procid_equal(const struct server_id *p1, const struct server_id *p2);
-bool cluster_id_equal(const struct server_id *id1,
- const struct server_id *id2);
+struct server_id *new_server_id_task(TALLOC_CTX *mem_ctx);
+bool serverid_equal(const struct server_id *p1, const struct server_id *p2);
bool procid_is_me(const struct server_id *pid);
struct server_id interpret_pid(const char *pid_string);
char *procid_str_static(const struct server_id *pid);
bool procid_valid(const struct server_id *pid);
bool procid_is_local(const struct server_id *pid);
-bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length);
bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off);
char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off);
char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off);
char **domain,
char **user);
const char *strip_hostname(const char *s);
-bool tevent_req_poll_ntstatus(struct tevent_req *req,
- struct tevent_context *ev,
- NTSTATUS *status);
bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result);
int timeval_to_msec(struct timeval t);
char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname);
uint32 *pcreate_disposition,
uint32 *pcreate_options,
uint32_t *pprivate_flags);
-
-/* The following definitions come from lib/util_cmdline.c */
-
-struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx);
-const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info);
-void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
- const char *username);
-const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info);
-void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
- const char *domain);
-void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
- const char *password);
-const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info);
-bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
- const char *arg);
-int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info);
-void set_cmdline_auth_info_use_ccache(struct user_auth_info *auth_info,
- bool b);
-bool get_cmdline_auth_info_use_ccache(const struct user_auth_info *auth_info);
-void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
- bool b);
-bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info);
-void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
- bool b);
-bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info);
-void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info);
-void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
-void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
-bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info);
-bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info);
-bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info);
-bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info);
-void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info);
+struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok);
+void init_modules(void);
/* The following definitions come from lib/util_builtin.c */
const char *builtin_domain_name(void);
bool sid_check_is_builtin(const struct dom_sid *sid);
bool sid_check_is_in_builtin(const struct dom_sid *sid);
+bool sid_check_is_wellknown_builtin(const struct dom_sid *sid);
/* The following definitions come from lib/util_file.c */
void restore_re_gid(void);
int set_re_uid(void);
void become_user_permanently(uid_t uid, gid_t gid);
+int set_thread_credentials(uid_t uid,
+ gid_t gid,
+ size_t setlen,
+ const gid_t *gidset);
bool is_setuid_root(void) ;
/* The following definitions come from lib/util_sid.c */
char **principal,
DATA_BLOB *secblob);
DATA_BLOB spnego_gen_krb5_wrap(TALLOC_CTX *ctx, const DATA_BLOB ticket, const uint8 tok_id[2]);
-bool spnego_parse_krb5_wrap(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2]);
int spnego_gen_krb5_negTokenInit(TALLOC_CTX *ctx,
const char *principal, int time_offset,
DATA_BLOB *targ,
bool spnego_parse_challenge(TALLOC_CTX *ctx, const DATA_BLOB blob,
DATA_BLOB *chal1, DATA_BLOB *chal2);
DATA_BLOB spnego_gen_auth(TALLOC_CTX *ctx, DATA_BLOB blob);
-bool spnego_parse_auth(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *auth);
-DATA_BLOB spnego_gen_auth_response(TALLOC_CTX *ctx, DATA_BLOB *reply, NTSTATUS nt_status,
- const char *mechOID);
bool spnego_parse_auth_response(TALLOC_CTX *ctx,
DATA_BLOB blob, NTSTATUS nt_status,
const char *mechOID,
DATA_BLOB *auth);
-bool spnego_parse_auth_and_mic(TALLOC_CTX *ctx, DATA_BLOB blob,
- DATA_BLOB *auth, DATA_BLOB *signature);
-DATA_BLOB spnego_gen_auth_response_and_mic(TALLOC_CTX *ctx,
- NTSTATUS nt_status,
- const char *mechOID,
- DATA_BLOB *reply,
- DATA_BLOB *mechlistMIC);
-bool spnego_mech_list_blob(TALLOC_CTX *mem_ctx,
- char **oid_list, DATA_BLOB *data);
-
/* The following definitions come from libsmb/conncache.c */
NTSTATUS check_negative_conn_cache( const char *domain, const char *server);
/* The following definitions come from libsmb/errormap.c */
NTSTATUS dos_to_ntstatus(uint8 eclass, uint32 ecode);
-NTSTATUS map_nt_error_from_gss(uint32 gss_maj, uint32 minor);
/* The following definitions come from libsmb/namecache.c */
const struct sockaddr_storage *to_ss,
fstring name);
int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2);
+int remove_duplicate_addrs2(struct ip_service *iplist, int count );
struct tevent_req *name_query_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
const char *name, int name_type,
/* The following definitions come from libsmb/ntlmssp.c */
struct ntlmssp_state;
NTSTATUS ntlmssp_set_username(struct ntlmssp_state *ntlmssp_state, const char *user) ;
-NTSTATUS ntlmssp_set_hashes(struct ntlmssp_state *ntlmssp_state,
- const uint8_t lm_hash[16],
- const uint8_t nt_hash[16]) ;
NTSTATUS ntlmssp_set_password(struct ntlmssp_state *ntlmssp_state, const char *password) ;
+NTSTATUS ntlmssp_set_password_hash(struct ntlmssp_state *ntlmssp_state,
+ const char *hash);
NTSTATUS ntlmssp_set_domain(struct ntlmssp_state *ntlmssp_state, const char *domain) ;
void ntlmssp_want_feature_list(struct ntlmssp_state *ntlmssp_state, char *feature_list);
void ntlmssp_want_feature(struct ntlmssp_state *ntlmssp_state, uint32_t feature);
NTSTATUS ntlmssp_update(struct ntlmssp_state *ntlmssp_state,
const DATA_BLOB in, DATA_BLOB *out) ;
+bool ntlmssp_is_anonymous(struct ntlmssp_state *ntlmssp_state);
NTSTATUS ntlmssp_server_start(TALLOC_CTX *mem_ctx,
bool is_standalone,
const char *netbios_name,
bool trustdom_cache_enable(void);
bool trustdom_cache_shutdown(void);
-bool trustdom_cache_store(char* name, char* alt_name, const struct dom_sid *sid,
- time_t timeout);
+bool trustdom_cache_store(const char *name, const char *alt_name,
+ const struct dom_sid *sid, time_t timeout);
bool trustdom_cache_fetch(const char* name, struct dom_sid* sid);
uint32 trustdom_cache_fetch_timestamp( void );
bool trustdom_cache_store_timestamp( uint32 t, time_t timeout );
NTSTATUS trust_pw_find_change_and_store_it(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
const char *domain) ;
-bool enumerate_domain_trusts( TALLOC_CTX *mem_ctx, const char *domain,
- char ***domain_names, uint32 *num_domains,
- struct dom_sid **sids );
NTSTATUS change_trust_account_password( const char *domain, const char *remote_machine);
/* The following definitions come from param/loadparm.c */
const char *lp_smb_ports(void);
const char *lp_dos_charset(void);
const char *lp_unix_charset(void);
-char *lp_logfile(void);
-char *lp_configfile(void);
+char *lp_logfile(TALLOC_CTX *ctx);
+char *lp_configfile(TALLOC_CTX *ctx);
const char *lp_smb_passwd_file(void);
const char *lp_private_dir(void);
-char *lp_serverstring(void);
+char *lp_serverstring(TALLOC_CTX *ctx);
int lp_printcap_cache_time(void);
-char *lp_addport_cmd(void);
-char *lp_enumports_cmd(void);
-char *lp_addprinter_cmd(void);
-char *lp_deleteprinter_cmd(void);
-char *lp_os2_driver_map(void);
+char *lp_addport_cmd(TALLOC_CTX *ctx);
+char *lp_enumports_cmd(TALLOC_CTX *ctx);
+char *lp_addprinter_cmd(TALLOC_CTX *ctx);
+char *lp_deleteprinter_cmd(TALLOC_CTX *ctx);
+char *lp_os2_driver_map(TALLOC_CTX *ctx);
const char *lp_lockdir(void);
const char *lp_statedir(void);
const char *lp_cachedir(void);
const char *lp_piddir(void);
-char *lp_mangling_method(void);
+char *lp_mangling_method(TALLOC_CTX *ctx);
int lp_mangle_prefix(void);
const char *lp_utmpdir(void);
const char *lp_wtmpdir(void);
bool lp_utmp(void);
-char *lp_rootdir(void);
-char *lp_defaultservice(void);
-char *lp_msg_command(void);
-char *lp_get_quota_command(void);
-char *lp_set_quota_command(void);
-char *lp_auto_services(void);
-char *lp_passwd_program(void);
-char *lp_passwd_chat(void);
+char *lp_rootdir(TALLOC_CTX *ctx);
+char *lp_defaultservice(TALLOC_CTX *ctx);
+char *lp_msg_command(TALLOC_CTX *ctx);
+char *lp_get_quota_command(TALLOC_CTX *ctx);
+char *lp_set_quota_command(TALLOC_CTX *ctx);
+char *lp_auto_services(TALLOC_CTX *ctx);
+char *lp_passwd_program(TALLOC_CTX *ctx);
+char *lp_passwd_chat(TALLOC_CTX *ctx);
const char *lp_passwordserver(void);
const char *lp_name_resolve_order(void);
const char *lp_netbios_scope(void);
const char *lp_dnsdomain(void);
const char *lp_afs_username_map(void);
int lp_afs_token_lifetime(void);
-char *lp_log_nt_token_command(void);
-char *lp_username_map(void);
+char *lp_log_nt_token_command(TALLOC_CTX *ctx);
+char *lp_username_map(TALLOC_CTX *ctx);
const char *lp_logon_script(void);
const char *lp_logon_path(void);
const char *lp_logon_drive(void);
const char *lp_logon_home(void);
-char *lp_remote_announce(void);
-char *lp_remote_browse_sync(void);
+char *lp_remote_announce(TALLOC_CTX *ctx);
+char *lp_remote_browse_sync(TALLOC_CTX *ctx);
bool lp_nmbd_bind_explicit_broadcast(void);
const char **lp_wins_server_list(void);
const char **lp_interfaces(void);
const char *lp_socket_address(void);
-char *lp_nis_home_map_name(void);
+char *lp_nis_home_map_name(TALLOC_CTX *ctx);
const char **lp_netbios_aliases(void);
const char *lp_passdb_backend(void);
const char **lp_preload_modules(void);
-char *lp_panic_action(void);
-char *lp_adduser_script(void);
-char *lp_renameuser_script(void);
-char *lp_deluser_script(void);
+char *lp_panic_action(TALLOC_CTX *ctx);
+char *lp_adduser_script(TALLOC_CTX *ctx);
+char *lp_renameuser_script(TALLOC_CTX *ctx);
+char *lp_deluser_script(TALLOC_CTX *ctx);
const char *lp_guestaccount(void);
-char *lp_addgroup_script(void);
-char *lp_delgroup_script(void);
-char *lp_addusertogroup_script(void);
-char *lp_deluserfromgroup_script(void);
-char *lp_setprimarygroup_script(void);
-char *lp_addmachine_script(void);
-char *lp_shutdown_script(void);
-char *lp_abort_shutdown_script(void);
-char *lp_username_map_script(void);
+char *lp_addgroup_script(TALLOC_CTX *ctx);
+char *lp_delgroup_script(TALLOC_CTX *ctx);
+char *lp_addusertogroup_script(TALLOC_CTX *ctx);
+char *lp_deluserfromgroup_script(TALLOC_CTX *ctx);
+char *lp_setprimarygroup_script(TALLOC_CTX *ctx);
+char *lp_addmachine_script(TALLOC_CTX *ctx);
+char *lp_shutdown_script(TALLOC_CTX *ctx);
+char *lp_abort_shutdown_script(TALLOC_CTX *ctx);
+char *lp_username_map_script(TALLOC_CTX *ctx);
int lp_username_map_cache_time(void);
-char *lp_check_password_script(void);
-char *lp_wins_hook(void);
+char *lp_check_password_script(TALLOC_CTX *ctx);
+char *lp_wins_hook(TALLOC_CTX *ctx);
const char *lp_template_homedir(void);
const char *lp_template_shell(void);
const char *lp_winbind_separator(void);
int lp_idmap_negative_cache_time(void);
int lp_keepalive(void);
bool lp_passdb_expand_explicit(void);
-char *lp_ldap_suffix(void);
-char *lp_ldap_admin_dn(void);
+char *lp_ldap_suffix(TALLOC_CTX *ctx);
+char *lp_ldap_admin_dn(TALLOC_CTX *ctx);
int lp_ldap_ssl(void);
bool lp_ldap_ssl_ads(void);
int lp_ldap_deref(void);
int lp_ldap_page_size(void);
int lp_ldap_debug_level(void);
int lp_ldap_debug_threshold(void);
-char *lp_add_share_cmd(void);
-char *lp_change_share_cmd(void);
-char *lp_delete_share_cmd(void);
-char *lp_usershare_path(void);
+char *lp_add_share_cmd(TALLOC_CTX *ctx);
+char *lp_change_share_cmd(TALLOC_CTX *ctx);
+char *lp_delete_share_cmd(TALLOC_CTX *ctx);
+char *lp_usershare_path(TALLOC_CTX *ctx);
const char **lp_usershare_prefix_allow_list(void);
const char **lp_usershare_prefix_deny_list(void);
const char **lp_eventlog_list(void);
bool lp_reset_on_zero_vc(void);
bool lp_log_writeable_files_on_exit(void);
bool lp_ms_add_printer_wizard(void);
-bool lp_dns_proxy(void);
+bool lp_wins_dns_proxy(void);
bool lp_we_are_a_wins_server(void);
bool lp_wins_proxy(void);
bool lp_local_master(void);
-bool lp_domain_logons(void);
const char **lp_init_logon_delayed_hosts(void);
int lp_init_logon_delay(void);
bool lp_load_printers(void);
bool lp_readraw(void);
-bool _lp_readraw(void);
bool lp_large_readwrite(void);
bool lp_writeraw(void);
-bool _lp_writeraw(void);
bool lp_null_passwords(void);
bool lp_obey_pam_restrictions(void);
bool lp_encrypted_passwords(void);
bool lp_client_lanman_auth(void);
bool lp_client_ntlmv2_auth(void);
bool lp_host_msdfs(void);
-bool lp_kernel_oplocks(void);
bool lp_enhanced_browsing(void);
bool lp_use_mmap(void);
bool lp_unix_extensions(void);
bool lp_use_spnego(void);
bool lp_client_use_spnego(void);
bool lp_client_use_spnego_principal(void);
-bool lp_send_spnego_principal(void);
bool lp_hostname_lookups(void);
bool lp_change_notify(const struct share_params *p );
bool lp_kernel_change_notify(const struct share_params *p );
int lp_max_log_size(void);
int lp_max_open_files(void);
int lp_open_files_db_hash_size(void);
-int lp_maxxmit(void);
+int lp_max_xmit(void);
int lp_maxmux(void);
int lp_passwordlevel(void);
int lp_usernamelevel(void);
int lp_deadtime(void);
bool lp_getwd_cache(void);
-int lp_maxprotocol(void);
-int lp_minprotocol(void);
+int lp_srv_maxprotocol(void);
+int lp_srv_minprotocol(void);
int lp_security(void);
const char **lp_auth_methods(void);
bool lp_paranoid_server_security(void);
int lp_maxdisksize(void);
int lp_lpqcachetime(void);
int lp_max_smbd_processes(void);
-bool _lp_disable_spoolss(void);
+bool lp__disable_spoolss(void);
int lp_syslog(void);
int lp_lm_announce(void);
int lp_lm_interval(void);
int lp_smb2_max_write(void);
int lp_smb2_max_trans(void);
int lp_smb2_max_credits(void);
-char *lp_preexec(int );
-char *lp_postexec(int );
-char *lp_rootpreexec(int );
-char *lp_rootpostexec(int );
-char *lp_servicename(int );
+char *lp_preexec(TALLOC_CTX *ctx, int );
+char *lp_postexec(TALLOC_CTX *ctx, int );
+char *lp_rootpreexec(TALLOC_CTX *ctx, int );
+char *lp_rootpostexec(TALLOC_CTX *ctx, int );
+char *lp_servicename(TALLOC_CTX *ctx, int );
const char *lp_const_servicename(int );
-char *lp_pathname(int );
-char *lp_dontdescend(int );
-char *lp_username(int );
+char *lp_pathname(TALLOC_CTX *ctx, int );
+char *lp_dontdescend(TALLOC_CTX *ctx, int );
+char *lp_username(TALLOC_CTX *ctx, int );
const char **lp_invalid_users(int );
const char **lp_valid_users(int );
const char **lp_admin_users(int );
const char **lp_svcctl_list(void);
-char *lp_cups_options(int );
-char *lp_cups_server(void);
+char *lp_cups_options(TALLOC_CTX *ctx, int );
+char *lp_cups_server(TALLOC_CTX *ctx);
int lp_cups_encrypt(void);
-char *lp_iprint_server(void);
+char *lp_iprint_server(TALLOC_CTX *ctx);
int lp_cups_connection_timeout(void);
const char *lp_ctdbd_socket(void);
+const char *_lp_ctdbd_socket(void);
const char **lp_cluster_addresses(void);
bool lp_clustering(void);
int lp_ctdb_timeout(void);
int lp_ctdb_locktime_warn_threshold(void);
-char *lp_printcommand(int );
-char *lp_lpqcommand(int );
-char *lp_lprmcommand(int );
-char *lp_lppausecommand(int );
-char *lp_lpresumecommand(int );
-char *lp_queuepausecommand(int );
-char *lp_queueresumecommand(int );
+char *lp_printcommand(TALLOC_CTX *ctx, int );
+char *lp_lpqcommand(TALLOC_CTX *ctx, int );
+char *lp_lprmcommand(TALLOC_CTX *ctx, int );
+char *lp_lppausecommand(TALLOC_CTX *ctx, int );
+char *lp_lpresumecommand(TALLOC_CTX *ctx, int );
+char *lp_queuepausecommand(TALLOC_CTX *ctx, int );
+char *lp_queueresumecommand(TALLOC_CTX *ctx, int );
const char *lp_printjob_username(int );
const char **lp_hostsallow(int );
const char **lp_hostsdeny(int );
-char *lp_magicscript(int );
-char *lp_magicoutput(int );
-char *lp_comment(int );
-char *lp_force_user(int );
-char *lp_force_group(int );
+char *lp_magicscript(TALLOC_CTX *ctx, int );
+char *lp_magicoutput(TALLOC_CTX *ctx, int );
+char *lp_comment(TALLOC_CTX *ctx, int );
+char *lp_force_user(TALLOC_CTX *ctx, int );
+char *lp_force_group(TALLOC_CTX *ctx, int );
const char **lp_readlist(int );
const char **lp_writelist(int );
-const char **lp_printer_admin(int );
-char *lp_fstype(int );
+char *lp_fstype(TALLOC_CTX *ctx, int );
const char **lp_vfs_objects(int );
-char *lp_msdfs_proxy(int );
-char *lp_veto_files(int );
-char *lp_hide_files(int );
-char *lp_veto_oplocks(int );
+char *lp_msdfs_proxy(TALLOC_CTX *ctx, int );
+char *lp_veto_files(TALLOC_CTX *ctx, int );
+char *lp_hide_files(TALLOC_CTX *ctx, int );
+char *lp_veto_oplocks(TALLOC_CTX *ctx, int );
bool lp_msdfs_root(int );
-char *lp_aio_write_behind(int );
-char *lp_dfree_command(int );
+char *lp_aio_write_behind(TALLOC_CTX *ctx, int );
+char *lp_dfree_command(TALLOC_CTX *ctx, int );
bool lp_autoloaded(int );
bool lp_preexec_close(int );
bool lp_rootpreexec_close(int );
bool lp_locking(const struct share_params *p );
int lp_strict_locking(const struct share_params *p );
bool lp_posix_locking(const struct share_params *p );
-bool lp_share_modes(int );
bool lp_oplocks(int );
+bool lp_kernel_oplocks(int );
bool lp_level2_oplocks(int );
bool lp_onlyuser(int );
bool lp_manglednames(const struct share_params *p );
int lp_client_signing(void);
int lp_server_signing(void);
int lp_client_ldap_sasl_wrapping(void);
-char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def);
+char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def);
const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def);
struct loadparm_service;
const char *lp_parm_const_string_service(struct loadparm_service *service, const char *type, const char *option);
bool lp_file_list_changed(void);
bool lp_idmap_uid(uid_t *low, uid_t *high);
bool lp_idmap_gid(gid_t *low, gid_t *high);
-const char *lp_ldap_machine_suffix(void);
-const char *lp_ldap_user_suffix(void);
-const char *lp_ldap_group_suffix(void);
-const char *lp_ldap_idmap_suffix(void);
+const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx);
+const char *lp_ldap_user_suffix(TALLOC_CTX *ctx);
+const char *lp_ldap_group_suffix(TALLOC_CTX *ctx);
+const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx);
struct parm_struct;
/* Return a pointer to a service by name. */
struct loadparm_service *lp_service(const char *pszServiceName);
struct security_descriptor **ppsd,
bool *pallow_guest);
int load_usershare_service(const char *servicename);
-int load_usershare_shares(struct smbd_server_connection *sconn);
+int load_usershare_shares(struct smbd_server_connection *sconn,
+ bool (*snumused) (struct smbd_server_connection *, int));
void gfree_loadparm(void);
bool lp_load(const char *pszFname,
bool global_only,
void lp_dump(FILE *f, bool show_defaults, int maxtoprint);
void lp_dump_one(FILE * f, bool show_defaults, int snum);
int lp_servicenumber(const char *pszServiceName);
-bool share_defined(const char *service_name);
struct share_params *get_share_params(TALLOC_CTX *mem_ctx,
const char *sharename);
-const char *volume_label(int snum);
+const char *volume_label(TALLOC_CTX *ctx, int snum);
bool lp_domain_master(void);
-bool lp_domain_master_true_or_auto(void);
bool lp_preferred_master(void);
void lp_remove_service(int snum);
void lp_copy_service(int snum, const char *new_name);
int lp_default_server_announce(void);
void lp_set_name_resolve_order(const char *new_order);
-const char *lp_printername(int snum);
+const char *lp_printername(TALLOC_CTX *ctx, int snum);
void lp_set_logfile(const char *name);
int lp_maxprintjobs(int snum);
const char *lp_printcapname(void);
enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp);
void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val);
int lp_min_receive_file_size(void);
-char* lp_perfcount_module(void);
+char* lp_perfcount_module(TALLOC_CTX *ctx);
void widelinks_warning(int snum);
const char *lp_ncalrpc_dir(void);
+void _lp_set_server_role(int server_role);
/* The following definitions come from param/loadparm_ctx.c */
-const struct loadparm_s3_context *loadparm_s3_context(void);
+const struct loadparm_s3_helpers *loadparm_s3_helpers(void);
/* The following definitions come from param/loadparm_server_role.c */
struct sessionid;
bool sessionid_init(void);
struct db_record *sessionid_fetch_record(TALLOC_CTX *mem_ctx, const char *key);
-int sessionid_traverse(int (*fn)(struct db_record *rec, const char *key,
- struct sessionid *session,
- void *private_data),
- void *private_data);
-int sessionid_traverse_read(int (*fn)(const char *key,
+NTSTATUS sessionid_traverse(int (*fn)(struct db_record *rec, const char *key,
struct sessionid *session,
void *private_data),
void *private_data);
+NTSTATUS sessionid_traverse_read(int (*fn)(const char *key,
+ struct sessionid *session,
+ void *private_data),
+ void *private_data);
/* The following definitions come from utils/passwd_util.c */
struct smb_filename **smb_fname_out);
const char *smb_fname_str_dbg(const struct smb_filename *smb_fname);
const char *fsp_str_dbg(const struct files_struct *fsp);
+const char *fsp_fnum_dbg(const struct files_struct *fsp);
NTSTATUS copy_smb_filename(TALLOC_CTX *ctx,
const struct smb_filename *smb_fname_in,
struct smb_filename **smb_fname_out);
/* The following definitions come from lib/dummysmbd.c */
int find_service(TALLOC_CTX *ctx, const char *service_in, char **p_service_out);
-bool conn_snum_used(struct smbd_server_connection *sconn, int snum);
void cancel_pending_lock_requests_by_fid(files_struct *fsp,
struct byte_range_lock *br_lck,
enum file_close_type close_type);