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