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