6770a715d8893dc0fea289db07be20981e75b520
[nivanova/samba-autobuild/.git] / source3 / lib / util.c
1 /* 
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
9
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.
14
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.
19
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/>.
22 */
23
24 #include "includes.h"
25 #include "secrets.h"
26
27 extern char *global_clobber_region_function;
28 extern unsigned int global_clobber_region_line;
29
30 /* Max allowable allococation - 256mb - 0x10000000 */
31 #define MAX_ALLOC_SIZE (1024*1024*256)
32
33 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
34 #ifdef WITH_NISPLUS_HOME
35 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
36 /*
37  * The following lines are needed due to buggy include files
38  * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
39  * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
40  * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
41  * an enum in /usr/include/rpcsvc/nis.h.
42  */
43
44 #if defined(GROUP)
45 #undef GROUP
46 #endif
47
48 #if defined(GROUP_OBJ)
49 #undef GROUP_OBJ
50 #endif
51
52 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
53
54 #include <rpcsvc/nis.h>
55
56 #endif /* WITH_NISPLUS_HOME */
57 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
58
59 static enum protocol_types Protocol = PROTOCOL_COREPLUS;
60
61 enum protocol_types get_Protocol(void)
62 {
63         return Protocol;
64 }
65
66 void set_Protocol(enum protocol_types  p)
67 {
68         Protocol = p;
69 }
70
71 static enum remote_arch_types ra_type = RA_UNKNOWN;
72
73 /***********************************************************************
74  Definitions for all names.
75 ***********************************************************************/
76
77 static char *smb_scope;
78 static int smb_num_netbios_names;
79 static char **smb_my_netbios_names;
80
81 /***********************************************************************
82  Allocate and set scope. Ensure upper case.
83 ***********************************************************************/
84
85 bool set_global_scope(const char *scope)
86 {
87         SAFE_FREE(smb_scope);
88         smb_scope = SMB_STRDUP(scope);
89         if (!smb_scope)
90                 return False;
91         strupper_m(smb_scope);
92         return True;
93 }
94
95 /*********************************************************************
96  Ensure scope is never null string.
97 *********************************************************************/
98
99 const char *global_scope(void)
100 {
101         if (!smb_scope)
102                 set_global_scope("");
103         return smb_scope;
104 }
105
106 static void free_netbios_names_array(void)
107 {
108         int i;
109
110         for (i = 0; i < smb_num_netbios_names; i++)
111                 SAFE_FREE(smb_my_netbios_names[i]);
112
113         SAFE_FREE(smb_my_netbios_names);
114         smb_num_netbios_names = 0;
115 }
116
117 static bool allocate_my_netbios_names_array(size_t number)
118 {
119         free_netbios_names_array();
120
121         smb_num_netbios_names = number + 1;
122         smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
123
124         if (!smb_my_netbios_names)
125                 return False;
126
127         memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
128         return True;
129 }
130
131 static bool set_my_netbios_names(const char *name, int i)
132 {
133         SAFE_FREE(smb_my_netbios_names[i]);
134
135         smb_my_netbios_names[i] = SMB_STRDUP(name);
136         if (!smb_my_netbios_names[i])
137                 return False;
138         strupper_m(smb_my_netbios_names[i]);
139         return True;
140 }
141
142 /***********************************************************************
143  Free memory allocated to global objects
144 ***********************************************************************/
145
146 void gfree_names(void)
147 {
148         gfree_netbios_names();
149         SAFE_FREE( smb_scope );
150         free_netbios_names_array();
151         free_local_machine_name();
152 }
153
154 void gfree_all( void )
155 {
156         gfree_names();
157         gfree_loadparm();
158         gfree_case_tables();
159         gfree_charcnv();
160         gfree_interfaces();
161         gfree_debugsyms();
162 }
163
164 const char *my_netbios_names(int i)
165 {
166         return smb_my_netbios_names[i];
167 }
168
169 bool set_netbios_aliases(const char **str_array)
170 {
171         size_t namecount;
172
173         /* Work out the max number of netbios aliases that we have */
174         for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
175                 ;
176
177         if ( global_myname() && *global_myname())
178                 namecount++;
179
180         /* Allocate space for the netbios aliases */
181         if (!allocate_my_netbios_names_array(namecount))
182                 return False;
183
184         /* Use the global_myname string first */
185         namecount=0;
186         if ( global_myname() && *global_myname()) {
187                 set_my_netbios_names( global_myname(), namecount );
188                 namecount++;
189         }
190
191         if (str_array) {
192                 size_t i;
193                 for ( i = 0; str_array[i] != NULL; i++) {
194                         size_t n;
195                         bool duplicate = False;
196
197                         /* Look for duplicates */
198                         for( n=0; n<namecount; n++ ) {
199                                 if( strequal( str_array[i], my_netbios_names(n) ) ) {
200                                         duplicate = True;
201                                         break;
202                                 }
203                         }
204                         if (!duplicate) {
205                                 if (!set_my_netbios_names(str_array[i], namecount))
206                                         return False;
207                                 namecount++;
208                         }
209                 }
210         }
211         return True;
212 }
213
214 /****************************************************************************
215   Common name initialization code.
216 ****************************************************************************/
217
218 bool init_names(void)
219 {
220         int n;
221
222         if (global_myname() == NULL || *global_myname() == '\0') {
223                 if (!set_global_myname(myhostname())) {
224                         DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
225                         return False;
226                 }
227         }
228
229         if (!set_netbios_aliases(lp_netbios_aliases())) {
230                 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
231                 return False;
232         }
233
234         set_local_machine_name(global_myname(),false);
235
236         DEBUG( 5, ("Netbios name list:-\n") );
237         for( n=0; my_netbios_names(n); n++ ) {
238                 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
239                                         n, my_netbios_names(n) ) );
240         }
241
242         return( True );
243 }
244
245 /**************************************************************************n
246   Code to cope with username/password auth options from the commandline.
247   Used mainly in client tools.
248 ****************************************************************************/
249
250 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
251 {
252         struct user_auth_info *result;
253
254         result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
255         if (result == NULL) {
256                 return NULL;
257         }
258
259         result->signing_state = Undefined;
260         return result;
261 }
262
263 const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
264 {
265         if (!auth_info->username) {
266                 return "";
267         }
268         return auth_info->username;
269 }
270
271 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
272                                     const char *username)
273 {
274         TALLOC_FREE(auth_info->username);
275         auth_info->username = talloc_strdup(auth_info, username);
276         if (!auth_info->username) {
277                 exit(ENOMEM);
278         }
279 }
280
281 const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
282 {
283         if (!auth_info->domain) {
284                 return "";
285         }
286         return auth_info->domain;
287 }
288
289 void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
290                                   const char *domain)
291 {
292         TALLOC_FREE(auth_info->domain);
293         auth_info->domain = talloc_strdup(auth_info, domain);
294         if (!auth_info->domain) {
295                 exit(ENOMEM);
296         }
297 }
298
299 const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
300 {
301         if (!auth_info->password) {
302                 return "";
303         }
304         return auth_info->password;
305 }
306
307 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
308                                     const char *password)
309 {
310         TALLOC_FREE(auth_info->password);
311         if (password == NULL) {
312                 password = "";
313         }
314         auth_info->password = talloc_strdup(auth_info, password);
315         if (!auth_info->password) {
316                 exit(ENOMEM);
317         }
318         auth_info->got_pass = true;
319 }
320
321 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
322                                          const char *arg)
323 {
324         auth_info->signing_state = -1;
325         if (strequal(arg, "off") || strequal(arg, "no") ||
326                         strequal(arg, "false")) {
327                 auth_info->signing_state = false;
328         } else if (strequal(arg, "on") || strequal(arg, "yes") ||
329                         strequal(arg, "true") || strequal(arg, "auto")) {
330                 auth_info->signing_state = true;
331         } else if (strequal(arg, "force") || strequal(arg, "required") ||
332                         strequal(arg, "forced")) {
333                 auth_info->signing_state = Required;
334         } else {
335                 return false;
336         }
337         return true;
338 }
339
340 int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
341 {
342         return auth_info->signing_state;
343 }
344
345 void set_cmdline_auth_info_use_ccache(struct user_auth_info *auth_info, bool b)
346 {
347         auth_info->use_ccache = b;
348 }
349
350 bool get_cmdline_auth_info_use_ccache(const struct user_auth_info *auth_info)
351 {
352         return auth_info->use_ccache;
353 }
354
355 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
356                                         bool b)
357 {
358         auth_info->use_kerberos = b;
359 }
360
361 bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
362 {
363         return auth_info->use_kerberos;
364 }
365
366 void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
367                                         bool b)
368 {
369         auth_info->fallback_after_kerberos = b;
370 }
371
372 bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
373 {
374         return auth_info->fallback_after_kerberos;
375 }
376
377 /* This should only be used by lib/popt_common.c JRA */
378 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
379 {
380         auth_info->use_kerberos = true;
381         auth_info->got_pass = true;
382 }
383
384 /* This should only be used by lib/popt_common.c JRA */
385 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
386 {
387         auth_info->smb_encrypt = true;
388 }
389
390 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
391 {
392         auth_info->use_machine_account = true;
393 }
394
395 bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
396 {
397         return auth_info->got_pass;
398 }
399
400 bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
401 {
402         return auth_info->smb_encrypt;
403 }
404
405 bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
406 {
407         return auth_info->use_machine_account;
408 }
409
410 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
411                                                   const struct user_auth_info *src)
412 {
413         struct user_auth_info *result;
414
415         result = user_auth_info_init(mem_ctx);
416         if (result == NULL) {
417                 return NULL;
418         }
419
420         *result = *src;
421
422         result->username = talloc_strdup(
423                 result, get_cmdline_auth_info_username(src));
424         result->password = talloc_strdup(
425                 result, get_cmdline_auth_info_password(src));
426         if ((result->username == NULL) || (result->password == NULL)) {
427                 TALLOC_FREE(result);
428                 return NULL;
429         }
430
431         return result;
432 }
433
434 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
435 {
436         char *pass = NULL;
437         char *account = NULL;
438
439         if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
440                 return false;
441         }
442
443         if (!secrets_init()) {
444                 d_printf("ERROR: Unable to open secrets database\n");
445                 return false;
446         }
447
448         if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
449                 return false;
450         }
451
452         pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
453         if (!pass) {
454                 d_printf("ERROR: Unable to fetch machine password for "
455                         "%s in domain %s\n",
456                         account, lp_workgroup());
457                 SAFE_FREE(account);
458                 return false;
459         }
460
461         set_cmdline_auth_info_username(auth_info, account);
462         set_cmdline_auth_info_password(auth_info, pass);
463
464         SAFE_FREE(account);
465         SAFE_FREE(pass);
466
467         return true;
468 }
469
470 /****************************************************************************
471  Ensure we have a password if one not given.
472 ****************************************************************************/
473
474 void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
475 {
476         char *label = NULL;
477         char *pass;
478         TALLOC_CTX *frame;
479
480         if (get_cmdline_auth_info_got_pass(auth_info) ||
481                         get_cmdline_auth_info_use_kerberos(auth_info)) {
482                 /* Already got one... */
483                 return;
484         }
485
486         frame = talloc_stackframe();
487         label = talloc_asprintf(frame, "Enter %s's password: ",
488                         get_cmdline_auth_info_username(auth_info));
489         pass = getpass(label);
490         if (pass) {
491                 set_cmdline_auth_info_password(auth_info, pass);
492         }
493         TALLOC_FREE(frame);
494 }
495
496 /*******************************************************************
497  Check if a file exists - call vfs_file_exist for samba files.
498 ********************************************************************/
499
500 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
501                      bool fake_dir_create_times)
502 {
503         SMB_STRUCT_STAT st;
504         if (!sbuf)
505                 sbuf = &st;
506
507         if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
508                 return(False);
509
510         return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
511 }
512
513 /*******************************************************************
514  Check if a unix domain socket exists - call vfs_file_exist for samba files.
515 ********************************************************************/
516
517 bool socket_exist(const char *fname)
518 {
519         SMB_STRUCT_STAT st;
520         if (sys_stat(fname, &st, false) != 0)
521                 return(False);
522
523         return S_ISSOCK(st.st_ex_mode);
524 }
525
526 /*******************************************************************
527  Returns the size in bytes of the named given the stat struct.
528 ********************************************************************/
529
530 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
531 {
532         return sbuf->st_ex_size;
533 }
534
535 /*******************************************************************
536  Returns the size in bytes of the named file.
537 ********************************************************************/
538
539 SMB_OFF_T get_file_size(char *file_name)
540 {
541         SMB_STRUCT_STAT buf;
542         buf.st_ex_size = 0;
543         if (sys_stat(file_name, &buf, false) != 0)
544                 return (SMB_OFF_T)-1;
545         return get_file_size_stat(&buf);
546 }
547
548 /*******************************************************************
549  Return a string representing an attribute for a file.
550 ********************************************************************/
551
552 char *attrib_string(uint16 mode)
553 {
554         fstring attrstr;
555
556         attrstr[0] = 0;
557
558         if (mode & aVOLID) fstrcat(attrstr,"V");
559         if (mode & aDIR) fstrcat(attrstr,"D");
560         if (mode & aARCH) fstrcat(attrstr,"A");
561         if (mode & aHIDDEN) fstrcat(attrstr,"H");
562         if (mode & aSYSTEM) fstrcat(attrstr,"S");
563         if (mode & aRONLY) fstrcat(attrstr,"R");          
564
565         return talloc_strdup(talloc_tos(), attrstr);
566 }
567
568 /*******************************************************************
569  Show a smb message structure.
570 ********************************************************************/
571
572 void show_msg(char *buf)
573 {
574         int i;
575         int bcc=0;
576
577         if (!DEBUGLVL(5))
578                 return;
579
580         DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
581                         smb_len(buf),
582                         (int)CVAL(buf,smb_com),
583                         (int)CVAL(buf,smb_rcls),
584                         (int)CVAL(buf,smb_reh),
585                         (int)SVAL(buf,smb_err),
586                         (int)CVAL(buf,smb_flg),
587                         (int)SVAL(buf,smb_flg2)));
588         DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
589                         (int)SVAL(buf,smb_tid),
590                         (int)SVAL(buf,smb_pid),
591                         (int)SVAL(buf,smb_uid),
592                         (int)SVAL(buf,smb_mid)));
593         DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
594
595         for (i=0;i<(int)CVAL(buf,smb_wct);i++)
596                 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
597                         SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
598
599         bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
600
601         DEBUGADD(5,("smb_bcc=%d\n",bcc));
602
603         if (DEBUGLEVEL < 10)
604                 return;
605
606         if (DEBUGLEVEL < 50)
607                 bcc = MIN(bcc, 512);
608
609         dump_data(10, (uint8 *)smb_buf(buf), bcc);      
610 }
611
612 /*******************************************************************
613  Set the length and marker of an encrypted smb packet.
614 ********************************************************************/
615
616 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
617 {
618         _smb_setlen(buf,len);
619
620         SCVAL(buf,4,0xFF);
621         SCVAL(buf,5,'E');
622         SSVAL(buf,6,enc_ctx_num);
623 }
624
625 /*******************************************************************
626  Set the length and marker of an smb packet.
627 ********************************************************************/
628
629 void smb_setlen(char *buf,int len)
630 {
631         _smb_setlen(buf,len);
632
633         SCVAL(buf,4,0xFF);
634         SCVAL(buf,5,'S');
635         SCVAL(buf,6,'M');
636         SCVAL(buf,7,'B');
637 }
638
639 /*******************************************************************
640  Setup only the byte count for a smb message.
641 ********************************************************************/
642
643 int set_message_bcc(char *buf,int num_bytes)
644 {
645         int num_words = CVAL(buf,smb_wct);
646         SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
647         _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
648         return (smb_size + num_words*2 + num_bytes);
649 }
650
651 /*******************************************************************
652  Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
653  Return the bytes added
654 ********************************************************************/
655
656 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
657 {
658         size_t newlen = smb_len(*outbuf) + 4 + blob.length;
659         uint8 *tmp;
660
661         if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
662                 DEBUG(0, ("talloc failed\n"));
663                 return -1;
664         }
665         *outbuf = tmp;
666
667         memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
668         set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
669         return blob.length;
670 }
671
672 /*******************************************************************
673  Reduce a file name, removing .. elements.
674 ********************************************************************/
675
676 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
677 {
678         char *p = NULL;
679         char *str = NULL;
680
681         DEBUG(3,("dos_clean_name [%s]\n",s));
682
683         /* remove any double slashes */
684         str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
685         if (!str) {
686                 return NULL;
687         }
688
689         /* Remove leading .\\ characters */
690         if(strncmp(str, ".\\", 2) == 0) {
691                 trim_string(str, ".\\", NULL);
692                 if(*str == 0) {
693                         str = talloc_strdup(ctx, ".\\");
694                         if (!str) {
695                                 return NULL;
696                         }
697                 }
698         }
699
700         while ((p = strstr_m(str,"\\..\\")) != NULL) {
701                 char *s1;
702
703                 *p = 0;
704                 s1 = p+3;
705
706                 if ((p=strrchr_m(str,'\\')) != NULL) {
707                         *p = 0;
708                 } else {
709                         *str = 0;
710                 }
711                 str = talloc_asprintf(ctx,
712                                 "%s%s",
713                                 str,
714                                 s1);
715                 if (!str) {
716                         return NULL;
717                 }
718         }
719
720         trim_string(str,NULL,"\\..");
721         return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
722 }
723
724 /*******************************************************************
725  Reduce a file name, removing .. elements.
726 ********************************************************************/
727
728 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
729 {
730         char *p = NULL;
731         char *str = NULL;
732
733         DEBUG(3,("unix_clean_name [%s]\n",s));
734
735         /* remove any double slashes */
736         str = talloc_all_string_sub(ctx, s, "//","/");
737         if (!str) {
738                 return NULL;
739         }
740
741         /* Remove leading ./ characters */
742         if(strncmp(str, "./", 2) == 0) {
743                 trim_string(str, "./", NULL);
744                 if(*str == 0) {
745                         str = talloc_strdup(ctx, "./");
746                         if (!str) {
747                                 return NULL;
748                         }
749                 }
750         }
751
752         while ((p = strstr_m(str,"/../")) != NULL) {
753                 char *s1;
754
755                 *p = 0;
756                 s1 = p+3;
757
758                 if ((p=strrchr_m(str,'/')) != NULL) {
759                         *p = 0;
760                 } else {
761                         *str = 0;
762                 }
763                 str = talloc_asprintf(ctx,
764                                 "%s%s",
765                                 str,
766                                 s1);
767                 if (!str) {
768                         return NULL;
769                 }
770         }
771
772         trim_string(str,NULL,"/..");
773         return talloc_all_string_sub(ctx, str, "/./", "/");
774 }
775
776 char *clean_name(TALLOC_CTX *ctx, const char *s)
777 {
778         char *str = dos_clean_name(ctx, s);
779         if (!str) {
780                 return NULL;
781         }
782         return unix_clean_name(ctx, str);
783 }
784
785 /*******************************************************************
786  Write data into an fd at a given offset. Ignore seek errors.
787 ********************************************************************/
788
789 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
790 {
791         size_t total=0;
792         ssize_t ret;
793
794         if (pos == (SMB_OFF_T)-1) {
795                 return write_data(fd, buffer, N);
796         }
797 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
798         while (total < N) {
799                 ret = sys_pwrite(fd,buffer + total,N - total, pos);
800                 if (ret == -1 && errno == ESPIPE) {
801                         return write_data(fd, buffer + total,N - total);
802                 }
803                 if (ret == -1) {
804                         DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
805                         return -1;
806                 }
807                 if (ret == 0) {
808                         return total;
809                 }
810                 total += ret;
811                 pos += ret;
812         }
813         return (ssize_t)total;
814 #else
815         /* Use lseek and write_data. */
816         if (sys_lseek(fd, pos, SEEK_SET) == -1) {
817                 if (errno != ESPIPE) {
818                         return -1;
819                 }
820         }
821         return write_data(fd, buffer, N);
822 #endif
823 }
824
825 /*******************************************************************
826  Sleep for a specified number of milliseconds.
827 ********************************************************************/
828
829 void smb_msleep(unsigned int t)
830 {
831 #if defined(HAVE_NANOSLEEP)
832         struct timespec tval;
833         int ret;
834
835         tval.tv_sec = t/1000;
836         tval.tv_nsec = 1000000*(t%1000);
837
838         do {
839                 errno = 0;
840                 ret = nanosleep(&tval, &tval);
841         } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
842 #else
843         unsigned int tdiff=0;
844         struct timeval tval,t1,t2;  
845         fd_set fds;
846
847         GetTimeOfDay(&t1);
848         t2 = t1;
849
850         while (tdiff < t) {
851                 tval.tv_sec = (t-tdiff)/1000;
852                 tval.tv_usec = 1000*((t-tdiff)%1000);
853
854                 /* Never wait for more than 1 sec. */
855                 if (tval.tv_sec > 1) {
856                         tval.tv_sec = 1; 
857                         tval.tv_usec = 0;
858                 }
859
860                 FD_ZERO(&fds);
861                 errno = 0;
862                 sys_select_intr(0,&fds,NULL,NULL,&tval);
863
864                 GetTimeOfDay(&t2);
865                 if (t2.tv_sec < t1.tv_sec) {
866                         /* Someone adjusted time... */
867                         t1 = t2;
868                 }
869
870                 tdiff = TvalDiff(&t1,&t2);
871         }
872 #endif
873 }
874
875 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
876                            struct event_context *ev_ctx,
877                            struct server_id id,
878                            bool parent_longlived)
879 {
880         NTSTATUS status = NT_STATUS_OK;
881
882         /* Reset the state of the random
883          * number generation system, so
884          * children do not get the same random
885          * numbers as each other */
886         set_need_random_reseed();
887
888         /* tdb needs special fork handling */
889         if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
890                 DEBUG(0,("tdb_reopen_all failed.\n"));
891                 status = NT_STATUS_OPEN_FAILED;
892                 goto done;
893         }
894
895         if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
896                 smb_panic(__location__ ": Failed to re-initialise event context");
897         }
898
899         if (msg_ctx) {
900                 /*
901                  * For clustering, we need to re-init our ctdbd connection after the
902                  * fork
903                  */
904                 status = messaging_reinit(msg_ctx, id);
905                 if (!NT_STATUS_IS_OK(status)) {
906                         DEBUG(0,("messaging_reinit() failed: %s\n",
907                                  nt_errstr(status)));
908                 }
909         }
910  done:
911         return status;
912 }
913
914 #if defined(PARANOID_MALLOC_CHECKER)
915
916 /****************************************************************************
917  Internal malloc wrapper. Externally visible.
918 ****************************************************************************/
919
920 void *malloc_(size_t size)
921 {
922         if (size == 0) {
923                 return NULL;
924         }
925 #undef malloc
926         return malloc(size);
927 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
928 }
929
930 /****************************************************************************
931  Internal calloc wrapper. Not externally visible.
932 ****************************************************************************/
933
934 static void *calloc_(size_t count, size_t size)
935 {
936         if (size == 0 || count == 0) {
937                 return NULL;
938         }
939 #undef calloc
940         return calloc(count, size);
941 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
942 }
943
944 /****************************************************************************
945  Internal realloc wrapper. Not externally visible.
946 ****************************************************************************/
947
948 static void *realloc_(void *ptr, size_t size)
949 {
950 #undef realloc
951         return realloc(ptr, size);
952 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
953 }
954
955 #endif /* PARANOID_MALLOC_CHECKER */
956
957 /****************************************************************************
958  Type-safe memalign
959 ****************************************************************************/
960
961 void *memalign_array(size_t el_size, size_t align, unsigned int count)
962 {
963         if (count >= MAX_ALLOC_SIZE/el_size) {
964                 return NULL;
965         }
966
967         return sys_memalign(align, el_size*count);
968 }
969
970 /****************************************************************************
971  Type-safe calloc.
972 ****************************************************************************/
973
974 void *calloc_array(size_t size, size_t nmemb)
975 {
976         if (nmemb >= MAX_ALLOC_SIZE/size) {
977                 return NULL;
978         }
979         if (size == 0 || nmemb == 0) {
980                 return NULL;
981         }
982 #if defined(PARANOID_MALLOC_CHECKER)
983         return calloc_(nmemb, size);
984 #else
985         return calloc(nmemb, size);
986 #endif
987 }
988
989 /****************************************************************************
990  Expand a pointer to be a particular size.
991  Note that this version of Realloc has an extra parameter that decides
992  whether to free the passed in storage on allocation failure or if the
993  new size is zero.
994
995  This is designed for use in the typical idiom of :
996
997  p = SMB_REALLOC(p, size)
998  if (!p) {
999     return error;
1000  }
1001
1002  and not to have to keep track of the old 'p' contents to free later, nor
1003  to worry if the size parameter was zero. In the case where NULL is returned
1004  we guarentee that p has been freed.
1005
1006  If free later semantics are desired, then pass 'free_old_on_error' as False which
1007  guarentees that the old contents are not freed on error, even if size == 0. To use
1008  this idiom use :
1009
1010  tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1011  if (!tmp) {
1012     SAFE_FREE(p);
1013     return error;
1014  } else {
1015     p = tmp;
1016  }
1017
1018  Changes were instigated by Coverity error checking. JRA.
1019 ****************************************************************************/
1020
1021 void *Realloc(void *p, size_t size, bool free_old_on_error)
1022 {
1023         void *ret=NULL;
1024
1025         if (size == 0) {
1026                 if (free_old_on_error) {
1027                         SAFE_FREE(p);
1028                 }
1029                 DEBUG(2,("Realloc asked for 0 bytes\n"));
1030                 return NULL;
1031         }
1032
1033 #if defined(PARANOID_MALLOC_CHECKER)
1034         if (!p) {
1035                 ret = (void *)malloc_(size);
1036         } else {
1037                 ret = (void *)realloc_(p,size);
1038         }
1039 #else
1040         if (!p) {
1041                 ret = (void *)malloc(size);
1042         } else {
1043                 ret = (void *)realloc(p,size);
1044         }
1045 #endif
1046
1047         if (!ret) {
1048                 if (free_old_on_error && p) {
1049                         SAFE_FREE(p);
1050                 }
1051                 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1052         }
1053
1054         return(ret);
1055 }
1056
1057 /****************************************************************************
1058  (Hopefully) efficient array append.
1059 ****************************************************************************/
1060
1061 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1062                         void *element, void *_array, uint32 *num_elements,
1063                         ssize_t *array_size)
1064 {
1065         void **array = (void **)_array;
1066
1067         if (*array_size < 0) {
1068                 return;
1069         }
1070
1071         if (*array == NULL) {
1072                 if (*array_size == 0) {
1073                         *array_size = 128;
1074                 }
1075
1076                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1077                         goto error;
1078                 }
1079
1080                 *array = TALLOC(mem_ctx, element_size * (*array_size));
1081                 if (*array == NULL) {
1082                         goto error;
1083                 }
1084         }
1085
1086         if (*num_elements == *array_size) {
1087                 *array_size *= 2;
1088
1089                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1090                         goto error;
1091                 }
1092
1093                 *array = TALLOC_REALLOC(mem_ctx, *array,
1094                                         element_size * (*array_size));
1095
1096                 if (*array == NULL) {
1097                         goto error;
1098                 }
1099         }
1100
1101         memcpy((char *)(*array) + element_size*(*num_elements),
1102                element, element_size);
1103         *num_elements += 1;
1104
1105         return;
1106
1107  error:
1108         *num_elements = 0;
1109         *array_size = -1;
1110 }
1111
1112 /****************************************************************************
1113  Get my own domain name, or "" if we have none.
1114 ****************************************************************************/
1115
1116 char *get_mydnsdomname(TALLOC_CTX *ctx)
1117 {
1118         const char *domname;
1119         char *p;
1120
1121         domname = get_mydnsfullname();
1122         if (!domname) {
1123                 return NULL;
1124         }
1125
1126         p = strchr_m(domname, '.');
1127         if (p) {
1128                 p++;
1129                 return talloc_strdup(ctx, p);
1130         } else {
1131                 return talloc_strdup(ctx, "");
1132         }
1133 }
1134
1135 /****************************************************************************
1136  Interpret a protocol description string, with a default.
1137 ****************************************************************************/
1138
1139 int interpret_protocol(const char *str,int def)
1140 {
1141         if (strequal(str,"NT1"))
1142                 return(PROTOCOL_NT1);
1143         if (strequal(str,"LANMAN2"))
1144                 return(PROTOCOL_LANMAN2);
1145         if (strequal(str,"LANMAN1"))
1146                 return(PROTOCOL_LANMAN1);
1147         if (strequal(str,"CORE"))
1148                 return(PROTOCOL_CORE);
1149         if (strequal(str,"COREPLUS"))
1150                 return(PROTOCOL_COREPLUS);
1151         if (strequal(str,"CORE+"))
1152                 return(PROTOCOL_COREPLUS);
1153
1154         DEBUG(0,("Unrecognised protocol level %s\n",str));
1155
1156         return(def);
1157 }
1158
1159
1160 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1161 /******************************************************************
1162  Remove any mount options such as -rsize=2048,wsize=2048 etc.
1163  Based on a fix from <Thomas.Hepper@icem.de>.
1164  Returns a malloc'ed string.
1165 *******************************************************************/
1166
1167 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1168 {
1169         if (*str == '-') {
1170                 const char *p = str;
1171                 while(*p && !isspace(*p))
1172                         p++;
1173                 while(*p && isspace(*p))
1174                         p++;
1175                 if(*p) {
1176                         return talloc_strdup(ctx, p);
1177                 }
1178         }
1179         return NULL;
1180 }
1181
1182 /*******************************************************************
1183  Patch from jkf@soton.ac.uk
1184  Split Luke's automount_server into YP lookup and string splitter
1185  so can easily implement automount_path().
1186  Returns a malloc'ed string.
1187 *******************************************************************/
1188
1189 #ifdef WITH_NISPLUS_HOME
1190 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1191 {
1192         char *value = NULL;
1193
1194         char *nis_map = (char *)lp_nis_home_map_name();
1195
1196         char buffer[NIS_MAXATTRVAL + 1];
1197         nis_result *result;
1198         nis_object *object;
1199         entry_obj  *entry;
1200
1201         snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1202         DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1203
1204         if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1205                 if (result->status != NIS_SUCCESS) {
1206                         DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1207                 } else {
1208                         object = result->objects.objects_val;
1209                         if (object->zo_data.zo_type == ENTRY_OBJ) {
1210                                 entry = &object->zo_data.objdata_u.en_data;
1211                                 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1212                                 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1213
1214                                 value = talloc_strdup(ctx,
1215                                                 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1216                                 if (!value) {
1217                                         nis_freeresult(result);
1218                                         return NULL;
1219                                 }
1220                                 value = talloc_string_sub(ctx,
1221                                                 value,
1222                                                 "&",
1223                                                 user_name);
1224                         }
1225                 }
1226         }
1227         nis_freeresult(result);
1228
1229         if (value) {
1230                 value = strip_mount_options(ctx, value);
1231                 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1232                                         user_name, value));
1233         }
1234         return value;
1235 }
1236 #else /* WITH_NISPLUS_HOME */
1237
1238 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1239 {
1240         char *value = NULL;
1241
1242         int nis_error;        /* returned by yp all functions */
1243         char *nis_result;     /* yp_match inits this */
1244         int nis_result_len;  /* and set this */
1245         char *nis_domain;     /* yp_get_default_domain inits this */
1246         char *nis_map = (char *)lp_nis_home_map_name();
1247
1248         if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1249                 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1250                 return NULL;
1251         }
1252
1253         DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1254
1255         if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1256                                         strlen(user_name), &nis_result,
1257                                         &nis_result_len)) == 0) {
1258                 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
1259                         nis_result[nis_result_len] = '\0';
1260                 }
1261                 value = talloc_strdup(ctx, nis_result);
1262                 if (!value) {
1263                         return NULL;
1264                 }
1265                 value = strip_mount_options(ctx, value);
1266         } else if(nis_error == YPERR_KEY) {
1267                 DEBUG(3, ("YP Key not found:  while looking up \"%s\" in map \"%s\"\n", 
1268                                 user_name, nis_map));
1269                 DEBUG(3, ("using defaults for server and home directory\n"));
1270         } else {
1271                 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n", 
1272                                 yperr_string(nis_error), user_name, nis_map));
1273         }
1274
1275         if (value) {
1276                 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1277         }
1278         return value;
1279 }
1280 #endif /* WITH_NISPLUS_HOME */
1281 #endif
1282
1283 /****************************************************************************
1284  Check if a process exists. Does this work on all unixes?
1285 ****************************************************************************/
1286
1287 bool process_exists(const struct server_id pid)
1288 {
1289         if (procid_is_me(&pid)) {
1290                 return True;
1291         }
1292
1293         if (procid_is_local(&pid)) {
1294                 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1295         }
1296
1297 #ifdef CLUSTER_SUPPORT
1298         return ctdbd_process_exists(messaging_ctdbd_connection(procid_self()),
1299                                     pid.vnn, pid.pid);
1300 #else
1301         return False;
1302 #endif
1303 }
1304
1305 /*******************************************************************
1306  Convert a uid into a user name.
1307 ********************************************************************/
1308
1309 const char *uidtoname(uid_t uid)
1310 {
1311         TALLOC_CTX *ctx = talloc_tos();
1312         char *name = NULL;
1313         struct passwd *pass = NULL;
1314
1315         pass = getpwuid_alloc(ctx,uid);
1316         if (pass) {
1317                 name = talloc_strdup(ctx,pass->pw_name);
1318                 TALLOC_FREE(pass);
1319         } else {
1320                 name = talloc_asprintf(ctx,
1321                                 "%ld",
1322                                 (long int)uid);
1323         }
1324         return name;
1325 }
1326
1327 /*******************************************************************
1328  Convert a gid into a group name.
1329 ********************************************************************/
1330
1331 char *gidtoname(gid_t gid)
1332 {
1333         struct group *grp;
1334
1335         grp = getgrgid(gid);
1336         if (grp) {
1337                 return talloc_strdup(talloc_tos(), grp->gr_name);
1338         }
1339         else {
1340                 return talloc_asprintf(talloc_tos(),
1341                                         "%d",
1342                                         (int)gid);
1343         }
1344 }
1345
1346 /*******************************************************************
1347  Convert a user name into a uid.
1348 ********************************************************************/
1349
1350 uid_t nametouid(const char *name)
1351 {
1352         struct passwd *pass;
1353         char *p;
1354         uid_t u;
1355
1356         pass = getpwnam_alloc(talloc_autofree_context(), name);
1357         if (pass) {
1358                 u = pass->pw_uid;
1359                 TALLOC_FREE(pass);
1360                 return u;
1361         }
1362
1363         u = (uid_t)strtol(name, &p, 0);
1364         if ((p != name) && (*p == '\0'))
1365                 return u;
1366
1367         return (uid_t)-1;
1368 }
1369
1370 /*******************************************************************
1371  Convert a name to a gid_t if possible. Return -1 if not a group. 
1372 ********************************************************************/
1373
1374 gid_t nametogid(const char *name)
1375 {
1376         struct group *grp;
1377         char *p;
1378         gid_t g;
1379
1380         g = (gid_t)strtol(name, &p, 0);
1381         if ((p != name) && (*p == '\0'))
1382                 return g;
1383
1384         grp = sys_getgrnam(name);
1385         if (grp)
1386                 return(grp->gr_gid);
1387         return (gid_t)-1;
1388 }
1389
1390 /*******************************************************************
1391  Something really nasty happened - panic !
1392 ********************************************************************/
1393
1394 void smb_panic(const char *const why)
1395 {
1396         char *cmd;
1397         int result;
1398
1399 #ifdef DEVELOPER
1400         {
1401
1402                 if (global_clobber_region_function) {
1403                         DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1404                                          global_clobber_region_function,
1405                                          global_clobber_region_line));
1406                 } 
1407         }
1408 #endif
1409
1410         DEBUG(0,("PANIC (pid %llu): %s\n",
1411                     (unsigned long long)sys_getpid(), why));
1412         log_stack_trace();
1413
1414         cmd = lp_panic_action();
1415         if (cmd && *cmd) {
1416                 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1417                 result = system(cmd);
1418
1419                 if (result == -1)
1420                         DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1421                                           strerror(errno)));
1422                 else
1423                         DEBUG(0, ("smb_panic(): action returned status %d\n",
1424                                           WEXITSTATUS(result)));
1425         }
1426
1427         dump_core();
1428 }
1429
1430 /*******************************************************************
1431  Print a backtrace of the stack to the debug log. This function
1432  DELIBERATELY LEAKS MEMORY. The expectation is that you should
1433  exit shortly after calling it.
1434 ********************************************************************/
1435
1436 #ifdef HAVE_LIBUNWIND_H
1437 #include <libunwind.h>
1438 #endif
1439
1440 #ifdef HAVE_EXECINFO_H
1441 #include <execinfo.h>
1442 #endif
1443
1444 #ifdef HAVE_LIBEXC_H
1445 #include <libexc.h>
1446 #endif
1447
1448 void log_stack_trace(void)
1449 {
1450 #ifdef HAVE_LIBUNWIND
1451         /* Try to use libunwind before any other technique since on ia64
1452          * libunwind correctly walks the stack in more circumstances than
1453          * backtrace.
1454          */ 
1455         unw_cursor_t cursor;
1456         unw_context_t uc;
1457         unsigned i = 0;
1458
1459         char procname[256];
1460         unw_word_t ip, sp, off;
1461
1462         procname[sizeof(procname) - 1] = '\0';
1463
1464         if (unw_getcontext(&uc) != 0) {
1465                 goto libunwind_failed;
1466         }
1467
1468         if (unw_init_local(&cursor, &uc) != 0) {
1469                 goto libunwind_failed;
1470         }
1471
1472         DEBUG(0, ("BACKTRACE:\n"));
1473
1474         do {
1475             ip = sp = 0;
1476             unw_get_reg(&cursor, UNW_REG_IP, &ip);
1477             unw_get_reg(&cursor, UNW_REG_SP, &sp);
1478
1479             switch (unw_get_proc_name(&cursor,
1480                         procname, sizeof(procname) - 1, &off) ) {
1481             case 0:
1482                     /* Name found. */
1483             case -UNW_ENOMEM:
1484                     /* Name truncated. */
1485                     DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1486                             i, procname, (long long)off,
1487                             (long long)ip, (long long) sp));
1488                     break;
1489             default:
1490             /* case -UNW_ENOINFO: */
1491             /* case -UNW_EUNSPEC: */
1492                     /* No symbol name found. */
1493                     DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1494                             i, "<unknown symbol>",
1495                             (long long)ip, (long long) sp));
1496             }
1497             ++i;
1498         } while (unw_step(&cursor) > 0);
1499
1500         return;
1501
1502 libunwind_failed:
1503         DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1504
1505 #elif HAVE_BACKTRACE_SYMBOLS
1506         void *backtrace_stack[BACKTRACE_STACK_SIZE];
1507         size_t backtrace_size;
1508         char **backtrace_strings;
1509
1510         /* get the backtrace (stack frames) */
1511         backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1512         backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1513
1514         DEBUG(0, ("BACKTRACE: %lu stack frames:\n", 
1515                   (unsigned long)backtrace_size));
1516
1517         if (backtrace_strings) {
1518                 int i;
1519
1520                 for (i = 0; i < backtrace_size; i++)
1521                         DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1522
1523                 /* Leak the backtrace_strings, rather than risk what free() might do */
1524         }
1525
1526 #elif HAVE_LIBEXC
1527
1528         /* The IRIX libexc library provides an API for unwinding the stack. See
1529          * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1530          * since we are about to abort anyway, it hardly matters.
1531          */
1532
1533 #define NAMESIZE 32 /* Arbitrary */
1534
1535         __uint64_t      addrs[BACKTRACE_STACK_SIZE];
1536         char *          names[BACKTRACE_STACK_SIZE];
1537         char            namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1538
1539         int             i;
1540         int             levels;
1541
1542         ZERO_ARRAY(addrs);
1543         ZERO_ARRAY(names);
1544         ZERO_ARRAY(namebuf);
1545
1546         /* We need to be root so we can open our /proc entry to walk
1547          * our stack. It also helps when we want to dump core.
1548          */
1549         become_root();
1550
1551         for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1552                 names[i] = namebuf + (i * NAMESIZE);
1553         }
1554
1555         levels = trace_back_stack(0, addrs, names,
1556                         BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1557
1558         DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1559         for (i = 0; i < levels; i++) {
1560                 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1561         }
1562 #undef NAMESIZE
1563
1564 #else
1565         DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1566 #endif
1567 }
1568
1569 /*******************************************************************
1570   A readdir wrapper which just returns the file name.
1571  ********************************************************************/
1572
1573 const char *readdirname(SMB_STRUCT_DIR *p)
1574 {
1575         SMB_STRUCT_DIRENT *ptr;
1576         char *dname;
1577
1578         if (!p)
1579                 return(NULL);
1580
1581         ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1582         if (!ptr)
1583                 return(NULL);
1584
1585         dname = ptr->d_name;
1586
1587 #ifdef NEXT2
1588         if (telldir(p) < 0)
1589                 return(NULL);
1590 #endif
1591
1592 #ifdef HAVE_BROKEN_READDIR_NAME
1593         /* using /usr/ucb/cc is BAD */
1594         dname = dname - 2;
1595 #endif
1596
1597         return talloc_strdup(talloc_tos(), dname);
1598 }
1599
1600 /*******************************************************************
1601  Utility function used to decide if the last component 
1602  of a path matches a (possibly wildcarded) entry in a namelist.
1603 ********************************************************************/
1604
1605 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1606 {
1607         const char *last_component;
1608
1609         /* if we have no list it's obviously not in the path */
1610         if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1611                 return False;
1612         }
1613
1614         DEBUG(8, ("is_in_path: %s\n", name));
1615
1616         /* Get the last component of the unix name. */
1617         last_component = strrchr_m(name, '/');
1618         if (!last_component) {
1619                 last_component = name;
1620         } else {
1621                 last_component++; /* Go past '/' */
1622         }
1623
1624         for(; namelist->name != NULL; namelist++) {
1625                 if(namelist->is_wild) {
1626                         if (mask_match(last_component, namelist->name, case_sensitive)) {
1627                                 DEBUG(8,("is_in_path: mask match succeeded\n"));
1628                                 return True;
1629                         }
1630                 } else {
1631                         if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1632                                                 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1633                                 DEBUG(8,("is_in_path: match succeeded\n"));
1634                                 return True;
1635                         }
1636                 }
1637         }
1638         DEBUG(8,("is_in_path: match not found\n"));
1639         return False;
1640 }
1641
1642 /*******************************************************************
1643  Strip a '/' separated list into an array of 
1644  name_compare_enties structures suitable for 
1645  passing to is_in_path(). We do this for
1646  speed so we can pre-parse all the names in the list 
1647  and don't do it for each call to is_in_path().
1648  namelist is modified here and is assumed to be 
1649  a copy owned by the caller.
1650  We also check if the entry contains a wildcard to
1651  remove a potentially expensive call to mask_match
1652  if possible.
1653 ********************************************************************/
1654
1655 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1656 {
1657         char *name_end;
1658         char *nameptr = (char *)namelist;
1659         int num_entries = 0;
1660         int i;
1661
1662         (*ppname_array) = NULL;
1663
1664         if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0'))) 
1665                 return;
1666
1667         /* We need to make two passes over the string. The
1668                 first to count the number of elements, the second
1669                 to split it.
1670         */
1671
1672         while(*nameptr) {
1673                 if ( *nameptr == '/' ) {
1674                         /* cope with multiple (useless) /s) */
1675                         nameptr++;
1676                         continue;
1677                 }
1678                 /* anything left? */
1679                 if ( *nameptr == '\0' )
1680                         break;
1681
1682                 /* find the next '/' or consume remaining */
1683                 name_end = strchr_m(nameptr, '/');
1684                 if (name_end == NULL)
1685                         name_end = (char *)nameptr + strlen(nameptr);
1686
1687                 /* next segment please */
1688                 nameptr = name_end + 1;
1689                 num_entries++;
1690         }
1691
1692         if(num_entries == 0)
1693                 return;
1694
1695         if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1696                 DEBUG(0,("set_namearray: malloc fail\n"));
1697                 return;
1698         }
1699
1700         /* Now copy out the names */
1701         nameptr = (char *)namelist;
1702         i = 0;
1703         while(*nameptr) {
1704                 if ( *nameptr == '/' ) {
1705                         /* cope with multiple (useless) /s) */
1706                         nameptr++;
1707                         continue;
1708                 }
1709                 /* anything left? */
1710                 if ( *nameptr == '\0' )
1711                         break;
1712
1713                 /* find the next '/' or consume remaining */
1714                 name_end = strchr_m(nameptr, '/');
1715                 if (name_end)
1716                         *name_end = '\0';
1717                 else
1718                         name_end = nameptr + strlen(nameptr);
1719
1720                 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1721                 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1722                         DEBUG(0,("set_namearray: malloc fail (1)\n"));
1723                         return;
1724                 }
1725
1726                 /* next segment please */
1727                 nameptr = name_end + 1;
1728                 i++;
1729         }
1730
1731         (*ppname_array)[i].name = NULL;
1732
1733         return;
1734 }
1735
1736 /****************************************************************************
1737  Routine to free a namearray.
1738 ****************************************************************************/
1739
1740 void free_namearray(name_compare_entry *name_array)
1741 {
1742         int i;
1743
1744         if(name_array == NULL)
1745                 return;
1746
1747         for(i=0; name_array[i].name!=NULL; i++)
1748                 SAFE_FREE(name_array[i].name);
1749         SAFE_FREE(name_array);
1750 }
1751
1752 #undef DBGC_CLASS
1753 #define DBGC_CLASS DBGC_LOCKING
1754
1755 /****************************************************************************
1756  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1757  is dealt with in posix.c
1758  Returns True if we have information regarding this lock region (and returns
1759  F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1760 ****************************************************************************/
1761
1762 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1763 {
1764         SMB_STRUCT_FLOCK lock;
1765         int ret;
1766
1767         DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1768                     fd,(double)*poffset,(double)*pcount,*ptype));
1769
1770         lock.l_type = *ptype;
1771         lock.l_whence = SEEK_SET;
1772         lock.l_start = *poffset;
1773         lock.l_len = *pcount;
1774         lock.l_pid = 0;
1775
1776         ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1777
1778         if (ret == -1) {
1779                 int sav = errno;
1780                 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1781                         (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1782                 errno = sav;
1783                 return False;
1784         }
1785
1786         *ptype = lock.l_type;
1787         *poffset = lock.l_start;
1788         *pcount = lock.l_len;
1789         *ppid = lock.l_pid;
1790
1791         DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1792                         fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1793         return True;
1794 }
1795
1796 #undef DBGC_CLASS
1797 #define DBGC_CLASS DBGC_ALL
1798
1799 /*******************************************************************
1800  Is the name specified one of my netbios names.
1801  Returns true if it is equal, false otherwise.
1802 ********************************************************************/
1803
1804 bool is_myname(const char *s)
1805 {
1806         int n;
1807         bool ret = False;
1808
1809         for (n=0; my_netbios_names(n); n++) {
1810                 if (strequal(my_netbios_names(n), s)) {
1811                         ret=True;
1812                         break;
1813                 }
1814         }
1815         DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1816         return(ret);
1817 }
1818
1819 /*******************************************************************
1820  Is the name specified our workgroup/domain.
1821  Returns true if it is equal, false otherwise.
1822 ********************************************************************/
1823
1824 bool is_myworkgroup(const char *s)
1825 {
1826         bool ret = False;
1827
1828         if (strequal(s, lp_workgroup())) {
1829                 ret=True;
1830         }
1831
1832         DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1833         return(ret);
1834 }
1835
1836 /*******************************************************************
1837  we distinguish between 2K and XP by the "Native Lan Manager" string
1838    WinXP => "Windows 2002 5.1"
1839    WinXP 64bit => "Windows XP 5.2"
1840    Win2k => "Windows 2000 5.0"
1841    NT4   => "Windows NT 4.0"
1842    Win9x => "Windows 4.0"
1843  Windows 2003 doesn't set the native lan manager string but
1844  they do set the domain to "Windows 2003 5.2" (probably a bug).
1845 ********************************************************************/
1846
1847 void ra_lanman_string( const char *native_lanman )
1848 {
1849         if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1850                 set_remote_arch( RA_WINXP );
1851         else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1852                 set_remote_arch( RA_WINXP64 );
1853         else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1854                 set_remote_arch( RA_WIN2K3 );
1855 }
1856
1857 static const char *remote_arch_str;
1858
1859 const char *get_remote_arch_str(void)
1860 {
1861         if (!remote_arch_str) {
1862                 return "UNKNOWN";
1863         }
1864         return remote_arch_str;
1865 }
1866
1867 /*******************************************************************
1868  Set the horrid remote_arch string based on an enum.
1869 ********************************************************************/
1870
1871 void set_remote_arch(enum remote_arch_types type)
1872 {
1873         ra_type = type;
1874         switch( type ) {
1875         case RA_WFWG:
1876                 remote_arch_str = "WfWg";
1877                 break;
1878         case RA_OS2:
1879                 remote_arch_str = "OS2";
1880                 break;
1881         case RA_WIN95:
1882                 remote_arch_str = "Win95";
1883                 break;
1884         case RA_WINNT:
1885                 remote_arch_str = "WinNT";
1886                 break;
1887         case RA_WIN2K:
1888                 remote_arch_str = "Win2K";
1889                 break;
1890         case RA_WINXP:
1891                 remote_arch_str = "WinXP";
1892                 break;
1893         case RA_WINXP64:
1894                 remote_arch_str = "WinXP64";
1895                 break;
1896         case RA_WIN2K3:
1897                 remote_arch_str = "Win2K3";
1898                 break;
1899         case RA_VISTA:
1900                 remote_arch_str = "Vista";
1901                 break;
1902         case RA_SAMBA:
1903                 remote_arch_str = "Samba";
1904                 break;
1905         case RA_CIFSFS:
1906                 remote_arch_str = "CIFSFS";
1907                 break;
1908         default:
1909                 ra_type = RA_UNKNOWN;
1910                 remote_arch_str = "UNKNOWN";
1911                 break;
1912         }
1913
1914         DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1915                                 remote_arch_str));
1916 }
1917
1918 /*******************************************************************
1919  Get the remote_arch type.
1920 ********************************************************************/
1921
1922 enum remote_arch_types get_remote_arch(void)
1923 {
1924         return ra_type;
1925 }
1926
1927 const char *tab_depth(int level, int depth)
1928 {
1929         if( CHECK_DEBUGLVL(level) ) {
1930                 dbgtext("%*s", depth*4, "");
1931         }
1932         return "";
1933 }
1934
1935 /*****************************************************************************
1936  Provide a checksum on a string
1937
1938  Input:  s - the null-terminated character string for which the checksum
1939              will be calculated.
1940
1941   Output: The checksum value calculated for s.
1942 *****************************************************************************/
1943
1944 int str_checksum(const char *s)
1945 {
1946         int res = 0;
1947         int c;
1948         int i=0;
1949
1950         while(*s) {
1951                 c = *s;
1952                 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
1953                 s++;
1954                 i++;
1955         }
1956         return(res);
1957 }
1958
1959 /*****************************************************************
1960  Zero a memory area then free it. Used to catch bugs faster.
1961 *****************************************************************/  
1962
1963 void zero_free(void *p, size_t size)
1964 {
1965         memset(p, 0, size);
1966         SAFE_FREE(p);
1967 }
1968
1969 /*****************************************************************
1970  Set our open file limit to a requested max and return the limit.
1971 *****************************************************************/  
1972
1973 int set_maxfiles(int requested_max)
1974 {
1975 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1976         struct rlimit rlp;
1977         int saved_current_limit;
1978
1979         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1980                 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1981                         strerror(errno) ));
1982                 /* just guess... */
1983                 return requested_max;
1984         }
1985
1986         /* 
1987          * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1988          * account for the extra fd we need 
1989          * as well as the log files and standard
1990          * handles etc. Save the limit we want to set in case
1991          * we are running on an OS that doesn't support this limit (AIX)
1992          * which always returns RLIM_INFINITY for rlp.rlim_max.
1993          */
1994
1995         /* Try raising the hard (max) limit to the requested amount. */
1996
1997 #if defined(RLIM_INFINITY)
1998         if (rlp.rlim_max != RLIM_INFINITY) {
1999                 int orig_max = rlp.rlim_max;
2000
2001                 if ( rlp.rlim_max < requested_max )
2002                         rlp.rlim_max = requested_max;
2003
2004                 /* This failing is not an error - many systems (Linux) don't
2005                         support our default request of 10,000 open files. JRA. */
2006
2007                 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2008                         DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n", 
2009                                 (int)rlp.rlim_max, strerror(errno) ));
2010
2011                         /* Set failed - restore original value from get. */
2012                         rlp.rlim_max = orig_max;
2013                 }
2014         }
2015 #endif
2016
2017         /* Now try setting the soft (current) limit. */
2018
2019         saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2020
2021         if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2022                 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n", 
2023                         (int)rlp.rlim_cur, strerror(errno) ));
2024                 /* just guess... */
2025                 return saved_current_limit;
2026         }
2027
2028         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2029                 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2030                         strerror(errno) ));
2031                 /* just guess... */
2032                 return saved_current_limit;
2033     }
2034
2035 #if defined(RLIM_INFINITY)
2036         if(rlp.rlim_cur == RLIM_INFINITY)
2037                 return saved_current_limit;
2038 #endif
2039
2040         if((int)rlp.rlim_cur > saved_current_limit)
2041                 return saved_current_limit;
2042
2043         return rlp.rlim_cur;
2044 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2045         /*
2046          * No way to know - just guess...
2047          */
2048         return requested_max;
2049 #endif
2050 }
2051
2052 /*****************************************************************
2053  malloc that aborts with smb_panic on fail or zero size.
2054  *****************************************************************/  
2055
2056 void *smb_xmalloc_array(size_t size, unsigned int count)
2057 {
2058         void *p;
2059         if (size == 0) {
2060                 smb_panic("smb_xmalloc_array: called with zero size");
2061         }
2062         if (count >= MAX_ALLOC_SIZE/size) {
2063                 smb_panic("smb_xmalloc_array: alloc size too large");
2064         }
2065         if ((p = SMB_MALLOC(size*count)) == NULL) {
2066                 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2067                         (unsigned long)size, (unsigned long)count));
2068                 smb_panic("smb_xmalloc_array: malloc failed");
2069         }
2070         return p;
2071 }
2072
2073 /*
2074   vasprintf that aborts on malloc fail
2075 */
2076
2077  int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2078 {
2079         int n;
2080         va_list ap2;
2081
2082         va_copy(ap2, ap);
2083
2084         n = vasprintf(ptr, format, ap2);
2085         va_end(ap2);
2086         if (n == -1 || ! *ptr) {
2087                 smb_panic("smb_xvasprintf: out of memory");
2088         }
2089         return n;
2090 }
2091
2092 /*****************************************************************
2093  Get local hostname and cache result.
2094 *****************************************************************/
2095
2096 char *myhostname(void)
2097 {
2098         static char *ret;
2099         if (ret == NULL) {
2100                 /* This is cached forever so
2101                  * use talloc_autofree_context() ctx. */
2102                 ret = get_myname(talloc_autofree_context());
2103         }
2104         return ret;
2105 }
2106
2107 /**
2108  * @brief Returns an absolute path to a file concatenating the provided
2109  * @a rootpath and @a basename
2110  *
2111  * @param name Filename, relative to @a rootpath
2112  *
2113  * @retval Pointer to a string containing the full path.
2114  **/
2115
2116 static char *xx_path(const char *name, const char *rootpath)
2117 {
2118         char *fname = NULL;
2119
2120         fname = talloc_strdup(talloc_tos(), rootpath);
2121         if (!fname) {
2122                 return NULL;
2123         }
2124         trim_string(fname,"","/");
2125
2126         if (!directory_exist(fname)) {
2127                 if (!mkdir(fname,0755))
2128                         DEBUG(1, ("Unable to create directory %s for file %s. "
2129                               "Error was %s\n", fname, name, strerror(errno)));
2130         }
2131
2132         return talloc_asprintf(talloc_tos(),
2133                                 "%s/%s",
2134                                 fname,
2135                                 name);
2136 }
2137
2138 /**
2139  * @brief Returns an absolute path to a file in the Samba lock directory.
2140  *
2141  * @param name File to find, relative to LOCKDIR.
2142  *
2143  * @retval Pointer to a talloc'ed string containing the full path.
2144  **/
2145
2146 char *lock_path(const char *name)
2147 {
2148         return xx_path(name, lp_lockdir());
2149 }
2150
2151 /**
2152  * @brief Returns an absolute path to a file in the Samba pid directory.
2153  *
2154  * @param name File to find, relative to PIDDIR.
2155  *
2156  * @retval Pointer to a talloc'ed string containing the full path.
2157  **/
2158
2159 char *pid_path(const char *name)
2160 {
2161         return xx_path(name, lp_piddir());
2162 }
2163
2164 /**
2165  * @brief Returns an absolute path to a file in the Samba lib directory.
2166  *
2167  * @param name File to find, relative to LIBDIR.
2168  *
2169  * @retval Pointer to a string containing the full path.
2170  **/
2171
2172 char *lib_path(const char *name)
2173 {
2174         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2175 }
2176
2177 /**
2178  * @brief Returns an absolute path to a file in the Samba modules directory.
2179  *
2180  * @param name File to find, relative to MODULESDIR.
2181  *
2182  * @retval Pointer to a string containing the full path.
2183  **/
2184
2185 char *modules_path(const char *name)
2186 {
2187         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2188 }
2189
2190 /**
2191  * @brief Returns an absolute path to a file in the Samba data directory.
2192  *
2193  * @param name File to find, relative to CODEPAGEDIR.
2194  *
2195  * @retval Pointer to a talloc'ed string containing the full path.
2196  **/
2197
2198 char *data_path(const char *name)
2199 {
2200         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2201 }
2202
2203 /**
2204  * @brief Returns an absolute path to a file in the Samba state directory.
2205  *
2206  * @param name File to find, relative to STATEDIR.
2207  *
2208  * @retval Pointer to a talloc'ed string containing the full path.
2209  **/
2210
2211 char *state_path(const char *name)
2212 {
2213         return xx_path(name, lp_statedir());
2214 }
2215
2216 /**
2217  * @brief Returns an absolute path to a file in the Samba cache directory.
2218  *
2219  * @param name File to find, relative to CACHEDIR.
2220  *
2221  * @retval Pointer to a talloc'ed string containing the full path.
2222  **/
2223
2224 char *cache_path(const char *name)
2225 {
2226         return xx_path(name, lp_cachedir());
2227 }
2228
2229 /**
2230  * @brief Returns the platform specific shared library extension.
2231  *
2232  * @retval Pointer to a const char * containing the extension.
2233  **/
2234
2235 const char *shlib_ext(void)
2236 {
2237         return get_dyn_SHLIBEXT();
2238 }
2239
2240 /*******************************************************************
2241  Given a filename - get its directory name
2242 ********************************************************************/
2243
2244 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2245                     const char **name)
2246 {
2247         char *p;
2248         ptrdiff_t len;
2249
2250         p = strrchr_m(dir, '/'); /* Find final '/', if any */
2251
2252         if (p == NULL) {
2253                 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2254                         return False;
2255                 }
2256                 if (name) {
2257                         *name = dir;
2258                 }
2259                 return True;
2260         }
2261
2262         len = p-dir;
2263
2264         if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2265                 return False;
2266         }
2267         (*parent)[len] = '\0';
2268
2269         if (name) {
2270                 *name = p+1;
2271         }
2272         return True;
2273 }
2274
2275 /*******************************************************************
2276  Determine if a pattern contains any Microsoft wildcard characters.
2277 *******************************************************************/
2278
2279 bool ms_has_wild(const char *s)
2280 {
2281         char c;
2282
2283         if (lp_posix_pathnames()) {
2284                 /* With posix pathnames no characters are wild. */
2285                 return False;
2286         }
2287
2288         while ((c = *s++)) {
2289                 switch (c) {
2290                 case '*':
2291                 case '?':
2292                 case '<':
2293                 case '>':
2294                 case '"':
2295                         return True;
2296                 }
2297         }
2298         return False;
2299 }
2300
2301 bool ms_has_wild_w(const smb_ucs2_t *s)
2302 {
2303         smb_ucs2_t c;
2304         if (!s) return False;
2305         while ((c = *s++)) {
2306                 switch (c) {
2307                 case UCS2_CHAR('*'):
2308                 case UCS2_CHAR('?'):
2309                 case UCS2_CHAR('<'):
2310                 case UCS2_CHAR('>'):
2311                 case UCS2_CHAR('"'):
2312                         return True;
2313                 }
2314         }
2315         return False;
2316 }
2317
2318 /*******************************************************************
2319  A wrapper that handles case sensitivity and the special handling
2320  of the ".." name.
2321 *******************************************************************/
2322
2323 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2324 {
2325         if (ISDOTDOT(string))
2326                 string = ".";
2327         if (ISDOT(pattern))
2328                 return False;
2329
2330         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2331 }
2332
2333 /*******************************************************************
2334  A wrapper that handles case sensitivity and the special handling
2335  of the ".." name. Varient that is only called by old search code which requires
2336  pattern translation.
2337 *******************************************************************/
2338
2339 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2340 {
2341         if (ISDOTDOT(string))
2342                 string = ".";
2343         if (ISDOT(pattern))
2344                 return False;
2345
2346         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2347 }
2348
2349 /*******************************************************************
2350  A wrapper that handles a list of patters and calls mask_match()
2351  on each.  Returns True if any of the patterns match.
2352 *******************************************************************/
2353
2354 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2355 {
2356        while (listLen-- > 0) {
2357                if (mask_match(string, *list++, is_case_sensitive))
2358                        return True;
2359        }
2360        return False;
2361 }
2362
2363 /*********************************************************
2364  Recursive routine that is called by unix_wild_match.
2365 *********************************************************/
2366
2367 static bool unix_do_match(const char *regexp, const char *str)
2368 {
2369         const char *p;
2370
2371         for( p = regexp; *p && *str; ) {
2372
2373                 switch(*p) {
2374                         case '?':
2375                                 str++;
2376                                 p++;
2377                                 break;
2378
2379                         case '*':
2380
2381                                 /*
2382                                  * Look for a character matching 
2383                                  * the one after the '*'.
2384                                  */
2385                                 p++;
2386                                 if(!*p)
2387                                         return true; /* Automatic match */
2388                                 while(*str) {
2389
2390                                         while(*str && (*p != *str))
2391                                                 str++;
2392
2393                                         /*
2394                                          * Patch from weidel@multichart.de. In the case of the regexp
2395                                          * '*XX*' we want to ensure there are at least 2 'X' characters
2396                                          * in the string after the '*' for a match to be made.
2397                                          */
2398
2399                                         {
2400                                                 int matchcount=0;
2401
2402                                                 /*
2403                                                  * Eat all the characters that match, but count how many there were.
2404                                                  */
2405
2406                                                 while(*str && (*p == *str)) {
2407                                                         str++;
2408                                                         matchcount++;
2409                                                 }
2410
2411                                                 /*
2412                                                  * Now check that if the regexp had n identical characters that
2413                                                  * matchcount had at least that many matches.
2414                                                  */
2415
2416                                                 while ( *(p+1) && (*(p+1) == *p)) {
2417                                                         p++;
2418                                                         matchcount--;
2419                                                 }
2420
2421                                                 if ( matchcount <= 0 )
2422                                                         return false;
2423                                         }
2424
2425                                         str--; /* We've eaten the match char after the '*' */
2426
2427                                         if(unix_do_match(p, str))
2428                                                 return true;
2429
2430                                         if(!*str)
2431                                                 return false;
2432                                         else
2433                                                 str++;
2434                                 }
2435                                 return false;
2436
2437                         default:
2438                                 if(*str != *p)
2439                                         return false;
2440                                 str++;
2441                                 p++;
2442                                 break;
2443                 }
2444         }
2445
2446         if(!*p && !*str)
2447                 return true;
2448
2449         if (!*p && str[0] == '.' && str[1] == 0)
2450                 return true;
2451
2452         if (!*str && *p == '?') {
2453                 while (*p == '?')
2454                         p++;
2455                 return(!*p);
2456         }
2457
2458         if(!*str && (*p == '*' && p[1] == '\0'))
2459                 return true;
2460
2461         return false;
2462 }
2463
2464 /*******************************************************************
2465  Simple case insensitive interface to a UNIX wildcard matcher.
2466  Returns True if match, False if not.
2467 *******************************************************************/
2468
2469 bool unix_wild_match(const char *pattern, const char *string)
2470 {
2471         TALLOC_CTX *ctx = talloc_stackframe();
2472         char *p2;
2473         char *s2;
2474         char *p;
2475         bool ret = false;
2476
2477         p2 = talloc_strdup(ctx,pattern);
2478         s2 = talloc_strdup(ctx,string);
2479         if (!p2 || !s2) {
2480                 TALLOC_FREE(ctx);
2481                 return false;
2482         }
2483         strlower_m(p2);
2484         strlower_m(s2);
2485
2486         /* Remove any *? and ** from the pattern as they are meaningless */
2487         for(p = p2; *p; p++) {
2488                 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2489                         memmove(&p[1], &p[2], strlen(&p[2])+1);
2490                 }
2491         }
2492
2493         if (strequal(p2,"*")) {
2494                 TALLOC_FREE(ctx);
2495                 return true;
2496         }
2497
2498         ret = unix_do_match(p2, s2);
2499         TALLOC_FREE(ctx);
2500         return ret;
2501 }
2502
2503 /**********************************************************************
2504  Converts a name to a fully qualified domain name.
2505  Returns true if lookup succeeded, false if not (then fqdn is set to name)
2506  Note we deliberately use gethostbyname here, not getaddrinfo as we want
2507  to examine the h_aliases and I don't know how to do that with getaddrinfo.
2508 ***********************************************************************/
2509
2510 bool name_to_fqdn(fstring fqdn, const char *name)
2511 {
2512         char *full = NULL;
2513         struct hostent *hp = gethostbyname(name);
2514
2515         if (!hp || !hp->h_name || !*hp->h_name) {
2516                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2517                 fstrcpy(fqdn, name);
2518                 return false;
2519         }
2520
2521         /* Find out if the fqdn is returned as an alias
2522          * to cope with /etc/hosts files where the first
2523          * name is not the fqdn but the short name */
2524         if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2525                 int i;
2526                 for (i = 0; hp->h_aliases[i]; i++) {
2527                         if (strchr_m(hp->h_aliases[i], '.')) {
2528                                 full = hp->h_aliases[i];
2529                                 break;
2530                         }
2531                 }
2532         }
2533         if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2534                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2535                 DEBUGADD(1, ("    Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2536                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
2537                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
2538                 full = hp->h_name;
2539         }
2540         if (!full) {
2541                 full = hp->h_name;
2542         }
2543
2544         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2545         fstrcpy(fqdn, full);
2546         return true;
2547 }
2548
2549 /**********************************************************************
2550  Append a DATA_BLOB to a talloc'ed object
2551 ***********************************************************************/
2552
2553 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2554 {
2555         size_t old_size = 0;
2556         char *result;
2557
2558         if (blob.length == 0) {
2559                 return buf;
2560         }
2561
2562         if (buf != NULL) {
2563                 old_size = talloc_get_size(buf);
2564         }
2565
2566         result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2567         if (result == NULL) {
2568                 return NULL;
2569         }
2570
2571         memcpy(result + old_size, blob.data, blob.length);
2572         return result;
2573 }
2574
2575 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2576 {
2577         switch (share_access & ~FILE_SHARE_DELETE) {
2578                 case FILE_SHARE_NONE:
2579                         return DENY_ALL;
2580                 case FILE_SHARE_READ:
2581                         return DENY_WRITE;
2582                 case FILE_SHARE_WRITE:
2583                         return DENY_READ;
2584                 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2585                         return DENY_NONE;
2586         }
2587         if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2588                 return DENY_DOS;
2589         } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2590                 return DENY_FCB;
2591         }
2592
2593         return (uint32)-1;
2594 }
2595
2596 pid_t procid_to_pid(const struct server_id *proc)
2597 {
2598         return proc->pid;
2599 }
2600
2601 static uint32 my_vnn = NONCLUSTER_VNN;
2602
2603 void set_my_vnn(uint32 vnn)
2604 {
2605         DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2606         my_vnn = vnn;
2607 }
2608
2609 uint32 get_my_vnn(void)
2610 {
2611         return my_vnn;
2612 }
2613
2614 static uint64_t my_unique_id = 0;
2615
2616 void set_my_unique_id(uint64_t unique_id)
2617 {
2618         my_unique_id = unique_id;
2619 }
2620
2621 struct server_id pid_to_procid(pid_t pid)
2622 {
2623         struct server_id result;
2624         result.pid = pid;
2625         result.unique_id = my_unique_id;
2626 #ifdef CLUSTER_SUPPORT
2627         result.vnn = my_vnn;
2628 #endif
2629         return result;
2630 }
2631
2632 struct server_id procid_self(void)
2633 {
2634         return pid_to_procid(sys_getpid());
2635 }
2636
2637 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2638 {
2639         if (p1->pid != p2->pid)
2640                 return False;
2641 #ifdef CLUSTER_SUPPORT
2642         if (p1->vnn != p2->vnn)
2643                 return False;
2644 #endif
2645         return True;
2646 }
2647
2648 bool cluster_id_equal(const struct server_id *id1,
2649                       const struct server_id *id2)
2650 {
2651         return procid_equal(id1, id2);
2652 }
2653
2654 bool procid_is_me(const struct server_id *pid)
2655 {
2656         if (pid->pid != sys_getpid())
2657                 return False;
2658 #ifdef CLUSTER_SUPPORT
2659         if (pid->vnn != my_vnn)
2660                 return False;
2661 #endif
2662         return True;
2663 }
2664
2665 struct server_id interpret_pid(const char *pid_string)
2666 {
2667         struct server_id result;
2668         int pid;
2669 #ifdef CLUSTER_SUPPORT
2670         unsigned int vnn;
2671         if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2672                 result.vnn = vnn;
2673                 result.pid = pid;
2674         }
2675         else if (sscanf(pid_string, "%d", &pid) == 1) {
2676                 result.vnn = get_my_vnn();
2677                 result.pid = pid;
2678         }
2679         else {
2680                 result.vnn = NONCLUSTER_VNN;
2681                 result.pid = -1;
2682         }
2683 #else
2684         if (sscanf(pid_string, "%d", &pid) != 1) {
2685                 result.pid = -1;
2686         } else {
2687                 result.pid = pid;
2688         }
2689 #endif
2690         /* Assigning to result.pid may have overflowed
2691            Map negative pid to -1: i.e. error */
2692         if (result.pid < 0) {
2693                 result.pid = -1;
2694         }
2695         result.unique_id = 0;
2696         return result;
2697 }
2698
2699 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2700 {
2701 #ifdef CLUSTER_SUPPORT
2702         if (pid->vnn == NONCLUSTER_VNN) {
2703                 return talloc_asprintf(mem_ctx,
2704                                 "%d",
2705                                 (int)pid->pid);
2706         }
2707         else {
2708                 return talloc_asprintf(mem_ctx,
2709                                         "%u:%d",
2710                                         (unsigned)pid->vnn,
2711                                         (int)pid->pid);
2712         }
2713 #else
2714         return talloc_asprintf(mem_ctx,
2715                         "%d",
2716                         (int)pid->pid);
2717 #endif
2718 }
2719
2720 char *procid_str_static(const struct server_id *pid)
2721 {
2722         return procid_str(talloc_tos(), pid);
2723 }
2724
2725 bool procid_valid(const struct server_id *pid)
2726 {
2727         return (pid->pid != -1);
2728 }
2729
2730 bool procid_is_local(const struct server_id *pid)
2731 {
2732 #ifdef CLUSTER_SUPPORT
2733         return pid->vnn == my_vnn;
2734 #else
2735         return True;
2736 #endif
2737 }
2738
2739 int this_is_smp(void)
2740 {
2741 #if defined(HAVE_SYSCONF)
2742
2743 #if defined(SYSCONF_SC_NPROC_ONLN)
2744         return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2745 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2746         return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2747 #else
2748         return 0;
2749 #endif
2750
2751 #else
2752         return 0;
2753 #endif
2754 }
2755
2756 /****************************************************************
2757  Check if offset/length fit into bufsize. Should probably be
2758  merged with is_offset_safe, but this would require a rewrite
2759  of lanman.c. Later :-)
2760 ****************************************************************/
2761
2762 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2763 {
2764         if ((offset + length < offset) || (offset + length < length)) {
2765                 /* wrap */
2766                 return true;
2767         }
2768         if ((offset > bufsize) || (offset + length > bufsize)) {
2769                 /* overflow */
2770                 return true;
2771         }
2772         return false;
2773 }
2774
2775 /****************************************************************
2776  Check if an offset into a buffer is safe.
2777  If this returns True it's safe to indirect into the byte at
2778  pointer ptr+off.
2779 ****************************************************************/
2780
2781 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2782 {
2783         const char *end_base = buf_base + buf_len;
2784         char *end_ptr = ptr + off;
2785
2786         if (!buf_base || !ptr) {
2787                 return False;
2788         }
2789
2790         if (end_base < buf_base || end_ptr < ptr) {
2791                 return False; /* wrap. */
2792         }
2793
2794         if (end_ptr < end_base) {
2795                 return True;
2796         }
2797         return False;
2798 }
2799
2800 /****************************************************************
2801  Return a safe pointer into a buffer, or NULL.
2802 ****************************************************************/
2803
2804 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2805 {
2806         return is_offset_safe(buf_base, buf_len, ptr, off) ?
2807                         ptr + off : NULL;
2808 }
2809
2810 /****************************************************************
2811  Return a safe pointer into a string within a buffer, or NULL.
2812 ****************************************************************/
2813
2814 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2815 {
2816         if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2817                 return NULL;
2818         }
2819         /* Check if a valid string exists at this offset. */
2820         if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2821                 return NULL;
2822         }
2823         return ptr + off;
2824 }
2825
2826 /****************************************************************
2827  Return an SVAL at a pointer, or failval if beyond the end.
2828 ****************************************************************/
2829
2830 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2831 {
2832         /*
2833          * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2834          * NOT ptr[2].
2835          */
2836         if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2837                 return failval;
2838         }
2839         return SVAL(ptr,off);
2840 }
2841
2842 /****************************************************************
2843  Return an IVAL at a pointer, or failval if beyond the end.
2844 ****************************************************************/
2845
2846 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2847 {
2848         /*
2849          * Note we use off+3 here, not off+4 as IVAL accesses 
2850          * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2851          */
2852         if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2853                 return failval;
2854         }
2855         return IVAL(ptr,off);
2856 }
2857
2858 /****************************************************************
2859  Split DOM\user into DOM and user. Do not mix with winbind variants of that
2860  call (they take care of winbind separator and other winbind specific settings).
2861 ****************************************************************/
2862
2863 void split_domain_user(TALLOC_CTX *mem_ctx,
2864                        const char *full_name,
2865                        char **domain,
2866                        char **user)
2867 {
2868         const char *p = NULL;
2869
2870         p = strchr_m(full_name, '\\');
2871
2872         if (p != NULL) {
2873                 *domain = talloc_strndup(mem_ctx, full_name,
2874                                          PTR_DIFF(p, full_name));
2875                 *user = talloc_strdup(mem_ctx, p+1);
2876         } else {
2877                 *domain = talloc_strdup(mem_ctx, "");
2878                 *user = talloc_strdup(mem_ctx, full_name);
2879         }
2880 }
2881
2882 #if 0
2883
2884 Disable these now we have checked all code paths and ensured
2885 NULL returns on zero request. JRA.
2886
2887 /****************************************************************
2888  talloc wrapper functions that guarentee a null pointer return
2889  if size == 0.
2890 ****************************************************************/
2891
2892 #ifndef MAX_TALLOC_SIZE
2893 #define MAX_TALLOC_SIZE 0x10000000
2894 #endif
2895
2896 /*
2897  *    talloc and zero memory.
2898  *    - returns NULL if size is zero.
2899  */
2900
2901 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2902 {
2903         void *p;
2904
2905         if (size == 0) {
2906                 return NULL;
2907         }
2908
2909         p = talloc_named_const(ctx, size, name);
2910
2911         if (p) {
2912                 memset(p, '\0', size);
2913         }
2914
2915         return p;
2916 }
2917
2918 /*
2919  *   memdup with a talloc.
2920  *   - returns NULL if size is zero.
2921  */
2922
2923 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2924 {
2925         void *newp;
2926
2927         if (size == 0) {
2928                 return NULL;
2929         }
2930
2931         newp = talloc_named_const(t, size, name);
2932         if (newp) {
2933                 memcpy(newp, p, size);
2934         }
2935
2936         return newp;
2937 }
2938
2939 /*
2940  *   alloc an array, checking for integer overflow in the array size.
2941  *   - returns NULL if count or el_size are zero.
2942  */
2943
2944 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2945 {
2946         if (count >= MAX_TALLOC_SIZE/el_size) {
2947                 return NULL;
2948         }
2949
2950         if (el_size == 0 || count == 0) {
2951                 return NULL;
2952         }
2953
2954         return talloc_named_const(ctx, el_size * count, name);
2955 }
2956
2957 /*
2958  *   alloc an zero array, checking for integer overflow in the array size
2959  *   - returns NULL if count or el_size are zero.
2960  */
2961
2962 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2963 {
2964         if (count >= MAX_TALLOC_SIZE/el_size) {
2965                 return NULL;
2966         }
2967
2968         if (el_size == 0 || count == 0) {
2969                 return NULL;
2970         }
2971
2972         return _talloc_zero(ctx, el_size * count, name);
2973 }
2974
2975 /*
2976  *   Talloc wrapper that returns NULL if size == 0.
2977  */
2978 void *talloc_zeronull(const void *context, size_t size, const char *name)
2979 {
2980         if (size == 0) {
2981                 return NULL;
2982         }
2983         return talloc_named_const(context, size, name);
2984 }
2985 #endif
2986
2987 bool is_valid_policy_hnd(const struct policy_handle *hnd)
2988 {
2989         struct policy_handle tmp;
2990         ZERO_STRUCT(tmp);
2991         return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
2992 }
2993
2994 bool policy_hnd_equal(const struct policy_handle *hnd1,
2995                       const struct policy_handle *hnd2)
2996 {
2997         if (!hnd1 || !hnd2) {
2998                 return false;
2999         }
3000
3001         return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3002 }
3003
3004 /****************************************************************
3005  strip off leading '\\' from a hostname
3006 ****************************************************************/
3007
3008 const char *strip_hostname(const char *s)
3009 {
3010         if (!s) {
3011                 return NULL;
3012         }
3013
3014         if (strlen_m(s) < 3) {
3015                 return s;
3016         }
3017
3018         if (s[0] == '\\') s++;
3019         if (s[0] == '\\') s++;
3020
3021         return s;
3022 }
3023
3024 bool tevent_req_poll_ntstatus(struct tevent_req *req,
3025                               struct tevent_context *ev,
3026                               NTSTATUS *status)
3027 {
3028         bool ret = tevent_req_poll(req, ev);
3029         if (!ret) {
3030                 *status = map_nt_error_from_unix(errno);
3031         }
3032         return ret;
3033 }