?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "s3: Make the implicit reference to Protocol in mask_match_list() explicit"
[Samba/gebeck_regimport.git] / source3 / lib / util.c
blobe3ceea495172a89eeb416e6a73bdaeb0e940743c
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,
1691 get_Protocol(), case_sensitive)) {
1692 DEBUG(8,("is_in_path: mask match succeeded\n"));
1693 return True;
1694 }
1695 } else {
1696 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1697 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1698 DEBUG(8,("is_in_path: match succeeded\n"));
1699 return True;
1700 }
1701 }
1702 }
1703 DEBUG(8,("is_in_path: match not found\n"));
1704 return False;
1705 }
1706
1707 /*******************************************************************
1708 Strip a '/' separated list into an array of
1709 name_compare_enties structures suitable for
1710 passing to is_in_path(). We do this for
1711 speed so we can pre-parse all the names in the list
1712 and don't do it for each call to is_in_path().
1713 namelist is modified here and is assumed to be
1714 a copy owned by the caller.
1715 We also check if the entry contains a wildcard to
1716 remove a potentially expensive call to mask_match
1717 if possible.
1718 ********************************************************************/
1719
1720 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1721 {
1722 char *name_end;
1723 char *nameptr = (char *)namelist;
1724 int num_entries = 0;
1725 int i;
1726
1727 (*ppname_array) = NULL;
1728
1729 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1730 return;
1731
1732 /* We need to make two passes over the string. The
1733 first to count the number of elements, the second
1734 to split it.
1735 */
1736
1737 while(*nameptr) {
1738 if ( *nameptr == '/' ) {
1739 /* cope with multiple (useless) /s) */
1740 nameptr++;
1741 continue;
1742 }
1743 /* anything left? */
1744 if ( *nameptr == '\0' )
1745 break;
1746
1747 /* find the next '/' or consume remaining */
1748 name_end = strchr_m(nameptr, '/');
1749 if (name_end == NULL)
1750 name_end = (char *)nameptr + strlen(nameptr);
1751
1752 /* next segment please */
1753 nameptr = name_end + 1;
1754 num_entries++;
1755 }
1756
1757 if(num_entries == 0)
1758 return;
1759
1760 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1761 DEBUG(0,("set_namearray: malloc fail\n"));
1762 return;
1763 }
1764
1765 /* Now copy out the names */
1766 nameptr = (char *)namelist;
1767 i = 0;
1768 while(*nameptr) {
1769 if ( *nameptr == '/' ) {
1770 /* cope with multiple (useless) /s) */
1771 nameptr++;
1772 continue;
1773 }
1774 /* anything left? */
1775 if ( *nameptr == '\0' )
1776 break;
1777
1778 /* find the next '/' or consume remaining */
1779 name_end = strchr_m(nameptr, '/');
1780 if (name_end)
1781 *name_end = '\0';
1782 else
1783 name_end = nameptr + strlen(nameptr);
1784
1785 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1786 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1787 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1788 return;
1789 }
1790
1791 /* next segment please */
1792 nameptr = name_end + 1;
1793 i++;
1794 }
1795
1796 (*ppname_array)[i].name = NULL;
1797
1798 return;
1799 }
1800
1801 /****************************************************************************
1802 Routine to free a namearray.
1803 ****************************************************************************/
1804
1805 void free_namearray(name_compare_entry *name_array)
1806 {
1807 int i;
1808
1809 if(name_array == NULL)
1810 return;
1811
1812 for(i=0; name_array[i].name!=NULL; i++)
1813 SAFE_FREE(name_array[i].name);
1814 SAFE_FREE(name_array);
1815 }
1816
1817 #undef DBGC_CLASS
1818 #define DBGC_CLASS DBGC_LOCKING
1819
1820 /****************************************************************************
1821 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1822 is dealt with in posix.c
1823 Returns True if we have information regarding this lock region (and returns
1824 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1825 ****************************************************************************/
1826
1827 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1828 {
1829 SMB_STRUCT_FLOCK lock;
1830 int ret;
1831
1832 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1833 fd,(double)*poffset,(double)*pcount,*ptype));
1834
1835 lock.l_type = *ptype;
1836 lock.l_whence = SEEK_SET;
1837 lock.l_start = *poffset;
1838 lock.l_len = *pcount;
1839 lock.l_pid = 0;
1840
1841 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1842
1843 if (ret == -1) {
1844 int sav = errno;
1845 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1846 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1847 errno = sav;
1848 return False;
1849 }
1850
1851 *ptype = lock.l_type;
1852 *poffset = lock.l_start;
1853 *pcount = lock.l_len;
1854 *ppid = lock.l_pid;
1855
1856 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1857 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1858 return True;
1859 }
1860
1861 #undef DBGC_CLASS
1862 #define DBGC_CLASS DBGC_ALL
1863
1864 /*******************************************************************
1865 Is the name specified one of my netbios names.
1866 Returns true if it is equal, false otherwise.
1867 ********************************************************************/
1868
1869 bool is_myname(const char *s)
1870 {
1871 int n;
1872 bool ret = False;
1873
1874 for (n=0; my_netbios_names(n); n++) {
1875 if (strequal(my_netbios_names(n), s)) {
1876 ret=True;
1877 break;
1878 }
1879 }
1880 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1881 return(ret);
1882 }
1883
1884 /*******************************************************************
1885 Is the name specified our workgroup/domain.
1886 Returns true if it is equal, false otherwise.
1887 ********************************************************************/
1888
1889 bool is_myworkgroup(const char *s)
1890 {
1891 bool ret = False;
1892
1893 if (strequal(s, lp_workgroup())) {
1894 ret=True;
1895 }
1896
1897 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1898 return(ret);
1899 }
1900
1901 /*******************************************************************
1902 we distinguish between 2K and XP by the "Native Lan Manager" string
1903 WinXP => "Windows 2002 5.1"
1904 WinXP 64bit => "Windows XP 5.2"
1905 Win2k => "Windows 2000 5.0"
1906 NT4 => "Windows NT 4.0"
1907 Win9x => "Windows 4.0"
1908 Windows 2003 doesn't set the native lan manager string but
1909 they do set the domain to "Windows 2003 5.2" (probably a bug).
1910 ********************************************************************/
1911
1912 void ra_lanman_string( const char *native_lanman )
1913 {
1914 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1915 set_remote_arch( RA_WINXP );
1916 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1917 set_remote_arch( RA_WINXP64 );
1918 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1919 set_remote_arch( RA_WIN2K3 );
1920 }
1921
1922 static const char *remote_arch_str;
1923
1924 const char *get_remote_arch_str(void)
1925 {
1926 if (!remote_arch_str) {
1927 return "UNKNOWN";
1928 }
1929 return remote_arch_str;
1930 }
1931
1932 /*******************************************************************
1933 Set the horrid remote_arch string based on an enum.
1934 ********************************************************************/
1935
1936 void set_remote_arch(enum remote_arch_types type)
1937 {
1938 ra_type = type;
1939 switch( type ) {
1940 case RA_WFWG:
1941 remote_arch_str = "WfWg";
1942 break;
1943 case RA_OS2:
1944 remote_arch_str = "OS2";
1945 break;
1946 case RA_WIN95:
1947 remote_arch_str = "Win95";
1948 break;
1949 case RA_WINNT:
1950 remote_arch_str = "WinNT";
1951 break;
1952 case RA_WIN2K:
1953 remote_arch_str = "Win2K";
1954 break;
1955 case RA_WINXP:
1956 remote_arch_str = "WinXP";
1957 break;
1958 case RA_WINXP64:
1959 remote_arch_str = "WinXP64";
1960 break;
1961 case RA_WIN2K3:
1962 remote_arch_str = "Win2K3";
1963 break;
1964 case RA_VISTA:
1965 remote_arch_str = "Vista";
1966 break;
1967 case RA_SAMBA:
1968 remote_arch_str = "Samba";
1969 break;
1970 case RA_CIFSFS:
1971 remote_arch_str = "CIFSFS";
1972 break;
1973 default:
1974 ra_type = RA_UNKNOWN;
1975 remote_arch_str = "UNKNOWN";
1976 break;
1977 }
1978
1979 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1980 remote_arch_str));
1981 }
1982
1983 /*******************************************************************
1984 Get the remote_arch type.
1985 ********************************************************************/
1986
1987 enum remote_arch_types get_remote_arch(void)
1988 {
1989 return ra_type;
1990 }
1991
1992 const char *tab_depth(int level, int depth)
1993 {
1994 if( CHECK_DEBUGLVL(level) ) {
1995 dbgtext("%*s", depth*4, "");
1996 }
1997 return "";
1998 }
1999
2000 /*****************************************************************************
2001 Provide a checksum on a string
2002
2003 Input: s - the null-terminated character string for which the checksum
2004 will be calculated.
2005
2006 Output: The checksum value calculated for s.
2007 *****************************************************************************/
2008
2009 int str_checksum(const char *s)
2010 {
2011 int res = 0;
2012 int c;
2013 int i=0;
2014
2015 while(*s) {
2016 c = *s;
2017 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2018 s++;
2019 i++;
2020 }
2021 return(res);
2022 }
2023
2024 /*****************************************************************
2025 Zero a memory area then free it. Used to catch bugs faster.
2026 *****************************************************************/
2027
2028 void zero_free(void *p, size_t size)
2029 {
2030 memset(p, 0, size);
2031 SAFE_FREE(p);
2032 }
2033
2034 /*****************************************************************
2035 Set our open file limit to a requested max and return the limit.
2036 *****************************************************************/
2037
2038 int set_maxfiles(int requested_max)
2039 {
2040 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2041 struct rlimit rlp;
2042 int saved_current_limit;
2043
2044 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2045 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2046 strerror(errno) ));
2047 /* just guess... */
2048 return requested_max;
2049 }
2050
2051 /*
2052 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2053 * account for the extra fd we need
2054 * as well as the log files and standard
2055 * handles etc. Save the limit we want to set in case
2056 * we are running on an OS that doesn't support this limit (AIX)
2057 * which always returns RLIM_INFINITY for rlp.rlim_max.
2058 */
2059
2060 /* Try raising the hard (max) limit to the requested amount. */
2061
2062 #if defined(RLIM_INFINITY)
2063 if (rlp.rlim_max != RLIM_INFINITY) {
2064 int orig_max = rlp.rlim_max;
2065
2066 if ( rlp.rlim_max < requested_max )
2067 rlp.rlim_max = requested_max;
2068
2069 /* This failing is not an error - many systems (Linux) don't
2070 support our default request of 10,000 open files. JRA. */
2071
2072 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2073 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2074 (int)rlp.rlim_max, strerror(errno) ));
2075
2076 /* Set failed - restore original value from get. */
2077 rlp.rlim_max = orig_max;
2078 }
2079 }
2080 #endif
2081
2082 /* Now try setting the soft (current) limit. */
2083
2084 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2085
2086 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2087 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2088 (int)rlp.rlim_cur, strerror(errno) ));
2089 /* just guess... */
2090 return saved_current_limit;
2091 }
2092
2093 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2094 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2095 strerror(errno) ));
2096 /* just guess... */
2097 return saved_current_limit;
2098 }
2099
2100 #if defined(RLIM_INFINITY)
2101 if(rlp.rlim_cur == RLIM_INFINITY)
2102 return saved_current_limit;
2103 #endif
2104
2105 if((int)rlp.rlim_cur > saved_current_limit)
2106 return saved_current_limit;
2107
2108 return rlp.rlim_cur;
2109 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2110 /*
2111 * No way to know - just guess...
2112 */
2113 return requested_max;
2114 #endif
2115 }
2116
2117 /*****************************************************************
2118 malloc that aborts with smb_panic on fail or zero size.
2119 *****************************************************************/
2120
2121 void *smb_xmalloc_array(size_t size, unsigned int count)
2122 {
2123 void *p;
2124 if (size == 0) {
2125 smb_panic("smb_xmalloc_array: called with zero size");
2126 }
2127 if (count >= MAX_ALLOC_SIZE/size) {
2128 smb_panic("smb_xmalloc_array: alloc size too large");
2129 }
2130 if ((p = SMB_MALLOC(size*count)) == NULL) {
2131 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2132 (unsigned long)size, (unsigned long)count));
2133 smb_panic("smb_xmalloc_array: malloc failed");
2134 }
2135 return p;
2136 }
2137
2138 /*
2139 vasprintf that aborts on malloc fail
2140 */
2141
2142 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2143 {
2144 int n;
2145 va_list ap2;
2146
2147 va_copy(ap2, ap);
2148
2149 n = vasprintf(ptr, format, ap2);
2150 va_end(ap2);
2151 if (n == -1 || ! *ptr) {
2152 smb_panic("smb_xvasprintf: out of memory");
2153 }
2154 return n;
2155 }
2156
2157 /*****************************************************************
2158 Get local hostname and cache result.
2159 *****************************************************************/
2160
2161 char *myhostname(void)
2162 {
2163 static char *ret;
2164 if (ret == NULL) {
2165 /* This is cached forever so
2166 * use talloc_autofree_context() ctx. */
2167 ret = get_myname(talloc_autofree_context());
2168 }
2169 return ret;
2170 }
2171
2172 /**
2173 * @brief Returns an absolute path to a file concatenating the provided
2174 * @a rootpath and @a basename
2175 *
2176 * @param name Filename, relative to @a rootpath
2177 *
2178 * @retval Pointer to a string containing the full path.
2179 **/
2180
2181 static char *xx_path(const char *name, const char *rootpath)
2182 {
2183 char *fname = NULL;
2184
2185 fname = talloc_strdup(talloc_tos(), rootpath);
2186 if (!fname) {
2187 return NULL;
2188 }
2189 trim_string(fname,"","/");
2190
2191 if (!directory_exist(fname)) {
2192 if (!mkdir(fname,0755))
2193 DEBUG(1, ("Unable to create directory %s for file %s. "
2194 "Error was %s\n", fname, name, strerror(errno)));
2195 }
2196
2197 return talloc_asprintf(talloc_tos(),
2198 "%s/%s",
2199 fname,
2200 name);
2201 }
2202
2203 /**
2204 * @brief Returns an absolute path to a file in the Samba lock directory.
2205 *
2206 * @param name File to find, relative to LOCKDIR.
2207 *
2208 * @retval Pointer to a talloc'ed string containing the full path.
2209 **/
2210
2211 char *lock_path(const char *name)
2212 {
2213 return xx_path(name, lp_lockdir());
2214 }
2215
2216 /**
2217 * @brief Returns an absolute path to a file in the Samba pid directory.
2218 *
2219 * @param name File to find, relative to PIDDIR.
2220 *
2221 * @retval Pointer to a talloc'ed string containing the full path.
2222 **/
2223
2224 char *pid_path(const char *name)
2225 {
2226 return xx_path(name, lp_piddir());
2227 }
2228
2229 /**
2230 * @brief Returns an absolute path to a file in the Samba lib directory.
2231 *
2232 * @param name File to find, relative to LIBDIR.
2233 *
2234 * @retval Pointer to a string containing the full path.
2235 **/
2236
2237 char *lib_path(const char *name)
2238 {
2239 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2240 }
2241
2242 /**
2243 * @brief Returns an absolute path to a file in the Samba modules directory.
2244 *
2245 * @param name File to find, relative to MODULESDIR.
2246 *
2247 * @retval Pointer to a string containing the full path.
2248 **/
2249
2250 char *modules_path(const char *name)
2251 {
2252 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2253 }
2254
2255 /**
2256 * @brief Returns an absolute path to a file in the Samba data directory.
2257 *
2258 * @param name File to find, relative to CODEPAGEDIR.
2259 *
2260 * @retval Pointer to a talloc'ed string containing the full path.
2261 **/
2262
2263 char *data_path(const char *name)
2264 {
2265 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2266 }
2267
2268 /**
2269 * @brief Returns an absolute path to a file in the Samba state directory.
2270 *
2271 * @param name File to find, relative to STATEDIR.
2272 *
2273 * @retval Pointer to a talloc'ed string containing the full path.
2274 **/
2275
2276 char *state_path(const char *name)
2277 {
2278 return xx_path(name, lp_statedir());
2279 }
2280
2281 /**
2282 * @brief Returns an absolute path to a file in the Samba cache directory.
2283 *
2284 * @param name File to find, relative to CACHEDIR.
2285 *
2286 * @retval Pointer to a talloc'ed string containing the full path.
2287 **/
2288
2289 char *cache_path(const char *name)
2290 {
2291 return xx_path(name, lp_cachedir());
2292 }
2293
2294 /**
2295 * @brief Returns the platform specific shared library extension.
2296 *
2297 * @retval Pointer to a const char * containing the extension.
2298 **/
2299
2300 const char *shlib_ext(void)
2301 {
2302 return get_dyn_SHLIBEXT();
2303 }
2304
2305 /*******************************************************************
2306 Given a filename - get its directory name
2307 ********************************************************************/
2308
2309 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2310 const char **name)
2311 {
2312 char *p;
2313 ptrdiff_t len;
2314
2315 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2316
2317 if (p == NULL) {
2318 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2319 return False;
2320 }
2321 if (name) {
2322 *name = dir;
2323 }
2324 return True;
2325 }
2326
2327 len = p-dir;
2328
2329 if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2330 return False;
2331 }
2332 (*parent)[len] = '\0';
2333
2334 if (name) {
2335 *name = p+1;
2336 }
2337 return True;
2338 }
2339
2340 /*******************************************************************
2341 Determine if a pattern contains any Microsoft wildcard characters.
2342 *******************************************************************/
2343
2344 bool ms_has_wild(const char *s)
2345 {
2346 char c;
2347
2348 if (lp_posix_pathnames()) {
2349 /* With posix pathnames no characters are wild. */
2350 return False;
2351 }
2352
2353 while ((c = *s++)) {
2354 switch (c) {
2355 case '*':
2356 case '?':
2357 case '<':
2358 case '>':
2359 case '"':
2360 return True;
2361 }
2362 }
2363 return False;
2364 }
2365
2366 bool ms_has_wild_w(const smb_ucs2_t *s)
2367 {
2368 smb_ucs2_t c;
2369 if (!s) return False;
2370 while ((c = *s++)) {
2371 switch (c) {
2372 case UCS2_CHAR('*'):
2373 case UCS2_CHAR('?'):
2374 case UCS2_CHAR('<'):
2375 case UCS2_CHAR('>'):
2376 case UCS2_CHAR('"'):
2377 return True;
2378 }
2379 }
2380 return False;
2381 }
2382
2383 /*******************************************************************
2384 A wrapper that handles case sensitivity and the special handling
2385 of the ".." name.
2386 *******************************************************************/
2387
2388 bool mask_match(const char *string, const char *pattern,
2389 enum protocol_types proto, bool is_case_sensitive)
2390 {
2391 if (ISDOTDOT(string))
2392 string = ".";
2393 if (ISDOT(pattern))
2394 return False;
2395
2396 return ms_fnmatch(pattern, string, proto <= PROTOCOL_LANMAN2,
2397 is_case_sensitive) == 0;
2398 }
2399
2400 /*******************************************************************
2401 A wrapper that handles case sensitivity and the special handling
2402 of the ".." name. Varient that is only called by old search code which requires
2403 pattern translation.
2404 *******************************************************************/
2405
2406 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2407 {
2408 if (ISDOTDOT(string))
2409 string = ".";
2410 if (ISDOT(pattern))
2411 return False;
2412
2413 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2414 }
2415
2416 /*******************************************************************
2417 A wrapper that handles a list of patters and calls mask_match()
2418 on each. Returns True if any of the patterns match.
2419 *******************************************************************/
2420
2421 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2422 {
2423 while (listLen-- > 0) {
2424 if (mask_match(string, *list++, get_Protocol(),
2425 is_case_sensitive))
2426 return True;
2427 }
2428 return False;
2429 }
2430
2431 /*********************************************************
2432 Recursive routine that is called by unix_wild_match.
2433 *********************************************************/
2434
2435 static bool unix_do_match(const char *regexp, const char *str)
2436 {
2437 const char *p;
2438
2439 for( p = regexp; *p && *str; ) {
2440
2441 switch(*p) {
2442 case '?':
2443 str++;
2444 p++;
2445 break;
2446
2447 case '*':
2448
2449 /*
2450 * Look for a character matching
2451 * the one after the '*'.
2452 */
2453 p++;
2454 if(!*p)
2455 return true; /* Automatic match */
2456 while(*str) {
2457
2458 while(*str && (*p != *str))
2459 str++;
2460
2461 /*
2462 * Patch from weidel@multichart.de. In the case of the regexp
2463 * '*XX*' we want to ensure there are at least 2 'X' characters
2464 * in the string after the '*' for a match to be made.
2465 */
2466
2467 {
2468 int matchcount=0;
2469
2470 /*
2471 * Eat all the characters that match, but count how many there were.
2472 */
2473
2474 while(*str && (*p == *str)) {
2475 str++;
2476 matchcount++;
2477 }
2478
2479 /*
2480 * Now check that if the regexp had n identical characters that
2481 * matchcount had at least that many matches.
2482 */
2483
2484 while ( *(p+1) && (*(p+1) == *p)) {
2485 p++;
2486 matchcount--;
2487 }
2488
2489 if ( matchcount <= 0 )
2490 return false;
2491 }
2492
2493 str--; /* We've eaten the match char after the '*' */
2494
2495 if(unix_do_match(p, str))
2496 return true;
2497
2498 if(!*str)
2499 return false;
2500 else
2501 str++;
2502 }
2503 return false;
2504
2505 default:
2506 if(*str != *p)
2507 return false;
2508 str++;
2509 p++;
2510 break;
2511 }
2512 }
2513
2514 if(!*p && !*str)
2515 return true;
2516
2517 if (!*p && str[0] == '.' && str[1] == 0)
2518 return true;
2519
2520 if (!*str && *p == '?') {
2521 while (*p == '?')
2522 p++;
2523 return(!*p);
2524 }
2525
2526 if(!*str && (*p == '*' && p[1] == '\0'))
2527 return true;
2528
2529 return false;
2530 }
2531
2532 /*******************************************************************
2533 Simple case insensitive interface to a UNIX wildcard matcher.
2534 Returns True if match, False if not.
2535 *******************************************************************/
2536
2537 bool unix_wild_match(const char *pattern, const char *string)
2538 {
2539 TALLOC_CTX *ctx = talloc_stackframe();
2540 char *p2;
2541 char *s2;
2542 char *p;
2543 bool ret = false;
2544
2545 p2 = talloc_strdup(ctx,pattern);
2546 s2 = talloc_strdup(ctx,string);
2547 if (!p2 || !s2) {
2548 TALLOC_FREE(ctx);
2549 return false;
2550 }
2551 strlower_m(p2);
2552 strlower_m(s2);
2553
2554 /* Remove any *? and ** from the pattern as they are meaningless */
2555 for(p = p2; *p; p++) {
2556 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2557 memmove(&p[1], &p[2], strlen(&p[2])+1);
2558 }
2559 }
2560
2561 if (strequal(p2,"*")) {
2562 TALLOC_FREE(ctx);
2563 return true;
2564 }
2565
2566 ret = unix_do_match(p2, s2);
2567 TALLOC_FREE(ctx);
2568 return ret;
2569 }
2570
2571 /**********************************************************************
2572 Converts a name to a fully qualified domain name.
2573 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2574 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2575 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2576 ***********************************************************************/
2577
2578 bool name_to_fqdn(fstring fqdn, const char *name)
2579 {
2580 char *full = NULL;
2581 struct hostent *hp = gethostbyname(name);
2582
2583 if (!hp || !hp->h_name || !*hp->h_name) {
2584 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2585 fstrcpy(fqdn, name);
2586 return false;
2587 }
2588
2589 /* Find out if the fqdn is returned as an alias
2590 * to cope with /etc/hosts files where the first
2591 * name is not the fqdn but the short name */
2592 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2593 int i;
2594 for (i = 0; hp->h_aliases[i]; i++) {
2595 if (strchr_m(hp->h_aliases[i], '.')) {
2596 full = hp->h_aliases[i];
2597 break;
2598 }
2599 }
2600 }
2601 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2602 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2603 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2604 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2605 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2606 full = hp->h_name;
2607 }
2608 if (!full) {
2609 full = hp->h_name;
2610 }
2611
2612 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2613 fstrcpy(fqdn, full);
2614 return true;
2615 }
2616
2617 /**********************************************************************
2618 Append a DATA_BLOB to a talloc'ed object
2619 ***********************************************************************/
2620
2621 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2622 {
2623 size_t old_size = 0;
2624 char *result;
2625
2626 if (blob.length == 0) {
2627 return buf;
2628 }
2629
2630 if (buf != NULL) {
2631 old_size = talloc_get_size(buf);
2632 }
2633
2634 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2635 if (result == NULL) {
2636 return NULL;
2637 }
2638
2639 memcpy(result + old_size, blob.data, blob.length);
2640 return result;
2641 }
2642
2643 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2644 {
2645 switch (share_access & ~FILE_SHARE_DELETE) {
2646 case FILE_SHARE_NONE:
2647 return DENY_ALL;
2648 case FILE_SHARE_READ:
2649 return DENY_WRITE;
2650 case FILE_SHARE_WRITE:
2651 return DENY_READ;
2652 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2653 return DENY_NONE;
2654 }
2655 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2656 return DENY_DOS;
2657 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2658 return DENY_FCB;
2659 }
2660
2661 return (uint32)-1;
2662 }
2663
2664 pid_t procid_to_pid(const struct server_id *proc)
2665 {
2666 return proc->pid;
2667 }
2668
2669 static uint32 my_vnn = NONCLUSTER_VNN;
2670
2671 void set_my_vnn(uint32 vnn)
2672 {
2673 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2674 my_vnn = vnn;
2675 }
2676
2677 uint32 get_my_vnn(void)
2678 {
2679 return my_vnn;
2680 }
2681
2682 struct server_id pid_to_procid(pid_t pid)
2683 {
2684 struct server_id result;
2685 result.pid = pid;
2686 #ifdef CLUSTER_SUPPORT
2687 result.vnn = my_vnn;
2688 #endif
2689 return result;
2690 }
2691
2692 struct server_id procid_self(void)
2693 {
2694 return pid_to_procid(sys_getpid());
2695 }
2696
2697 struct server_id server_id_self(void)
2698 {
2699 return procid_self();
2700 }
2701
2702 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2703 {
2704 if (p1->pid != p2->pid)
2705 return False;
2706 #ifdef CLUSTER_SUPPORT
2707 if (p1->vnn != p2->vnn)
2708 return False;
2709 #endif
2710 return True;
2711 }
2712
2713 bool cluster_id_equal(const struct server_id *id1,
2714 const struct server_id *id2)
2715 {
2716 return procid_equal(id1, id2);
2717 }
2718
2719 bool procid_is_me(const struct server_id *pid)
2720 {
2721 if (pid->pid != sys_getpid())
2722 return False;
2723 #ifdef CLUSTER_SUPPORT
2724 if (pid->vnn != my_vnn)
2725 return False;
2726 #endif
2727 return True;
2728 }
2729
2730 struct server_id interpret_pid(const char *pid_string)
2731 {
2732 struct server_id result;
2733 int pid;
2734 #ifdef CLUSTER_SUPPORT
2735 unsigned int vnn;
2736 if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2737 result.vnn = vnn;
2738 result.pid = pid;
2739 }
2740 else if (sscanf(pid_string, "%d", &pid) == 1) {
2741 result.vnn = get_my_vnn();
2742 result.pid = pid;
2743 }
2744 else {
2745 result.vnn = NONCLUSTER_VNN;
2746 result.pid = -1;
2747 }
2748 #else
2749 if (sscanf(pid_string, "%d", &pid) != 1) {
2750 result.pid = -1;
2751 } else {
2752 result.pid = pid;
2753 }
2754 #endif
2755 /* Assigning to result.pid may have overflowed
2756 Map negative pid to -1: i.e. error */
2757 if (result.pid < 0) {
2758 result.pid = -1;
2759 }
2760 return result;
2761 }
2762
2763 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2764 {
2765 #ifdef CLUSTER_SUPPORT
2766 if (pid->vnn == NONCLUSTER_VNN) {
2767 return talloc_asprintf(mem_ctx,
2768 "%d",
2769 (int)pid->pid);
2770 }
2771 else {
2772 return talloc_asprintf(mem_ctx,
2773 "%u:%d",
2774 (unsigned)pid->vnn,
2775 (int)pid->pid);
2776 }
2777 #else
2778 return talloc_asprintf(mem_ctx,
2779 "%d",
2780 (int)pid->pid);
2781 #endif
2782 }
2783
2784 char *procid_str_static(const struct server_id *pid)
2785 {
2786 return procid_str(talloc_tos(), pid);
2787 }
2788
2789 bool procid_valid(const struct server_id *pid)
2790 {
2791 return (pid->pid != -1);
2792 }
2793
2794 bool procid_is_local(const struct server_id *pid)
2795 {
2796 #ifdef CLUSTER_SUPPORT
2797 return pid->vnn == my_vnn;
2798 #else
2799 return True;
2800 #endif
2801 }
2802
2803 int this_is_smp(void)
2804 {
2805 #if defined(HAVE_SYSCONF)
2806
2807 #if defined(SYSCONF_SC_NPROC_ONLN)
2808 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2809 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2810 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2811 #else
2812 return 0;
2813 #endif
2814
2815 #else
2816 return 0;
2817 #endif
2818 }
2819
2820 /****************************************************************
2821 Check if offset/length fit into bufsize. Should probably be
2822 merged with is_offset_safe, but this would require a rewrite
2823 of lanman.c. Later :-)
2824 ****************************************************************/
2825
2826 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2827 {
2828 if ((offset + length < offset) || (offset + length < length)) {
2829 /* wrap */
2830 return true;
2831 }
2832 if ((offset > bufsize) || (offset + length > bufsize)) {
2833 /* overflow */
2834 return true;
2835 }
2836 return false;
2837 }
2838
2839 /****************************************************************
2840 Check if an offset into a buffer is safe.
2841 If this returns True it's safe to indirect into the byte at
2842 pointer ptr+off.
2843 ****************************************************************/
2844
2845 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2846 {
2847 const char *end_base = buf_base + buf_len;
2848 char *end_ptr = ptr + off;
2849
2850 if (!buf_base || !ptr) {
2851 return False;
2852 }
2853
2854 if (end_base < buf_base || end_ptr < ptr) {
2855 return False; /* wrap. */
2856 }
2857
2858 if (end_ptr < end_base) {
2859 return True;
2860 }
2861 return False;
2862 }
2863
2864 /****************************************************************
2865 Return a safe pointer into a buffer, or NULL.
2866 ****************************************************************/
2867
2868 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2869 {
2870 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2871 ptr + off : NULL;
2872 }
2873
2874 /****************************************************************
2875 Return a safe pointer into a string within a buffer, or NULL.
2876 ****************************************************************/
2877
2878 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2879 {
2880 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2881 return NULL;
2882 }
2883 /* Check if a valid string exists at this offset. */
2884 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2885 return NULL;
2886 }
2887 return ptr + off;
2888 }
2889
2890 /****************************************************************
2891 Return an SVAL at a pointer, or failval if beyond the end.
2892 ****************************************************************/
2893
2894 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2895 {
2896 /*
2897 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2898 * NOT ptr[2].
2899 */
2900 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2901 return failval;
2902 }
2903 return SVAL(ptr,off);
2904 }
2905
2906 /****************************************************************
2907 Return an IVAL at a pointer, or failval if beyond the end.
2908 ****************************************************************/
2909
2910 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2911 {
2912 /*
2913 * Note we use off+3 here, not off+4 as IVAL accesses
2914 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2915 */
2916 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2917 return failval;
2918 }
2919 return IVAL(ptr,off);
2920 }
2921
2922 /****************************************************************
2923 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2924 call (they take care of winbind separator and other winbind specific settings).
2925 ****************************************************************/
2926
2927 void split_domain_user(TALLOC_CTX *mem_ctx,
2928 const char *full_name,
2929 char **domain,
2930 char **user)
2931 {
2932 const char *p = NULL;
2933
2934 p = strchr_m(full_name, '\\');
2935
2936 if (p != NULL) {
2937 *domain = talloc_strndup(mem_ctx, full_name,
2938 PTR_DIFF(p, full_name));
2939 *user = talloc_strdup(mem_ctx, p+1);
2940 } else {
2941 *domain = talloc_strdup(mem_ctx, "");
2942 *user = talloc_strdup(mem_ctx, full_name);
2943 }
2944 }
2945
2946 #if 0
2947
2948 Disable these now we have checked all code paths and ensured
2949 NULL returns on zero request. JRA.
2950
2951 /****************************************************************
2952 talloc wrapper functions that guarentee a null pointer return
2953 if size == 0.
2954 ****************************************************************/
2955
2956 #ifndef MAX_TALLOC_SIZE
2957 #define MAX_TALLOC_SIZE 0x10000000
2958 #endif
2959
2960 /*
2961 * talloc and zero memory.
2962 * - returns NULL if size is zero.
2963 */
2964
2965 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2966 {
2967 void *p;
2968
2969 if (size == 0) {
2970 return NULL;
2971 }
2972
2973 p = talloc_named_const(ctx, size, name);
2974
2975 if (p) {
2976 memset(p, '\0', size);
2977 }
2978
2979 return p;
2980 }
2981
2982 /*
2983 * memdup with a talloc.
2984 * - returns NULL if size is zero.
2985 */
2986
2987 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2988 {
2989 void *newp;
2990
2991 if (size == 0) {
2992 return NULL;
2993 }
2994
2995 newp = talloc_named_const(t, size, name);
2996 if (newp) {
2997 memcpy(newp, p, size);
2998 }
2999
3000 return newp;
3001 }
3002
3003 /*
3004 * alloc an array, checking for integer overflow in the array size.
3005 * - returns NULL if count or el_size are zero.
3006 */
3007
3008 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3009 {
3010 if (count >= MAX_TALLOC_SIZE/el_size) {
3011 return NULL;
3012 }
3013
3014 if (el_size == 0 || count == 0) {
3015 return NULL;
3016 }
3017
3018 return talloc_named_const(ctx, el_size * count, name);
3019 }
3020
3021 /*
3022 * alloc an zero array, checking for integer overflow in the array size
3023 * - returns NULL if count or el_size are zero.
3024 */
3025
3026 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3027 {
3028 if (count >= MAX_TALLOC_SIZE/el_size) {
3029 return NULL;
3030 }
3031
3032 if (el_size == 0 || count == 0) {
3033 return NULL;
3034 }
3035
3036 return _talloc_zero(ctx, el_size * count, name);
3037 }
3038
3039 /*
3040 * Talloc wrapper that returns NULL if size == 0.
3041 */
3042 void *talloc_zeronull(const void *context, size_t size, const char *name)
3043 {
3044 if (size == 0) {
3045 return NULL;
3046 }
3047 return talloc_named_const(context, size, name);
3048 }
3049 #endif
3050
3051 bool is_valid_policy_hnd(const struct policy_handle *hnd)
3052 {
3053 struct policy_handle tmp;
3054 ZERO_STRUCT(tmp);
3055 return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3056 }
3057
3058 bool policy_hnd_equal(const struct policy_handle *hnd1,
3059 const struct policy_handle *hnd2)
3060 {
3061 if (!hnd1 || !hnd2) {
3062 return false;
3063 }
3064
3065 return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3066 }
3067
3068 /****************************************************************
3069 strip off leading '\\' from a hostname
3070 ****************************************************************/
3071
3072 const char *strip_hostname(const char *s)
3073 {
3074 if (!s) {
3075 return NULL;
3076 }
3077
3078 if (strlen_m(s) < 3) {
3079 return s;
3080 }
3081
3082 if (s[0] == '\\') s++;
3083 if (s[0] == '\\') s++;
3084
3085 return s;
3086 }
3087
3088 bool tevent_req_poll_ntstatus(struct tevent_req *req,
3089 struct tevent_context *ev,
3090 NTSTATUS *status)
3091 {
3092 bool ret = tevent_req_poll(req, ev);
3093 if (!ret) {
3094 *status = map_nt_error_from_unix(errno);
3095 }
3096 return ret;
3097 }
reg import