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