?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tiny simplification to dom_sid_string_buf
[Samba.git] / source3 / lib / util.c
blob173e9067cc24da3ea2f3d2d6e79666e8b662503b
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 "system/passwd.h"
26 #include "system/filesys.h"
27 #include "util_tdb.h"
28 #include "ctdbd_conn.h"
29 #include "../lib/util/util_pw.h"
30 #include "messages.h"
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 void gfree_all( void )
76 {
77 gfree_names();
78 gfree_loadparm();
79 gfree_charcnv();
80 gfree_interfaces();
81 gfree_debugsyms();
82 }
83
84 /*******************************************************************
85 Check if a file exists - call vfs_file_exist for samba files.
86 ********************************************************************/
87
88 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
89 bool fake_dir_create_times)
90 {
91 SMB_STRUCT_STAT st;
92 if (!sbuf)
93 sbuf = &st;
94
95 if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
96 return(False);
97
98 return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
99 }
100
101 /*******************************************************************
102 Check if a unix domain socket exists - call vfs_file_exist for samba files.
103 ********************************************************************/
104
105 bool socket_exist(const char *fname)
106 {
107 SMB_STRUCT_STAT st;
108 if (sys_stat(fname, &st, false) != 0)
109 return(False);
110
111 return S_ISSOCK(st.st_ex_mode);
112 }
113
114 /*******************************************************************
115 Returns the size in bytes of the named given the stat struct.
116 ********************************************************************/
117
118 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
119 {
120 return sbuf->st_ex_size;
121 }
122
123 /*******************************************************************
124 Returns the size in bytes of the named file.
125 ********************************************************************/
126
127 SMB_OFF_T get_file_size(char *file_name)
128 {
129 SMB_STRUCT_STAT buf;
130 buf.st_ex_size = 0;
131 if (sys_stat(file_name, &buf, false) != 0)
132 return (SMB_OFF_T)-1;
133 return get_file_size_stat(&buf);
134 }
135
136 /*******************************************************************
137 Show a smb message structure.
138 ********************************************************************/
139
140 void show_msg(const char *buf)
141 {
142 int i;
143 int bcc=0;
144
145 if (!DEBUGLVL(5))
146 return;
147
148 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
149 smb_len(buf),
150 (int)CVAL(buf,smb_com),
151 (int)CVAL(buf,smb_rcls),
152 (int)CVAL(buf,smb_reh),
153 (int)SVAL(buf,smb_err),
154 (int)CVAL(buf,smb_flg),
155 (int)SVAL(buf,smb_flg2)));
156 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
157 (int)SVAL(buf,smb_tid),
158 (int)SVAL(buf,smb_pid),
159 (int)SVAL(buf,smb_uid),
160 (int)SVAL(buf,smb_mid)));
161 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
162
163 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
164 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
165 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
166
167 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
168
169 DEBUGADD(5,("smb_bcc=%d\n",bcc));
170
171 if (DEBUGLEVEL < 10)
172 return;
173
174 if (DEBUGLEVEL < 50)
175 bcc = MIN(bcc, 512);
176
177 dump_data(10, (const uint8 *)smb_buf_const(buf), bcc);
178 }
179
180 /*******************************************************************
181 Set the length and marker of an encrypted smb packet.
182 ********************************************************************/
183
184 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
185 {
186 _smb_setlen(buf,len);
187
188 SCVAL(buf,4,0xFF);
189 SCVAL(buf,5,'E');
190 SSVAL(buf,6,enc_ctx_num);
191 }
192
193 /*******************************************************************
194 Set the length and marker of an smb packet.
195 ********************************************************************/
196
197 void smb_setlen(char *buf,int len)
198 {
199 _smb_setlen(buf,len);
200
201 SCVAL(buf,4,0xFF);
202 SCVAL(buf,5,'S');
203 SCVAL(buf,6,'M');
204 SCVAL(buf,7,'B');
205 }
206
207 /*******************************************************************
208 Setup only the byte count for a smb message.
209 ********************************************************************/
210
211 int set_message_bcc(char *buf,int num_bytes)
212 {
213 int num_words = CVAL(buf,smb_wct);
214 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
215 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
216 return (smb_size + num_words*2 + num_bytes);
217 }
218
219 /*******************************************************************
220 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
221 Return the bytes added
222 ********************************************************************/
223
224 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
225 {
226 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
227 uint8 *tmp;
228
229 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
230 DEBUG(0, ("talloc failed\n"));
231 return -1;
232 }
233 *outbuf = tmp;
234
235 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
236 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
237 return blob.length;
238 }
239
240 /*******************************************************************
241 Reduce a file name, removing .. elements.
242 ********************************************************************/
243
244 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
245 {
246 char *p = NULL;
247 char *str = NULL;
248
249 DEBUG(3,("dos_clean_name [%s]\n",s));
250
251 /* remove any double slashes */
252 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
253 if (!str) {
254 return NULL;
255 }
256
257 /* Remove leading .\\ characters */
258 if(strncmp(str, ".\\", 2) == 0) {
259 trim_string(str, ".\\", NULL);
260 if(*str == 0) {
261 str = talloc_strdup(ctx, ".\\");
262 if (!str) {
263 return NULL;
264 }
265 }
266 }
267
268 while ((p = strstr_m(str,"\\..\\")) != NULL) {
269 char *s1;
270
271 *p = 0;
272 s1 = p+3;
273
274 if ((p=strrchr_m(str,'\\')) != NULL) {
275 *p = 0;
276 } else {
277 *str = 0;
278 }
279 str = talloc_asprintf(ctx,
280 "%s%s",
281 str,
282 s1);
283 if (!str) {
284 return NULL;
285 }
286 }
287
288 trim_string(str,NULL,"\\..");
289 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
290 }
291
292 /*******************************************************************
293 Reduce a file name, removing .. elements.
294 ********************************************************************/
295
296 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
297 {
298 char *p = NULL;
299 char *str = NULL;
300
301 DEBUG(3,("unix_clean_name [%s]\n",s));
302
303 /* remove any double slashes */
304 str = talloc_all_string_sub(ctx, s, "//","/");
305 if (!str) {
306 return NULL;
307 }
308
309 /* Remove leading ./ characters */
310 if(strncmp(str, "./", 2) == 0) {
311 trim_string(str, "./", NULL);
312 if(*str == 0) {
313 str = talloc_strdup(ctx, "./");
314 if (!str) {
315 return NULL;
316 }
317 }
318 }
319
320 while ((p = strstr_m(str,"/../")) != NULL) {
321 char *s1;
322
323 *p = 0;
324 s1 = p+3;
325
326 if ((p=strrchr_m(str,'/')) != NULL) {
327 *p = 0;
328 } else {
329 *str = 0;
330 }
331 str = talloc_asprintf(ctx,
332 "%s%s",
333 str,
334 s1);
335 if (!str) {
336 return NULL;
337 }
338 }
339
340 trim_string(str,NULL,"/..");
341 return talloc_all_string_sub(ctx, str, "/./", "/");
342 }
343
344 char *clean_name(TALLOC_CTX *ctx, const char *s)
345 {
346 char *str = dos_clean_name(ctx, s);
347 if (!str) {
348 return NULL;
349 }
350 return unix_clean_name(ctx, str);
351 }
352
353 /*******************************************************************
354 Write data into an fd at a given offset. Ignore seek errors.
355 ********************************************************************/
356
357 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
358 {
359 size_t total=0;
360 ssize_t ret;
361
362 if (pos == (SMB_OFF_T)-1) {
363 return write_data(fd, buffer, N);
364 }
365 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
366 while (total < N) {
367 ret = sys_pwrite(fd,buffer + total,N - total, pos);
368 if (ret == -1 && errno == ESPIPE) {
369 return write_data(fd, buffer + total,N - total);
370 }
371 if (ret == -1) {
372 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
373 return -1;
374 }
375 if (ret == 0) {
376 return total;
377 }
378 total += ret;
379 pos += ret;
380 }
381 return (ssize_t)total;
382 #else
383 /* Use lseek and write_data. */
384 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
385 if (errno != ESPIPE) {
386 return -1;
387 }
388 }
389 return write_data(fd, buffer, N);
390 #endif
391 }
392
393
394 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
395 struct event_context *ev_ctx,
396 struct server_id id,
397 bool parent_longlived)
398 {
399 NTSTATUS status = NT_STATUS_OK;
400
401 /* Reset the state of the random
402 * number generation system, so
403 * children do not get the same random
404 * numbers as each other */
405 set_need_random_reseed();
406
407 /* tdb needs special fork handling */
408 if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
409 DEBUG(0,("tdb_reopen_all failed.\n"));
410 status = NT_STATUS_OPEN_FAILED;
411 goto done;
412 }
413
414 if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
415 smb_panic(__location__ ": Failed to re-initialise event context");
416 }
417
418 if (msg_ctx) {
419 /*
420 * For clustering, we need to re-init our ctdbd connection after the
421 * fork
422 */
423 status = messaging_reinit(msg_ctx, id);
424 if (!NT_STATUS_IS_OK(status)) {
425 DEBUG(0,("messaging_reinit() failed: %s\n",
426 nt_errstr(status)));
427 }
428 }
429 done:
430 return status;
431 }
432
433 /****************************************************************************
434 (Hopefully) efficient array append.
435 ****************************************************************************/
436
437 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
438 void *element, void *_array, uint32 *num_elements,
439 ssize_t *array_size)
440 {
441 void **array = (void **)_array;
442
443 if (*array_size < 0) {
444 return;
445 }
446
447 if (*array == NULL) {
448 if (*array_size == 0) {
449 *array_size = 128;
450 }
451
452 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
453 goto error;
454 }
455
456 *array = TALLOC(mem_ctx, element_size * (*array_size));
457 if (*array == NULL) {
458 goto error;
459 }
460 }
461
462 if (*num_elements == *array_size) {
463 *array_size *= 2;
464
465 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
466 goto error;
467 }
468
469 *array = TALLOC_REALLOC(mem_ctx, *array,
470 element_size * (*array_size));
471
472 if (*array == NULL) {
473 goto error;
474 }
475 }
476
477 memcpy((char *)(*array) + element_size*(*num_elements),
478 element, element_size);
479 *num_elements += 1;
480
481 return;
482
483 error:
484 *num_elements = 0;
485 *array_size = -1;
486 }
487
488 /****************************************************************************
489 Get my own domain name, or "" if we have none.
490 ****************************************************************************/
491
492 char *get_mydnsdomname(TALLOC_CTX *ctx)
493 {
494 const char *domname;
495 char *p;
496
497 domname = get_mydnsfullname();
498 if (!domname) {
499 return NULL;
500 }
501
502 p = strchr_m(domname, '.');
503 if (p) {
504 p++;
505 return talloc_strdup(ctx, p);
506 } else {
507 return talloc_strdup(ctx, "");
508 }
509 }
510
511 /****************************************************************************
512 Interpret a protocol description string, with a default.
513 ****************************************************************************/
514
515 int interpret_protocol(const char *str,int def)
516 {
517 if (strequal(str,"NT1"))
518 return(PROTOCOL_NT1);
519 if (strequal(str,"LANMAN2"))
520 return(PROTOCOL_LANMAN2);
521 if (strequal(str,"LANMAN1"))
522 return(PROTOCOL_LANMAN1);
523 if (strequal(str,"CORE"))
524 return(PROTOCOL_CORE);
525 if (strequal(str,"COREPLUS"))
526 return(PROTOCOL_COREPLUS);
527 if (strequal(str,"CORE+"))
528 return(PROTOCOL_COREPLUS);
529
530 DEBUG(0,("Unrecognised protocol level %s\n",str));
531
532 return(def);
533 }
534
535
536 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
537 /******************************************************************
538 Remove any mount options such as -rsize=2048,wsize=2048 etc.
539 Based on a fix from <Thomas.Hepper@icem.de>.
540 Returns a malloc'ed string.
541 *******************************************************************/
542
543 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
544 {
545 if (*str == '-') {
546 const char *p = str;
547 while(*p && !isspace(*p))
548 p++;
549 while(*p && isspace(*p))
550 p++;
551 if(*p) {
552 return talloc_strdup(ctx, p);
553 }
554 }
555 return NULL;
556 }
557
558 /*******************************************************************
559 Patch from jkf@soton.ac.uk
560 Split Luke's automount_server into YP lookup and string splitter
561 so can easily implement automount_path().
562 Returns a malloc'ed string.
563 *******************************************************************/
564
565 #ifdef WITH_NISPLUS_HOME
566 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
567 {
568 char *value = NULL;
569
570 char *nis_map = (char *)lp_nis_home_map_name();
571
572 char buffer[NIS_MAXATTRVAL + 1];
573 nis_result *result;
574 nis_object *object;
575 entry_obj *entry;
576
577 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
578 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
579
580 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
581 if (result->status != NIS_SUCCESS) {
582 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
583 } else {
584 object = result->objects.objects_val;
585 if (object->zo_data.zo_type == ENTRY_OBJ) {
586 entry = &object->zo_data.objdata_u.en_data;
587 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
588 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
589
590 value = talloc_strdup(ctx,
591 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
592 if (!value) {
593 nis_freeresult(result);
594 return NULL;
595 }
596 value = talloc_string_sub(ctx,
597 value,
598 "&",
599 user_name);
600 }
601 }
602 }
603 nis_freeresult(result);
604
605 if (value) {
606 value = strip_mount_options(ctx, value);
607 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
608 user_name, value));
609 }
610 return value;
611 }
612 #else /* WITH_NISPLUS_HOME */
613
614 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
615 {
616 char *value = NULL;
617
618 int nis_error; /* returned by yp all functions */
619 char *nis_result; /* yp_match inits this */
620 int nis_result_len; /* and set this */
621 char *nis_domain; /* yp_get_default_domain inits this */
622 char *nis_map = (char *)lp_nis_home_map_name();
623
624 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
625 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
626 return NULL;
627 }
628
629 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
630
631 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
632 strlen(user_name), &nis_result,
633 &nis_result_len)) == 0) {
634 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
635 nis_result[nis_result_len] = '\0';
636 }
637 value = talloc_strdup(ctx, nis_result);
638 if (!value) {
639 return NULL;
640 }
641 value = strip_mount_options(ctx, value);
642 } else if(nis_error == YPERR_KEY) {
643 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
644 user_name, nis_map));
645 DEBUG(3, ("using defaults for server and home directory\n"));
646 } else {
647 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
648 yperr_string(nis_error), user_name, nis_map));
649 }
650
651 if (value) {
652 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
653 }
654 return value;
655 }
656 #endif /* WITH_NISPLUS_HOME */
657 #endif
658
659 /****************************************************************************
660 Check if a process exists. Does this work on all unixes?
661 ****************************************************************************/
662
663 bool process_exists(const struct server_id pid)
664 {
665 if (procid_is_me(&pid)) {
666 return True;
667 }
668
669 if (procid_is_local(&pid)) {
670 return (kill(pid.pid,0) == 0 || errno != ESRCH);
671 }
672
673 #ifdef CLUSTER_SUPPORT
674 return ctdbd_process_exists(messaging_ctdbd_connection(),
675 pid.vnn, pid.pid);
676 #else
677 return False;
678 #endif
679 }
680
681 /*******************************************************************
682 Convert a uid into a user name.
683 ********************************************************************/
684
685 const char *uidtoname(uid_t uid)
686 {
687 TALLOC_CTX *ctx = talloc_tos();
688 char *name = NULL;
689 struct passwd *pass = NULL;
690
691 pass = getpwuid_alloc(ctx,uid);
692 if (pass) {
693 name = talloc_strdup(ctx,pass->pw_name);
694 TALLOC_FREE(pass);
695 } else {
696 name = talloc_asprintf(ctx,
697 "%ld",
698 (long int)uid);
699 }
700 return name;
701 }
702
703 /*******************************************************************
704 Convert a gid into a group name.
705 ********************************************************************/
706
707 char *gidtoname(gid_t gid)
708 {
709 struct group *grp;
710
711 grp = getgrgid(gid);
712 if (grp) {
713 return talloc_strdup(talloc_tos(), grp->gr_name);
714 }
715 else {
716 return talloc_asprintf(talloc_tos(),
717 "%d",
718 (int)gid);
719 }
720 }
721
722 /*******************************************************************
723 Convert a user name into a uid.
724 ********************************************************************/
725
726 uid_t nametouid(const char *name)
727 {
728 struct passwd *pass;
729 char *p;
730 uid_t u;
731
732 pass = Get_Pwnam_alloc(talloc_tos(), name);
733 if (pass) {
734 u = pass->pw_uid;
735 TALLOC_FREE(pass);
736 return u;
737 }
738
739 u = (uid_t)strtol(name, &p, 0);
740 if ((p != name) && (*p == '\0'))
741 return u;
742
743 return (uid_t)-1;
744 }
745
746 /*******************************************************************
747 Convert a name to a gid_t if possible. Return -1 if not a group.
748 ********************************************************************/
749
750 gid_t nametogid(const char *name)
751 {
752 struct group *grp;
753 char *p;
754 gid_t g;
755
756 g = (gid_t)strtol(name, &p, 0);
757 if ((p != name) && (*p == '\0'))
758 return g;
759
760 grp = sys_getgrnam(name);
761 if (grp)
762 return(grp->gr_gid);
763 return (gid_t)-1;
764 }
765
766 /*******************************************************************
767 Something really nasty happened - panic !
768 ********************************************************************/
769
770 void smb_panic_s3(const char *why)
771 {
772 char *cmd;
773 int result;
774
775 DEBUG(0,("PANIC (pid %llu): %s\n",
776 (unsigned long long)sys_getpid(), why));
777 log_stack_trace();
778
779 cmd = lp_panic_action();
780 if (cmd && *cmd) {
781 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
782 result = system(cmd);
783
784 if (result == -1)
785 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
786 strerror(errno)));
787 else
788 DEBUG(0, ("smb_panic(): action returned status %d\n",
789 WEXITSTATUS(result)));
790 }
791
792 dump_core();
793 }
794
795 /*******************************************************************
796 Print a backtrace of the stack to the debug log. This function
797 DELIBERATELY LEAKS MEMORY. The expectation is that you should
798 exit shortly after calling it.
799 ********************************************************************/
800
801 #ifdef HAVE_LIBUNWIND_H
802 #include <libunwind.h>
803 #endif
804
805 #ifdef HAVE_EXECINFO_H
806 #include <execinfo.h>
807 #endif
808
809 #ifdef HAVE_LIBEXC_H
810 #include <libexc.h>
811 #endif
812
813 void log_stack_trace(void)
814 {
815 #ifdef HAVE_LIBUNWIND
816 /* Try to use libunwind before any other technique since on ia64
817 * libunwind correctly walks the stack in more circumstances than
818 * backtrace.
819 */
820 unw_cursor_t cursor;
821 unw_context_t uc;
822 unsigned i = 0;
823
824 char procname[256];
825 unw_word_t ip, sp, off;
826
827 procname[sizeof(procname) - 1] = '\0';
828
829 if (unw_getcontext(&uc) != 0) {
830 goto libunwind_failed;
831 }
832
833 if (unw_init_local(&cursor, &uc) != 0) {
834 goto libunwind_failed;
835 }
836
837 DEBUG(0, ("BACKTRACE:\n"));
838
839 do {
840 ip = sp = 0;
841 unw_get_reg(&cursor, UNW_REG_IP, &ip);
842 unw_get_reg(&cursor, UNW_REG_SP, &sp);
843
844 switch (unw_get_proc_name(&cursor,
845 procname, sizeof(procname) - 1, &off) ) {
846 case 0:
847 /* Name found. */
848 case -UNW_ENOMEM:
849 /* Name truncated. */
850 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
851 i, procname, (long long)off,
852 (long long)ip, (long long) sp));
853 break;
854 default:
855 /* case -UNW_ENOINFO: */
856 /* case -UNW_EUNSPEC: */
857 /* No symbol name found. */
858 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
859 i, "<unknown symbol>",
860 (long long)ip, (long long) sp));
861 }
862 ++i;
863 } while (unw_step(&cursor) > 0);
864
865 return;
866
867 libunwind_failed:
868 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
869
870 #elif HAVE_BACKTRACE_SYMBOLS
871 void *backtrace_stack[BACKTRACE_STACK_SIZE];
872 size_t backtrace_size;
873 char **backtrace_strings;
874
875 /* get the backtrace (stack frames) */
876 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
877 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
878
879 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
880 (unsigned long)backtrace_size));
881
882 if (backtrace_strings) {
883 int i;
884
885 for (i = 0; i < backtrace_size; i++)
886 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
887
888 /* Leak the backtrace_strings, rather than risk what free() might do */
889 }
890
891 #elif HAVE_LIBEXC
892
893 /* The IRIX libexc library provides an API for unwinding the stack. See
894 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
895 * since we are about to abort anyway, it hardly matters.
896 */
897
898 #define NAMESIZE 32 /* Arbitrary */
899
900 __uint64_t addrs[BACKTRACE_STACK_SIZE];
901 char * names[BACKTRACE_STACK_SIZE];
902 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
903
904 int i;
905 int levels;
906
907 ZERO_ARRAY(addrs);
908 ZERO_ARRAY(names);
909 ZERO_ARRAY(namebuf);
910
911 /* We need to be root so we can open our /proc entry to walk
912 * our stack. It also helps when we want to dump core.
913 */
914 become_root();
915
916 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
917 names[i] = namebuf + (i * NAMESIZE);
918 }
919
920 levels = trace_back_stack(0, addrs, names,
921 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
922
923 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
924 for (i = 0; i < levels; i++) {
925 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
926 }
927 #undef NAMESIZE
928
929 #else
930 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
931 #endif
932 }
933
934 /*******************************************************************
935 A readdir wrapper which just returns the file name.
936 ********************************************************************/
937
938 const char *readdirname(SMB_STRUCT_DIR *p)
939 {
940 SMB_STRUCT_DIRENT *ptr;
941 char *dname;
942
943 if (!p)
944 return(NULL);
945
946 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
947 if (!ptr)
948 return(NULL);
949
950 dname = ptr->d_name;
951
952 #ifdef NEXT2
953 if (telldir(p) < 0)
954 return(NULL);
955 #endif
956
957 #ifdef HAVE_BROKEN_READDIR_NAME
958 /* using /usr/ucb/cc is BAD */
959 dname = dname - 2;
960 #endif
961
962 return talloc_strdup(talloc_tos(), dname);
963 }
964
965 /*******************************************************************
966 Utility function used to decide if the last component
967 of a path matches a (possibly wildcarded) entry in a namelist.
968 ********************************************************************/
969
970 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
971 {
972 const char *last_component;
973
974 /* if we have no list it's obviously not in the path */
975 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
976 return False;
977 }
978
979 DEBUG(8, ("is_in_path: %s\n", name));
980
981 /* Get the last component of the unix name. */
982 last_component = strrchr_m(name, '/');
983 if (!last_component) {
984 last_component = name;
985 } else {
986 last_component++; /* Go past '/' */
987 }
988
989 for(; namelist->name != NULL; namelist++) {
990 if(namelist->is_wild) {
991 if (mask_match(last_component, namelist->name, case_sensitive)) {
992 DEBUG(8,("is_in_path: mask match succeeded\n"));
993 return True;
994 }
995 } else {
996 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
997 (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
998 DEBUG(8,("is_in_path: match succeeded\n"));
999 return True;
1000 }
1001 }
1002 }
1003 DEBUG(8,("is_in_path: match not found\n"));
1004 return False;
1005 }
1006
1007 /*******************************************************************
1008 Strip a '/' separated list into an array of
1009 name_compare_enties structures suitable for
1010 passing to is_in_path(). We do this for
1011 speed so we can pre-parse all the names in the list
1012 and don't do it for each call to is_in_path().
1013 We also check if the entry contains a wildcard to
1014 remove a potentially expensive call to mask_match
1015 if possible.
1016 ********************************************************************/
1017
1018 void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
1019 {
1020 char *name_end;
1021 char *namelist;
1022 char *nameptr;
1023 int num_entries = 0;
1024 int i;
1025
1026 (*ppname_array) = NULL;
1027
1028 if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0')))
1029 return;
1030
1031 namelist = talloc_strdup(talloc_tos(), namelist_in);
1032 if (namelist == NULL) {
1033 DEBUG(0,("set_namearray: talloc fail\n"));
1034 return;
1035 }
1036 nameptr = namelist;
1037
1038 /* We need to make two passes over the string. The
1039 first to count the number of elements, the second
1040 to split it.
1041 */
1042
1043 while(*nameptr) {
1044 if ( *nameptr == '/' ) {
1045 /* cope with multiple (useless) /s) */
1046 nameptr++;
1047 continue;
1048 }
1049 /* anything left? */
1050 if ( *nameptr == '\0' )
1051 break;
1052
1053 /* find the next '/' or consume remaining */
1054 name_end = strchr_m(nameptr, '/');
1055 if (name_end == NULL)
1056 name_end = (char *)nameptr + strlen(nameptr);
1057
1058 /* next segment please */
1059 nameptr = name_end + 1;
1060 num_entries++;
1061 }
1062
1063 if(num_entries == 0) {
1064 talloc_free(namelist);
1065 return;
1066 }
1067
1068 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1069 DEBUG(0,("set_namearray: malloc fail\n"));
1070 talloc_free(namelist);
1071 return;
1072 }
1073
1074 /* Now copy out the names */
1075 nameptr = namelist;
1076 i = 0;
1077 while(*nameptr) {
1078 if ( *nameptr == '/' ) {
1079 /* cope with multiple (useless) /s) */
1080 nameptr++;
1081 continue;
1082 }
1083 /* anything left? */
1084 if ( *nameptr == '\0' )
1085 break;
1086
1087 /* find the next '/' or consume remaining */
1088 name_end = strchr_m(nameptr, '/');
1089 if (name_end)
1090 *name_end = '\0';
1091 else
1092 name_end = nameptr + strlen(nameptr);
1093
1094 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1095 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1096 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1097 talloc_free(namelist);
1098 return;
1099 }
1100
1101 /* next segment please */
1102 nameptr = name_end + 1;
1103 i++;
1104 }
1105
1106 (*ppname_array)[i].name = NULL;
1107
1108 talloc_free(namelist);
1109 return;
1110 }
1111
1112 #undef DBGC_CLASS
1113 #define DBGC_CLASS DBGC_LOCKING
1114
1115 /****************************************************************************
1116 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1117 is dealt with in posix.c
1118 Returns True if we have information regarding this lock region (and returns
1119 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1120 ****************************************************************************/
1121
1122 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1123 {
1124 SMB_STRUCT_FLOCK lock;
1125 int ret;
1126
1127 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1128 fd,(double)*poffset,(double)*pcount,*ptype));
1129
1130 lock.l_type = *ptype;
1131 lock.l_whence = SEEK_SET;
1132 lock.l_start = *poffset;
1133 lock.l_len = *pcount;
1134 lock.l_pid = 0;
1135
1136 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1137
1138 if (ret == -1) {
1139 int sav = errno;
1140 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1141 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1142 errno = sav;
1143 return False;
1144 }
1145
1146 *ptype = lock.l_type;
1147 *poffset = lock.l_start;
1148 *pcount = lock.l_len;
1149 *ppid = lock.l_pid;
1150
1151 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1152 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1153 return True;
1154 }
1155
1156 #undef DBGC_CLASS
1157 #define DBGC_CLASS DBGC_ALL
1158
1159 /*******************************************************************
1160 Is the name specified one of my netbios names.
1161 Returns true if it is equal, false otherwise.
1162 ********************************************************************/
1163
1164 bool is_myname(const char *s)
1165 {
1166 int n;
1167 bool ret = False;
1168
1169 for (n=0; my_netbios_names(n); n++) {
1170 if (strequal(my_netbios_names(n), s)) {
1171 ret=True;
1172 break;
1173 }
1174 }
1175 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1176 return(ret);
1177 }
1178
1179 /*******************************************************************
1180 Is the name specified our workgroup/domain.
1181 Returns true if it is equal, false otherwise.
1182 ********************************************************************/
1183
1184 bool is_myworkgroup(const char *s)
1185 {
1186 bool ret = False;
1187
1188 if (strequal(s, lp_workgroup())) {
1189 ret=True;
1190 }
1191
1192 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1193 return(ret);
1194 }
1195
1196 /*******************************************************************
1197 we distinguish between 2K and XP by the "Native Lan Manager" string
1198 WinXP => "Windows 2002 5.1"
1199 WinXP 64bit => "Windows XP 5.2"
1200 Win2k => "Windows 2000 5.0"
1201 NT4 => "Windows NT 4.0"
1202 Win9x => "Windows 4.0"
1203 Windows 2003 doesn't set the native lan manager string but
1204 they do set the domain to "Windows 2003 5.2" (probably a bug).
1205 ********************************************************************/
1206
1207 void ra_lanman_string( const char *native_lanman )
1208 {
1209 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1210 set_remote_arch( RA_WINXP );
1211 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1212 set_remote_arch( RA_WINXP64 );
1213 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1214 set_remote_arch( RA_WIN2K3 );
1215 }
1216
1217 static const char *remote_arch_str;
1218
1219 const char *get_remote_arch_str(void)
1220 {
1221 if (!remote_arch_str) {
1222 return "UNKNOWN";
1223 }
1224 return remote_arch_str;
1225 }
1226
1227 /*******************************************************************
1228 Set the horrid remote_arch string based on an enum.
1229 ********************************************************************/
1230
1231 void set_remote_arch(enum remote_arch_types type)
1232 {
1233 ra_type = type;
1234 switch( type ) {
1235 case RA_WFWG:
1236 remote_arch_str = "WfWg";
1237 break;
1238 case RA_OS2:
1239 remote_arch_str = "OS2";
1240 break;
1241 case RA_WIN95:
1242 remote_arch_str = "Win95";
1243 break;
1244 case RA_WINNT:
1245 remote_arch_str = "WinNT";
1246 break;
1247 case RA_WIN2K:
1248 remote_arch_str = "Win2K";
1249 break;
1250 case RA_WINXP:
1251 remote_arch_str = "WinXP";
1252 break;
1253 case RA_WINXP64:
1254 remote_arch_str = "WinXP64";
1255 break;
1256 case RA_WIN2K3:
1257 remote_arch_str = "Win2K3";
1258 break;
1259 case RA_VISTA:
1260 remote_arch_str = "Vista";
1261 break;
1262 case RA_SAMBA:
1263 remote_arch_str = "Samba";
1264 break;
1265 case RA_CIFSFS:
1266 remote_arch_str = "CIFSFS";
1267 break;
1268 case RA_OSX:
1269 remote_arch_str = "OSX";
1270 break;
1271 default:
1272 ra_type = RA_UNKNOWN;
1273 remote_arch_str = "UNKNOWN";
1274 break;
1275 }
1276
1277 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1278 remote_arch_str));
1279 }
1280
1281 /*******************************************************************
1282 Get the remote_arch type.
1283 ********************************************************************/
1284
1285 enum remote_arch_types get_remote_arch(void)
1286 {
1287 return ra_type;
1288 }
1289
1290 const char *tab_depth(int level, int depth)
1291 {
1292 if( CHECK_DEBUGLVL(level) ) {
1293 dbgtext("%*s", depth*4, "");
1294 }
1295 return "";
1296 }
1297
1298 /*****************************************************************************
1299 Provide a checksum on a string
1300
1301 Input: s - the null-terminated character string for which the checksum
1302 will be calculated.
1303
1304 Output: The checksum value calculated for s.
1305 *****************************************************************************/
1306
1307 int str_checksum(const char *s)
1308 {
1309 TDB_DATA key = string_tdb_data(s);
1310 return tdb_jenkins_hash(&key);
1311 }
1312
1313 /*****************************************************************
1314 Zero a memory area then free it. Used to catch bugs faster.
1315 *****************************************************************/
1316
1317 void zero_free(void *p, size_t size)
1318 {
1319 memset(p, 0, size);
1320 SAFE_FREE(p);
1321 }
1322
1323 /*****************************************************************
1324 Set our open file limit to a requested max and return the limit.
1325 *****************************************************************/
1326
1327 int set_maxfiles(int requested_max)
1328 {
1329 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1330 struct rlimit rlp;
1331 int saved_current_limit;
1332
1333 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1334 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1335 strerror(errno) ));
1336 /* just guess... */
1337 return requested_max;
1338 }
1339
1340 /*
1341 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1342 * account for the extra fd we need
1343 * as well as the log files and standard
1344 * handles etc. Save the limit we want to set in case
1345 * we are running on an OS that doesn't support this limit (AIX)
1346 * which always returns RLIM_INFINITY for rlp.rlim_max.
1347 */
1348
1349 /* Try raising the hard (max) limit to the requested amount. */
1350
1351 #if defined(RLIM_INFINITY)
1352 if (rlp.rlim_max != RLIM_INFINITY) {
1353 int orig_max = rlp.rlim_max;
1354
1355 if ( rlp.rlim_max < requested_max )
1356 rlp.rlim_max = requested_max;
1357
1358 /* This failing is not an error - many systems (Linux) don't
1359 support our default request of 10,000 open files. JRA. */
1360
1361 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1362 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
1363 (int)rlp.rlim_max, strerror(errno) ));
1364
1365 /* Set failed - restore original value from get. */
1366 rlp.rlim_max = orig_max;
1367 }
1368 }
1369 #endif
1370
1371 /* Now try setting the soft (current) limit. */
1372
1373 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1374
1375 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1376 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
1377 (int)rlp.rlim_cur, strerror(errno) ));
1378 /* just guess... */
1379 return saved_current_limit;
1380 }
1381
1382 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1383 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1384 strerror(errno) ));
1385 /* just guess... */
1386 return saved_current_limit;
1387 }
1388
1389 #if defined(RLIM_INFINITY)
1390 if(rlp.rlim_cur == RLIM_INFINITY)
1391 return saved_current_limit;
1392 #endif
1393
1394 if((int)rlp.rlim_cur > saved_current_limit)
1395 return saved_current_limit;
1396
1397 return rlp.rlim_cur;
1398 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1399 /*
1400 * No way to know - just guess...
1401 */
1402 return requested_max;
1403 #endif
1404 }
1405
1406 /*****************************************************************
1407 malloc that aborts with smb_panic on fail or zero size.
1408 *****************************************************************/
1409
1410 void *smb_xmalloc_array(size_t size, unsigned int count)
1411 {
1412 void *p;
1413 if (size == 0) {
1414 smb_panic("smb_xmalloc_array: called with zero size");
1415 }
1416 if (count >= MAX_ALLOC_SIZE/size) {
1417 smb_panic("smb_xmalloc_array: alloc size too large");
1418 }
1419 if ((p = SMB_MALLOC(size*count)) == NULL) {
1420 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
1421 (unsigned long)size, (unsigned long)count));
1422 smb_panic("smb_xmalloc_array: malloc failed");
1423 }
1424 return p;
1425 }
1426
1427 /*
1428 vasprintf that aborts on malloc fail
1429 */
1430
1431 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
1432 {
1433 int n;
1434 va_list ap2;
1435
1436 va_copy(ap2, ap);
1437
1438 n = vasprintf(ptr, format, ap2);
1439 va_end(ap2);
1440 if (n == -1 || ! *ptr) {
1441 smb_panic("smb_xvasprintf: out of memory");
1442 }
1443 return n;
1444 }
1445
1446 /*****************************************************************
1447 Get local hostname and cache result.
1448 *****************************************************************/
1449
1450 char *myhostname(void)
1451 {
1452 static char *ret;
1453 if (ret == NULL) {
1454 ret = get_myname(NULL);
1455 }
1456 return ret;
1457 }
1458
1459 /**
1460 * @brief Returns an absolute path to a file concatenating the provided
1461 * @a rootpath and @a basename
1462 *
1463 * @param name Filename, relative to @a rootpath
1464 *
1465 * @retval Pointer to a string containing the full path.
1466 **/
1467
1468 static char *xx_path(const char *name, const char *rootpath)
1469 {
1470 char *fname = NULL;
1471
1472 fname = talloc_strdup(talloc_tos(), rootpath);
1473 if (!fname) {
1474 return NULL;
1475 }
1476 trim_string(fname,"","/");
1477
1478 if (!directory_exist(fname)) {
1479 if (!mkdir(fname,0755))
1480 DEBUG(1, ("Unable to create directory %s for file %s. "
1481 "Error was %s\n", fname, name, strerror(errno)));
1482 }
1483
1484 return talloc_asprintf(talloc_tos(),
1485 "%s/%s",
1486 fname,
1487 name);
1488 }
1489
1490 /**
1491 * @brief Returns an absolute path to a file in the Samba lock directory.
1492 *
1493 * @param name File to find, relative to LOCKDIR.
1494 *
1495 * @retval Pointer to a talloc'ed string containing the full path.
1496 **/
1497
1498 char *lock_path(const char *name)
1499 {
1500 return xx_path(name, lp_lockdir());
1501 }
1502
1503 /**
1504 * @brief Returns an absolute path to a file in the Samba pid directory.
1505 *
1506 * @param name File to find, relative to PIDDIR.
1507 *
1508 * @retval Pointer to a talloc'ed string containing the full path.
1509 **/
1510
1511 char *pid_path(const char *name)
1512 {
1513 return xx_path(name, lp_piddir());
1514 }
1515
1516 /**
1517 * @brief Returns an absolute path to a file in the Samba lib directory.
1518 *
1519 * @param name File to find, relative to LIBDIR.
1520 *
1521 * @retval Pointer to a string containing the full path.
1522 **/
1523
1524 char *lib_path(const char *name)
1525 {
1526 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
1527 }
1528
1529 /**
1530 * @brief Returns an absolute path to a file in the Samba modules directory.
1531 *
1532 * @param name File to find, relative to MODULESDIR.
1533 *
1534 * @retval Pointer to a string containing the full path.
1535 **/
1536
1537 char *modules_path(const char *name)
1538 {
1539 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
1540 }
1541
1542 /**
1543 * @brief Returns an absolute path to a file in the Samba data directory.
1544 *
1545 * @param name File to find, relative to CODEPAGEDIR.
1546 *
1547 * @retval Pointer to a talloc'ed string containing the full path.
1548 **/
1549
1550 char *data_path(const char *name)
1551 {
1552 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
1553 }
1554
1555 /**
1556 * @brief Returns an absolute path to a file in the Samba state directory.
1557 *
1558 * @param name File to find, relative to STATEDIR.
1559 *
1560 * @retval Pointer to a talloc'ed string containing the full path.
1561 **/
1562
1563 char *state_path(const char *name)
1564 {
1565 return xx_path(name, lp_statedir());
1566 }
1567
1568 /**
1569 * @brief Returns an absolute path to a file in the Samba cache directory.
1570 *
1571 * @param name File to find, relative to CACHEDIR.
1572 *
1573 * @retval Pointer to a talloc'ed string containing the full path.
1574 **/
1575
1576 char *cache_path(const char *name)
1577 {
1578 return xx_path(name, lp_cachedir());
1579 }
1580
1581 /**
1582 * @brief Returns the platform specific shared library extension.
1583 *
1584 * @retval Pointer to a const char * containing the extension.
1585 **/
1586
1587 const char *shlib_ext(void)
1588 {
1589 return get_dyn_SHLIBEXT();
1590 }
1591
1592 /*******************************************************************
1593 Given a filename - get its directory name
1594 ********************************************************************/
1595
1596 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
1597 const char **name)
1598 {
1599 char *p;
1600 ptrdiff_t len;
1601
1602 p = strrchr_m(dir, '/'); /* Find final '/', if any */
1603
1604 if (p == NULL) {
1605 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
1606 return False;
1607 }
1608 if (name) {
1609 *name = dir;
1610 }
1611 return True;
1612 }
1613
1614 len = p-dir;
1615
1616 if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
1617 return False;
1618 }
1619 (*parent)[len] = '\0';
1620
1621 if (name) {
1622 *name = p+1;
1623 }
1624 return True;
1625 }
1626
1627 /*******************************************************************
1628 Determine if a pattern contains any Microsoft wildcard characters.
1629 *******************************************************************/
1630
1631 bool ms_has_wild(const char *s)
1632 {
1633 char c;
1634
1635 if (lp_posix_pathnames()) {
1636 /* With posix pathnames no characters are wild. */
1637 return False;
1638 }
1639
1640 while ((c = *s++)) {
1641 switch (c) {
1642 case '*':
1643 case '?':
1644 case '<':
1645 case '>':
1646 case '"':
1647 return True;
1648 }
1649 }
1650 return False;
1651 }
1652
1653 bool ms_has_wild_w(const smb_ucs2_t *s)
1654 {
1655 smb_ucs2_t c;
1656 if (!s) return False;
1657 while ((c = *s++)) {
1658 switch (c) {
1659 case UCS2_CHAR('*'):
1660 case UCS2_CHAR('?'):
1661 case UCS2_CHAR('<'):
1662 case UCS2_CHAR('>'):
1663 case UCS2_CHAR('"'):
1664 return True;
1665 }
1666 }
1667 return False;
1668 }
1669
1670 /*******************************************************************
1671 A wrapper that handles case sensitivity and the special handling
1672 of the ".." name.
1673 *******************************************************************/
1674
1675 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
1676 {
1677 if (ISDOTDOT(string))
1678 string = ".";
1679 if (ISDOT(pattern))
1680 return False;
1681
1682 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
1683 }
1684
1685 /*******************************************************************
1686 A wrapper that handles case sensitivity and the special handling
1687 of the ".." name. Varient that is only called by old search code which requires
1688 pattern translation.
1689 *******************************************************************/
1690
1691 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
1692 {
1693 if (ISDOTDOT(string))
1694 string = ".";
1695 if (ISDOT(pattern))
1696 return False;
1697
1698 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
1699 }
1700
1701 /*******************************************************************
1702 A wrapper that handles a list of patters and calls mask_match()
1703 on each. Returns True if any of the patterns match.
1704 *******************************************************************/
1705
1706 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
1707 {
1708 while (listLen-- > 0) {
1709 if (mask_match(string, *list++, is_case_sensitive))
1710 return True;
1711 }
1712 return False;
1713 }
1714
1715 /*********************************************************
1716 Recursive routine that is called by unix_wild_match.
1717 *********************************************************/
1718
1719 static bool unix_do_match(const char *regexp, const char *str)
1720 {
1721 const char *p;
1722
1723 for( p = regexp; *p && *str; ) {
1724
1725 switch(*p) {
1726 case '?':
1727 str++;
1728 p++;
1729 break;
1730
1731 case '*':
1732
1733 /*
1734 * Look for a character matching
1735 * the one after the '*'.
1736 */
1737 p++;
1738 if(!*p)
1739 return true; /* Automatic match */
1740 while(*str) {
1741
1742 while(*str && (*p != *str))
1743 str++;
1744
1745 /*
1746 * Patch from weidel@multichart.de. In the case of the regexp
1747 * '*XX*' we want to ensure there are at least 2 'X' characters
1748 * in the string after the '*' for a match to be made.
1749 */
1750
1751 {
1752 int matchcount=0;
1753
1754 /*
1755 * Eat all the characters that match, but count how many there were.
1756 */
1757
1758 while(*str && (*p == *str)) {
1759 str++;
1760 matchcount++;
1761 }
1762
1763 /*
1764 * Now check that if the regexp had n identical characters that
1765 * matchcount had at least that many matches.
1766 */
1767
1768 while ( *(p+1) && (*(p+1) == *p)) {
1769 p++;
1770 matchcount--;
1771 }
1772
1773 if ( matchcount <= 0 )
1774 return false;
1775 }
1776
1777 str--; /* We've eaten the match char after the '*' */
1778
1779 if(unix_do_match(p, str))
1780 return true;
1781
1782 if(!*str)
1783 return false;
1784 else
1785 str++;
1786 }
1787 return false;
1788
1789 default:
1790 if(*str != *p)
1791 return false;
1792 str++;
1793 p++;
1794 break;
1795 }
1796 }
1797
1798 if(!*p && !*str)
1799 return true;
1800
1801 if (!*p && str[0] == '.' && str[1] == 0)
1802 return true;
1803
1804 if (!*str && *p == '?') {
1805 while (*p == '?')
1806 p++;
1807 return(!*p);
1808 }
1809
1810 if(!*str && (*p == '*' && p[1] == '\0'))
1811 return true;
1812
1813 return false;
1814 }
1815
1816 /*******************************************************************
1817 Simple case insensitive interface to a UNIX wildcard matcher.
1818 Returns True if match, False if not.
1819 *******************************************************************/
1820
1821 bool unix_wild_match(const char *pattern, const char *string)
1822 {
1823 TALLOC_CTX *ctx = talloc_stackframe();
1824 char *p2;
1825 char *s2;
1826 char *p;
1827 bool ret = false;
1828
1829 p2 = talloc_strdup(ctx,pattern);
1830 s2 = talloc_strdup(ctx,string);
1831 if (!p2 || !s2) {
1832 TALLOC_FREE(ctx);
1833 return false;
1834 }
1835 strlower_m(p2);
1836 strlower_m(s2);
1837
1838 /* Remove any *? and ** from the pattern as they are meaningless */
1839 for(p = p2; *p; p++) {
1840 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
1841 memmove(&p[1], &p[2], strlen(&p[2])+1);
1842 }
1843 }
1844
1845 if (strequal(p2,"*")) {
1846 TALLOC_FREE(ctx);
1847 return true;
1848 }
1849
1850 ret = unix_do_match(p2, s2);
1851 TALLOC_FREE(ctx);
1852 return ret;
1853 }
1854
1855 /**********************************************************************
1856 Converts a name to a fully qualified domain name.
1857 Returns true if lookup succeeded, false if not (then fqdn is set to name)
1858 Note we deliberately use gethostbyname here, not getaddrinfo as we want
1859 to examine the h_aliases and I don't know how to do that with getaddrinfo.
1860 ***********************************************************************/
1861
1862 bool name_to_fqdn(fstring fqdn, const char *name)
1863 {
1864 char *full = NULL;
1865 struct hostent *hp = gethostbyname(name);
1866
1867 if (!hp || !hp->h_name || !*hp->h_name) {
1868 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
1869 fstrcpy(fqdn, name);
1870 return false;
1871 }
1872
1873 /* Find out if the fqdn is returned as an alias
1874 * to cope with /etc/hosts files where the first
1875 * name is not the fqdn but the short name */
1876 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
1877 int i;
1878 for (i = 0; hp->h_aliases[i]; i++) {
1879 if (strchr_m(hp->h_aliases[i], '.')) {
1880 full = hp->h_aliases[i];
1881 break;
1882 }
1883 }
1884 }
1885 if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
1886 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1887 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
1888 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
1889 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
1890 full = hp->h_name;
1891 }
1892 if (!full) {
1893 full = hp->h_name;
1894 }
1895
1896 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
1897 fstrcpy(fqdn, full);
1898 return true;
1899 }
1900
1901 /**********************************************************************
1902 Append a DATA_BLOB to a talloc'ed object
1903 ***********************************************************************/
1904
1905 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
1906 {
1907 size_t old_size = 0;
1908 char *result;
1909
1910 if (blob.length == 0) {
1911 return buf;
1912 }
1913
1914 if (buf != NULL) {
1915 old_size = talloc_get_size(buf);
1916 }
1917
1918 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
1919 if (result == NULL) {
1920 return NULL;
1921 }
1922
1923 memcpy(result + old_size, blob.data, blob.length);
1924 return result;
1925 }
1926
1927 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
1928 {
1929 switch (share_access & ~FILE_SHARE_DELETE) {
1930 case FILE_SHARE_NONE:
1931 return DENY_ALL;
1932 case FILE_SHARE_READ:
1933 return DENY_WRITE;
1934 case FILE_SHARE_WRITE:
1935 return DENY_READ;
1936 case FILE_SHARE_READ|FILE_SHARE_WRITE:
1937 return DENY_NONE;
1938 }
1939 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
1940 return DENY_DOS;
1941 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
1942 return DENY_FCB;
1943 }
1944
1945 return (uint32)-1;
1946 }
1947
1948 pid_t procid_to_pid(const struct server_id *proc)
1949 {
1950 return proc->pid;
1951 }
1952
1953 static uint32 my_vnn = NONCLUSTER_VNN;
1954
1955 void set_my_vnn(uint32 vnn)
1956 {
1957 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
1958 my_vnn = vnn;
1959 }
1960
1961 uint32 get_my_vnn(void)
1962 {
1963 return my_vnn;
1964 }
1965
1966 static uint64_t my_unique_id = 0;
1967
1968 void set_my_unique_id(uint64_t unique_id)
1969 {
1970 my_unique_id = unique_id;
1971 }
1972
1973 struct server_id pid_to_procid(pid_t pid)
1974 {
1975 struct server_id result;
1976 result.pid = pid;
1977 result.unique_id = my_unique_id;
1978 result.vnn = my_vnn;
1979 return result;
1980 }
1981
1982 struct server_id procid_self(void)
1983 {
1984 return pid_to_procid(sys_getpid());
1985 }
1986
1987 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
1988 {
1989 if (p1->pid != p2->pid)
1990 return False;
1991 if (p1->vnn != p2->vnn)
1992 return False;
1993 return True;
1994 }
1995
1996 bool cluster_id_equal(const struct server_id *id1,
1997 const struct server_id *id2)
1998 {
1999 return procid_equal(id1, id2);
2000 }
2001
2002 bool procid_is_me(const struct server_id *pid)
2003 {
2004 if (pid->pid != sys_getpid())
2005 return False;
2006 if (pid->vnn != my_vnn)
2007 return False;
2008 return True;
2009 }
2010
2011 struct server_id interpret_pid(const char *pid_string)
2012 {
2013 struct server_id result;
2014 int pid;
2015 unsigned int vnn;
2016 if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2017 result.vnn = vnn;
2018 result.pid = pid;
2019 }
2020 else if (sscanf(pid_string, "%d", &pid) == 1) {
2021 result.vnn = get_my_vnn();
2022 result.pid = pid;
2023 }
2024 else {
2025 result.vnn = NONCLUSTER_VNN;
2026 result.pid = -1;
2027 }
2028 /* Assigning to result.pid may have overflowed
2029 Map negative pid to -1: i.e. error */
2030 if (result.pid < 0) {
2031 result.pid = -1;
2032 }
2033 result.unique_id = 0;
2034 return result;
2035 }
2036
2037 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2038 {
2039 if (pid->vnn == NONCLUSTER_VNN) {
2040 return talloc_asprintf(mem_ctx,
2041 "%d",
2042 (int)pid->pid);
2043 }
2044 else {
2045 return talloc_asprintf(mem_ctx,
2046 "%u:%d",
2047 (unsigned)pid->vnn,
2048 (int)pid->pid);
2049 }
2050 }
2051
2052 char *procid_str_static(const struct server_id *pid)
2053 {
2054 return procid_str(talloc_tos(), pid);
2055 }
2056
2057 bool procid_valid(const struct server_id *pid)
2058 {
2059 return (pid->pid != -1);
2060 }
2061
2062 bool procid_is_local(const struct server_id *pid)
2063 {
2064 return pid->vnn == my_vnn;
2065 }
2066
2067 /****************************************************************
2068 Check if offset/length fit into bufsize. Should probably be
2069 merged with is_offset_safe, but this would require a rewrite
2070 of lanman.c. Later :-)
2071 ****************************************************************/
2072
2073 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2074 {
2075 if ((offset + length < offset) || (offset + length < length)) {
2076 /* wrap */
2077 return true;
2078 }
2079 if ((offset > bufsize) || (offset + length > bufsize)) {
2080 /* overflow */
2081 return true;
2082 }
2083 return false;
2084 }
2085
2086 /****************************************************************
2087 Check if an offset into a buffer is safe.
2088 If this returns True it's safe to indirect into the byte at
2089 pointer ptr+off.
2090 ****************************************************************/
2091
2092 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2093 {
2094 const char *end_base = buf_base + buf_len;
2095 char *end_ptr = ptr + off;
2096
2097 if (!buf_base || !ptr) {
2098 return False;
2099 }
2100
2101 if (end_base < buf_base || end_ptr < ptr) {
2102 return False; /* wrap. */
2103 }
2104
2105 if (end_ptr < end_base) {
2106 return True;
2107 }
2108 return False;
2109 }
2110
2111 /****************************************************************
2112 Return a safe pointer into a buffer, or NULL.
2113 ****************************************************************/
2114
2115 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2116 {
2117 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2118 ptr + off : NULL;
2119 }
2120
2121 /****************************************************************
2122 Return a safe pointer into a string within a buffer, or NULL.
2123 ****************************************************************/
2124
2125 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2126 {
2127 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2128 return NULL;
2129 }
2130 /* Check if a valid string exists at this offset. */
2131 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2132 return NULL;
2133 }
2134 return ptr + off;
2135 }
2136
2137 /****************************************************************
2138 Return an SVAL at a pointer, or failval if beyond the end.
2139 ****************************************************************/
2140
2141 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2142 {
2143 /*
2144 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2145 * NOT ptr[2].
2146 */
2147 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2148 return failval;
2149 }
2150 return SVAL(ptr,off);
2151 }
2152
2153 /****************************************************************
2154 Return an IVAL at a pointer, or failval if beyond the end.
2155 ****************************************************************/
2156
2157 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2158 {
2159 /*
2160 * Note we use off+3 here, not off+4 as IVAL accesses
2161 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2162 */
2163 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2164 return failval;
2165 }
2166 return IVAL(ptr,off);
2167 }
2168
2169 /****************************************************************
2170 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2171 call (they take care of winbind separator and other winbind specific settings).
2172 ****************************************************************/
2173
2174 void split_domain_user(TALLOC_CTX *mem_ctx,
2175 const char *full_name,
2176 char **domain,
2177 char **user)
2178 {
2179 const char *p = NULL;
2180
2181 p = strchr_m(full_name, '\\');
2182
2183 if (p != NULL) {
2184 *domain = talloc_strndup(mem_ctx, full_name,
2185 PTR_DIFF(p, full_name));
2186 *user = talloc_strdup(mem_ctx, p+1);
2187 } else {
2188 *domain = talloc_strdup(mem_ctx, "");
2189 *user = talloc_strdup(mem_ctx, full_name);
2190 }
2191 }
2192
2193 #if 0
2194
2195 Disable these now we have checked all code paths and ensured
2196 NULL returns on zero request. JRA.
2197
2198 /****************************************************************
2199 talloc wrapper functions that guarentee a null pointer return
2200 if size == 0.
2201 ****************************************************************/
2202
2203 #ifndef MAX_TALLOC_SIZE
2204 #define MAX_TALLOC_SIZE 0x10000000
2205 #endif
2206
2207 /*
2208 * talloc and zero memory.
2209 * - returns NULL if size is zero.
2210 */
2211
2212 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2213 {
2214 void *p;
2215
2216 if (size == 0) {
2217 return NULL;
2218 }
2219
2220 p = talloc_named_const(ctx, size, name);
2221
2222 if (p) {
2223 memset(p, '\0', size);
2224 }
2225
2226 return p;
2227 }
2228
2229 /*
2230 * memdup with a talloc.
2231 * - returns NULL if size is zero.
2232 */
2233
2234 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2235 {
2236 void *newp;
2237
2238 if (size == 0) {
2239 return NULL;
2240 }
2241
2242 newp = talloc_named_const(t, size, name);
2243 if (newp) {
2244 memcpy(newp, p, size);
2245 }
2246
2247 return newp;
2248 }
2249
2250 /*
2251 * alloc an array, checking for integer overflow in the array size.
2252 * - returns NULL if count or el_size are zero.
2253 */
2254
2255 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2256 {
2257 if (count >= MAX_TALLOC_SIZE/el_size) {
2258 return NULL;
2259 }
2260
2261 if (el_size == 0 || count == 0) {
2262 return NULL;
2263 }
2264
2265 return talloc_named_const(ctx, el_size * count, name);
2266 }
2267
2268 /*
2269 * alloc an zero array, checking for integer overflow in the array size
2270 * - returns NULL if count or el_size are zero.
2271 */
2272
2273 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2274 {
2275 if (count >= MAX_TALLOC_SIZE/el_size) {
2276 return NULL;
2277 }
2278
2279 if (el_size == 0 || count == 0) {
2280 return NULL;
2281 }
2282
2283 return _talloc_zero(ctx, el_size * count, name);
2284 }
2285
2286 /*
2287 * Talloc wrapper that returns NULL if size == 0.
2288 */
2289 void *talloc_zeronull(const void *context, size_t size, const char *name)
2290 {
2291 if (size == 0) {
2292 return NULL;
2293 }
2294 return talloc_named_const(context, size, name);
2295 }
2296 #endif
2297
2298 /****************************************************************
2299 strip off leading '\\' from a hostname
2300 ****************************************************************/
2301
2302 const char *strip_hostname(const char *s)
2303 {
2304 if (!s) {
2305 return NULL;
2306 }
2307
2308 if (strlen_m(s) < 3) {
2309 return s;
2310 }
2311
2312 if (s[0] == '\\') s++;
2313 if (s[0] == '\\') s++;
2314
2315 return s;
2316 }
2317
2318 bool tevent_req_poll_ntstatus(struct tevent_req *req,
2319 struct tevent_context *ev,
2320 NTSTATUS *status)
2321 {
2322 bool ret = tevent_req_poll(req, ev);
2323 if (!ret) {
2324 *status = map_nt_error_from_unix(errno);
2325 }
2326 return ret;
2327 }
2328
2329 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2330 {
2331 if (!NT_STATUS_IS_OK(err1)) {
2332 *result = err1;
2333 return true;
2334 }
2335 if (!NT_STATUS_IS_OK(err2)) {
2336 *result = err2;
2337 return true;
2338 }
2339 return false;
2340 }
2341
2342 int timeval_to_msec(struct timeval t)
2343 {
2344 return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2345 }
2346
2347 /*******************************************************************
2348 Check a given DOS pathname is valid for a share.
2349 ********************************************************************/
2350
2351 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
2352 {
2353 char *ptr = NULL;
2354
2355 if (!dos_pathname) {
2356 return NULL;
2357 }
2358
2359 ptr = talloc_strdup(ctx, dos_pathname);
2360 if (!ptr) {
2361 return NULL;
2362 }
2363 /* Convert any '\' paths to '/' */
2364 unix_format(ptr);
2365 ptr = unix_clean_name(ctx, ptr);
2366 if (!ptr) {
2367 return NULL;
2368 }
2369
2370 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
2371 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
2372 ptr += 2;
2373
2374 /* Only absolute paths allowed. */
2375 if (*ptr != '/')
2376 return NULL;
2377
2378 return ptr;
2379 }
Samba GIT mirror