2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2007
6 Copyright (C) Simo Sorce 2001
7 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
8 Copyright (C) James Peach 2006
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
26 extern char *global_clobber_region_function;
27 extern unsigned int global_clobber_region_line;
29 /* Max allowable allococation - 256mb - 0x10000000 */
30 #define MAX_ALLOC_SIZE (1024*1024*256)
32 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
33 #ifdef WITH_NISPLUS_HOME
34 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
36 * The following lines are needed due to buggy include files
37 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
38 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
39 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
40 * an enum in /usr/include/rpcsvc/nis.h.
47 #if defined(GROUP_OBJ)
51 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
53 #include <rpcsvc/nis.h>
55 #endif /* WITH_NISPLUS_HOME */
56 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
58 enum protocol_types Protocol = PROTOCOL_COREPLUS;
60 /* this is used by the chaining code */
65 static enum remote_arch_types ra_type = RA_UNKNOWN;
67 /***********************************************************************
68 Definitions for all names.
69 ***********************************************************************/
71 static char *smb_myname;
72 static char *smb_myworkgroup;
73 static char *smb_scope;
74 static int smb_num_netbios_names;
75 static char **smb_my_netbios_names;
77 /***********************************************************************
78 Allocate and set myname. Ensure upper case.
79 ***********************************************************************/
81 bool set_global_myname(const char *myname)
83 SAFE_FREE(smb_myname);
84 smb_myname = SMB_STRDUP(myname);
87 strupper_m(smb_myname);
91 const char *global_myname(void)
96 /***********************************************************************
97 Allocate and set myworkgroup. Ensure upper case.
98 ***********************************************************************/
100 bool set_global_myworkgroup(const char *myworkgroup)
102 SAFE_FREE(smb_myworkgroup);
103 smb_myworkgroup = SMB_STRDUP(myworkgroup);
104 if (!smb_myworkgroup)
106 strupper_m(smb_myworkgroup);
110 const char *lp_workgroup(void)
112 return smb_myworkgroup;
115 /***********************************************************************
116 Allocate and set scope. Ensure upper case.
117 ***********************************************************************/
119 bool set_global_scope(const char *scope)
121 SAFE_FREE(smb_scope);
122 smb_scope = SMB_STRDUP(scope);
125 strupper_m(smb_scope);
129 /*********************************************************************
130 Ensure scope is never null string.
131 *********************************************************************/
133 const char *global_scope(void)
136 set_global_scope("");
140 static void free_netbios_names_array(void)
144 for (i = 0; i < smb_num_netbios_names; i++)
145 SAFE_FREE(smb_my_netbios_names[i]);
147 SAFE_FREE(smb_my_netbios_names);
148 smb_num_netbios_names = 0;
151 static bool allocate_my_netbios_names_array(size_t number)
153 free_netbios_names_array();
155 smb_num_netbios_names = number + 1;
156 smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
158 if (!smb_my_netbios_names)
161 memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
165 static bool set_my_netbios_names(const char *name, int i)
167 SAFE_FREE(smb_my_netbios_names[i]);
169 smb_my_netbios_names[i] = SMB_STRDUP(name);
170 if (!smb_my_netbios_names[i])
172 strupper_m(smb_my_netbios_names[i]);
176 /***********************************************************************
177 Free memory allocated to global objects
178 ***********************************************************************/
180 void gfree_names(void)
182 SAFE_FREE( smb_myname );
183 SAFE_FREE( smb_myworkgroup );
184 SAFE_FREE( smb_scope );
185 free_netbios_names_array();
186 free_local_machine_name();
189 void gfree_all( void )
198 /* release the talloc null_context memory last */
199 talloc_disable_null_tracking();
202 const char *my_netbios_names(int i)
204 return smb_my_netbios_names[i];
207 bool set_netbios_aliases(const char **str_array)
211 /* Work out the max number of netbios aliases that we have */
212 for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
215 if ( global_myname() && *global_myname())
218 /* Allocate space for the netbios aliases */
219 if (!allocate_my_netbios_names_array(namecount))
222 /* Use the global_myname string first */
224 if ( global_myname() && *global_myname()) {
225 set_my_netbios_names( global_myname(), namecount );
231 for ( i = 0; str_array[i] != NULL; i++) {
233 bool duplicate = False;
235 /* Look for duplicates */
236 for( n=0; n<namecount; n++ ) {
237 if( strequal( str_array[i], my_netbios_names(n) ) ) {
243 if (!set_my_netbios_names(str_array[i], namecount))
252 /****************************************************************************
253 Common name initialization code.
254 ****************************************************************************/
256 bool init_names(void)
260 if (global_myname() == NULL || *global_myname() == '\0') {
261 if (!set_global_myname(myhostname())) {
262 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
267 if (!set_netbios_aliases(lp_netbios_aliases())) {
268 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
272 set_local_machine_name(global_myname(),false);
274 DEBUG( 5, ("Netbios name list:-\n") );
275 for( n=0; my_netbios_names(n); n++ ) {
276 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
277 n, my_netbios_names(n) ) );
283 /**************************************************************************n
284 Code to cope with username/password auth options from the commandline.
285 Used mainly in client tools.
286 ****************************************************************************/
288 static struct user_auth_info cmdline_auth_info = {
291 false, /* got_pass */
292 false, /* use_kerberos */
293 Undefined, /* signing state */
294 false /* smb_encrypt */
297 const char *get_cmdline_auth_info_username(void)
299 if (!cmdline_auth_info.username) {
302 return cmdline_auth_info.username;
305 void set_cmdline_auth_info_username(const char *username)
307 SAFE_FREE(cmdline_auth_info.username);
308 cmdline_auth_info.username = SMB_STRDUP(username);
309 if (!cmdline_auth_info.username) {
314 const char *get_cmdline_auth_info_password(void)
316 if (!cmdline_auth_info.password) {
319 return cmdline_auth_info.password;
322 void set_cmdline_auth_info_password(const char *password)
324 SAFE_FREE(cmdline_auth_info.password);
325 cmdline_auth_info.password = SMB_STRDUP(password);
326 if (!cmdline_auth_info.password) {
329 cmdline_auth_info.got_pass = true;
332 bool set_cmdline_auth_info_signing_state(const char *arg)
334 cmdline_auth_info.signing_state = -1;
335 if (strequal(arg, "off") || strequal(arg, "no") ||
336 strequal(arg, "false")) {
337 cmdline_auth_info.signing_state = false;
338 } else if (strequal(arg, "on") || strequal(arg, "yes") ||
339 strequal(arg, "true") || strequal(arg, "auto")) {
340 cmdline_auth_info.signing_state = true;
341 } else if (strequal(arg, "force") || strequal(arg, "required") ||
342 strequal(arg, "forced")) {
343 cmdline_auth_info.signing_state = Required;
350 int get_cmdline_auth_info_signing_state(void)
352 return cmdline_auth_info.signing_state;
355 bool get_cmdline_auth_info_use_kerberos(void)
357 return cmdline_auth_info.use_kerberos;
360 /* This should only be used by lib/popt_common.c JRA */
361 void set_cmdline_auth_info_use_krb5_ticket(void)
363 cmdline_auth_info.use_kerberos = true;
364 cmdline_auth_info.got_pass = true;
367 /* This should only be used by lib/popt_common.c JRA */
368 void set_cmdline_auth_info_smb_encrypt(void)
370 cmdline_auth_info.smb_encrypt = true;
373 bool get_cmdline_auth_info_got_pass(void)
375 return cmdline_auth_info.got_pass;
378 bool get_cmdline_auth_info_smb_encrypt(void)
380 return cmdline_auth_info.smb_encrypt;
383 bool get_cmdline_auth_info_copy(struct user_auth_info *info)
385 *info = cmdline_auth_info;
386 /* Now re-alloc the strings. */
387 info->username = SMB_STRDUP(get_cmdline_auth_info_username());
388 info->password = SMB_STRDUP(get_cmdline_auth_info_password());
389 if (!info->username || !info->password) {
395 /**************************************************************************n
396 Find a suitable temporary directory. The result should be copied immediately
397 as it may be overwritten by a subsequent call.
398 ****************************************************************************/
400 const char *tmpdir(void)
403 if ((p = getenv("TMPDIR")))
408 /****************************************************************************
409 Add a gid to an array of gids if it's not already there.
410 ****************************************************************************/
412 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
413 gid_t **gids, size_t *num_gids)
417 if ((*num_gids != 0) && (*gids == NULL)) {
419 * A former call to this routine has failed to allocate memory
424 for (i=0; i<*num_gids; i++) {
425 if ((*gids)[i] == gid) {
430 *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
436 (*gids)[*num_gids] = gid;
441 /****************************************************************************
442 Like atoi but gets the value up to the separator character.
443 ****************************************************************************/
445 static const char *Atoic(const char *p, int *n, const char *c)
447 if (!isdigit((int)*p)) {
448 DEBUG(5, ("Atoic: malformed number\n"));
454 while ((*p) && isdigit((int)*p))
457 if (strchr_m(c, *p) == NULL) {
458 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
465 /*************************************************************************
466 Reads a list of numbers.
467 *************************************************************************/
469 const char *get_numlist(const char *p, uint32 **num, int *count)
473 if (num == NULL || count == NULL)
479 while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
480 *num = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
484 (*num)[(*count)] = val;
492 /*******************************************************************
493 Check if a file exists - call vfs_file_exist for samba files.
494 ********************************************************************/
496 bool file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
502 if (sys_stat(fname,sbuf) != 0)
505 return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
508 /*******************************************************************
509 Check if a unix domain socket exists - call vfs_file_exist for samba files.
510 ********************************************************************/
512 bool socket_exist(const char *fname)
515 if (sys_stat(fname,&st) != 0)
518 return S_ISSOCK(st.st_mode);
521 /*******************************************************************
522 Check a files mod time.
523 ********************************************************************/
525 time_t file_modtime(const char *fname)
529 if (sys_stat(fname,&st) != 0)
535 /*******************************************************************
536 Check if a directory exists.
537 ********************************************************************/
539 bool directory_exist(char *dname,SMB_STRUCT_STAT *st)
547 if (sys_stat(dname,st) != 0)
550 ret = S_ISDIR(st->st_mode);
556 /*******************************************************************
557 Returns the size in bytes of the named file.
558 ********************************************************************/
560 SMB_OFF_T get_file_size(char *file_name)
564 if(sys_stat(file_name,&buf) != 0)
565 return (SMB_OFF_T)-1;
569 /*******************************************************************
570 Return a string representing an attribute for a file.
571 ********************************************************************/
573 char *attrib_string(uint16 mode)
579 if (mode & aVOLID) fstrcat(attrstr,"V");
580 if (mode & aDIR) fstrcat(attrstr,"D");
581 if (mode & aARCH) fstrcat(attrstr,"A");
582 if (mode & aHIDDEN) fstrcat(attrstr,"H");
583 if (mode & aSYSTEM) fstrcat(attrstr,"S");
584 if (mode & aRONLY) fstrcat(attrstr,"R");
586 return talloc_strdup(talloc_tos(), attrstr);
589 /*******************************************************************
590 Show a smb message structure.
591 ********************************************************************/
593 void show_msg(char *buf)
601 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
603 (int)CVAL(buf,smb_com),
604 (int)CVAL(buf,smb_rcls),
605 (int)CVAL(buf,smb_reh),
606 (int)SVAL(buf,smb_err),
607 (int)CVAL(buf,smb_flg),
608 (int)SVAL(buf,smb_flg2)));
609 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
610 (int)SVAL(buf,smb_tid),
611 (int)SVAL(buf,smb_pid),
612 (int)SVAL(buf,smb_uid),
613 (int)SVAL(buf,smb_mid)));
614 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
616 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
617 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
618 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
620 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
622 DEBUGADD(5,("smb_bcc=%d\n",bcc));
630 dump_data(10, (uint8 *)smb_buf(buf), bcc);
633 /*******************************************************************
634 Set the length and marker of an encrypted smb packet.
635 ********************************************************************/
637 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
639 _smb_setlen(buf,len);
643 SSVAL(buf,6,enc_ctx_num);
646 /*******************************************************************
647 Set the length and marker of an smb packet.
648 ********************************************************************/
650 void smb_setlen(char *buf,int len)
652 _smb_setlen(buf,len);
660 /*******************************************************************
661 Setup only the byte count for a smb message.
662 ********************************************************************/
664 int set_message_bcc(char *buf,int num_bytes)
666 int num_words = CVAL(buf,smb_wct);
667 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
668 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
669 return (smb_size + num_words*2 + num_bytes);
672 /*******************************************************************
673 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
674 Return the bytes added
675 ********************************************************************/
677 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
679 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
682 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
683 DEBUG(0, ("talloc failed\n"));
688 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
689 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
693 /*******************************************************************
694 Reduce a file name, removing .. elements.
695 ********************************************************************/
697 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
702 DEBUG(3,("dos_clean_name [%s]\n",s));
704 /* remove any double slashes */
705 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
710 /* Remove leading .\\ characters */
711 if(strncmp(str, ".\\", 2) == 0) {
712 trim_string(str, ".\\", NULL);
714 str = talloc_strdup(ctx, ".\\");
721 while ((p = strstr_m(str,"\\..\\")) != NULL) {
727 if ((p=strrchr_m(str,'\\')) != NULL) {
732 str = talloc_asprintf(ctx,
741 trim_string(str,NULL,"\\..");
742 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
745 /*******************************************************************
746 Reduce a file name, removing .. elements.
747 ********************************************************************/
749 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
754 DEBUG(3,("unix_clean_name [%s]\n",s));
756 /* remove any double slashes */
757 str = talloc_all_string_sub(ctx, s, "//","/");
762 /* Remove leading ./ characters */
763 if(strncmp(str, "./", 2) == 0) {
764 trim_string(str, "./", NULL);
766 str = talloc_strdup(ctx, "./");
773 while ((p = strstr_m(str,"/../")) != NULL) {
779 if ((p=strrchr_m(str,'/')) != NULL) {
784 str = talloc_asprintf(ctx,
793 trim_string(str,NULL,"/..");
794 return talloc_all_string_sub(ctx, str, "/./", "/");
797 char *clean_name(TALLOC_CTX *ctx, const char *s)
799 char *str = dos_clean_name(ctx, s);
803 return unix_clean_name(ctx, str);
806 /*******************************************************************
807 Close the low 3 fd's and open dev/null in their place.
808 ********************************************************************/
810 void close_low_fds(bool stderr_too)
822 /* try and use up these file descriptors, so silly
823 library routines writing to stdout etc won't cause havoc */
825 if (i == 2 && !stderr_too)
828 fd = sys_open("/dev/null",O_RDWR,0);
830 fd = sys_open("/dev/null",O_WRONLY,0);
832 DEBUG(0,("Can't open /dev/null\n"));
836 DEBUG(0,("Didn't get file descriptor %d\n",i));
843 /*******************************************************************
844 Write data into an fd at a given offset. Ignore seek errors.
845 ********************************************************************/
847 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
852 if (pos == (SMB_OFF_T)-1) {
853 return write_data(fd, buffer, N);
855 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
857 ret = sys_pwrite(fd,buffer + total,N - total, pos);
858 if (ret == -1 && errno == ESPIPE) {
859 return write_data(fd, buffer + total,N - total);
862 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
871 return (ssize_t)total;
873 /* Use lseek and write_data. */
874 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
875 if (errno != ESPIPE) {
879 return write_data(fd, buffer, N);
883 /****************************************************************************
884 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
888 ****************************************************************************/
890 int set_blocking(int fd, bool set)
894 #define FLAG_TO_SET O_NONBLOCK
897 #define FLAG_TO_SET O_NDELAY
899 #define FLAG_TO_SET FNDELAY
903 if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
905 if(set) /* Turn blocking on - ie. clear nonblock flag */
909 return sys_fcntl_long( fd, F_SETFL, val);
913 /*******************************************************************
914 Sleep for a specified number of milliseconds.
915 ********************************************************************/
917 void smb_msleep(unsigned int t)
919 #if defined(HAVE_NANOSLEEP)
920 struct timespec tval;
923 tval.tv_sec = t/1000;
924 tval.tv_nsec = 1000000*(t%1000);
928 ret = nanosleep(&tval, &tval);
929 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
931 unsigned int tdiff=0;
932 struct timeval tval,t1,t2;
939 tval.tv_sec = (t-tdiff)/1000;
940 tval.tv_usec = 1000*((t-tdiff)%1000);
942 /* Never wait for more than 1 sec. */
943 if (tval.tv_sec > 1) {
950 sys_select_intr(0,&fds,NULL,NULL,&tval);
953 if (t2.tv_sec < t1.tv_sec) {
954 /* Someone adjusted time... */
958 tdiff = TvalDiff(&t1,&t2);
963 /****************************************************************************
964 Become a daemon, discarding the controlling terminal.
965 ****************************************************************************/
967 void become_daemon(bool Fork, bool no_process_group)
975 /* detach from the terminal */
977 if (!no_process_group) setsid();
978 #elif defined(TIOCNOTTY)
979 if (!no_process_group) {
980 int i = sys_open("/dev/tty", O_RDWR, 0);
982 ioctl(i, (int) TIOCNOTTY, (char *)0);
986 #endif /* HAVE_SETSID */
988 /* Close fd's 0,1,2. Needed if started by rsh */
989 close_low_fds(False); /* Don't close stderr, let the debug system
990 attach it to the logfile */
993 bool reinit_after_fork(struct messaging_context *msg_ctx,
994 bool parent_longlived)
998 /* Reset the state of the random
999 * number generation system, so
1000 * children do not get the same random
1001 * numbers as each other */
1002 set_need_random_reseed();
1004 /* tdb needs special fork handling */
1005 if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
1006 DEBUG(0,("tdb_reopen_all failed.\n"));
1011 * For clustering, we need to re-init our ctdbd connection after the
1014 status = messaging_reinit(msg_ctx);
1015 if (!NT_STATUS_IS_OK(status)) {
1016 DEBUG(0,("messaging_reinit() failed: %s\n",
1017 nt_errstr(status)));
1024 /****************************************************************************
1025 Put up a yes/no prompt.
1026 ****************************************************************************/
1028 bool yesno(const char *p)
1033 if (!fgets(ans,sizeof(ans)-1,stdin))
1036 if (*ans == 'y' || *ans == 'Y')
1042 #if defined(PARANOID_MALLOC_CHECKER)
1044 /****************************************************************************
1045 Internal malloc wrapper. Externally visible.
1046 ****************************************************************************/
1048 void *malloc_(size_t size)
1054 return malloc(size);
1055 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
1058 /****************************************************************************
1059 Internal calloc wrapper. Not externally visible.
1060 ****************************************************************************/
1062 static void *calloc_(size_t count, size_t size)
1064 if (size == 0 || count == 0) {
1068 return calloc(count, size);
1069 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
1072 /****************************************************************************
1073 Internal realloc wrapper. Not externally visible.
1074 ****************************************************************************/
1076 static void *realloc_(void *ptr, size_t size)
1079 return realloc(ptr, size);
1080 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1083 #endif /* PARANOID_MALLOC_CHECKER */
1085 /****************************************************************************
1087 ****************************************************************************/
1089 void *malloc_array(size_t el_size, unsigned int count)
1091 if (count >= MAX_ALLOC_SIZE/el_size) {
1095 if (el_size == 0 || count == 0) {
1098 #if defined(PARANOID_MALLOC_CHECKER)
1099 return malloc_(el_size*count);
1101 return malloc(el_size*count);
1105 /****************************************************************************
1107 ****************************************************************************/
1109 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1111 if (count >= MAX_ALLOC_SIZE/el_size) {
1115 return sys_memalign(align, el_size*count);
1118 /****************************************************************************
1120 ****************************************************************************/
1122 void *calloc_array(size_t size, size_t nmemb)
1124 if (nmemb >= MAX_ALLOC_SIZE/size) {
1127 if (size == 0 || nmemb == 0) {
1130 #if defined(PARANOID_MALLOC_CHECKER)
1131 return calloc_(nmemb, size);
1133 return calloc(nmemb, size);
1137 /****************************************************************************
1138 Expand a pointer to be a particular size.
1139 Note that this version of Realloc has an extra parameter that decides
1140 whether to free the passed in storage on allocation failure or if the
1143 This is designed for use in the typical idiom of :
1145 p = SMB_REALLOC(p, size)
1150 and not to have to keep track of the old 'p' contents to free later, nor
1151 to worry if the size parameter was zero. In the case where NULL is returned
1152 we guarentee that p has been freed.
1154 If free later semantics are desired, then pass 'free_old_on_error' as False which
1155 guarentees that the old contents are not freed on error, even if size == 0. To use
1158 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1166 Changes were instigated by Coverity error checking. JRA.
1167 ****************************************************************************/
1169 void *Realloc(void *p, size_t size, bool free_old_on_error)
1174 if (free_old_on_error) {
1177 DEBUG(2,("Realloc asked for 0 bytes\n"));
1181 #if defined(PARANOID_MALLOC_CHECKER)
1183 ret = (void *)malloc_(size);
1185 ret = (void *)realloc_(p,size);
1189 ret = (void *)malloc(size);
1191 ret = (void *)realloc(p,size);
1196 if (free_old_on_error && p) {
1199 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1205 /****************************************************************************
1207 ****************************************************************************/
1209 void *realloc_array(void *p, size_t el_size, unsigned int count, bool free_old_on_error)
1211 if (count >= MAX_ALLOC_SIZE/el_size) {
1212 if (free_old_on_error) {
1217 return Realloc(p, el_size*count, free_old_on_error);
1220 /****************************************************************************
1221 (Hopefully) efficient array append.
1222 ****************************************************************************/
1224 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1225 void *element, void *_array, uint32 *num_elements,
1226 ssize_t *array_size)
1228 void **array = (void **)_array;
1230 if (*array_size < 0) {
1234 if (*array == NULL) {
1235 if (*array_size == 0) {
1239 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1243 *array = TALLOC(mem_ctx, element_size * (*array_size));
1244 if (*array == NULL) {
1249 if (*num_elements == *array_size) {
1252 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1256 *array = TALLOC_REALLOC(mem_ctx, *array,
1257 element_size * (*array_size));
1259 if (*array == NULL) {
1264 memcpy((char *)(*array) + element_size*(*num_elements),
1265 element, element_size);
1275 /****************************************************************************
1276 Free memory, checks for NULL.
1277 Use directly SAFE_FREE()
1278 Exists only because we need to pass a function pointer somewhere --SSS
1279 ****************************************************************************/
1281 void safe_free(void *p)
1286 /****************************************************************************
1287 Get my own name and IP.
1288 ****************************************************************************/
1290 char *get_myname(TALLOC_CTX *ctx)
1293 char hostname[HOST_NAME_MAX];
1297 /* get my host name */
1298 if (gethostname(hostname, sizeof(hostname)) == -1) {
1299 DEBUG(0,("gethostname failed\n"));
1303 /* Ensure null termination. */
1304 hostname[sizeof(hostname)-1] = '\0';
1306 /* split off any parts after an initial . */
1307 p = strchr_m(hostname,'.');
1312 return talloc_strdup(ctx, hostname);
1315 /****************************************************************************
1316 Get my own domain name, or "" if we have none.
1317 ****************************************************************************/
1319 char *get_mydnsdomname(TALLOC_CTX *ctx)
1321 const char *domname;
1324 domname = get_mydnsfullname();
1329 p = strchr_m(domname, '.');
1332 return talloc_strdup(ctx, p);
1334 return talloc_strdup(ctx, "");
1338 /****************************************************************************
1339 Interpret a protocol description string, with a default.
1340 ****************************************************************************/
1342 int interpret_protocol(const char *str,int def)
1344 if (strequal(str,"NT1"))
1345 return(PROTOCOL_NT1);
1346 if (strequal(str,"LANMAN2"))
1347 return(PROTOCOL_LANMAN2);
1348 if (strequal(str,"LANMAN1"))
1349 return(PROTOCOL_LANMAN1);
1350 if (strequal(str,"CORE"))
1351 return(PROTOCOL_CORE);
1352 if (strequal(str,"COREPLUS"))
1353 return(PROTOCOL_COREPLUS);
1354 if (strequal(str,"CORE+"))
1355 return(PROTOCOL_COREPLUS);
1357 DEBUG(0,("Unrecognised protocol level %s\n",str));
1363 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1364 /******************************************************************
1365 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1366 Based on a fix from <Thomas.Hepper@icem.de>.
1367 Returns a malloc'ed string.
1368 *******************************************************************/
1370 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1373 const char *p = str;
1374 while(*p && !isspace(*p))
1376 while(*p && isspace(*p))
1379 return talloc_strdup(ctx, p);
1385 /*******************************************************************
1386 Patch from jkf@soton.ac.uk
1387 Split Luke's automount_server into YP lookup and string splitter
1388 so can easily implement automount_path().
1389 Returns a malloc'ed string.
1390 *******************************************************************/
1392 #ifdef WITH_NISPLUS_HOME
1393 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1397 char *nis_map = (char *)lp_nis_home_map_name();
1399 char buffer[NIS_MAXATTRVAL + 1];
1404 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1405 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1407 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1408 if (result->status != NIS_SUCCESS) {
1409 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1411 object = result->objects.objects_val;
1412 if (object->zo_data.zo_type == ENTRY_OBJ) {
1413 entry = &object->zo_data.objdata_u.en_data;
1414 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1415 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1417 value = talloc_strdup(ctx,
1418 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1420 nis_freeresult(result);
1423 value = talloc_string_sub(ctx,
1430 nis_freeresult(result);
1433 value = strip_mount_options(ctx, value);
1434 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1439 #else /* WITH_NISPLUS_HOME */
1441 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1445 int nis_error; /* returned by yp all functions */
1446 char *nis_result; /* yp_match inits this */
1447 int nis_result_len; /* and set this */
1448 char *nis_domain; /* yp_get_default_domain inits this */
1449 char *nis_map = (char *)lp_nis_home_map_name();
1451 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1452 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1456 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1458 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1459 strlen(user_name), &nis_result,
1460 &nis_result_len)) == 0) {
1461 value = talloc_strdup(ctx, nis_result);
1465 value = strip_mount_options(ctx, value);
1466 } else if(nis_error == YPERR_KEY) {
1467 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1468 user_name, nis_map));
1469 DEBUG(3, ("using defaults for server and home directory\n"));
1471 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1472 yperr_string(nis_error), user_name, nis_map));
1476 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1480 #endif /* WITH_NISPLUS_HOME */
1483 /****************************************************************************
1484 Check if a process exists. Does this work on all unixes?
1485 ****************************************************************************/
1487 bool process_exists(const struct server_id pid)
1489 if (procid_is_me(&pid)) {
1493 if (procid_is_local(&pid)) {
1494 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1497 #ifdef CLUSTER_SUPPORT
1498 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1505 bool process_exists_by_pid(pid_t pid)
1507 /* Doing kill with a non-positive pid causes messages to be
1508 * sent to places we don't want. */
1509 SMB_ASSERT(pid > 0);
1510 return(kill(pid,0) == 0 || errno != ESRCH);
1513 /*******************************************************************
1514 Convert a uid into a user name.
1515 ********************************************************************/
1517 const char *uidtoname(uid_t uid)
1519 TALLOC_CTX *ctx = talloc_tos();
1521 struct passwd *pass = NULL;
1523 pass = getpwuid_alloc(ctx,uid);
1525 name = talloc_strdup(ctx,pass->pw_name);
1528 name = talloc_asprintf(ctx,
1535 /*******************************************************************
1536 Convert a gid into a group name.
1537 ********************************************************************/
1539 char *gidtoname(gid_t gid)
1543 grp = getgrgid(gid);
1545 return talloc_strdup(talloc_tos(), grp->gr_name);
1548 return talloc_asprintf(talloc_tos(),
1554 /*******************************************************************
1555 Convert a user name into a uid.
1556 ********************************************************************/
1558 uid_t nametouid(const char *name)
1560 struct passwd *pass;
1564 pass = getpwnam_alloc(NULL, name);
1571 u = (uid_t)strtol(name, &p, 0);
1572 if ((p != name) && (*p == '\0'))
1578 /*******************************************************************
1579 Convert a name to a gid_t if possible. Return -1 if not a group.
1580 ********************************************************************/
1582 gid_t nametogid(const char *name)
1588 g = (gid_t)strtol(name, &p, 0);
1589 if ((p != name) && (*p == '\0'))
1592 grp = sys_getgrnam(name);
1594 return(grp->gr_gid);
1598 /*******************************************************************
1599 Something really nasty happened - panic !
1600 ********************************************************************/
1602 void smb_panic(const char *const why)
1610 if (global_clobber_region_function) {
1611 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1612 global_clobber_region_function,
1613 global_clobber_region_line));
1618 DEBUG(0,("PANIC (pid %llu): %s\n",
1619 (unsigned long long)sys_getpid(), why));
1622 cmd = lp_panic_action();
1624 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1625 result = system(cmd);
1628 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1631 DEBUG(0, ("smb_panic(): action returned status %d\n",
1632 WEXITSTATUS(result)));
1638 /*******************************************************************
1639 Print a backtrace of the stack to the debug log. This function
1640 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1641 exit shortly after calling it.
1642 ********************************************************************/
1644 #ifdef HAVE_LIBUNWIND_H
1645 #include <libunwind.h>
1648 #ifdef HAVE_EXECINFO_H
1649 #include <execinfo.h>
1652 #ifdef HAVE_LIBEXC_H
1656 void log_stack_trace(void)
1658 #ifdef HAVE_LIBUNWIND
1659 /* Try to use libunwind before any other technique since on ia64
1660 * libunwind correctly walks the stack in more circumstances than
1663 unw_cursor_t cursor;
1668 unw_word_t ip, sp, off;
1670 procname[sizeof(procname) - 1] = '\0';
1672 if (unw_getcontext(&uc) != 0) {
1673 goto libunwind_failed;
1676 if (unw_init_local(&cursor, &uc) != 0) {
1677 goto libunwind_failed;
1680 DEBUG(0, ("BACKTRACE:\n"));
1684 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1685 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1687 switch (unw_get_proc_name(&cursor,
1688 procname, sizeof(procname) - 1, &off) ) {
1692 /* Name truncated. */
1693 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1694 i, procname, (long long)off,
1695 (long long)ip, (long long) sp));
1698 /* case -UNW_ENOINFO: */
1699 /* case -UNW_EUNSPEC: */
1700 /* No symbol name found. */
1701 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1702 i, "<unknown symbol>",
1703 (long long)ip, (long long) sp));
1706 } while (unw_step(&cursor) > 0);
1711 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1713 #elif HAVE_BACKTRACE_SYMBOLS
1714 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1715 size_t backtrace_size;
1716 char **backtrace_strings;
1718 /* get the backtrace (stack frames) */
1719 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1720 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1722 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1723 (unsigned long)backtrace_size));
1725 if (backtrace_strings) {
1728 for (i = 0; i < backtrace_size; i++)
1729 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1731 /* Leak the backtrace_strings, rather than risk what free() might do */
1736 /* The IRIX libexc library provides an API for unwinding the stack. See
1737 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1738 * since we are about to abort anyway, it hardly matters.
1741 #define NAMESIZE 32 /* Arbitrary */
1743 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1744 char * names[BACKTRACE_STACK_SIZE];
1745 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1752 ZERO_ARRAY(namebuf);
1754 /* We need to be root so we can open our /proc entry to walk
1755 * our stack. It also helps when we want to dump core.
1759 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1760 names[i] = namebuf + (i * NAMESIZE);
1763 levels = trace_back_stack(0, addrs, names,
1764 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1766 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1767 for (i = 0; i < levels; i++) {
1768 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1773 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1777 /*******************************************************************
1778 A readdir wrapper which just returns the file name.
1779 ********************************************************************/
1781 const char *readdirname(SMB_STRUCT_DIR *p)
1783 SMB_STRUCT_DIRENT *ptr;
1789 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1793 dname = ptr->d_name;
1800 #ifdef HAVE_BROKEN_READDIR_NAME
1801 /* using /usr/ucb/cc is BAD */
1805 return talloc_strdup(talloc_tos(), dname);
1808 /*******************************************************************
1809 Utility function used to decide if the last component
1810 of a path matches a (possibly wildcarded) entry in a namelist.
1811 ********************************************************************/
1813 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1815 const char *last_component;
1817 /* if we have no list it's obviously not in the path */
1818 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1822 DEBUG(8, ("is_in_path: %s\n", name));
1824 /* Get the last component of the unix name. */
1825 last_component = strrchr_m(name, '/');
1826 if (!last_component) {
1827 last_component = name;
1829 last_component++; /* Go past '/' */
1832 for(; namelist->name != NULL; namelist++) {
1833 if(namelist->is_wild) {
1834 if (mask_match(last_component, namelist->name, case_sensitive)) {
1835 DEBUG(8,("is_in_path: mask match succeeded\n"));
1839 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1840 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1841 DEBUG(8,("is_in_path: match succeeded\n"));
1846 DEBUG(8,("is_in_path: match not found\n"));
1850 /*******************************************************************
1851 Strip a '/' separated list into an array of
1852 name_compare_enties structures suitable for
1853 passing to is_in_path(). We do this for
1854 speed so we can pre-parse all the names in the list
1855 and don't do it for each call to is_in_path().
1856 namelist is modified here and is assumed to be
1857 a copy owned by the caller.
1858 We also check if the entry contains a wildcard to
1859 remove a potentially expensive call to mask_match
1861 ********************************************************************/
1863 void set_namearray(name_compare_entry **ppname_array, char *namelist)
1866 char *nameptr = namelist;
1867 int num_entries = 0;
1870 (*ppname_array) = NULL;
1872 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1875 /* We need to make two passes over the string. The
1876 first to count the number of elements, the second
1881 if ( *nameptr == '/' ) {
1882 /* cope with multiple (useless) /s) */
1886 /* find the next / */
1887 name_end = strchr_m(nameptr, '/');
1889 /* oops - the last check for a / didn't find one. */
1890 if (name_end == NULL)
1893 /* next segment please */
1894 nameptr = name_end + 1;
1898 if(num_entries == 0)
1901 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1902 DEBUG(0,("set_namearray: malloc fail\n"));
1906 /* Now copy out the names */
1910 if ( *nameptr == '/' ) {
1911 /* cope with multiple (useless) /s) */
1915 /* find the next / */
1916 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1919 /* oops - the last check for a / didn't find one. */
1920 if(name_end == NULL)
1923 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1924 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1925 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1929 /* next segment please */
1930 nameptr = name_end + 1;
1934 (*ppname_array)[i].name = NULL;
1939 /****************************************************************************
1940 Routine to free a namearray.
1941 ****************************************************************************/
1943 void free_namearray(name_compare_entry *name_array)
1947 if(name_array == NULL)
1950 for(i=0; name_array[i].name!=NULL; i++)
1951 SAFE_FREE(name_array[i].name);
1952 SAFE_FREE(name_array);
1956 #define DBGC_CLASS DBGC_LOCKING
1958 /****************************************************************************
1959 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1960 is dealt with in posix.c
1961 Returns True if the lock was granted, False otherwise.
1962 ****************************************************************************/
1964 bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
1966 SMB_STRUCT_FLOCK lock;
1969 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1970 fd,op,(double)offset,(double)count,type));
1973 lock.l_whence = SEEK_SET;
1974 lock.l_start = offset;
1978 ret = sys_fcntl_ptr(fd,op,&lock);
1982 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
1983 (double)offset,(double)count,op,type,strerror(errno)));
1988 /* everything went OK */
1989 DEBUG(8,("fcntl_lock: Lock call successful\n"));
1994 /****************************************************************************
1995 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1996 is dealt with in posix.c
1997 Returns True if we have information regarding this lock region (and returns
1998 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1999 ****************************************************************************/
2001 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
2003 SMB_STRUCT_FLOCK lock;
2006 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
2007 fd,(double)*poffset,(double)*pcount,*ptype));
2009 lock.l_type = *ptype;
2010 lock.l_whence = SEEK_SET;
2011 lock.l_start = *poffset;
2012 lock.l_len = *pcount;
2015 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
2019 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
2020 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
2025 *ptype = lock.l_type;
2026 *poffset = lock.l_start;
2027 *pcount = lock.l_len;
2030 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
2031 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
2036 #define DBGC_CLASS DBGC_ALL
2038 /*******************************************************************
2039 Is the name specified one of my netbios names.
2040 Returns true if it is equal, false otherwise.
2041 ********************************************************************/
2043 bool is_myname(const char *s)
2048 for (n=0; my_netbios_names(n); n++) {
2049 if (strequal(my_netbios_names(n), s)) {
2054 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
2058 /*******************************************************************
2059 Is the name specified our workgroup/domain.
2060 Returns true if it is equal, false otherwise.
2061 ********************************************************************/
2063 bool is_myworkgroup(const char *s)
2067 if (strequal(s, lp_workgroup())) {
2071 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
2075 /*******************************************************************
2076 we distinguish between 2K and XP by the "Native Lan Manager" string
2077 WinXP => "Windows 2002 5.1"
2078 WinXP 64bit => "Windows XP 5.2"
2079 Win2k => "Windows 2000 5.0"
2080 NT4 => "Windows NT 4.0"
2081 Win9x => "Windows 4.0"
2082 Windows 2003 doesn't set the native lan manager string but
2083 they do set the domain to "Windows 2003 5.2" (probably a bug).
2084 ********************************************************************/
2086 void ra_lanman_string( const char *native_lanman )
2088 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
2089 set_remote_arch( RA_WINXP );
2090 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
2091 set_remote_arch( RA_WINXP64 );
2092 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
2093 set_remote_arch( RA_WIN2K3 );
2096 static const char *remote_arch_str;
2098 const char *get_remote_arch_str(void)
2100 if (!remote_arch_str) {
2103 return remote_arch_str;
2106 /*******************************************************************
2107 Set the horrid remote_arch string based on an enum.
2108 ********************************************************************/
2110 void set_remote_arch(enum remote_arch_types type)
2115 remote_arch_str = "WfWg";
2118 remote_arch_str = "OS2";
2121 remote_arch_str = "Win95";
2124 remote_arch_str = "WinNT";
2127 remote_arch_str = "Win2K";
2130 remote_arch_str = "WinXP";
2133 remote_arch_str = "WinXP64";
2136 remote_arch_str = "Win2K3";
2139 remote_arch_str = "Vista";
2142 remote_arch_str = "Samba";
2145 remote_arch_str = "CIFSFS";
2148 ra_type = RA_UNKNOWN;
2149 remote_arch_str = "UNKNOWN";
2153 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
2157 /*******************************************************************
2158 Get the remote_arch type.
2159 ********************************************************************/
2161 enum remote_arch_types get_remote_arch(void)
2166 void print_asc(int level, const unsigned char *buf,int len)
2170 DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
2173 void dump_data(int level, const unsigned char *buf1,int len)
2175 const unsigned char *buf = (const unsigned char *)buf1;
2179 if (!DEBUGLVL(level)) return;
2181 DEBUGADD(level,("[%03X] ",i));
2183 DEBUGADD(level,("%02X ",(int)buf[i]));
2185 if (i%8 == 0) DEBUGADD(level,(" "));
2187 print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
2188 print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
2189 if (i<len) DEBUGADD(level,("[%03X] ",i));
2195 DEBUGADD(level,(" "));
2196 if (n>8) DEBUGADD(level,(" "));
2197 while (n--) DEBUGADD(level,(" "));
2199 print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
2201 if (n>0) print_asc(level,&buf[i-n],n);
2202 DEBUGADD(level,("\n"));
2206 void dump_data_pw(const char *msg, const uchar * data, size_t len)
2208 #ifdef DEBUG_PASSWORD
2209 DEBUG(11, ("%s", msg));
2210 if (data != NULL && len > 0)
2212 dump_data(11, data, len);
2217 const char *tab_depth(int level, int depth)
2219 if( CHECK_DEBUGLVL(level) ) {
2220 dbgtext("%*s", depth*4, "");
2225 /*****************************************************************************
2226 Provide a checksum on a string
2228 Input: s - the null-terminated character string for which the checksum
2231 Output: The checksum value calculated for s.
2232 *****************************************************************************/
2234 int str_checksum(const char *s)
2242 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2249 /*****************************************************************
2250 Zero a memory area then free it. Used to catch bugs faster.
2251 *****************************************************************/
2253 void zero_free(void *p, size_t size)
2259 /*****************************************************************
2260 Set our open file limit to a requested max and return the limit.
2261 *****************************************************************/
2263 int set_maxfiles(int requested_max)
2265 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2267 int saved_current_limit;
2269 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2270 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2273 return requested_max;
2277 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2278 * account for the extra fd we need
2279 * as well as the log files and standard
2280 * handles etc. Save the limit we want to set in case
2281 * we are running on an OS that doesn't support this limit (AIX)
2282 * which always returns RLIM_INFINITY for rlp.rlim_max.
2285 /* Try raising the hard (max) limit to the requested amount. */
2287 #if defined(RLIM_INFINITY)
2288 if (rlp.rlim_max != RLIM_INFINITY) {
2289 int orig_max = rlp.rlim_max;
2291 if ( rlp.rlim_max < requested_max )
2292 rlp.rlim_max = requested_max;
2294 /* This failing is not an error - many systems (Linux) don't
2295 support our default request of 10,000 open files. JRA. */
2297 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2298 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2299 (int)rlp.rlim_max, strerror(errno) ));
2301 /* Set failed - restore original value from get. */
2302 rlp.rlim_max = orig_max;
2307 /* Now try setting the soft (current) limit. */
2309 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2311 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2312 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2313 (int)rlp.rlim_cur, strerror(errno) ));
2315 return saved_current_limit;
2318 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2319 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2322 return saved_current_limit;
2325 #if defined(RLIM_INFINITY)
2326 if(rlp.rlim_cur == RLIM_INFINITY)
2327 return saved_current_limit;
2330 if((int)rlp.rlim_cur > saved_current_limit)
2331 return saved_current_limit;
2333 return rlp.rlim_cur;
2334 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2336 * No way to know - just guess...
2338 return requested_max;
2342 /*****************************************************************
2343 Possibly replace mkstemp if it is broken.
2344 *****************************************************************/
2346 int smb_mkstemp(char *name_template)
2348 #if HAVE_SECURE_MKSTEMP
2349 return mkstemp(name_template);
2351 /* have a reasonable go at emulating it. Hope that
2352 the system mktemp() isn't completly hopeless */
2353 char *p = mktemp(name_template);
2356 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2360 /*****************************************************************
2361 malloc that aborts with smb_panic on fail or zero size.
2362 *****************************************************************/
2364 void *smb_xmalloc_array(size_t size, unsigned int count)
2368 smb_panic("smb_xmalloc_array: called with zero size");
2370 if (count >= MAX_ALLOC_SIZE/size) {
2371 smb_panic("smb_xmalloc_array: alloc size too large");
2373 if ((p = SMB_MALLOC(size*count)) == NULL) {
2374 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2375 (unsigned long)size, (unsigned long)count));
2376 smb_panic("smb_xmalloc_array: malloc failed");
2382 Memdup with smb_panic on fail.
2385 void *smb_xmemdup(const void *p, size_t size)
2388 p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
2389 memcpy(p2, p, size);
2394 strdup that aborts on malloc fail.
2397 char *smb_xstrdup(const char *s)
2399 #if defined(PARANOID_MALLOC_CHECKER)
2406 #define strdup rep_strdup
2409 char *s1 = strdup(s);
2410 #if defined(PARANOID_MALLOC_CHECKER)
2414 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2417 smb_panic("smb_xstrdup: malloc failed");
2424 strndup that aborts on malloc fail.
2427 char *smb_xstrndup(const char *s, size_t n)
2429 #if defined(PARANOID_MALLOC_CHECKER)
2435 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
2437 #define strndup rep_strndup
2440 char *s1 = strndup(s, n);
2441 #if defined(PARANOID_MALLOC_CHECKER)
2445 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2448 smb_panic("smb_xstrndup: malloc failed");
2454 vasprintf that aborts on malloc fail
2457 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2464 n = vasprintf(ptr, format, ap2);
2465 if (n == -1 || ! *ptr) {
2466 smb_panic("smb_xvasprintf: out of memory");
2472 /*****************************************************************
2473 Like strdup but for memory.
2474 *****************************************************************/
2476 void *memdup(const void *p, size_t size)
2481 p2 = SMB_MALLOC(size);
2484 memcpy(p2, p, size);
2488 /*****************************************************************
2489 Get local hostname and cache result.
2490 *****************************************************************/
2492 char *myhostname(void)
2496 /* This is cached forever so
2497 * use NULL talloc ctx. */
2498 ret = get_myname(NULL);
2503 /*****************************************************************
2504 A useful function for returning a path in the Samba pid directory.
2505 *****************************************************************/
2507 static char *xx_path(const char *name, const char *rootpath)
2511 fname = talloc_strdup(talloc_tos(), rootpath);
2515 trim_string(fname,"","/");
2517 if (!directory_exist(fname,NULL)) {
2521 return talloc_asprintf(talloc_tos(),
2527 /*****************************************************************
2528 A useful function for returning a path in the Samba lock directory.
2529 *****************************************************************/
2531 char *lock_path(const char *name)
2533 return xx_path(name, lp_lockdir());
2536 /*****************************************************************
2537 A useful function for returning a path in the Samba pid directory.
2538 *****************************************************************/
2540 char *pid_path(const char *name)
2542 return xx_path(name, lp_piddir());
2546 * @brief Returns an absolute path to a file in the Samba lib directory.
2548 * @param name File to find, relative to LIBDIR.
2550 * @retval Pointer to a string containing the full path.
2553 char *lib_path(const char *name)
2555 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2559 * @brief Returns an absolute path to a file in the Samba data directory.
2561 * @param name File to find, relative to CODEPAGEDIR.
2563 * @retval Pointer to a talloc'ed string containing the full path.
2566 char *data_path(const char *name)
2568 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2571 /*****************************************************************
2572 a useful function for returning a path in the Samba state directory
2573 *****************************************************************/
2575 char *state_path(const char *name)
2577 return xx_path(name, get_dyn_STATEDIR());
2581 * @brief Returns the platform specific shared library extension.
2583 * @retval Pointer to a const char * containing the extension.
2586 const char *shlib_ext(void)
2588 return get_dyn_SHLIBEXT();
2591 /*******************************************************************
2592 Given a filename - get its directory name
2593 NB: Returned in static storage. Caveats:
2594 o If caller wishes to preserve, they should copy.
2595 ********************************************************************/
2597 char *parent_dirname(const char *path)
2601 if (!parent_dirname_talloc(talloc_tos(), path, &parent, NULL)) {
2608 bool parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
2609 char **parent, const char **name)
2614 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2617 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2628 if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
2631 memcpy(*parent, dir, len);
2632 (*parent)[len] = '\0';
2640 /*******************************************************************
2641 Determine if a pattern contains any Microsoft wildcard characters.
2642 *******************************************************************/
2644 bool ms_has_wild(const char *s)
2648 if (lp_posix_pathnames()) {
2649 /* With posix pathnames no characters are wild. */
2653 while ((c = *s++)) {
2666 bool ms_has_wild_w(const smb_ucs2_t *s)
2669 if (!s) return False;
2670 while ((c = *s++)) {
2672 case UCS2_CHAR('*'):
2673 case UCS2_CHAR('?'):
2674 case UCS2_CHAR('<'):
2675 case UCS2_CHAR('>'):
2676 case UCS2_CHAR('"'):
2683 /*******************************************************************
2684 A wrapper that handles case sensitivity and the special handling
2686 *******************************************************************/
2688 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2690 if (strcmp(string,"..") == 0)
2692 if (strcmp(pattern,".") == 0)
2695 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2698 /*******************************************************************
2699 A wrapper that handles case sensitivity and the special handling
2700 of the ".." name. Varient that is only called by old search code which requires
2701 pattern translation.
2702 *******************************************************************/
2704 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2706 if (strcmp(string,"..") == 0)
2708 if (strcmp(pattern,".") == 0)
2711 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2714 /*******************************************************************
2715 A wrapper that handles a list of patters and calls mask_match()
2716 on each. Returns True if any of the patterns match.
2717 *******************************************************************/
2719 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2721 while (listLen-- > 0) {
2722 if (mask_match(string, *list++, is_case_sensitive))
2728 /*********************************************************
2729 Recursive routine that is called by unix_wild_match.
2730 *********************************************************/
2732 static bool unix_do_match(const char *regexp, const char *str)
2736 for( p = regexp; *p && *str; ) {
2747 * Look for a character matching
2748 * the one after the '*'.
2752 return true; /* Automatic match */
2755 while(*str && (*p != *str))
2759 * Patch from weidel@multichart.de. In the case of the regexp
2760 * '*XX*' we want to ensure there are at least 2 'X' characters
2761 * in the string after the '*' for a match to be made.
2768 * Eat all the characters that match, but count how many there were.
2771 while(*str && (*p == *str)) {
2777 * Now check that if the regexp had n identical characters that
2778 * matchcount had at least that many matches.
2781 while ( *(p+1) && (*(p+1) == *p)) {
2786 if ( matchcount <= 0 )
2790 str--; /* We've eaten the match char after the '*' */
2792 if(unix_do_match(p, str))
2814 if (!*p && str[0] == '.' && str[1] == 0)
2817 if (!*str && *p == '?') {
2823 if(!*str && (*p == '*' && p[1] == '\0'))
2829 /*******************************************************************
2830 Simple case insensitive interface to a UNIX wildcard matcher.
2831 Returns True if match, False if not.
2832 *******************************************************************/
2834 bool unix_wild_match(const char *pattern, const char *string)
2836 TALLOC_CTX *ctx = talloc_stackframe();
2842 p2 = talloc_strdup(ctx,pattern);
2843 s2 = talloc_strdup(ctx,string);
2851 /* Remove any *? and ** from the pattern as they are meaningless */
2852 for(p = p2; *p; p++) {
2853 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2854 memmove(&p[1], &p[2], strlen(&p[2])+1);
2858 if (strequal(p2,"*")) {
2863 ret = unix_do_match(p2, s2);
2868 /**********************************************************************
2869 Converts a name to a fully qualified domain name.
2870 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2871 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2872 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2873 ***********************************************************************/
2875 bool name_to_fqdn(fstring fqdn, const char *name)
2878 struct hostent *hp = gethostbyname(name);
2880 if (!hp || !hp->h_name || !*hp->h_name) {
2881 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2882 fstrcpy(fqdn, name);
2886 /* Find out if the fqdn is returned as an alias
2887 * to cope with /etc/hosts files where the first
2888 * name is not the fqdn but the short name */
2889 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2891 for (i = 0; hp->h_aliases[i]; i++) {
2892 if (strchr_m(hp->h_aliases[i], '.')) {
2893 full = hp->h_aliases[i];
2898 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2899 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2900 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2901 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2902 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2909 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2910 fstrcpy(fqdn, full);
2914 /**********************************************************************
2915 Extension to talloc_get_type: Abort on type mismatch
2916 ***********************************************************************/
2918 void *talloc_check_name_abort(const void *ptr, const char *name)
2922 result = talloc_check_name(ptr, name);
2926 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2927 name, talloc_get_name(ptr)));
2928 smb_panic("talloc type mismatch");
2929 /* Keep the compiler happy */
2933 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2935 switch (share_access & ~FILE_SHARE_DELETE) {
2936 case FILE_SHARE_NONE:
2938 case FILE_SHARE_READ:
2940 case FILE_SHARE_WRITE:
2942 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2945 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2947 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2954 pid_t procid_to_pid(const struct server_id *proc)
2959 static uint32 my_vnn = NONCLUSTER_VNN;
2961 void set_my_vnn(uint32 vnn)
2963 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2967 uint32 get_my_vnn(void)
2972 struct server_id pid_to_procid(pid_t pid)
2974 struct server_id result;
2976 #ifdef CLUSTER_SUPPORT
2977 result.vnn = my_vnn;
2982 struct server_id procid_self(void)
2984 return pid_to_procid(sys_getpid());
2987 struct server_id server_id_self(void)
2989 return procid_self();
2992 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2994 if (p1->pid != p2->pid)
2996 #ifdef CLUSTER_SUPPORT
2997 if (p1->vnn != p2->vnn)
3003 bool cluster_id_equal(const struct server_id *id1,
3004 const struct server_id *id2)
3006 return procid_equal(id1, id2);
3009 bool procid_is_me(const struct server_id *pid)
3011 if (pid->pid != sys_getpid())
3013 #ifdef CLUSTER_SUPPORT
3014 if (pid->vnn != my_vnn)
3020 struct server_id interpret_pid(const char *pid_string)
3022 #ifdef CLUSTER_SUPPORT
3023 unsigned int vnn, pid;
3024 struct server_id result;
3025 if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
3029 else if (sscanf(pid_string, "%u", &pid) == 1) {
3030 result.vnn = NONCLUSTER_VNN;
3034 result.vnn = NONCLUSTER_VNN;
3039 return pid_to_procid(atoi(pid_string));
3043 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
3045 #ifdef CLUSTER_SUPPORT
3046 if (pid->vnn == NONCLUSTER_VNN) {
3047 return talloc_asprintf(mem_ctx,
3052 return talloc_asprintf(mem_ctx,
3058 return talloc_asprintf(mem_ctx,
3064 char *procid_str_static(const struct server_id *pid)
3066 return procid_str(talloc_tos(), pid);
3069 bool procid_valid(const struct server_id *pid)
3071 return (pid->pid != -1);
3074 bool procid_is_local(const struct server_id *pid)
3076 #ifdef CLUSTER_SUPPORT
3077 return pid->vnn == my_vnn;
3083 int this_is_smp(void)
3085 #if defined(HAVE_SYSCONF)
3087 #if defined(SYSCONF_SC_NPROC_ONLN)
3088 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
3089 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
3090 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
3100 /****************************************************************
3101 Check if an offset into a buffer is safe.
3102 If this returns True it's safe to indirect into the byte at
3104 ****************************************************************/
3106 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3108 const char *end_base = buf_base + buf_len;
3109 char *end_ptr = ptr + off;
3111 if (!buf_base || !ptr) {
3115 if (end_base < buf_base || end_ptr < ptr) {
3116 return False; /* wrap. */
3119 if (end_ptr < end_base) {
3125 /****************************************************************
3126 Return a safe pointer into a buffer, or NULL.
3127 ****************************************************************/
3129 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3131 return is_offset_safe(buf_base, buf_len, ptr, off) ?
3135 /****************************************************************
3136 Return a safe pointer into a string within a buffer, or NULL.
3137 ****************************************************************/
3139 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3141 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
3144 /* Check if a valid string exists at this offset. */
3145 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
3151 /****************************************************************
3152 Return an SVAL at a pointer, or failval if beyond the end.
3153 ****************************************************************/
3155 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3158 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
3161 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
3164 return SVAL(ptr,off);
3167 /****************************************************************
3168 Return an IVAL at a pointer, or failval if beyond the end.
3169 ****************************************************************/
3171 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3174 * Note we use off+3 here, not off+4 as IVAL accesses
3175 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3177 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
3180 return IVAL(ptr,off);
3183 /****************************************************************
3184 Split DOM\user into DOM and user. Do not mix with winbind variants of that
3185 call (they take care of winbind separator and other winbind specific settings).
3186 ****************************************************************/
3188 void split_domain_user(TALLOC_CTX *mem_ctx,
3189 const char *full_name,
3193 const char *p = NULL;
3195 p = strchr_m(full_name, '\\');
3198 *domain = talloc_strndup(mem_ctx, full_name,
3199 PTR_DIFF(p, full_name));
3200 *user = talloc_strdup(mem_ctx, p+1);
3202 *domain = talloc_strdup(mem_ctx, "");
3203 *user = talloc_strdup(mem_ctx, full_name);
3209 Disable these now we have checked all code paths and ensured
3210 NULL returns on zero request. JRA.
3212 /****************************************************************
3213 talloc wrapper functions that guarentee a null pointer return
3215 ****************************************************************/
3217 #ifndef MAX_TALLOC_SIZE
3218 #define MAX_TALLOC_SIZE 0x10000000
3222 * talloc and zero memory.
3223 * - returns NULL if size is zero.
3226 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3234 p = talloc_named_const(ctx, size, name);
3237 memset(p, '\0', size);
3244 * memdup with a talloc.
3245 * - returns NULL if size is zero.
3248 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3256 newp = talloc_named_const(t, size, name);
3258 memcpy(newp, p, size);
3265 * alloc an array, checking for integer overflow in the array size.
3266 * - returns NULL if count or el_size are zero.
3269 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3271 if (count >= MAX_TALLOC_SIZE/el_size) {
3275 if (el_size == 0 || count == 0) {
3279 return talloc_named_const(ctx, el_size * count, name);
3283 * alloc an zero array, checking for integer overflow in the array size
3284 * - returns NULL if count or el_size are zero.
3287 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3289 if (count >= MAX_TALLOC_SIZE/el_size) {
3293 if (el_size == 0 || count == 0) {
3297 return _talloc_zero(ctx, el_size * count, name);
3301 * Talloc wrapper that returns NULL if size == 0.
3303 void *talloc_zeronull(const void *context, size_t size, const char *name)
3308 return talloc_named_const(context, size, name);
3312 /* Split a path name into filename and stream name components. Canonicalise
3313 * such that an implicit $DATA token is always explicit.
3315 * The "specification" of this function can be found in the
3316 * run_local_stream_name() function in torture.c, I've tried those
3317 * combinations against a W2k3 server.
3320 NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
3321 char **pbase, char **pstream)
3324 char *stream = NULL;
3325 char *sname; /* stream name */
3326 const char *stype; /* stream type */
3328 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
3330 sname = strchr_m(fname, ':');
3332 if (lp_posix_pathnames() || (sname == NULL)) {
3333 if (pbase != NULL) {
3334 base = talloc_strdup(mem_ctx, fname);
3335 NT_STATUS_HAVE_NO_MEMORY(base);
3340 if (pbase != NULL) {
3341 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
3342 NT_STATUS_HAVE_NO_MEMORY(base);
3347 stype = strchr_m(sname, ':');
3349 if (stype == NULL) {
3350 sname = talloc_strdup(mem_ctx, sname);
3354 if (StrCaseCmp(stype, ":$DATA") != 0) {
3356 * If there is an explicit stream type, so far we only
3357 * allow $DATA. Is there anything else allowed? -- vl
3359 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
3361 return NT_STATUS_OBJECT_NAME_INVALID;
3363 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
3367 if (sname == NULL) {
3369 return NT_STATUS_NO_MEMORY;
3372 if (sname[0] == '\0') {
3374 * no stream name, so no stream
3379 if (pstream != NULL) {
3380 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
3381 if (stream == NULL) {
3384 return NT_STATUS_NO_MEMORY;
3387 * upper-case the type field
3389 strupper_m(strchr_m(stream, ':')+1);
3393 if (pbase != NULL) {
3396 if (pstream != NULL) {
3399 return NT_STATUS_OK;
3402 bool is_valid_policy_hnd(const POLICY_HND *hnd)
3406 return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);