*/
#include "includes.h"
-
-extern char *global_clobber_region_function;
-extern unsigned int global_clobber_region_line;
+#include "system/passwd.h"
+#include "system/filesys.h"
+#include "util_tdb.h"
+#include "ctdbd_conn.h"
+#include "../lib/util/util_pw.h"
+#include "messages.h"
/* Max allowable allococation - 256mb - 0x10000000 */
#define MAX_ALLOC_SIZE (1024*1024*256)
static enum remote_arch_types ra_type = RA_UNKNOWN;
-/***********************************************************************
- Definitions for all names.
-***********************************************************************/
-
-static char *smb_myname;
-static char *smb_myworkgroup;
-static char *smb_scope;
-static int smb_num_netbios_names;
-static char **smb_my_netbios_names;
-
-/***********************************************************************
- Allocate and set myname. Ensure upper case.
-***********************************************************************/
-
-bool set_global_myname(const char *myname)
-{
- SAFE_FREE(smb_myname);
- smb_myname = SMB_STRDUP(myname);
- if (!smb_myname)
- return False;
- strupper_m(smb_myname);
- return True;
-}
-
-const char *global_myname(void)
-{
- return smb_myname;
-}
-
-/***********************************************************************
- Allocate and set myworkgroup. Ensure upper case.
-***********************************************************************/
-
-bool set_global_myworkgroup(const char *myworkgroup)
-{
- SAFE_FREE(smb_myworkgroup);
- smb_myworkgroup = SMB_STRDUP(myworkgroup);
- if (!smb_myworkgroup)
- return False;
- strupper_m(smb_myworkgroup);
- return True;
-}
-
-const char *lp_workgroup(void)
-{
- return smb_myworkgroup;
-}
-
-/***********************************************************************
- Allocate and set scope. Ensure upper case.
-***********************************************************************/
-
-bool set_global_scope(const char *scope)
-{
- SAFE_FREE(smb_scope);
- smb_scope = SMB_STRDUP(scope);
- if (!smb_scope)
- return False;
- strupper_m(smb_scope);
- return True;
-}
-
-/*********************************************************************
- Ensure scope is never null string.
-*********************************************************************/
-
-const char *global_scope(void)
-{
- if (!smb_scope)
- set_global_scope("");
- return smb_scope;
-}
-
-static void free_netbios_names_array(void)
-{
- int i;
-
- for (i = 0; i < smb_num_netbios_names; i++)
- SAFE_FREE(smb_my_netbios_names[i]);
-
- SAFE_FREE(smb_my_netbios_names);
- smb_num_netbios_names = 0;
-}
-
-static bool allocate_my_netbios_names_array(size_t number)
-{
- free_netbios_names_array();
-
- smb_num_netbios_names = number + 1;
- smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
-
- if (!smb_my_netbios_names)
- return False;
-
- memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
- return True;
-}
-
-static bool set_my_netbios_names(const char *name, int i)
-{
- SAFE_FREE(smb_my_netbios_names[i]);
-
- smb_my_netbios_names[i] = SMB_STRDUP(name);
- if (!smb_my_netbios_names[i])
- return False;
- strupper_m(smb_my_netbios_names[i]);
- return True;
-}
-
-/***********************************************************************
- Free memory allocated to global objects
-***********************************************************************/
-
-void gfree_names(void)
-{
- SAFE_FREE( smb_myname );
- SAFE_FREE( smb_myworkgroup );
- SAFE_FREE( smb_scope );
- free_netbios_names_array();
- free_local_machine_name();
-}
-
void gfree_all( void )
{
gfree_names();
gfree_loadparm();
- gfree_case_tables();
gfree_charcnv();
gfree_interfaces();
gfree_debugsyms();
}
-const char *my_netbios_names(int i)
-{
- return smb_my_netbios_names[i];
-}
-
-bool set_netbios_aliases(const char **str_array)
-{
- size_t namecount;
-
- /* Work out the max number of netbios aliases that we have */
- for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
- ;
-
- if ( global_myname() && *global_myname())
- namecount++;
-
- /* Allocate space for the netbios aliases */
- if (!allocate_my_netbios_names_array(namecount))
- return False;
-
- /* Use the global_myname string first */
- namecount=0;
- if ( global_myname() && *global_myname()) {
- set_my_netbios_names( global_myname(), namecount );
- namecount++;
- }
-
- if (str_array) {
- size_t i;
- for ( i = 0; str_array[i] != NULL; i++) {
- size_t n;
- bool duplicate = False;
-
- /* Look for duplicates */
- for( n=0; n<namecount; n++ ) {
- if( strequal( str_array[i], my_netbios_names(n) ) ) {
- duplicate = True;
- break;
- }
- }
- if (!duplicate) {
- if (!set_my_netbios_names(str_array[i], namecount))
- return False;
- namecount++;
- }
- }
- }
- return True;
-}
-
-/****************************************************************************
- Common name initialization code.
-****************************************************************************/
-
-bool init_names(void)
-{
- int n;
-
- if (global_myname() == NULL || *global_myname() == '\0') {
- if (!set_global_myname(myhostname())) {
- DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
- return False;
- }
- }
-
- if (!set_netbios_aliases(lp_netbios_aliases())) {
- DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
- return False;
- }
-
- set_local_machine_name(global_myname(),false);
-
- DEBUG( 5, ("Netbios name list:-\n") );
- for( n=0; my_netbios_names(n); n++ ) {
- DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
- n, my_netbios_names(n) ) );
- }
-
- return( True );
-}
-
-/**************************************************************************n
- Code to cope with username/password auth options from the commandline.
- Used mainly in client tools.
-****************************************************************************/
-
-struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
-{
- struct user_auth_info *result;
-
- result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
- if (result == NULL) {
- return NULL;
- }
-
- result->signing_state = Undefined;
- return result;
-}
-
-const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
-{
- if (!auth_info->username) {
- return "";
- }
- return auth_info->username;
-}
-
-void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
- const char *username)
-{
- TALLOC_FREE(auth_info->username);
- auth_info->username = talloc_strdup(auth_info, username);
- if (!auth_info->username) {
- exit(ENOMEM);
- }
-}
-
-const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
-{
- if (!auth_info->domain) {
- return "";
- }
- return auth_info->domain;
-}
-
-void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
- const char *domain)
-{
- TALLOC_FREE(auth_info->domain);
- auth_info->domain = talloc_strdup(auth_info, domain);
- if (!auth_info->domain) {
- exit(ENOMEM);
- }
-}
-
-const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
-{
- if (!auth_info->password) {
- return "";
- }
- return auth_info->password;
-}
-
-void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
- const char *password)
-{
- TALLOC_FREE(auth_info->password);
- if (password == NULL) {
- password = "";
- }
- auth_info->password = talloc_strdup(auth_info, password);
- if (!auth_info->password) {
- exit(ENOMEM);
- }
- auth_info->got_pass = true;
-}
-
-bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
- const char *arg)
-{
- auth_info->signing_state = -1;
- if (strequal(arg, "off") || strequal(arg, "no") ||
- strequal(arg, "false")) {
- auth_info->signing_state = false;
- } else if (strequal(arg, "on") || strequal(arg, "yes") ||
- strequal(arg, "true") || strequal(arg, "auto")) {
- auth_info->signing_state = true;
- } else if (strequal(arg, "force") || strequal(arg, "required") ||
- strequal(arg, "forced")) {
- auth_info->signing_state = Required;
- } else {
- return false;
- }
- return true;
-}
-
-int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
-{
- return auth_info->signing_state;
-}
-
-void set_cmdline_auth_info_use_ccache(struct user_auth_info *auth_info, bool b)
-{
- auth_info->use_ccache = b;
-}
-
-bool get_cmdline_auth_info_use_ccache(const struct user_auth_info *auth_info)
-{
- return auth_info->use_ccache;
-}
-
-void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
- bool b)
-{
- auth_info->use_kerberos = b;
-}
-
-bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
-{
- return auth_info->use_kerberos;
-}
-
-void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
- bool b)
-{
- auth_info->fallback_after_kerberos = b;
-}
-
-bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
-{
- return auth_info->fallback_after_kerberos;
-}
-
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
-{
- auth_info->use_kerberos = true;
- auth_info->got_pass = true;
-}
-
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
-{
- auth_info->smb_encrypt = true;
-}
-
-void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
-{
- auth_info->use_machine_account = true;
-}
-
-bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
-{
- return auth_info->got_pass;
-}
-
-bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
-{
- return auth_info->smb_encrypt;
-}
-
-bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
-{
- return auth_info->use_machine_account;
-}
-
-struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
- const struct user_auth_info *src)
-{
- struct user_auth_info *result;
-
- result = user_auth_info_init(mem_ctx);
- if (result == NULL) {
- return NULL;
- }
-
- *result = *src;
-
- result->username = talloc_strdup(
- result, get_cmdline_auth_info_username(src));
- result->password = talloc_strdup(
- result, get_cmdline_auth_info_password(src));
- if ((result->username == NULL) || (result->password == NULL)) {
- TALLOC_FREE(result);
- return NULL;
- }
-
- return result;
-}
-
-bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
-{
- char *pass = NULL;
- char *account = NULL;
-
- if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
- return false;
- }
-
- if (!secrets_init()) {
- d_printf("ERROR: Unable to open secrets database\n");
- return false;
- }
-
- if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
- return false;
- }
-
- pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
- if (!pass) {
- d_printf("ERROR: Unable to fetch machine password for "
- "%s in domain %s\n",
- account, lp_workgroup());
- SAFE_FREE(account);
- return false;
- }
-
- set_cmdline_auth_info_username(auth_info, account);
- set_cmdline_auth_info_password(auth_info, pass);
-
- SAFE_FREE(account);
- SAFE_FREE(pass);
-
- return true;
-}
-
-/****************************************************************************
- Ensure we have a password if one not given.
-****************************************************************************/
-
-void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
-{
- char *label = NULL;
- char *pass;
- TALLOC_CTX *frame;
-
- if (get_cmdline_auth_info_got_pass(auth_info) ||
- get_cmdline_auth_info_use_kerberos(auth_info)) {
- /* Already got one... */
- return;
- }
-
- frame = talloc_stackframe();
- label = talloc_asprintf(frame, "Enter %s's password: ",
- get_cmdline_auth_info_username(auth_info));
- pass = getpass(label);
- if (pass) {
- set_cmdline_auth_info_password(auth_info, pass);
- }
- TALLOC_FREE(frame);
-}
-
/*******************************************************************
Check if a file exists - call vfs_file_exist for samba files.
********************************************************************/
return get_file_size_stat(&buf);
}
-/*******************************************************************
- Return a string representing an attribute for a file.
-********************************************************************/
-
-char *attrib_string(uint16 mode)
-{
- fstring attrstr;
-
- attrstr[0] = 0;
-
- if (mode & aVOLID) fstrcat(attrstr,"V");
- if (mode & aDIR) fstrcat(attrstr,"D");
- if (mode & aARCH) fstrcat(attrstr,"A");
- if (mode & aHIDDEN) fstrcat(attrstr,"H");
- if (mode & aSYSTEM) fstrcat(attrstr,"S");
- if (mode & aRONLY) fstrcat(attrstr,"R");
-
- return talloc_strdup(talloc_tos(), attrstr);
-}
-
/*******************************************************************
Show a smb message structure.
********************************************************************/
-void show_msg(char *buf)
+void show_msg(const char *buf)
{
int i;
int bcc=0;
if (DEBUGLEVEL < 50)
bcc = MIN(bcc, 512);
- dump_data(10, (uint8 *)smb_buf(buf), bcc);
+ dump_data(10, (const uint8 *)smb_buf_const(buf), bcc);
}
/*******************************************************************
#endif
}
-/*******************************************************************
- Sleep for a specified number of milliseconds.
-********************************************************************/
-
-void smb_msleep(unsigned int t)
-{
-#if defined(HAVE_NANOSLEEP)
- struct timespec tval;
- int ret;
-
- tval.tv_sec = t/1000;
- tval.tv_nsec = 1000000*(t%1000);
-
- do {
- errno = 0;
- ret = nanosleep(&tval, &tval);
- } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
-#else
- unsigned int tdiff=0;
- struct timeval tval,t1,t2;
- fd_set fds;
-
- GetTimeOfDay(&t1);
- t2 = t1;
-
- while (tdiff < t) {
- tval.tv_sec = (t-tdiff)/1000;
- tval.tv_usec = 1000*((t-tdiff)%1000);
-
- /* Never wait for more than 1 sec. */
- if (tval.tv_sec > 1) {
- tval.tv_sec = 1;
- tval.tv_usec = 0;
- }
-
- FD_ZERO(&fds);
- errno = 0;
- sys_select_intr(0,&fds,NULL,NULL,&tval);
-
- GetTimeOfDay(&t2);
- if (t2.tv_sec < t1.tv_sec) {
- /* Someone adjusted time... */
- t1 = t2;
- }
-
- tdiff = TvalDiff(&t1,&t2);
- }
-#endif
-}
NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
- struct event_context *ev_ctx,
- bool parent_longlived)
+ struct event_context *ev_ctx,
+ struct server_id id,
+ bool parent_longlived)
{
NTSTATUS status = NT_STATUS_OK;
* For clustering, we need to re-init our ctdbd connection after the
* fork
*/
- status = messaging_reinit(msg_ctx);
+ status = messaging_reinit(msg_ctx, id);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("messaging_reinit() failed: %s\n",
nt_errstr(status)));
return status;
}
-#if defined(PARANOID_MALLOC_CHECKER)
-
-/****************************************************************************
- Internal malloc wrapper. Externally visible.
-****************************************************************************/
-
-void *malloc_(size_t size)
-{
- if (size == 0) {
- return NULL;
- }
-#undef malloc
- return malloc(size);
-#define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
-}
-
-/****************************************************************************
- Internal calloc wrapper. Not externally visible.
-****************************************************************************/
-
-static void *calloc_(size_t count, size_t size)
-{
- if (size == 0 || count == 0) {
- return NULL;
- }
-#undef calloc
- return calloc(count, size);
-#define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
-}
-
-/****************************************************************************
- Internal realloc wrapper. Not externally visible.
-****************************************************************************/
-
-static void *realloc_(void *ptr, size_t size)
-{
-#undef realloc
- return realloc(ptr, size);
-#define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
-}
-
-#endif /* PARANOID_MALLOC_CHECKER */
-
-/****************************************************************************
- Type-safe memalign
-****************************************************************************/
-
-void *memalign_array(size_t el_size, size_t align, unsigned int count)
-{
- if (count >= MAX_ALLOC_SIZE/el_size) {
- return NULL;
- }
-
- return sys_memalign(align, el_size*count);
-}
-
-/****************************************************************************
- Type-safe calloc.
-****************************************************************************/
-
-void *calloc_array(size_t size, size_t nmemb)
-{
- if (nmemb >= MAX_ALLOC_SIZE/size) {
- return NULL;
- }
- if (size == 0 || nmemb == 0) {
- return NULL;
- }
-#if defined(PARANOID_MALLOC_CHECKER)
- return calloc_(nmemb, size);
-#else
- return calloc(nmemb, size);
-#endif
-}
-
-/****************************************************************************
- Expand a pointer to be a particular size.
- Note that this version of Realloc has an extra parameter that decides
- whether to free the passed in storage on allocation failure or if the
- new size is zero.
-
- This is designed for use in the typical idiom of :
-
- p = SMB_REALLOC(p, size)
- if (!p) {
- return error;
- }
-
- and not to have to keep track of the old 'p' contents to free later, nor
- to worry if the size parameter was zero. In the case where NULL is returned
- we guarentee that p has been freed.
-
- If free later semantics are desired, then pass 'free_old_on_error' as False which
- guarentees that the old contents are not freed on error, even if size == 0. To use
- this idiom use :
-
- tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
- if (!tmp) {
- SAFE_FREE(p);
- return error;
- } else {
- p = tmp;
- }
-
- Changes were instigated by Coverity error checking. JRA.
-****************************************************************************/
-
-void *Realloc(void *p, size_t size, bool free_old_on_error)
-{
- void *ret=NULL;
-
- if (size == 0) {
- if (free_old_on_error) {
- SAFE_FREE(p);
- }
- DEBUG(2,("Realloc asked for 0 bytes\n"));
- return NULL;
- }
-
-#if defined(PARANOID_MALLOC_CHECKER)
- if (!p) {
- ret = (void *)malloc_(size);
- } else {
- ret = (void *)realloc_(p,size);
- }
-#else
- if (!p) {
- ret = (void *)malloc(size);
- } else {
- ret = (void *)realloc(p,size);
- }
-#endif
-
- if (!ret) {
- if (free_old_on_error && p) {
- SAFE_FREE(p);
- }
- DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
- }
-
- return(ret);
-}
-
/****************************************************************************
(Hopefully) efficient array append.
****************************************************************************/
if ((nis_error = yp_match(nis_domain, nis_map, user_name,
strlen(user_name), &nis_result,
&nis_result_len)) == 0) {
+ if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
+ nis_result[nis_result_len] = '\0';
+ }
value = talloc_strdup(ctx, nis_result);
if (!value) {
return NULL;
}
#ifdef CLUSTER_SUPPORT
- return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
- pid.pid);
+ return ctdbd_process_exists(messaging_ctdbd_connection(),
+ pid.vnn, pid.pid);
#else
return False;
#endif
char *p;
uid_t u;
- pass = getpwnam_alloc(talloc_autofree_context(), name);
+ pass = Get_Pwnam_alloc(talloc_tos(), name);
if (pass) {
u = pass->pw_uid;
TALLOC_FREE(pass);
Something really nasty happened - panic !
********************************************************************/
-void smb_panic(const char *const why)
+void smb_panic_s3(const char *why)
{
char *cmd;
int result;
-#ifdef DEVELOPER
- {
-
- if (global_clobber_region_function) {
- DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
- global_clobber_region_function,
- global_clobber_region_line));
- }
- }
-#endif
-
DEBUG(0,("PANIC (pid %llu): %s\n",
(unsigned long long)sys_getpid(), why));
log_stack_trace();
}
} else {
if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
- (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
+ (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
DEBUG(8,("is_in_path: match succeeded\n"));
return True;
}
passing to is_in_path(). We do this for
speed so we can pre-parse all the names in the list
and don't do it for each call to is_in_path().
- namelist is modified here and is assumed to be
- a copy owned by the caller.
We also check if the entry contains a wildcard to
remove a potentially expensive call to mask_match
if possible.
********************************************************************/
-void set_namearray(name_compare_entry **ppname_array, const char *namelist)
+void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
{
char *name_end;
- char *nameptr = (char *)namelist;
+ char *namelist;
+ char *nameptr;
int num_entries = 0;
int i;
(*ppname_array) = NULL;
- if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
+ if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0')))
return;
+ namelist = talloc_strdup(talloc_tos(), namelist_in);
+ if (namelist == NULL) {
+ DEBUG(0,("set_namearray: talloc fail\n"));
+ return;
+ }
+ nameptr = namelist;
+
/* We need to make two passes over the string. The
first to count the number of elements, the second
to split it.
num_entries++;
}
- if(num_entries == 0)
+ if(num_entries == 0) {
+ talloc_free(namelist);
return;
+ }
if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
DEBUG(0,("set_namearray: malloc fail\n"));
+ talloc_free(namelist);
return;
}
/* Now copy out the names */
- nameptr = (char *)namelist;
+ nameptr = namelist;
i = 0;
while(*nameptr) {
if ( *nameptr == '/' ) {
(*ppname_array)[i].is_wild = ms_has_wild(nameptr);
if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
DEBUG(0,("set_namearray: malloc fail (1)\n"));
+ talloc_free(namelist);
return;
}
(*ppname_array)[i].name = NULL;
+ talloc_free(namelist);
return;
}
-/****************************************************************************
- Routine to free a namearray.
-****************************************************************************/
-
-void free_namearray(name_compare_entry *name_array)
-{
- int i;
-
- if(name_array == NULL)
- return;
-
- for(i=0; name_array[i].name!=NULL; i++)
- SAFE_FREE(name_array[i].name);
- SAFE_FREE(name_array);
-}
-
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
case RA_CIFSFS:
remote_arch_str = "CIFSFS";
break;
+ case RA_OSX:
+ remote_arch_str = "OSX";
+ break;
default:
ra_type = RA_UNKNOWN;
remote_arch_str = "UNKNOWN";
int str_checksum(const char *s)
{
- int res = 0;
- int c;
- int i=0;
-
- while(*s) {
- c = *s;
- res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
- s++;
- i++;
- }
- return(res);
+ TDB_DATA key = string_tdb_data(s);
+ return tdb_jenkins_hash(&key);
}
/*****************************************************************
{
static char *ret;
if (ret == NULL) {
- /* This is cached forever so
- * use talloc_autofree_context() ctx. */
- ret = get_myname(talloc_autofree_context());
+ ret = get_myname(NULL);
}
return ret;
}
}
}
}
- if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
+ if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
struct server_id result;
result.pid = pid;
result.unique_id = my_unique_id;
-#ifdef CLUSTER_SUPPORT
result.vnn = my_vnn;
-#endif
return result;
}
{
if (p1->pid != p2->pid)
return False;
-#ifdef CLUSTER_SUPPORT
if (p1->vnn != p2->vnn)
return False;
-#endif
return True;
}
{
if (pid->pid != sys_getpid())
return False;
-#ifdef CLUSTER_SUPPORT
if (pid->vnn != my_vnn)
return False;
-#endif
return True;
}
{
struct server_id result;
int pid;
-#ifdef CLUSTER_SUPPORT
unsigned int vnn;
if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
result.vnn = vnn;
result.vnn = NONCLUSTER_VNN;
result.pid = -1;
}
-#else
- if (sscanf(pid_string, "%d", &pid) != 1) {
- result.pid = -1;
- } else {
- result.pid = pid;
- }
-#endif
/* Assigning to result.pid may have overflowed
Map negative pid to -1: i.e. error */
if (result.pid < 0) {
char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
{
-#ifdef CLUSTER_SUPPORT
if (pid->vnn == NONCLUSTER_VNN) {
return talloc_asprintf(mem_ctx,
"%d",
(unsigned)pid->vnn,
(int)pid->pid);
}
-#else
- return talloc_asprintf(mem_ctx,
- "%d",
- (int)pid->pid);
-#endif
}
char *procid_str_static(const struct server_id *pid)
bool procid_is_local(const struct server_id *pid)
{
-#ifdef CLUSTER_SUPPORT
return pid->vnn == my_vnn;
-#else
- return True;
-#endif
-}
-
-int this_is_smp(void)
-{
-#if defined(HAVE_SYSCONF)
-
-#if defined(SYSCONF_SC_NPROC_ONLN)
- return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
-#elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
- return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
-#else
- return 0;
-#endif
-
-#else
- return 0;
-#endif
}
/****************************************************************
}
#endif
-bool is_valid_policy_hnd(const struct policy_handle *hnd)
-{
- struct policy_handle tmp;
- ZERO_STRUCT(tmp);
- return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
-}
-
-bool policy_hnd_equal(const struct policy_handle *hnd1,
- const struct policy_handle *hnd2)
-{
- if (!hnd1 || !hnd2) {
- return false;
- }
-
- return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
-}
-
/****************************************************************
strip off leading '\\' from a hostname
****************************************************************/
}
return ret;
}
+
+bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
+{
+ if (!NT_STATUS_IS_OK(err1)) {
+ *result = err1;
+ return true;
+ }
+ if (!NT_STATUS_IS_OK(err2)) {
+ *result = err2;
+ return true;
+ }
+ return false;
+}
+
+int timeval_to_msec(struct timeval t)
+{
+ return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
+}
+
+/*******************************************************************
+ Check a given DOS pathname is valid for a share.
+********************************************************************/
+
+char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
+{
+ char *ptr = NULL;
+
+ if (!dos_pathname) {
+ return NULL;
+ }
+
+ ptr = talloc_strdup(ctx, dos_pathname);
+ if (!ptr) {
+ return NULL;
+ }
+ /* Convert any '\' paths to '/' */
+ unix_format(ptr);
+ ptr = unix_clean_name(ctx, ptr);
+ if (!ptr) {
+ return NULL;
+ }
+
+ /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
+ if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
+ ptr += 2;
+
+ /* Only absolute paths allowed. */
+ if (*ptr != '/')
+ return NULL;
+
+ return ptr;
+}