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 static enum remote_arch_types ra_type = RA_UNKNOWN;
60 /***********************************************************************
61 Definitions for all names.
62 ***********************************************************************/
64 static char *smb_myname;
65 static char *smb_myworkgroup;
66 static char *smb_scope;
67 static int smb_num_netbios_names;
68 static char **smb_my_netbios_names;
70 /***********************************************************************
71 Allocate and set myname. Ensure upper case.
72 ***********************************************************************/
74 bool set_global_myname(const char *myname)
76 SAFE_FREE(smb_myname);
77 smb_myname = SMB_STRDUP(myname);
80 strupper_m(smb_myname);
84 const char *global_myname(void)
89 /***********************************************************************
90 Allocate and set myworkgroup. Ensure upper case.
91 ***********************************************************************/
93 bool set_global_myworkgroup(const char *myworkgroup)
95 SAFE_FREE(smb_myworkgroup);
96 smb_myworkgroup = SMB_STRDUP(myworkgroup);
99 strupper_m(smb_myworkgroup);
103 const char *lp_workgroup(void)
105 return smb_myworkgroup;
108 /***********************************************************************
109 Allocate and set scope. Ensure upper case.
110 ***********************************************************************/
112 bool set_global_scope(const char *scope)
114 SAFE_FREE(smb_scope);
115 smb_scope = SMB_STRDUP(scope);
118 strupper_m(smb_scope);
122 /*********************************************************************
123 Ensure scope is never null string.
124 *********************************************************************/
126 const char *global_scope(void)
129 set_global_scope("");
133 static void free_netbios_names_array(void)
137 for (i = 0; i < smb_num_netbios_names; i++)
138 SAFE_FREE(smb_my_netbios_names[i]);
140 SAFE_FREE(smb_my_netbios_names);
141 smb_num_netbios_names = 0;
144 static bool allocate_my_netbios_names_array(size_t number)
146 free_netbios_names_array();
148 smb_num_netbios_names = number + 1;
149 smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
151 if (!smb_my_netbios_names)
154 memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
158 static bool set_my_netbios_names(const char *name, int i)
160 SAFE_FREE(smb_my_netbios_names[i]);
162 smb_my_netbios_names[i] = SMB_STRDUP(name);
163 if (!smb_my_netbios_names[i])
165 strupper_m(smb_my_netbios_names[i]);
169 /***********************************************************************
170 Free memory allocated to global objects
171 ***********************************************************************/
173 void gfree_names(void)
175 SAFE_FREE( smb_myname );
176 SAFE_FREE( smb_myworkgroup );
177 SAFE_FREE( smb_scope );
178 free_netbios_names_array();
179 free_local_machine_name();
182 void gfree_all( void )
192 const char *my_netbios_names(int i)
194 return smb_my_netbios_names[i];
197 bool set_netbios_aliases(const char **str_array)
201 /* Work out the max number of netbios aliases that we have */
202 for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
205 if ( global_myname() && *global_myname())
208 /* Allocate space for the netbios aliases */
209 if (!allocate_my_netbios_names_array(namecount))
212 /* Use the global_myname string first */
214 if ( global_myname() && *global_myname()) {
215 set_my_netbios_names( global_myname(), namecount );
221 for ( i = 0; str_array[i] != NULL; i++) {
223 bool duplicate = False;
225 /* Look for duplicates */
226 for( n=0; n<namecount; n++ ) {
227 if( strequal( str_array[i], my_netbios_names(n) ) ) {
233 if (!set_my_netbios_names(str_array[i], namecount))
242 /****************************************************************************
243 Common name initialization code.
244 ****************************************************************************/
246 bool init_names(void)
250 if (global_myname() == NULL || *global_myname() == '\0') {
251 if (!set_global_myname(myhostname())) {
252 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
257 if (!set_netbios_aliases(lp_netbios_aliases())) {
258 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
262 set_local_machine_name(global_myname(),false);
264 DEBUG( 5, ("Netbios name list:-\n") );
265 for( n=0; my_netbios_names(n); n++ ) {
266 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
267 n, my_netbios_names(n) ) );
273 /**************************************************************************n
274 Code to cope with username/password auth options from the commandline.
275 Used mainly in client tools.
276 ****************************************************************************/
278 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
280 struct user_auth_info *result;
282 result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
283 if (result == NULL) {
287 result->signing_state = Undefined;
291 const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
293 if (!auth_info->username) {
296 return auth_info->username;
299 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
300 const char *username)
302 TALLOC_FREE(auth_info->username);
303 auth_info->username = talloc_strdup(auth_info, username);
304 if (!auth_info->username) {
309 const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
311 if (!auth_info->domain) {
314 return auth_info->domain;
317 void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
320 TALLOC_FREE(auth_info->domain);
321 auth_info->domain = talloc_strdup(auth_info, domain);
322 if (!auth_info->domain) {
327 const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
329 if (!auth_info->password) {
332 return auth_info->password;
335 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
336 const char *password)
338 TALLOC_FREE(auth_info->password);
339 if (password == NULL) {
342 auth_info->password = talloc_strdup(auth_info, password);
343 if (!auth_info->password) {
346 auth_info->got_pass = true;
349 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
352 auth_info->signing_state = -1;
353 if (strequal(arg, "off") || strequal(arg, "no") ||
354 strequal(arg, "false")) {
355 auth_info->signing_state = false;
356 } else if (strequal(arg, "on") || strequal(arg, "yes") ||
357 strequal(arg, "true") || strequal(arg, "auto")) {
358 auth_info->signing_state = true;
359 } else if (strequal(arg, "force") || strequal(arg, "required") ||
360 strequal(arg, "forced")) {
361 auth_info->signing_state = Required;
368 int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
370 return auth_info->signing_state;
373 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
376 auth_info->use_kerberos = b;
379 bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
381 return auth_info->use_kerberos;
384 void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
387 auth_info->fallback_after_kerberos = b;
390 bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
392 return auth_info->fallback_after_kerberos;
395 /* This should only be used by lib/popt_common.c JRA */
396 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
398 auth_info->use_kerberos = true;
399 auth_info->got_pass = true;
402 /* This should only be used by lib/popt_common.c JRA */
403 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
405 auth_info->smb_encrypt = true;
408 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
410 auth_info->use_machine_account = true;
413 bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
415 return auth_info->got_pass;
418 bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
420 return auth_info->smb_encrypt;
423 bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
425 return auth_info->use_machine_account;
428 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
429 const struct user_auth_info *src)
431 struct user_auth_info *result;
433 result = user_auth_info_init(mem_ctx);
434 if (result == NULL) {
440 result->username = talloc_strdup(
441 result, get_cmdline_auth_info_username(src));
442 result->password = talloc_strdup(
443 result, get_cmdline_auth_info_password(src));
444 if ((result->username == NULL) || (result->password == NULL)) {
452 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
455 char *account = NULL;
457 if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
461 if (!secrets_init()) {
462 d_printf("ERROR: Unable to open secrets database\n");
466 if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
470 pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
472 d_printf("ERROR: Unable to fetch machine password for "
474 account, lp_workgroup());
479 set_cmdline_auth_info_username(auth_info, account);
480 set_cmdline_auth_info_password(auth_info, pass);
488 /****************************************************************************
489 Ensure we have a password if one not given.
490 ****************************************************************************/
492 void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
498 if (get_cmdline_auth_info_got_pass(auth_info) ||
499 get_cmdline_auth_info_use_kerberos(auth_info)) {
500 /* Already got one... */
504 frame = talloc_stackframe();
505 label = talloc_asprintf(frame, "Enter %s's password: ",
506 get_cmdline_auth_info_username(auth_info));
507 pass = getpass(label);
509 set_cmdline_auth_info_password(auth_info, pass);
514 /*******************************************************************
515 Check if a file exists - call vfs_file_exist for samba files.
516 ********************************************************************/
518 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
524 if (sys_stat(fname,sbuf) != 0)
527 return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
530 /*******************************************************************
531 Check if a unix domain socket exists - call vfs_file_exist for samba files.
532 ********************************************************************/
534 bool socket_exist(const char *fname)
537 if (sys_stat(fname,&st) != 0)
540 return S_ISSOCK(st.st_ex_mode);
543 /*******************************************************************
544 Check if a directory exists.
545 ********************************************************************/
547 bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
555 if (sys_stat(dname,st) != 0)
558 ret = S_ISDIR(st->st_ex_mode);
564 /*******************************************************************
565 Returns the size in bytes of the named given the stat struct.
566 ********************************************************************/
568 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
570 return sbuf->st_ex_size;
573 /*******************************************************************
574 Returns the size in bytes of the named file.
575 ********************************************************************/
577 SMB_OFF_T get_file_size(char *file_name)
581 if(sys_stat(file_name,&buf) != 0)
582 return (SMB_OFF_T)-1;
583 return get_file_size_stat(&buf);
586 /*******************************************************************
587 Return a string representing an attribute for a file.
588 ********************************************************************/
590 char *attrib_string(uint16 mode)
596 if (mode & aVOLID) fstrcat(attrstr,"V");
597 if (mode & aDIR) fstrcat(attrstr,"D");
598 if (mode & aARCH) fstrcat(attrstr,"A");
599 if (mode & aHIDDEN) fstrcat(attrstr,"H");
600 if (mode & aSYSTEM) fstrcat(attrstr,"S");
601 if (mode & aRONLY) fstrcat(attrstr,"R");
603 return talloc_strdup(talloc_tos(), attrstr);
606 /*******************************************************************
607 Show a smb message structure.
608 ********************************************************************/
610 void show_msg(char *buf)
618 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
620 (int)CVAL(buf,smb_com),
621 (int)CVAL(buf,smb_rcls),
622 (int)CVAL(buf,smb_reh),
623 (int)SVAL(buf,smb_err),
624 (int)CVAL(buf,smb_flg),
625 (int)SVAL(buf,smb_flg2)));
626 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
627 (int)SVAL(buf,smb_tid),
628 (int)SVAL(buf,smb_pid),
629 (int)SVAL(buf,smb_uid),
630 (int)SVAL(buf,smb_mid)));
631 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
633 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
634 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
635 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
637 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
639 DEBUGADD(5,("smb_bcc=%d\n",bcc));
647 dump_data(10, (uint8 *)smb_buf(buf), bcc);
650 /*******************************************************************
651 Set the length and marker of an encrypted smb packet.
652 ********************************************************************/
654 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
656 _smb_setlen(buf,len);
660 SSVAL(buf,6,enc_ctx_num);
663 /*******************************************************************
664 Set the length and marker of an smb packet.
665 ********************************************************************/
667 void smb_setlen(char *buf,int len)
669 _smb_setlen(buf,len);
677 /*******************************************************************
678 Setup only the byte count for a smb message.
679 ********************************************************************/
681 int set_message_bcc(char *buf,int num_bytes)
683 int num_words = CVAL(buf,smb_wct);
684 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
685 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
686 return (smb_size + num_words*2 + num_bytes);
689 /*******************************************************************
690 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
691 Return the bytes added
692 ********************************************************************/
694 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
696 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
699 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
700 DEBUG(0, ("talloc failed\n"));
705 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
706 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
710 /*******************************************************************
711 Reduce a file name, removing .. elements.
712 ********************************************************************/
714 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
719 DEBUG(3,("dos_clean_name [%s]\n",s));
721 /* remove any double slashes */
722 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
727 /* Remove leading .\\ characters */
728 if(strncmp(str, ".\\", 2) == 0) {
729 trim_string(str, ".\\", NULL);
731 str = talloc_strdup(ctx, ".\\");
738 while ((p = strstr_m(str,"\\..\\")) != NULL) {
744 if ((p=strrchr_m(str,'\\')) != NULL) {
749 str = talloc_asprintf(ctx,
758 trim_string(str,NULL,"\\..");
759 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
762 /*******************************************************************
763 Reduce a file name, removing .. elements.
764 ********************************************************************/
766 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
771 DEBUG(3,("unix_clean_name [%s]\n",s));
773 /* remove any double slashes */
774 str = talloc_all_string_sub(ctx, s, "//","/");
779 /* Remove leading ./ characters */
780 if(strncmp(str, "./", 2) == 0) {
781 trim_string(str, "./", NULL);
783 str = talloc_strdup(ctx, "./");
790 while ((p = strstr_m(str,"/../")) != NULL) {
796 if ((p=strrchr_m(str,'/')) != NULL) {
801 str = talloc_asprintf(ctx,
810 trim_string(str,NULL,"/..");
811 return talloc_all_string_sub(ctx, str, "/./", "/");
814 char *clean_name(TALLOC_CTX *ctx, const char *s)
816 char *str = dos_clean_name(ctx, s);
820 return unix_clean_name(ctx, str);
823 /*******************************************************************
824 Write data into an fd at a given offset. Ignore seek errors.
825 ********************************************************************/
827 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
832 if (pos == (SMB_OFF_T)-1) {
833 return write_data(fd, buffer, N);
835 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
837 ret = sys_pwrite(fd,buffer + total,N - total, pos);
838 if (ret == -1 && errno == ESPIPE) {
839 return write_data(fd, buffer + total,N - total);
842 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
851 return (ssize_t)total;
853 /* Use lseek and write_data. */
854 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
855 if (errno != ESPIPE) {
859 return write_data(fd, buffer, N);
863 /*******************************************************************
864 Sleep for a specified number of milliseconds.
865 ********************************************************************/
867 void smb_msleep(unsigned int t)
869 #if defined(HAVE_NANOSLEEP)
870 struct timespec tval;
873 tval.tv_sec = t/1000;
874 tval.tv_nsec = 1000000*(t%1000);
878 ret = nanosleep(&tval, &tval);
879 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
881 unsigned int tdiff=0;
882 struct timeval tval,t1,t2;
889 tval.tv_sec = (t-tdiff)/1000;
890 tval.tv_usec = 1000*((t-tdiff)%1000);
892 /* Never wait for more than 1 sec. */
893 if (tval.tv_sec > 1) {
900 sys_select_intr(0,&fds,NULL,NULL,&tval);
903 if (t2.tv_sec < t1.tv_sec) {
904 /* Someone adjusted time... */
908 tdiff = TvalDiff(&t1,&t2);
913 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
914 struct event_context *ev_ctx,
915 bool parent_longlived)
917 NTSTATUS status = NT_STATUS_OK;
919 /* Reset the state of the random
920 * number generation system, so
921 * children do not get the same random
922 * numbers as each other */
923 set_need_random_reseed();
925 /* tdb needs special fork handling */
926 if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
927 DEBUG(0,("tdb_reopen_all failed.\n"));
928 status = NT_STATUS_OPEN_FAILED;
933 event_context_reinit(ev_ctx);
938 * For clustering, we need to re-init our ctdbd connection after the
941 status = messaging_reinit(msg_ctx);
942 if (!NT_STATUS_IS_OK(status)) {
943 DEBUG(0,("messaging_reinit() failed: %s\n",
951 /****************************************************************************
952 Put up a yes/no prompt.
953 ****************************************************************************/
955 bool yesno(const char *p)
960 if (!fgets(ans,sizeof(ans)-1,stdin))
963 if (*ans == 'y' || *ans == 'Y')
969 #if defined(PARANOID_MALLOC_CHECKER)
971 /****************************************************************************
972 Internal malloc wrapper. Externally visible.
973 ****************************************************************************/
975 void *malloc_(size_t size)
982 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
985 /****************************************************************************
986 Internal calloc wrapper. Not externally visible.
987 ****************************************************************************/
989 static void *calloc_(size_t count, size_t size)
991 if (size == 0 || count == 0) {
995 return calloc(count, size);
996 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
999 /****************************************************************************
1000 Internal realloc wrapper. Not externally visible.
1001 ****************************************************************************/
1003 static void *realloc_(void *ptr, size_t size)
1006 return realloc(ptr, size);
1007 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1010 #endif /* PARANOID_MALLOC_CHECKER */
1012 /****************************************************************************
1014 ****************************************************************************/
1016 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1018 if (count >= MAX_ALLOC_SIZE/el_size) {
1022 return sys_memalign(align, el_size*count);
1025 /****************************************************************************
1027 ****************************************************************************/
1029 void *calloc_array(size_t size, size_t nmemb)
1031 if (nmemb >= MAX_ALLOC_SIZE/size) {
1034 if (size == 0 || nmemb == 0) {
1037 #if defined(PARANOID_MALLOC_CHECKER)
1038 return calloc_(nmemb, size);
1040 return calloc(nmemb, size);
1044 /****************************************************************************
1045 Expand a pointer to be a particular size.
1046 Note that this version of Realloc has an extra parameter that decides
1047 whether to free the passed in storage on allocation failure or if the
1050 This is designed for use in the typical idiom of :
1052 p = SMB_REALLOC(p, size)
1057 and not to have to keep track of the old 'p' contents to free later, nor
1058 to worry if the size parameter was zero. In the case where NULL is returned
1059 we guarentee that p has been freed.
1061 If free later semantics are desired, then pass 'free_old_on_error' as False which
1062 guarentees that the old contents are not freed on error, even if size == 0. To use
1065 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1073 Changes were instigated by Coverity error checking. JRA.
1074 ****************************************************************************/
1076 void *Realloc(void *p, size_t size, bool free_old_on_error)
1081 if (free_old_on_error) {
1084 DEBUG(2,("Realloc asked for 0 bytes\n"));
1088 #if defined(PARANOID_MALLOC_CHECKER)
1090 ret = (void *)malloc_(size);
1092 ret = (void *)realloc_(p,size);
1096 ret = (void *)malloc(size);
1098 ret = (void *)realloc(p,size);
1103 if (free_old_on_error && p) {
1106 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1112 /****************************************************************************
1113 (Hopefully) efficient array append.
1114 ****************************************************************************/
1116 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1117 void *element, void *_array, uint32 *num_elements,
1118 ssize_t *array_size)
1120 void **array = (void **)_array;
1122 if (*array_size < 0) {
1126 if (*array == NULL) {
1127 if (*array_size == 0) {
1131 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1135 *array = TALLOC(mem_ctx, element_size * (*array_size));
1136 if (*array == NULL) {
1141 if (*num_elements == *array_size) {
1144 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1148 *array = TALLOC_REALLOC(mem_ctx, *array,
1149 element_size * (*array_size));
1151 if (*array == NULL) {
1156 memcpy((char *)(*array) + element_size*(*num_elements),
1157 element, element_size);
1167 /****************************************************************************
1168 Get my own domain name, or "" if we have none.
1169 ****************************************************************************/
1171 char *get_mydnsdomname(TALLOC_CTX *ctx)
1173 const char *domname;
1176 domname = get_mydnsfullname();
1181 p = strchr_m(domname, '.');
1184 return talloc_strdup(ctx, p);
1186 return talloc_strdup(ctx, "");
1190 /****************************************************************************
1191 Interpret a protocol description string, with a default.
1192 ****************************************************************************/
1194 int interpret_protocol(const char *str,int def)
1196 if (strequal(str,"NT1"))
1197 return(PROTOCOL_NT1);
1198 if (strequal(str,"LANMAN2"))
1199 return(PROTOCOL_LANMAN2);
1200 if (strequal(str,"LANMAN1"))
1201 return(PROTOCOL_LANMAN1);
1202 if (strequal(str,"CORE"))
1203 return(PROTOCOL_CORE);
1204 if (strequal(str,"COREPLUS"))
1205 return(PROTOCOL_COREPLUS);
1206 if (strequal(str,"CORE+"))
1207 return(PROTOCOL_COREPLUS);
1209 DEBUG(0,("Unrecognised protocol level %s\n",str));
1215 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1216 /******************************************************************
1217 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1218 Based on a fix from <Thomas.Hepper@icem.de>.
1219 Returns a malloc'ed string.
1220 *******************************************************************/
1222 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1225 const char *p = str;
1226 while(*p && !isspace(*p))
1228 while(*p && isspace(*p))
1231 return talloc_strdup(ctx, p);
1237 /*******************************************************************
1238 Patch from jkf@soton.ac.uk
1239 Split Luke's automount_server into YP lookup and string splitter
1240 so can easily implement automount_path().
1241 Returns a malloc'ed string.
1242 *******************************************************************/
1244 #ifdef WITH_NISPLUS_HOME
1245 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1249 char *nis_map = (char *)lp_nis_home_map_name();
1251 char buffer[NIS_MAXATTRVAL + 1];
1256 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1257 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1259 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1260 if (result->status != NIS_SUCCESS) {
1261 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1263 object = result->objects.objects_val;
1264 if (object->zo_data.zo_type == ENTRY_OBJ) {
1265 entry = &object->zo_data.objdata_u.en_data;
1266 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1267 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1269 value = talloc_strdup(ctx,
1270 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1272 nis_freeresult(result);
1275 value = talloc_string_sub(ctx,
1282 nis_freeresult(result);
1285 value = strip_mount_options(ctx, value);
1286 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1291 #else /* WITH_NISPLUS_HOME */
1293 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1297 int nis_error; /* returned by yp all functions */
1298 char *nis_result; /* yp_match inits this */
1299 int nis_result_len; /* and set this */
1300 char *nis_domain; /* yp_get_default_domain inits this */
1301 char *nis_map = (char *)lp_nis_home_map_name();
1303 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1304 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1308 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1310 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1311 strlen(user_name), &nis_result,
1312 &nis_result_len)) == 0) {
1313 value = talloc_strdup(ctx, nis_result);
1317 value = strip_mount_options(ctx, value);
1318 } else if(nis_error == YPERR_KEY) {
1319 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1320 user_name, nis_map));
1321 DEBUG(3, ("using defaults for server and home directory\n"));
1323 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1324 yperr_string(nis_error), user_name, nis_map));
1328 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1332 #endif /* WITH_NISPLUS_HOME */
1335 /****************************************************************************
1336 Check if a process exists. Does this work on all unixes?
1337 ****************************************************************************/
1339 bool process_exists(const struct server_id pid)
1341 if (procid_is_me(&pid)) {
1345 if (procid_is_local(&pid)) {
1346 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1349 #ifdef CLUSTER_SUPPORT
1350 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1357 /*******************************************************************
1358 Convert a uid into a user name.
1359 ********************************************************************/
1361 const char *uidtoname(uid_t uid)
1363 TALLOC_CTX *ctx = talloc_tos();
1365 struct passwd *pass = NULL;
1367 pass = getpwuid_alloc(ctx,uid);
1369 name = talloc_strdup(ctx,pass->pw_name);
1372 name = talloc_asprintf(ctx,
1379 /*******************************************************************
1380 Convert a gid into a group name.
1381 ********************************************************************/
1383 char *gidtoname(gid_t gid)
1387 grp = getgrgid(gid);
1389 return talloc_strdup(talloc_tos(), grp->gr_name);
1392 return talloc_asprintf(talloc_tos(),
1398 /*******************************************************************
1399 Convert a user name into a uid.
1400 ********************************************************************/
1402 uid_t nametouid(const char *name)
1404 struct passwd *pass;
1408 pass = getpwnam_alloc(talloc_autofree_context(), name);
1415 u = (uid_t)strtol(name, &p, 0);
1416 if ((p != name) && (*p == '\0'))
1422 /*******************************************************************
1423 Convert a name to a gid_t if possible. Return -1 if not a group.
1424 ********************************************************************/
1426 gid_t nametogid(const char *name)
1432 g = (gid_t)strtol(name, &p, 0);
1433 if ((p != name) && (*p == '\0'))
1436 grp = sys_getgrnam(name);
1438 return(grp->gr_gid);
1442 /*******************************************************************
1443 Something really nasty happened - panic !
1444 ********************************************************************/
1446 void smb_panic(const char *const why)
1454 if (global_clobber_region_function) {
1455 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1456 global_clobber_region_function,
1457 global_clobber_region_line));
1462 DEBUG(0,("PANIC (pid %llu): %s\n",
1463 (unsigned long long)sys_getpid(), why));
1466 cmd = lp_panic_action();
1468 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1469 result = system(cmd);
1472 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1475 DEBUG(0, ("smb_panic(): action returned status %d\n",
1476 WEXITSTATUS(result)));
1482 /*******************************************************************
1483 Print a backtrace of the stack to the debug log. This function
1484 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1485 exit shortly after calling it.
1486 ********************************************************************/
1488 #ifdef HAVE_LIBUNWIND_H
1489 #include <libunwind.h>
1492 #ifdef HAVE_EXECINFO_H
1493 #include <execinfo.h>
1496 #ifdef HAVE_LIBEXC_H
1500 void log_stack_trace(void)
1502 #ifdef HAVE_LIBUNWIND
1503 /* Try to use libunwind before any other technique since on ia64
1504 * libunwind correctly walks the stack in more circumstances than
1507 unw_cursor_t cursor;
1512 unw_word_t ip, sp, off;
1514 procname[sizeof(procname) - 1] = '\0';
1516 if (unw_getcontext(&uc) != 0) {
1517 goto libunwind_failed;
1520 if (unw_init_local(&cursor, &uc) != 0) {
1521 goto libunwind_failed;
1524 DEBUG(0, ("BACKTRACE:\n"));
1528 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1529 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1531 switch (unw_get_proc_name(&cursor,
1532 procname, sizeof(procname) - 1, &off) ) {
1536 /* Name truncated. */
1537 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1538 i, procname, (long long)off,
1539 (long long)ip, (long long) sp));
1542 /* case -UNW_ENOINFO: */
1543 /* case -UNW_EUNSPEC: */
1544 /* No symbol name found. */
1545 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1546 i, "<unknown symbol>",
1547 (long long)ip, (long long) sp));
1550 } while (unw_step(&cursor) > 0);
1555 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1557 #elif HAVE_BACKTRACE_SYMBOLS
1558 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1559 size_t backtrace_size;
1560 char **backtrace_strings;
1562 /* get the backtrace (stack frames) */
1563 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1564 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1566 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1567 (unsigned long)backtrace_size));
1569 if (backtrace_strings) {
1572 for (i = 0; i < backtrace_size; i++)
1573 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1575 /* Leak the backtrace_strings, rather than risk what free() might do */
1580 /* The IRIX libexc library provides an API for unwinding the stack. See
1581 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1582 * since we are about to abort anyway, it hardly matters.
1585 #define NAMESIZE 32 /* Arbitrary */
1587 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1588 char * names[BACKTRACE_STACK_SIZE];
1589 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1596 ZERO_ARRAY(namebuf);
1598 /* We need to be root so we can open our /proc entry to walk
1599 * our stack. It also helps when we want to dump core.
1603 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1604 names[i] = namebuf + (i * NAMESIZE);
1607 levels = trace_back_stack(0, addrs, names,
1608 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1610 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1611 for (i = 0; i < levels; i++) {
1612 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1617 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1621 /*******************************************************************
1622 A readdir wrapper which just returns the file name.
1623 ********************************************************************/
1625 const char *readdirname(SMB_STRUCT_DIR *p)
1627 SMB_STRUCT_DIRENT *ptr;
1633 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1637 dname = ptr->d_name;
1644 #ifdef HAVE_BROKEN_READDIR_NAME
1645 /* using /usr/ucb/cc is BAD */
1649 return talloc_strdup(talloc_tos(), dname);
1652 /*******************************************************************
1653 Utility function used to decide if the last component
1654 of a path matches a (possibly wildcarded) entry in a namelist.
1655 ********************************************************************/
1657 bool is_in_path(const char *name, name_compare_entry *namelist,
1658 enum protocol_types proto, bool case_sensitive)
1660 const char *last_component;
1662 /* if we have no list it's obviously not in the path */
1663 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1667 DEBUG(8, ("is_in_path: %s\n", name));
1669 /* Get the last component of the unix name. */
1670 last_component = strrchr_m(name, '/');
1671 if (!last_component) {
1672 last_component = name;
1674 last_component++; /* Go past '/' */
1677 for(; namelist->name != NULL; namelist++) {
1678 if(namelist->is_wild) {
1679 if (mask_match(last_component, namelist->name,
1680 proto, case_sensitive)) {
1681 DEBUG(8,("is_in_path: mask match succeeded\n"));
1685 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1686 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1687 DEBUG(8,("is_in_path: match succeeded\n"));
1692 DEBUG(8,("is_in_path: match not found\n"));
1696 /*******************************************************************
1697 Strip a '/' separated list into an array of
1698 name_compare_enties structures suitable for
1699 passing to is_in_path(). We do this for
1700 speed so we can pre-parse all the names in the list
1701 and don't do it for each call to is_in_path().
1702 namelist is modified here and is assumed to be
1703 a copy owned by the caller.
1704 We also check if the entry contains a wildcard to
1705 remove a potentially expensive call to mask_match
1707 ********************************************************************/
1709 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1712 char *nameptr = (char *)namelist;
1713 int num_entries = 0;
1716 (*ppname_array) = NULL;
1718 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1721 /* We need to make two passes over the string. The
1722 first to count the number of elements, the second
1727 if ( *nameptr == '/' ) {
1728 /* cope with multiple (useless) /s) */
1732 /* anything left? */
1733 if ( *nameptr == '\0' )
1736 /* find the next '/' or consume remaining */
1737 name_end = strchr_m(nameptr, '/');
1738 if (name_end == NULL)
1739 name_end = (char *)nameptr + strlen(nameptr);
1741 /* next segment please */
1742 nameptr = name_end + 1;
1746 if(num_entries == 0)
1749 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1750 DEBUG(0,("set_namearray: malloc fail\n"));
1754 /* Now copy out the names */
1755 nameptr = (char *)namelist;
1758 if ( *nameptr == '/' ) {
1759 /* cope with multiple (useless) /s) */
1763 /* anything left? */
1764 if ( *nameptr == '\0' )
1767 /* find the next '/' or consume remaining */
1768 name_end = strchr_m(nameptr, '/');
1772 name_end = nameptr + strlen(nameptr);
1774 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1775 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1776 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1780 /* next segment please */
1781 nameptr = name_end + 1;
1785 (*ppname_array)[i].name = NULL;
1790 /****************************************************************************
1791 Routine to free a namearray.
1792 ****************************************************************************/
1794 void free_namearray(name_compare_entry *name_array)
1798 if(name_array == NULL)
1801 for(i=0; name_array[i].name!=NULL; i++)
1802 SAFE_FREE(name_array[i].name);
1803 SAFE_FREE(name_array);
1807 #define DBGC_CLASS DBGC_LOCKING
1809 /****************************************************************************
1810 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1811 is dealt with in posix.c
1812 Returns True if we have information regarding this lock region (and returns
1813 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1814 ****************************************************************************/
1816 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1818 SMB_STRUCT_FLOCK lock;
1821 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1822 fd,(double)*poffset,(double)*pcount,*ptype));
1824 lock.l_type = *ptype;
1825 lock.l_whence = SEEK_SET;
1826 lock.l_start = *poffset;
1827 lock.l_len = *pcount;
1830 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1834 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1835 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1840 *ptype = lock.l_type;
1841 *poffset = lock.l_start;
1842 *pcount = lock.l_len;
1845 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1846 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1851 #define DBGC_CLASS DBGC_ALL
1853 /*******************************************************************
1854 Is the name specified one of my netbios names.
1855 Returns true if it is equal, false otherwise.
1856 ********************************************************************/
1858 bool is_myname(const char *s)
1863 for (n=0; my_netbios_names(n); n++) {
1864 if (strequal(my_netbios_names(n), s)) {
1869 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1873 /*******************************************************************
1874 Is the name specified our workgroup/domain.
1875 Returns true if it is equal, false otherwise.
1876 ********************************************************************/
1878 bool is_myworkgroup(const char *s)
1882 if (strequal(s, lp_workgroup())) {
1886 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1890 /*******************************************************************
1891 we distinguish between 2K and XP by the "Native Lan Manager" string
1892 WinXP => "Windows 2002 5.1"
1893 WinXP 64bit => "Windows XP 5.2"
1894 Win2k => "Windows 2000 5.0"
1895 NT4 => "Windows NT 4.0"
1896 Win9x => "Windows 4.0"
1897 Windows 2003 doesn't set the native lan manager string but
1898 they do set the domain to "Windows 2003 5.2" (probably a bug).
1899 ********************************************************************/
1901 void ra_lanman_string( const char *native_lanman )
1903 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1904 set_remote_arch( RA_WINXP );
1905 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1906 set_remote_arch( RA_WINXP64 );
1907 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1908 set_remote_arch( RA_WIN2K3 );
1911 static const char *remote_arch_str;
1913 const char *get_remote_arch_str(void)
1915 if (!remote_arch_str) {
1918 return remote_arch_str;
1921 /*******************************************************************
1922 Set the horrid remote_arch string based on an enum.
1923 ********************************************************************/
1925 void set_remote_arch(enum remote_arch_types type)
1930 remote_arch_str = "WfWg";
1933 remote_arch_str = "OS2";
1936 remote_arch_str = "Win95";
1939 remote_arch_str = "WinNT";
1942 remote_arch_str = "Win2K";
1945 remote_arch_str = "WinXP";
1948 remote_arch_str = "WinXP64";
1951 remote_arch_str = "Win2K3";
1954 remote_arch_str = "Vista";
1957 remote_arch_str = "Samba";
1960 remote_arch_str = "CIFSFS";
1963 ra_type = RA_UNKNOWN;
1964 remote_arch_str = "UNKNOWN";
1968 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1972 /*******************************************************************
1973 Get the remote_arch type.
1974 ********************************************************************/
1976 enum remote_arch_types get_remote_arch(void)
1981 const char *tab_depth(int level, int depth)
1983 if( CHECK_DEBUGLVL(level) ) {
1984 dbgtext("%*s", depth*4, "");
1989 /*****************************************************************************
1990 Provide a checksum on a string
1992 Input: s - the null-terminated character string for which the checksum
1995 Output: The checksum value calculated for s.
1996 *****************************************************************************/
1998 int str_checksum(const char *s)
2006 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2013 /*****************************************************************
2014 Zero a memory area then free it. Used to catch bugs faster.
2015 *****************************************************************/
2017 void zero_free(void *p, size_t size)
2023 /*****************************************************************
2024 Set our open file limit to a requested max and return the limit.
2025 *****************************************************************/
2027 int set_maxfiles(int requested_max)
2029 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2031 int saved_current_limit;
2033 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2034 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2037 return requested_max;
2041 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2042 * account for the extra fd we need
2043 * as well as the log files and standard
2044 * handles etc. Save the limit we want to set in case
2045 * we are running on an OS that doesn't support this limit (AIX)
2046 * which always returns RLIM_INFINITY for rlp.rlim_max.
2049 /* Try raising the hard (max) limit to the requested amount. */
2051 #if defined(RLIM_INFINITY)
2052 if (rlp.rlim_max != RLIM_INFINITY) {
2053 int orig_max = rlp.rlim_max;
2055 if ( rlp.rlim_max < requested_max )
2056 rlp.rlim_max = requested_max;
2058 /* This failing is not an error - many systems (Linux) don't
2059 support our default request of 10,000 open files. JRA. */
2061 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2062 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2063 (int)rlp.rlim_max, strerror(errno) ));
2065 /* Set failed - restore original value from get. */
2066 rlp.rlim_max = orig_max;
2071 /* Now try setting the soft (current) limit. */
2073 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2075 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2076 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2077 (int)rlp.rlim_cur, strerror(errno) ));
2079 return saved_current_limit;
2082 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2083 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2086 return saved_current_limit;
2089 #if defined(RLIM_INFINITY)
2090 if(rlp.rlim_cur == RLIM_INFINITY)
2091 return saved_current_limit;
2094 if((int)rlp.rlim_cur > saved_current_limit)
2095 return saved_current_limit;
2097 return rlp.rlim_cur;
2098 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2100 * No way to know - just guess...
2102 return requested_max;
2106 /*****************************************************************
2107 malloc that aborts with smb_panic on fail or zero size.
2108 *****************************************************************/
2110 void *smb_xmalloc_array(size_t size, unsigned int count)
2114 smb_panic("smb_xmalloc_array: called with zero size");
2116 if (count >= MAX_ALLOC_SIZE/size) {
2117 smb_panic("smb_xmalloc_array: alloc size too large");
2119 if ((p = SMB_MALLOC(size*count)) == NULL) {
2120 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2121 (unsigned long)size, (unsigned long)count));
2122 smb_panic("smb_xmalloc_array: malloc failed");
2128 vasprintf that aborts on malloc fail
2131 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2138 n = vasprintf(ptr, format, ap2);
2140 if (n == -1 || ! *ptr) {
2141 smb_panic("smb_xvasprintf: out of memory");
2146 /*****************************************************************
2147 Get local hostname and cache result.
2148 *****************************************************************/
2150 char *myhostname(void)
2154 /* This is cached forever so
2155 * use talloc_autofree_context() ctx. */
2156 ret = get_myname(talloc_autofree_context());
2162 * @brief Returns an absolute path to a file concatenating the provided
2163 * @a rootpath and @a basename
2165 * @param name Filename, relative to @a rootpath
2167 * @retval Pointer to a string containing the full path.
2170 static char *xx_path(const char *name, const char *rootpath)
2174 fname = talloc_strdup(talloc_tos(), rootpath);
2178 trim_string(fname,"","/");
2180 if (!directory_exist(fname)) {
2181 if (!mkdir(fname,0755))
2182 DEBUG(1, ("Unable to create directory %s for file %s. "
2183 "Error was %s\n", fname, name, strerror(errno)));
2186 return talloc_asprintf(talloc_tos(),
2193 * @brief Returns an absolute path to a file in the Samba lock directory.
2195 * @param name File to find, relative to LOCKDIR.
2197 * @retval Pointer to a talloc'ed string containing the full path.
2200 char *lock_path(const char *name)
2202 return xx_path(name, lp_lockdir());
2206 * @brief Returns an absolute path to a file in the Samba pid directory.
2208 * @param name File to find, relative to PIDDIR.
2210 * @retval Pointer to a talloc'ed string containing the full path.
2213 char *pid_path(const char *name)
2215 return xx_path(name, lp_piddir());
2219 * @brief Returns an absolute path to a file in the Samba lib directory.
2221 * @param name File to find, relative to LIBDIR.
2223 * @retval Pointer to a string containing the full path.
2226 char *lib_path(const char *name)
2228 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2232 * @brief Returns an absolute path to a file in the Samba modules directory.
2234 * @param name File to find, relative to MODULESDIR.
2236 * @retval Pointer to a string containing the full path.
2239 char *modules_path(const char *name)
2241 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2245 * @brief Returns an absolute path to a file in the Samba data directory.
2247 * @param name File to find, relative to CODEPAGEDIR.
2249 * @retval Pointer to a talloc'ed string containing the full path.
2252 char *data_path(const char *name)
2254 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2258 * @brief Returns an absolute path to a file in the Samba state directory.
2260 * @param name File to find, relative to STATEDIR.
2262 * @retval Pointer to a talloc'ed string containing the full path.
2265 char *state_path(const char *name)
2267 return xx_path(name, lp_statedir());
2271 * @brief Returns an absolute path to a file in the Samba cache directory.
2273 * @param name File to find, relative to CACHEDIR.
2275 * @retval Pointer to a talloc'ed string containing the full path.
2278 char *cache_path(const char *name)
2280 return xx_path(name, lp_cachedir());
2284 * @brief Returns the platform specific shared library extension.
2286 * @retval Pointer to a const char * containing the extension.
2289 const char *shlib_ext(void)
2291 return get_dyn_SHLIBEXT();
2294 /*******************************************************************
2295 Given a filename - get its directory name
2296 ********************************************************************/
2298 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2304 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2307 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2318 if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2321 (*parent)[len] = '\0';
2329 /*******************************************************************
2330 Determine if a pattern contains any Microsoft wildcard characters.
2331 *******************************************************************/
2333 bool ms_has_wild(const char *s)
2337 if (lp_posix_pathnames()) {
2338 /* With posix pathnames no characters are wild. */
2342 while ((c = *s++)) {
2355 bool ms_has_wild_w(const smb_ucs2_t *s)
2358 if (!s) return False;
2359 while ((c = *s++)) {
2361 case UCS2_CHAR('*'):
2362 case UCS2_CHAR('?'):
2363 case UCS2_CHAR('<'):
2364 case UCS2_CHAR('>'):
2365 case UCS2_CHAR('"'):
2372 /*******************************************************************
2373 A wrapper that handles case sensitivity and the special handling
2375 *******************************************************************/
2377 bool mask_match(const char *string, const char *pattern,
2378 enum protocol_types proto, bool is_case_sensitive)
2380 if (ISDOTDOT(string))
2385 return ms_fnmatch(pattern, string, proto <= PROTOCOL_LANMAN2,
2386 is_case_sensitive) == 0;
2389 /*******************************************************************
2390 A wrapper that handles case sensitivity and the special handling
2391 of the ".." name. Varient that is only called by old search code which requires
2392 pattern translation.
2393 *******************************************************************/
2395 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2397 if (ISDOTDOT(string))
2402 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2405 /*******************************************************************
2406 A wrapper that handles a list of patters and calls mask_match()
2407 on each. Returns True if any of the patterns match.
2408 *******************************************************************/
2410 bool mask_match_list(const char *string, char **list, int listLen,
2411 enum protocol_types proto, bool is_case_sensitive)
2413 while (listLen-- > 0) {
2414 if (mask_match(string, *list++, proto, is_case_sensitive))
2420 /*********************************************************
2421 Recursive routine that is called by unix_wild_match.
2422 *********************************************************/
2424 static bool unix_do_match(const char *regexp, const char *str)
2428 for( p = regexp; *p && *str; ) {
2439 * Look for a character matching
2440 * the one after the '*'.
2444 return true; /* Automatic match */
2447 while(*str && (*p != *str))
2451 * Patch from weidel@multichart.de. In the case of the regexp
2452 * '*XX*' we want to ensure there are at least 2 'X' characters
2453 * in the string after the '*' for a match to be made.
2460 * Eat all the characters that match, but count how many there were.
2463 while(*str && (*p == *str)) {
2469 * Now check that if the regexp had n identical characters that
2470 * matchcount had at least that many matches.
2473 while ( *(p+1) && (*(p+1) == *p)) {
2478 if ( matchcount <= 0 )
2482 str--; /* We've eaten the match char after the '*' */
2484 if(unix_do_match(p, str))
2506 if (!*p && str[0] == '.' && str[1] == 0)
2509 if (!*str && *p == '?') {
2515 if(!*str && (*p == '*' && p[1] == '\0'))
2521 /*******************************************************************
2522 Simple case insensitive interface to a UNIX wildcard matcher.
2523 Returns True if match, False if not.
2524 *******************************************************************/
2526 bool unix_wild_match(const char *pattern, const char *string)
2528 TALLOC_CTX *ctx = talloc_stackframe();
2534 p2 = talloc_strdup(ctx,pattern);
2535 s2 = talloc_strdup(ctx,string);
2543 /* Remove any *? and ** from the pattern as they are meaningless */
2544 for(p = p2; *p; p++) {
2545 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2546 memmove(&p[1], &p[2], strlen(&p[2])+1);
2550 if (strequal(p2,"*")) {
2555 ret = unix_do_match(p2, s2);
2560 /**********************************************************************
2561 Converts a name to a fully qualified domain name.
2562 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2563 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2564 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2565 ***********************************************************************/
2567 bool name_to_fqdn(fstring fqdn, const char *name)
2570 struct hostent *hp = gethostbyname(name);
2572 if (!hp || !hp->h_name || !*hp->h_name) {
2573 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2574 fstrcpy(fqdn, name);
2578 /* Find out if the fqdn is returned as an alias
2579 * to cope with /etc/hosts files where the first
2580 * name is not the fqdn but the short name */
2581 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2583 for (i = 0; hp->h_aliases[i]; i++) {
2584 if (strchr_m(hp->h_aliases[i], '.')) {
2585 full = hp->h_aliases[i];
2590 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2591 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2592 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2593 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2594 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2601 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2602 fstrcpy(fqdn, full);
2606 /**********************************************************************
2607 Append a DATA_BLOB to a talloc'ed object
2608 ***********************************************************************/
2610 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2612 size_t old_size = 0;
2615 if (blob.length == 0) {
2620 old_size = talloc_get_size(buf);
2623 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2624 if (result == NULL) {
2628 memcpy(result + old_size, blob.data, blob.length);
2632 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2634 switch (share_access & ~FILE_SHARE_DELETE) {
2635 case FILE_SHARE_NONE:
2637 case FILE_SHARE_READ:
2639 case FILE_SHARE_WRITE:
2641 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2644 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2646 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2653 pid_t procid_to_pid(const struct server_id *proc)
2658 static uint32 my_vnn = NONCLUSTER_VNN;
2660 void set_my_vnn(uint32 vnn)
2662 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2666 uint32 get_my_vnn(void)
2671 struct server_id pid_to_procid(pid_t pid)
2673 struct server_id result;
2675 #ifdef CLUSTER_SUPPORT
2676 result.vnn = my_vnn;
2681 struct server_id procid_self(void)
2683 return pid_to_procid(sys_getpid());
2686 struct server_id server_id_self(void)
2688 return procid_self();
2691 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2693 if (p1->pid != p2->pid)
2695 #ifdef CLUSTER_SUPPORT
2696 if (p1->vnn != p2->vnn)
2702 bool cluster_id_equal(const struct server_id *id1,
2703 const struct server_id *id2)
2705 return procid_equal(id1, id2);
2708 bool procid_is_me(const struct server_id *pid)
2710 if (pid->pid != sys_getpid())
2712 #ifdef CLUSTER_SUPPORT
2713 if (pid->vnn != my_vnn)
2719 struct server_id interpret_pid(const char *pid_string)
2721 struct server_id result;
2723 #ifdef CLUSTER_SUPPORT
2725 if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2729 else if (sscanf(pid_string, "%d", &pid) == 1) {
2730 result.vnn = get_my_vnn();
2734 result.vnn = NONCLUSTER_VNN;
2738 if (sscanf(pid_string, "%d", &pid) != 1) {
2744 /* Assigning to result.pid may have overflowed
2745 Map negative pid to -1: i.e. error */
2746 if (result.pid < 0) {
2752 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2754 #ifdef CLUSTER_SUPPORT
2755 if (pid->vnn == NONCLUSTER_VNN) {
2756 return talloc_asprintf(mem_ctx,
2761 return talloc_asprintf(mem_ctx,
2767 return talloc_asprintf(mem_ctx,
2773 char *procid_str_static(const struct server_id *pid)
2775 return procid_str(talloc_tos(), pid);
2778 bool procid_valid(const struct server_id *pid)
2780 return (pid->pid != -1);
2783 bool procid_is_local(const struct server_id *pid)
2785 #ifdef CLUSTER_SUPPORT
2786 return pid->vnn == my_vnn;
2792 int this_is_smp(void)
2794 #if defined(HAVE_SYSCONF)
2796 #if defined(SYSCONF_SC_NPROC_ONLN)
2797 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2798 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2799 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2809 /****************************************************************
2810 Check if offset/length fit into bufsize. Should probably be
2811 merged with is_offset_safe, but this would require a rewrite
2812 of lanman.c. Later :-)
2813 ****************************************************************/
2815 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2817 if ((offset + length < offset) || (offset + length < length)) {
2821 if ((offset > bufsize) || (offset + length > bufsize)) {
2828 /****************************************************************
2829 Check if an offset into a buffer is safe.
2830 If this returns True it's safe to indirect into the byte at
2832 ****************************************************************/
2834 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2836 const char *end_base = buf_base + buf_len;
2837 char *end_ptr = ptr + off;
2839 if (!buf_base || !ptr) {
2843 if (end_base < buf_base || end_ptr < ptr) {
2844 return False; /* wrap. */
2847 if (end_ptr < end_base) {
2853 /****************************************************************
2854 Return a safe pointer into a buffer, or NULL.
2855 ****************************************************************/
2857 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2859 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2863 /****************************************************************
2864 Return a safe pointer into a string within a buffer, or NULL.
2865 ****************************************************************/
2867 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2869 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2872 /* Check if a valid string exists at this offset. */
2873 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2879 /****************************************************************
2880 Return an SVAL at a pointer, or failval if beyond the end.
2881 ****************************************************************/
2883 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2886 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2889 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2892 return SVAL(ptr,off);
2895 /****************************************************************
2896 Return an IVAL at a pointer, or failval if beyond the end.
2897 ****************************************************************/
2899 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2902 * Note we use off+3 here, not off+4 as IVAL accesses
2903 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2905 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2908 return IVAL(ptr,off);
2911 /****************************************************************
2912 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2913 call (they take care of winbind separator and other winbind specific settings).
2914 ****************************************************************/
2916 void split_domain_user(TALLOC_CTX *mem_ctx,
2917 const char *full_name,
2921 const char *p = NULL;
2923 p = strchr_m(full_name, '\\');
2926 *domain = talloc_strndup(mem_ctx, full_name,
2927 PTR_DIFF(p, full_name));
2928 *user = talloc_strdup(mem_ctx, p+1);
2930 *domain = talloc_strdup(mem_ctx, "");
2931 *user = talloc_strdup(mem_ctx, full_name);
2937 Disable these now we have checked all code paths and ensured
2938 NULL returns on zero request. JRA.
2940 /****************************************************************
2941 talloc wrapper functions that guarentee a null pointer return
2943 ****************************************************************/
2945 #ifndef MAX_TALLOC_SIZE
2946 #define MAX_TALLOC_SIZE 0x10000000
2950 * talloc and zero memory.
2951 * - returns NULL if size is zero.
2954 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2962 p = talloc_named_const(ctx, size, name);
2965 memset(p, '\0', size);
2972 * memdup with a talloc.
2973 * - returns NULL if size is zero.
2976 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2984 newp = talloc_named_const(t, size, name);
2986 memcpy(newp, p, size);
2993 * alloc an array, checking for integer overflow in the array size.
2994 * - returns NULL if count or el_size are zero.
2997 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2999 if (count >= MAX_TALLOC_SIZE/el_size) {
3003 if (el_size == 0 || count == 0) {
3007 return talloc_named_const(ctx, el_size * count, name);
3011 * alloc an zero array, checking for integer overflow in the array size
3012 * - returns NULL if count or el_size are zero.
3015 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3017 if (count >= MAX_TALLOC_SIZE/el_size) {
3021 if (el_size == 0 || count == 0) {
3025 return _talloc_zero(ctx, el_size * count, name);
3029 * Talloc wrapper that returns NULL if size == 0.
3031 void *talloc_zeronull(const void *context, size_t size, const char *name)
3036 return talloc_named_const(context, size, name);
3040 bool is_valid_policy_hnd(const struct policy_handle *hnd)
3042 struct policy_handle tmp;
3044 return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3047 bool policy_hnd_equal(const struct policy_handle *hnd1,
3048 const struct policy_handle *hnd2)
3050 if (!hnd1 || !hnd2) {
3054 return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3057 /****************************************************************
3058 strip off leading '\\' from a hostname
3059 ****************************************************************/
3061 const char *strip_hostname(const char *s)
3067 if (strlen_m(s) < 3) {
3071 if (s[0] == '\\') s++;
3072 if (s[0] == '\\') s++;
3077 bool tevent_req_poll_ntstatus(struct tevent_req *req,
3078 struct tevent_context *ev,
3081 bool ret = tevent_req_poll(req, ev);
3083 *status = map_nt_error_from_unix(errno);