enum protocol_types Protocol = PROTOCOL_COREPLUS;
-/* this is used by the chaining code */
-int chain_size = 0;
-
-int trans_num = 0;
-
static enum remote_arch_types ra_type = RA_UNKNOWN;
/***********************************************************************
gfree_names();
gfree_loadparm();
gfree_case_tables();
- gfree_debugsyms();
gfree_charcnv();
gfree_interfaces();
-
- /* release the talloc null_context memory last */
- talloc_disable_null_tracking();
+ gfree_debugsyms();
}
const char *my_netbios_names(int i)
Used mainly in client tools.
****************************************************************************/
-static struct user_auth_info cmdline_auth_info = {
- NULL, /* username */
- NULL, /* password */
- false, /* got_pass */
- false, /* use_kerberos */
- Undefined, /* signing state */
- false /* smb_encrypt */
-};
+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;
+ }
-const char *get_cmdline_auth_info_username(void)
+ result->signing_state = Undefined;
+ return result;
+}
+
+const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
{
- if (!cmdline_auth_info.username) {
+ if (!auth_info->username) {
return "";
}
- return cmdline_auth_info.username;
+ return auth_info->username;
}
-void set_cmdline_auth_info_username(const char *username)
+void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
+ const char *username)
{
- SAFE_FREE(cmdline_auth_info.username);
- cmdline_auth_info.username = SMB_STRDUP(username);
- if (!cmdline_auth_info.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_password(void)
+const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
{
- if (!cmdline_auth_info.password) {
+ if (!auth_info->password) {
return "";
}
- return cmdline_auth_info.password;
+ return auth_info->password;
}
-void set_cmdline_auth_info_password(const char *password)
+void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
+ const char *password)
{
- SAFE_FREE(cmdline_auth_info.password);
- cmdline_auth_info.password = SMB_STRDUP(password);
- if (!cmdline_auth_info.password) {
+ TALLOC_FREE(auth_info->password);
+ if (password == NULL) {
+ password = "";
+ }
+ auth_info->password = talloc_strdup(auth_info, password);
+ if (!auth_info->password) {
exit(ENOMEM);
}
- cmdline_auth_info.got_pass = true;
+ auth_info->got_pass = true;
}
-bool set_cmdline_auth_info_signing_state(const char *arg)
+bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
+ const char *arg)
{
- cmdline_auth_info.signing_state = -1;
+ auth_info->signing_state = -1;
if (strequal(arg, "off") || strequal(arg, "no") ||
strequal(arg, "false")) {
- cmdline_auth_info.signing_state = false;
+ auth_info->signing_state = false;
} else if (strequal(arg, "on") || strequal(arg, "yes") ||
strequal(arg, "true") || strequal(arg, "auto")) {
- cmdline_auth_info.signing_state = true;
+ auth_info->signing_state = true;
} else if (strequal(arg, "force") || strequal(arg, "required") ||
strequal(arg, "forced")) {
- cmdline_auth_info.signing_state = Required;
+ auth_info->signing_state = Required;
} else {
return false;
}
return true;
}
-int get_cmdline_auth_info_signing_state(void)
+int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
{
- return cmdline_auth_info.signing_state;
+ return auth_info->signing_state;
}
-bool get_cmdline_auth_info_use_kerberos(void)
+void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
+ bool b)
{
- return cmdline_auth_info.use_kerberos;
+ auth_info->use_kerberos = b;
}
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_use_krb5_ticket(void)
+bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
{
- cmdline_auth_info.use_kerberos = true;
- cmdline_auth_info.got_pass = true;
+ return auth_info->use_kerberos;
}
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_smb_encrypt(void)
+void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
+ bool b)
{
- cmdline_auth_info.smb_encrypt = true;
+ auth_info->fallback_after_kerberos = b;
}
-bool get_cmdline_auth_info_got_pass(void)
+bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
{
- return cmdline_auth_info.got_pass;
+ return auth_info->fallback_after_kerberos;
}
-bool get_cmdline_auth_info_smb_encrypt(void)
+/* 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)
{
- return cmdline_auth_info.smb_encrypt;
+ auth_info->use_kerberos = true;
+ auth_info->got_pass = true;
}
-bool get_cmdline_auth_info_copy(struct user_auth_info *info)
+/* This should only be used by lib/popt_common.c JRA */
+void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
{
- *info = cmdline_auth_info;
- /* Now re-alloc the strings. */
- info->username = SMB_STRDUP(get_cmdline_auth_info_username());
- info->password = SMB_STRDUP(get_cmdline_auth_info_password());
- if (!info->username || !info->password) {
- return false;
- }
- return true;
+ auth_info->smb_encrypt = true;
}
-/**************************************************************************n
- Find a suitable temporary directory. The result should be copied immediately
- as it may be overwritten by a subsequent call.
-****************************************************************************/
+void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
+{
+ auth_info->use_machine_account = true;
+}
-const char *tmpdir(void)
+bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
{
- char *p;
- if ((p = getenv("TMPDIR")))
- return p;
- return "/tmp";
+ return auth_info->got_pass;
}
-/****************************************************************************
- Add a gid to an array of gids if it's not already there.
-****************************************************************************/
+bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
+{
+ return auth_info->smb_encrypt;
+}
-bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
- gid_t **gids, size_t *num_gids)
+bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
{
- int i;
+ return auth_info->use_machine_account;
+}
- if ((*num_gids != 0) && (*gids == NULL)) {
- /*
- * A former call to this routine has failed to allocate memory
- */
- return False;
- }
+struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
+ const struct user_auth_info *src)
+{
+ struct user_auth_info *result;
- for (i=0; i<*num_gids; i++) {
- if ((*gids)[i] == gid) {
- return True;
- }
+ result = user_auth_info_init(mem_ctx);
+ if (result == NULL) {
+ return NULL;
}
- *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
- if (*gids == NULL) {
- *num_gids = 0;
- return False;
+ *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;
}
- (*gids)[*num_gids] = gid;
- *num_gids += 1;
- return True;
+ return result;
}
-/****************************************************************************
- Like atoi but gets the value up to the separator character.
-****************************************************************************/
-
-static const char *Atoic(const char *p, int *n, const char *c)
+bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
{
- if (!isdigit((int)*p)) {
- DEBUG(5, ("Atoic: malformed number\n"));
- return NULL;
+ char *pass = NULL;
+ char *account = NULL;
+
+ if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
+ return false;
}
- (*n) = atoi(p);
+ if (!secrets_init()) {
+ d_printf("ERROR: Unable to open secrets database\n");
+ return false;
+ }
- while ((*p) && isdigit((int)*p))
- p++;
+ if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
+ return false;
+ }
- if (strchr_m(c, *p) == NULL) {
- DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
- return NULL;
+ 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;
}
- return p;
-}
+ set_cmdline_auth_info_username(auth_info, account);
+ set_cmdline_auth_info_password(auth_info, pass);
-/*************************************************************************
- Reads a list of numbers.
- *************************************************************************/
+ SAFE_FREE(account);
+ SAFE_FREE(pass);
-const char *get_numlist(const char *p, uint32 **num, int *count)
-{
- int val;
+ return true;
+}
- if (num == NULL || count == NULL)
- return NULL;
+/****************************************************************************
+ Ensure we have a password if one not given.
+****************************************************************************/
- (*count) = 0;
- (*num ) = NULL;
+void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
+{
+ char *label = NULL;
+ char *pass;
+ TALLOC_CTX *frame;
- while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
- *num = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
- if (!(*num)) {
- return NULL;
- }
- (*num)[(*count)] = val;
- (*count)++;
- p++;
+ if (get_cmdline_auth_info_got_pass(auth_info) ||
+ get_cmdline_auth_info_use_kerberos(auth_info)) {
+ /* Already got one... */
+ return;
}
- return p;
+ 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.
********************************************************************/
-bool file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
+bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
{
SMB_STRUCT_STAT st;
if (!sbuf)
if (sys_stat(fname,sbuf) != 0)
return(False);
- return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
+ return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
}
/*******************************************************************
- Check a files mod time.
+ Check if a unix domain socket exists - call vfs_file_exist for samba files.
********************************************************************/
-time_t file_modtime(const char *fname)
+bool socket_exist(const char *fname)
{
SMB_STRUCT_STAT st;
-
if (sys_stat(fname,&st) != 0)
- return(0);
+ return(False);
- return(st.st_mtime);
+ return S_ISSOCK(st.st_ex_mode);
}
/*******************************************************************
Check if a directory exists.
********************************************************************/
-bool directory_exist(char *dname,SMB_STRUCT_STAT *st)
+bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
{
SMB_STRUCT_STAT st2;
bool ret;
if (sys_stat(dname,st) != 0)
return(False);
- ret = S_ISDIR(st->st_mode);
+ ret = S_ISDIR(st->st_ex_mode);
if(!ret)
errno = ENOTDIR;
return ret;
}
+/*******************************************************************
+ Returns the size in bytes of the named given the stat struct.
+********************************************************************/
+
+uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
+{
+ return sbuf->st_ex_size;
+}
+
/*******************************************************************
Returns the size in bytes of the named file.
********************************************************************/
SMB_OFF_T get_file_size(char *file_name)
{
SMB_STRUCT_STAT buf;
- buf.st_size = 0;
+ buf.st_ex_size = 0;
if(sys_stat(file_name,&buf) != 0)
return (SMB_OFF_T)-1;
- return(buf.st_size);
+ return get_file_size_stat(&buf);
}
/*******************************************************************
return unix_clean_name(ctx, str);
}
-/*******************************************************************
- Close the low 3 fd's and open dev/null in their place.
-********************************************************************/
-
-void close_low_fds(bool stderr_too)
-{
-#ifndef VALGRIND
- int fd;
- int i;
-
- close(0);
- close(1);
-
- if (stderr_too)
- close(2);
-
- /* try and use up these file descriptors, so silly
- library routines writing to stdout etc won't cause havoc */
- for (i=0;i<3;i++) {
- if (i == 2 && !stderr_too)
- continue;
-
- fd = sys_open("/dev/null",O_RDWR,0);
- if (fd < 0)
- fd = sys_open("/dev/null",O_WRONLY,0);
- if (fd < 0) {
- DEBUG(0,("Can't open /dev/null\n"));
- return;
- }
- if (fd != i) {
- DEBUG(0,("Didn't get file descriptor %d\n",i));
- return;
- }
- }
-#endif
-}
-
/*******************************************************************
Write data into an fd at a given offset. Ignore seek errors.
********************************************************************/
#endif
}
-/****************************************************************************
- Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
- else
- if SYSV use O_NDELAY
- if BSD use FNDELAY
-****************************************************************************/
-
-int set_blocking(int fd, bool set)
-{
- int val;
-#ifdef O_NONBLOCK
-#define FLAG_TO_SET O_NONBLOCK
-#else
-#ifdef SYSV
-#define FLAG_TO_SET O_NDELAY
-#else /* BSD */
-#define FLAG_TO_SET FNDELAY
-#endif
-#endif
-
- if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
- return -1;
- if(set) /* Turn blocking on - ie. clear nonblock flag */
- val &= ~FLAG_TO_SET;
- else
- val |= FLAG_TO_SET;
- return sys_fcntl_long( fd, F_SETFL, val);
-#undef FLAG_TO_SET
-}
-
-/****************************************************************************
- Transfer some data between two fd's.
-****************************************************************************/
-
-#ifndef TRANSFER_BUF_SIZE
-#define TRANSFER_BUF_SIZE 65536
-#endif
-
-ssize_t transfer_file_internal(int infd, int outfd, size_t n, ssize_t (*read_fn)(int, void *, size_t),
- ssize_t (*write_fn)(int, const void *, size_t))
-{
- char *buf;
- size_t total = 0;
- ssize_t read_ret;
- ssize_t write_ret;
- size_t num_to_read_thistime;
- size_t num_written = 0;
-
- if ((buf = SMB_MALLOC_ARRAY(char, TRANSFER_BUF_SIZE)) == NULL)
- return -1;
-
- while (total < n) {
- num_to_read_thistime = MIN((n - total), TRANSFER_BUF_SIZE);
-
- read_ret = (*read_fn)(infd, buf, num_to_read_thistime);
- if (read_ret == -1) {
- DEBUG(0,("transfer_file_internal: read failure. Error = %s\n", strerror(errno) ));
- SAFE_FREE(buf);
- return -1;
- }
- if (read_ret == 0)
- break;
-
- num_written = 0;
-
- while (num_written < read_ret) {
- write_ret = (*write_fn)(outfd,buf + num_written, read_ret - num_written);
-
- if (write_ret == -1) {
- DEBUG(0,("transfer_file_internal: write failure. Error = %s\n", strerror(errno) ));
- SAFE_FREE(buf);
- return -1;
- }
- if (write_ret == 0)
- return (ssize_t)total;
-
- num_written += (size_t)write_ret;
- }
-
- total += (size_t)read_ret;
- }
-
- SAFE_FREE(buf);
- return (ssize_t)total;
-}
-
-SMB_OFF_T transfer_file(int infd,int outfd,SMB_OFF_T n)
-{
- return (SMB_OFF_T)transfer_file_internal(infd, outfd, (size_t)n, sys_read, sys_write);
-}
-
/*******************************************************************
Sleep for a specified number of milliseconds.
********************************************************************/
#endif
}
-/****************************************************************************
- Become a daemon, discarding the controlling terminal.
-****************************************************************************/
-
-void become_daemon(bool Fork, bool no_process_group)
+NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
+ struct event_context *ev_ctx,
+ bool parent_longlived)
{
- if (Fork) {
- if (sys_fork()) {
- _exit(0);
- }
+ NTSTATUS status = NT_STATUS_OK;
+
+ /* Reset the state of the random
+ * number generation system, so
+ * children do not get the same random
+ * numbers as each other */
+ set_need_random_reseed();
+
+ /* tdb needs special fork handling */
+ if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
+ DEBUG(0,("tdb_reopen_all failed.\n"));
+ status = NT_STATUS_OPEN_FAILED;
+ goto done;
}
- /* detach from the terminal */
-#ifdef HAVE_SETSID
- if (!no_process_group) setsid();
-#elif defined(TIOCNOTTY)
- if (!no_process_group) {
- int i = sys_open("/dev/tty", O_RDWR, 0);
- if (i != -1) {
- ioctl(i, (int) TIOCNOTTY, (char *)0);
- close(i);
- }
+ if (ev_ctx) {
+ event_context_reinit(ev_ctx);
}
-#endif /* HAVE_SETSID */
- /* Close fd's 0,1,2. Needed if started by rsh */
- close_low_fds(False); /* Don't close stderr, let the debug system
- attach it to the logfile */
+ if (msg_ctx) {
+ /*
+ * For clustering, we need to re-init our ctdbd connection after the
+ * fork
+ */
+ status = messaging_reinit(msg_ctx);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("messaging_reinit() failed: %s\n",
+ nt_errstr(status)));
+ }
+ }
+ done:
+ return status;
}
/****************************************************************************
#endif /* PARANOID_MALLOC_CHECKER */
-/****************************************************************************
- Type-safe malloc.
-****************************************************************************/
-
-void *malloc_array(size_t el_size, unsigned int count)
-{
- if (count >= MAX_ALLOC_SIZE/el_size) {
- return NULL;
- }
-
- if (el_size == 0 || count == 0) {
- return NULL;
- }
-#if defined(PARANOID_MALLOC_CHECKER)
- return malloc_(el_size*count);
-#else
- return malloc(el_size*count);
-#endif
-}
-
/****************************************************************************
Type-safe memalign
****************************************************************************/
return(ret);
}
-/****************************************************************************
- Type-safe realloc.
-****************************************************************************/
-
-void *realloc_array(void *p, size_t el_size, unsigned int count, bool free_old_on_error)
-{
- if (count >= MAX_ALLOC_SIZE/el_size) {
- if (free_old_on_error) {
- SAFE_FREE(p);
- }
- return NULL;
- }
- return Realloc(p, el_size*count, free_old_on_error);
-}
-
/****************************************************************************
(Hopefully) efficient array append.
****************************************************************************/
*array_size = -1;
}
-/****************************************************************************
- Free memory, checks for NULL.
- Use directly SAFE_FREE()
- Exists only because we need to pass a function pointer somewhere --SSS
-****************************************************************************/
-
-void safe_free(void *p)
-{
- SAFE_FREE(p);
-}
-
-/****************************************************************************
- Get my own name and IP.
-****************************************************************************/
-
-char *get_myname(TALLOC_CTX *ctx)
-{
- char *p;
- char hostname[HOST_NAME_MAX];
-
- *hostname = 0;
-
- /* get my host name */
- if (gethostname(hostname, sizeof(hostname)) == -1) {
- DEBUG(0,("gethostname failed\n"));
- return False;
- }
-
- /* Ensure null termination. */
- hostname[sizeof(hostname)-1] = '\0';
-
- /* split off any parts after an initial . */
- p = strchr_m(hostname,'.');
- if (p) {
- *p = 0;
- }
-
- return talloc_strdup(ctx, hostname);
-}
-
/****************************************************************************
Get my own domain name, or "" if we have none.
****************************************************************************/
#endif
}
-bool process_exists_by_pid(pid_t pid)
-{
- /* Doing kill with a non-positive pid causes messages to be
- * sent to places we don't want. */
- SMB_ASSERT(pid > 0);
- return(kill(pid,0) == 0 || errno != ESRCH);
-}
-
/*******************************************************************
Convert a uid into a user name.
********************************************************************/
char *p;
uid_t u;
- pass = getpwnam_alloc(NULL, name);
+ pass = getpwnam_alloc(talloc_autofree_context(), name);
if (pass) {
u = pass->pw_uid;
TALLOC_FREE(pass);
if possible.
********************************************************************/
-void set_namearray(name_compare_entry **ppname_array, char *namelist)
+void set_namearray(name_compare_entry **ppname_array, const char *namelist)
{
char *name_end;
- char *nameptr = namelist;
+ const char *nameptr = namelist;
int num_entries = 0;
int i;
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
-/****************************************************************************
- Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
- is dealt with in posix.c
- Returns True if the lock was granted, False otherwise.
-****************************************************************************/
-
-bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
-{
- SMB_STRUCT_FLOCK lock;
- int ret;
-
- DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
- fd,op,(double)offset,(double)count,type));
-
- lock.l_type = type;
- lock.l_whence = SEEK_SET;
- lock.l_start = offset;
- lock.l_len = count;
- lock.l_pid = 0;
-
- ret = sys_fcntl_ptr(fd,op,&lock);
-
- if (ret == -1) {
- int sav = errno;
- DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
- (double)offset,(double)count,op,type,strerror(errno)));
- errno = sav;
- return False;
- }
-
- /* everything went OK */
- DEBUG(8,("fcntl_lock: Lock call successful\n"));
-
- return True;
-}
-
/****************************************************************************
Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
is dealt with in posix.c
if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
set_remote_arch( RA_WINXP );
else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
- set_remote_arch( RA_WINXP );
+ set_remote_arch( RA_WINXP64 );
else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
set_remote_arch( RA_WIN2K3 );
}
case RA_WINXP:
remote_arch_str = "WinXP";
break;
+ case RA_WINXP64:
+ remote_arch_str = "WinXP64";
+ break;
case RA_WIN2K3:
remote_arch_str = "Win2K3";
break;
return ra_type;
}
-void print_asc(int level, const unsigned char *buf,int len)
-{
- int i;
- for (i=0;i<len;i++)
- DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
-}
-
-void dump_data(int level, const unsigned char *buf1,int len)
-{
- const unsigned char *buf = (const unsigned char *)buf1;
- int i=0;
- if (len<=0) return;
-
- if (!DEBUGLVL(level)) return;
-
- DEBUGADD(level,("[%03X] ",i));
- for (i=0;i<len;) {
- DEBUGADD(level,("%02X ",(int)buf[i]));
- i++;
- if (i%8 == 0) DEBUGADD(level,(" "));
- if (i%16 == 0) {
- print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
- print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
- if (i<len) DEBUGADD(level,("[%03X] ",i));
- }
- }
- if (i%16) {
- int n;
- n = 16 - (i%16);
- DEBUGADD(level,(" "));
- if (n>8) DEBUGADD(level,(" "));
- while (n--) DEBUGADD(level,(" "));
- n = MIN(8,i%16);
- print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
- n = (i%16) - n;
- if (n>0) print_asc(level,&buf[i-n],n);
- DEBUGADD(level,("\n"));
- }
-}
-
-void dump_data_pw(const char *msg, const uchar * data, size_t len)
-{
-#ifdef DEBUG_PASSWORD
- DEBUG(11, ("%s", msg));
- if (data != NULL && len > 0)
- {
- dump_data(11, data, len);
- }
-#endif
-}
-
const char *tab_depth(int level, int depth)
{
- if( DEBUGLVL(level) ) {
+ if( CHECK_DEBUGLVL(level) ) {
dbgtext("%*s", depth*4, "");
}
return "";
#endif
}
-/*****************************************************************
- Possibly replace mkstemp if it is broken.
-*****************************************************************/
-
-int smb_mkstemp(char *name_template)
-{
-#if HAVE_SECURE_MKSTEMP
- return mkstemp(name_template);
-#else
- /* have a reasonable go at emulating it. Hope that
- the system mktemp() isn't completly hopeless */
- char *p = mktemp(name_template);
- if (!p)
- return -1;
- return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
-#endif
-}
-
/*****************************************************************
malloc that aborts with smb_panic on fail or zero size.
*****************************************************************/
return p;
}
-/**
- Memdup with smb_panic on fail.
-**/
-
-void *smb_xmemdup(const void *p, size_t size)
-{
- void *p2;
- p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
- memcpy(p2, p, size);
- return p2;
-}
-
-/**
- strdup that aborts on malloc fail.
-**/
-
-char *smb_xstrdup(const char *s)
-{
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strdup
-#undef strdup
-#endif
-#endif
-
-#ifndef HAVE_STRDUP
-#define strdup rep_strdup
-#endif
-
- char *s1 = strdup(s);
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strdup
-#undef strdup
-#endif
-#define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
-#endif
- if (!s1) {
- smb_panic("smb_xstrdup: malloc failed");
- }
- return s1;
-
-}
-
-/**
- strndup that aborts on malloc fail.
-**/
-
-char *smb_xstrndup(const char *s, size_t n)
-{
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strndup
-#undef strndup
-#endif
-#endif
-
-#if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
-#undef HAVE_STRNDUP
-#define strndup rep_strndup
-#endif
-
- char *s1 = strndup(s, n);
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strndup
-#undef strndup
-#endif
-#define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
-#endif
- if (!s1) {
- smb_panic("smb_xstrndup: malloc failed");
- }
- return s1;
-}
-
/*
vasprintf that aborts on malloc fail
*/
int n;
va_list ap2;
- VA_COPY(ap2, ap);
+ va_copy(ap2, ap);
n = vasprintf(ptr, format, ap2);
if (n == -1 || ! *ptr) {
smb_panic("smb_xvasprintf: out of memory");
}
+ va_end(ap2);
return n;
}
-/*****************************************************************
- Like strdup but for memory.
-*****************************************************************/
-
-void *memdup(const void *p, size_t size)
-{
- void *p2;
- if (size == 0)
- return NULL;
- p2 = SMB_MALLOC(size);
- if (!p2)
- return NULL;
- memcpy(p2, p, size);
- return p2;
-}
-
/*****************************************************************
Get local hostname and cache result.
*****************************************************************/
static char *ret;
if (ret == NULL) {
/* This is cached forever so
- * use NULL talloc ctx. */
- ret = get_myname(NULL);
+ * use talloc_autofree_context() ctx. */
+ ret = get_myname(talloc_autofree_context());
}
return ret;
}
-/*****************************************************************
- A useful function for returning a path in the Samba pid directory.
-*****************************************************************/
+/**
+ * @brief Returns an absolute path to a file concatenating the provided
+ * @a rootpath and @a basename
+ *
+ * @param name Filename, relative to @a rootpath
+ *
+ * @retval Pointer to a string containing the full path.
+ **/
static char *xx_path(const char *name, const char *rootpath)
{
}
trim_string(fname,"","/");
- if (!directory_exist(fname,NULL)) {
- mkdir(fname,0755);
+ if (!directory_exist(fname)) {
+ if (!mkdir(fname,0755))
+ DEBUG(1, ("Unable to create directory %s for file %s. "
+ "Error was %s\n", fname, name, strerror(errno)));
}
return talloc_asprintf(talloc_tos(),
name);
}
-/*****************************************************************
- A useful function for returning a path in the Samba lock directory.
-*****************************************************************/
+/**
+ * @brief Returns an absolute path to a file in the Samba lock directory.
+ *
+ * @param name File to find, relative to LOCKDIR.
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
char *lock_path(const char *name)
{
return xx_path(name, lp_lockdir());
}
-/*****************************************************************
- A useful function for returning a path in the Samba pid directory.
-*****************************************************************/
+/**
+ * @brief Returns an absolute path to a file in the Samba pid directory.
+ *
+ * @param name File to find, relative to PIDDIR.
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
char *pid_path(const char *name)
{
return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
}
+/**
+ * @brief Returns an absolute path to a file in the Samba modules directory.
+ *
+ * @param name File to find, relative to MODULESDIR.
+ *
+ * @retval Pointer to a string containing the full path.
+ **/
+
+char *modules_path(const char *name)
+{
+ return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
+}
+
/**
* @brief Returns an absolute path to a file in the Samba data directory.
*
return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
}
-/*****************************************************************
-a useful function for returning a path in the Samba state directory
- *****************************************************************/
+/**
+ * @brief Returns an absolute path to a file in the Samba state directory.
+ *
+ * @param name File to find, relative to STATEDIR.
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
char *state_path(const char *name)
{
- return xx_path(name, get_dyn_STATEDIR());
+ return xx_path(name, lp_statedir());
+}
+
+/**
+ * @brief Returns an absolute path to a file in the Samba cache directory.
+ *
+ * @param name File to find, relative to CACHEDIR.
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
+
+char *cache_path(const char *name)
+{
+ return xx_path(name, lp_cachedir());
}
/**
/*******************************************************************
Given a filename - get its directory name
- NB: Returned in static storage. Caveats:
- o If caller wishes to preserve, they should copy.
********************************************************************/
-char *parent_dirname(const char *path)
-{
- char *parent;
-
- if (!parent_dirname_talloc(talloc_tos(), path, &parent, NULL)) {
- return NULL;
- }
-
- return parent;
-}
-
-bool parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
- char **parent, const char **name)
+bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
+ const char **name)
{
char *p;
ptrdiff_t len;
len = p-dir;
- if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
+ if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
return False;
}
- memcpy(*parent, dir, len);
(*parent)[len] = '\0';
if (name) {
}
/**********************************************************************
- Extension to talloc_get_type: Abort on type mismatch
+ Append a DATA_BLOB to a talloc'ed object
***********************************************************************/
-void *talloc_check_name_abort(const void *ptr, const char *name)
+void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
{
- void *result;
+ size_t old_size = 0;
+ char *result;
- result = talloc_check_name(ptr, name);
- if (result != NULL)
- return result;
+ if (blob.length == 0) {
+ return buf;
+ }
- DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
- name, talloc_get_name(ptr)));
- smb_panic("talloc type mismatch");
- /* Keep the compiler happy */
- return NULL;
+ if (buf != NULL) {
+ old_size = talloc_get_size(buf);
+ }
+
+ result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
+ if (result == NULL) {
+ return NULL;
+ }
+
+ memcpy(result + old_size, blob.data, blob.length);
+ return result;
}
uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
result.pid = pid;
}
else if (sscanf(pid_string, "%u", &pid) == 1) {
- result.vnn = NONCLUSTER_VNN;
+ result.vnn = get_my_vnn();
result.pid = pid;
}
else {
#endif
}
+/****************************************************************
+ Check if offset/length fit into bufsize. Should probably be
+ merged with is_offset_safe, but this would require a rewrite
+ of lanman.c. Later :-)
+****************************************************************/
+
+bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
+{
+ if ((offset + length < offset) || (offset + length < length)) {
+ /* wrap */
+ return true;
+ }
+ if ((offset > bufsize) || (offset + length > bufsize)) {
+ /* overflow */
+ return true;
+ }
+ return false;
+}
+
/****************************************************************
Check if an offset into a buffer is safe.
If this returns True it's safe to indirect into the byte at
return talloc_named_const(context, size, name);
}
#endif
+
+/* Split a path name into filename and stream name components. Canonicalise
+ * such that an implicit $DATA token is always explicit.
+ *
+ * The "specification" of this function can be found in the
+ * run_local_stream_name() function in torture.c, I've tried those
+ * combinations against a W2k3 server.
+ */
+
+NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
+ char **pbase, char **pstream)
+{
+ char *base = NULL;
+ char *stream = NULL;
+ char *sname; /* stream name */
+ const char *stype; /* stream type */
+
+ DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
+
+ sname = strchr_m(fname, ':');
+
+ if (lp_posix_pathnames() || (sname == NULL)) {
+ if (pbase != NULL) {
+ base = talloc_strdup(mem_ctx, fname);
+ NT_STATUS_HAVE_NO_MEMORY(base);
+ }
+ goto done;
+ }
+
+ if (pbase != NULL) {
+ base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
+ NT_STATUS_HAVE_NO_MEMORY(base);
+ }
+
+ sname += 1;
+
+ stype = strchr_m(sname, ':');
+
+ if (stype == NULL) {
+ sname = talloc_strdup(mem_ctx, sname);
+ stype = "$DATA";
+ }
+ else {
+ if (StrCaseCmp(stype, ":$DATA") != 0) {
+ /*
+ * If there is an explicit stream type, so far we only
+ * allow $DATA. Is there anything else allowed? -- vl
+ */
+ DEBUG(10, ("[%s] is an invalid stream type\n", stype));
+ TALLOC_FREE(base);
+ return NT_STATUS_OBJECT_NAME_INVALID;
+ }
+ sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
+ stype += 1;
+ }
+
+ if (sname == NULL) {
+ TALLOC_FREE(base);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (sname[0] == '\0') {
+ /*
+ * no stream name, so no stream
+ */
+ goto done;
+ }
+
+ if (pstream != NULL) {
+ stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
+ if (stream == NULL) {
+ TALLOC_FREE(sname);
+ TALLOC_FREE(base);
+ return NT_STATUS_NO_MEMORY;
+ }
+ /*
+ * upper-case the type field
+ */
+ strupper_m(strchr_m(stream, ':')+1);
+ }
+
+ done:
+ if (pbase != NULL) {
+ *pbase = base;
+ }
+ if (pstream != NULL) {
+ *pstream = stream;
+ }
+ return NT_STATUS_OK;
+}
+
+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
+****************************************************************/
+
+const char *strip_hostname(const char *s)
+{
+ if (!s) {
+ return NULL;
+ }
+
+ if (strlen_m(s) < 3) {
+ return s;
+ }
+
+ if (s[0] == '\\') s++;
+ if (s[0] == '\\') s++;
+
+ return s;
+}
git.samba.org / ira / wip.git / blobdiff