?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gssapi: check for gss_acquire_cred_from
[Samba.git] / source3 / lib / util.c
blobd525be6d6bba454065d82626797505e9df31a631
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 "lib/util/server_id.h"
28 #include "util_tdb.h"
29 #include "ctdbd_conn.h"
30 #include "../lib/util/util_pw.h"
31 #include "messages.h"
32 #include "messages_dgm.h"
33 #include "libcli/security/security.h"
34 #include "serverid.h"
35 #include "lib/util/sys_rw.h"
36 #include "lib/util/sys_rw_data.h"
37 #include "lib/util/util_process.h"
38
39 #ifdef HAVE_SYS_PRCTL_H
40 #include <sys/prctl.h>
41 #endif
42
43 /* Max allowable allococation - 256mb - 0x10000000 */
44 #define MAX_ALLOC_SIZE (1024*1024*256)
45
46 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
47 #ifdef WITH_NISPLUS_HOME
48 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
49 /*
50 * The following lines are needed due to buggy include files
51 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
52 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
53 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
54 * an enum in /usr/include/rpcsvc/nis.h.
55 */
56
57 #if defined(GROUP)
58 #undef GROUP
59 #endif
60
61 #if defined(GROUP_OBJ)
62 #undef GROUP_OBJ
63 #endif
64
65 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
66
67 #include <rpcsvc/nis.h>
68
69 #endif /* WITH_NISPLUS_HOME */
70 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
71
72 static enum protocol_types Protocol = PROTOCOL_COREPLUS;
73
74 enum protocol_types get_Protocol(void)
75 {
76 return Protocol;
77 }
78
79 void set_Protocol(enum protocol_types p)
80 {
81 Protocol = p;
82 }
83
84 static enum remote_arch_types ra_type = RA_UNKNOWN;
85
86 void gfree_all( void )
87 {
88 gfree_names();
89 gfree_loadparm();
90 gfree_charcnv();
91 gfree_interfaces();
92 gfree_debugsyms();
93 }
94
95 /*******************************************************************
96 Check if a file exists - call vfs_file_exist for samba files.
97 ********************************************************************/
98
99 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
100 bool fake_dir_create_times)
101 {
102 SMB_STRUCT_STAT st;
103 if (!sbuf)
104 sbuf = &st;
105
106 if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
107 return(False);
108
109 return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
110 }
111
112 /*******************************************************************
113 Check if a unix domain socket exists - call vfs_file_exist for samba files.
114 ********************************************************************/
115
116 bool socket_exist(const char *fname)
117 {
118 SMB_STRUCT_STAT st;
119 if (sys_stat(fname, &st, false) != 0)
120 return(False);
121
122 return S_ISSOCK(st.st_ex_mode);
123 }
124
125 /*******************************************************************
126 Returns the size in bytes of the named given the stat struct.
127 ********************************************************************/
128
129 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
130 {
131 return sbuf->st_ex_size;
132 }
133
134 /****************************************************************************
135 Check two stats have identical dev and ino fields.
136 ****************************************************************************/
137
138 bool check_same_dev_ino(const SMB_STRUCT_STAT *sbuf1,
139 const SMB_STRUCT_STAT *sbuf2)
140 {
141 if (sbuf1->st_ex_dev != sbuf2->st_ex_dev ||
142 sbuf1->st_ex_ino != sbuf2->st_ex_ino) {
143 return false;
144 }
145 return true;
146 }
147
148 /****************************************************************************
149 Check if a stat struct is identical for use.
150 ****************************************************************************/
151
152 bool check_same_stat(const SMB_STRUCT_STAT *sbuf1,
153 const SMB_STRUCT_STAT *sbuf2)
154 {
155 if (sbuf1->st_ex_uid != sbuf2->st_ex_uid ||
156 sbuf1->st_ex_gid != sbuf2->st_ex_gid ||
157 !check_same_dev_ino(sbuf1, sbuf2)) {
158 return false;
159 }
160 return true;
161 }
162
163 /*******************************************************************
164 Show a smb message structure.
165 ********************************************************************/
166
167 void show_msg(const char *buf)
168 {
169 int i;
170 int bcc=0;
171
172 if (!DEBUGLVL(5))
173 return;
174
175 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
176 smb_len(buf),
177 (int)CVAL(buf,smb_com),
178 (int)CVAL(buf,smb_rcls),
179 (int)CVAL(buf,smb_reh),
180 (int)SVAL(buf,smb_err),
181 (int)CVAL(buf,smb_flg),
182 (int)SVAL(buf,smb_flg2)));
183 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
184 (int)SVAL(buf,smb_tid),
185 (int)SVAL(buf,smb_pid),
186 (int)SVAL(buf,smb_uid),
187 (int)SVAL(buf,smb_mid)));
188 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
189
190 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
191 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
192 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
193
194 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
195
196 DEBUGADD(5,("smb_bcc=%d\n",bcc));
197
198 if (DEBUGLEVEL < 10)
199 return;
200
201 if (DEBUGLEVEL < 50)
202 bcc = MIN(bcc, 512);
203
204 dump_data(10, (const uint8_t *)smb_buf_const(buf), bcc);
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_t **outbuf, DATA_BLOB blob)
225 {
226 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
227 uint8_t *tmp;
228
229 if (!(tmp = talloc_realloc(NULL, *outbuf, uint8_t, 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, off_t pos)
358 {
359 size_t total=0;
360 ssize_t ret;
361
362 if (pos == (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 (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 static int reinit_after_fork_pipe[2] = { -1, -1 };
394
395 NTSTATUS init_before_fork(void)
396 {
397 int ret;
398
399 ret = pipe(reinit_after_fork_pipe);
400 if (ret == -1) {
401 NTSTATUS status;
402
403 status = map_nt_error_from_unix_common(errno);
404
405 DEBUG(0, ("Error creating child_pipe: %s\n",
406 nt_errstr(status)));
407
408 return status;
409 }
410
411 return NT_STATUS_OK;
412 }
413
414 /**
415 * Detect died parent by detecting EOF on the pipe
416 */
417 static void reinit_after_fork_pipe_handler(struct tevent_context *ev,
418 struct tevent_fd *fde,
419 uint16_t flags,
420 void *private_data)
421 {
422 char c;
423
424 if (sys_read(reinit_after_fork_pipe[0], &c, 1) != 1) {
425 /*
426 * we have reached EOF on stdin, which means the
427 * parent has exited. Shutdown the server
428 */
429 (void)kill(getpid(), SIGTERM);
430 }
431 }
432
433
434 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
435 struct tevent_context *ev_ctx,
436 bool parent_longlived,
437 const char *comment)
438 {
439 NTSTATUS status = NT_STATUS_OK;
440
441 if (reinit_after_fork_pipe[1] != -1) {
442 close(reinit_after_fork_pipe[1]);
443 reinit_after_fork_pipe[1] = -1;
444 }
445
446 /* tdb needs special fork handling */
447 if (tdb_reopen_all(parent_longlived ? 1 : 0) != 0) {
448 DEBUG(0,("tdb_reopen_all failed.\n"));
449 status = NT_STATUS_OPEN_FAILED;
450 goto done;
451 }
452
453 if (ev_ctx != NULL) {
454 tevent_set_trace_callback(ev_ctx, NULL, NULL);
455 if (tevent_re_initialise(ev_ctx) != 0) {
456 smb_panic(__location__ ": Failed to re-initialise event context");
457 }
458 }
459
460 if (reinit_after_fork_pipe[0] != -1) {
461 struct tevent_fd *fde;
462
463 fde = tevent_add_fd(ev_ctx, ev_ctx /* TALLOC_CTX */,
464 reinit_after_fork_pipe[0], TEVENT_FD_READ,
465 reinit_after_fork_pipe_handler, NULL);
466 if (fde == NULL) {
467 smb_panic(__location__ ": Failed to add reinit_after_fork pipe event");
468 }
469 }
470
471 if (msg_ctx) {
472 /*
473 * For clustering, we need to re-init our ctdbd connection after the
474 * fork
475 */
476 status = messaging_reinit(msg_ctx);
477 if (!NT_STATUS_IS_OK(status)) {
478 DEBUG(0,("messaging_reinit() failed: %s\n",
479 nt_errstr(status)));
480 }
481 }
482
483 if (comment) {
484 prctl_set_comment(comment);
485 }
486
487 done:
488 return status;
489 }
490
491 /****************************************************************************
492 (Hopefully) efficient array append.
493 ****************************************************************************/
494
495 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
496 void *element, void *_array, uint32_t *num_elements,
497 ssize_t *array_size)
498 {
499 void **array = (void **)_array;
500
501 if (*array_size < 0) {
502 return;
503 }
504
505 if (*array == NULL) {
506 if (*array_size == 0) {
507 *array_size = 128;
508 }
509
510 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
511 goto error;
512 }
513
514 *array = TALLOC(mem_ctx, element_size * (*array_size));
515 if (*array == NULL) {
516 goto error;
517 }
518 }
519
520 if (*num_elements == *array_size) {
521 *array_size *= 2;
522
523 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
524 goto error;
525 }
526
527 *array = TALLOC_REALLOC(mem_ctx, *array,
528 element_size * (*array_size));
529
530 if (*array == NULL) {
531 goto error;
532 }
533 }
534
535 memcpy((char *)(*array) + element_size*(*num_elements),
536 element, element_size);
537 *num_elements += 1;
538
539 return;
540
541 error:
542 *num_elements = 0;
543 *array_size = -1;
544 }
545
546 /****************************************************************************
547 Get my own domain name, or "" if we have none.
548 ****************************************************************************/
549
550 char *get_mydnsdomname(TALLOC_CTX *ctx)
551 {
552 const char *domname;
553 char *p;
554
555 domname = get_mydnsfullname();
556 if (!domname) {
557 return NULL;
558 }
559
560 p = strchr_m(domname, '.');
561 if (p) {
562 p++;
563 return talloc_strdup(ctx, p);
564 } else {
565 return talloc_strdup(ctx, "");
566 }
567 }
568
569 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
570 /******************************************************************
571 Remove any mount options such as -rsize=2048,wsize=2048 etc.
572 Based on a fix from <Thomas.Hepper@icem.de>.
573 Returns a malloc'ed string.
574 *******************************************************************/
575
576 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
577 {
578 if (*str == '-') {
579 const char *p = str;
580 while(*p && !isspace(*p))
581 p++;
582 while(*p && isspace(*p))
583 p++;
584 if(*p) {
585 return talloc_strdup(ctx, p);
586 }
587 }
588 return NULL;
589 }
590
591 /*******************************************************************
592 Patch from jkf@soton.ac.uk
593 Split Luke's automount_server into YP lookup and string splitter
594 so can easily implement automount_path().
595 Returns a malloc'ed string.
596 *******************************************************************/
597
598 #ifdef WITH_NISPLUS_HOME
599 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
600 {
601 char *value = NULL;
602
603 char *nis_map = (char *)lp_homedir_map();
604
605 char buffer[NIS_MAXATTRVAL + 1];
606 nis_result *result;
607 nis_object *object;
608 entry_obj *entry;
609
610 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
611 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
612
613 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
614 if (result->status != NIS_SUCCESS) {
615 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
616 } else {
617 object = result->objects.objects_val;
618 if (object->zo_data.zo_type == ENTRY_OBJ) {
619 entry = &object->zo_data.objdata_u.en_data;
620 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
621 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
622
623 value = talloc_strdup(ctx,
624 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
625 if (!value) {
626 nis_freeresult(result);
627 return NULL;
628 }
629 value = talloc_string_sub(ctx,
630 value,
631 "&",
632 user_name);
633 }
634 }
635 }
636 nis_freeresult(result);
637
638 if (value) {
639 value = strip_mount_options(ctx, value);
640 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
641 user_name, value));
642 }
643 return value;
644 }
645 #else /* WITH_NISPLUS_HOME */
646
647 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
648 {
649 char *value = NULL;
650
651 int nis_error; /* returned by yp all functions */
652 char *nis_result; /* yp_match inits this */
653 int nis_result_len; /* and set this */
654 char *nis_domain; /* yp_get_default_domain inits this */
655 char *nis_map = lp_homedir_map(talloc_tos());
656
657 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
658 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
659 return NULL;
660 }
661
662 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
663
664 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
665 strlen(user_name), &nis_result,
666 &nis_result_len)) == 0) {
667 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
668 nis_result[nis_result_len] = '\0';
669 }
670 value = talloc_strdup(ctx, nis_result);
671 if (!value) {
672 return NULL;
673 }
674 value = strip_mount_options(ctx, value);
675 } else if(nis_error == YPERR_KEY) {
676 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
677 user_name, nis_map));
678 DEBUG(3, ("using defaults for server and home directory\n"));
679 } else {
680 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
681 yperr_string(nis_error), user_name, nis_map));
682 }
683
684 if (value) {
685 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
686 }
687 return value;
688 }
689 #endif /* WITH_NISPLUS_HOME */
690 #endif
691
692 bool process_exists(const struct server_id pid)
693 {
694 return serverid_exists(&pid);
695 }
696
697 /*******************************************************************
698 Convert a uid into a user name.
699 ********************************************************************/
700
701 const char *uidtoname(uid_t uid)
702 {
703 TALLOC_CTX *ctx = talloc_tos();
704 char *name = NULL;
705 struct passwd *pass = NULL;
706
707 pass = getpwuid_alloc(ctx,uid);
708 if (pass) {
709 name = talloc_strdup(ctx,pass->pw_name);
710 TALLOC_FREE(pass);
711 } else {
712 name = talloc_asprintf(ctx,
713 "%ld",
714 (long int)uid);
715 }
716 return name;
717 }
718
719 /*******************************************************************
720 Convert a gid into a group name.
721 ********************************************************************/
722
723 char *gidtoname(gid_t gid)
724 {
725 struct group *grp;
726
727 grp = getgrgid(gid);
728 if (grp) {
729 return talloc_strdup(talloc_tos(), grp->gr_name);
730 }
731 else {
732 return talloc_asprintf(talloc_tos(),
733 "%d",
734 (int)gid);
735 }
736 }
737
738 /*******************************************************************
739 Convert a user name into a uid.
740 ********************************************************************/
741
742 uid_t nametouid(const char *name)
743 {
744 struct passwd *pass;
745 char *p;
746 uid_t u;
747
748 pass = Get_Pwnam_alloc(talloc_tos(), name);
749 if (pass) {
750 u = pass->pw_uid;
751 TALLOC_FREE(pass);
752 return u;
753 }
754
755 u = (uid_t)strtol(name, &p, 0);
756 if ((p != name) && (*p == '\0'))
757 return u;
758
759 return (uid_t)-1;
760 }
761
762 /*******************************************************************
763 Convert a name to a gid_t if possible. Return -1 if not a group.
764 ********************************************************************/
765
766 gid_t nametogid(const char *name)
767 {
768 struct group *grp;
769 char *p;
770 gid_t g;
771
772 g = (gid_t)strtol(name, &p, 0);
773 if ((p != name) && (*p == '\0'))
774 return g;
775
776 grp = getgrnam(name);
777 if (grp)
778 return(grp->gr_gid);
779 return (gid_t)-1;
780 }
781
782 /*******************************************************************
783 Something really nasty happened - panic !
784 ********************************************************************/
785
786 void smb_panic_s3(const char *why)
787 {
788 char *cmd;
789 int result;
790
791 DEBUG(0,("PANIC (pid %llu): %s\n",
792 (unsigned long long)getpid(), why));
793 log_stack_trace();
794
795 #if defined(HAVE_PRCTL) && defined(PR_SET_PTRACER)
796 /*
797 * Make sure all children can attach a debugger.
798 */
799 prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
800 #endif
801
802 cmd = lp_panic_action(talloc_tos());
803 if (cmd && *cmd) {
804 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
805 result = system(cmd);
806
807 if (result == -1)
808 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
809 strerror(errno)));
810 else
811 DEBUG(0, ("smb_panic(): action returned status %d\n",
812 WEXITSTATUS(result)));
813 }
814
815 dump_core();
816 }
817
818 /*******************************************************************
819 Print a backtrace of the stack to the debug log. This function
820 DELIBERATELY LEAKS MEMORY. The expectation is that you should
821 exit shortly after calling it.
822 ********************************************************************/
823
824 #ifdef HAVE_LIBUNWIND_H
825 #include <libunwind.h>
826 #endif
827
828 #ifdef HAVE_EXECINFO_H
829 #include <execinfo.h>
830 #endif
831
832 #ifdef HAVE_LIBEXC_H
833 #include <libexc.h>
834 #endif
835
836 void log_stack_trace(void)
837 {
838 #ifdef HAVE_LIBUNWIND
839 /* Try to use libunwind before any other technique since on ia64
840 * libunwind correctly walks the stack in more circumstances than
841 * backtrace.
842 */
843 unw_cursor_t cursor;
844 unw_context_t uc;
845 unsigned i = 0;
846
847 char procname[256];
848 unw_word_t ip, sp, off;
849
850 procname[sizeof(procname) - 1] = '\0';
851
852 if (unw_getcontext(&uc) != 0) {
853 goto libunwind_failed;
854 }
855
856 if (unw_init_local(&cursor, &uc) != 0) {
857 goto libunwind_failed;
858 }
859
860 DEBUG(0, ("BACKTRACE:\n"));
861
862 do {
863 ip = sp = 0;
864 unw_get_reg(&cursor, UNW_REG_IP, &ip);
865 unw_get_reg(&cursor, UNW_REG_SP, &sp);
866
867 switch (unw_get_proc_name(&cursor,
868 procname, sizeof(procname) - 1, &off) ) {
869 case 0:
870 /* Name found. */
871 case -UNW_ENOMEM:
872 /* Name truncated. */
873 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
874 i, procname, (long long)off,
875 (long long)ip, (long long) sp));
876 break;
877 default:
878 /* case -UNW_ENOINFO: */
879 /* case -UNW_EUNSPEC: */
880 /* No symbol name found. */
881 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
882 i, "<unknown symbol>",
883 (long long)ip, (long long) sp));
884 }
885 ++i;
886 } while (unw_step(&cursor) > 0);
887
888 return;
889
890 libunwind_failed:
891 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
892
893 #elif HAVE_BACKTRACE_SYMBOLS
894 void *backtrace_stack[BACKTRACE_STACK_SIZE];
895 size_t backtrace_size;
896 char **backtrace_strings;
897
898 /* get the backtrace (stack frames) */
899 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
900 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
901
902 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
903 (unsigned long)backtrace_size));
904
905 if (backtrace_strings) {
906 int i;
907
908 for (i = 0; i < backtrace_size; i++)
909 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
910
911 /* Leak the backtrace_strings, rather than risk what free() might do */
912 }
913
914 #elif HAVE_LIBEXC
915
916 /* The IRIX libexc library provides an API for unwinding the stack. See
917 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
918 * since we are about to abort anyway, it hardly matters.
919 */
920
921 #define NAMESIZE 32 /* Arbitrary */
922
923 __uint64_t addrs[BACKTRACE_STACK_SIZE];
924 char * names[BACKTRACE_STACK_SIZE];
925 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
926
927 int i;
928 int levels;
929
930 ZERO_ARRAY(addrs);
931 ZERO_ARRAY(names);
932 ZERO_ARRAY(namebuf);
933
934 /* We need to be root so we can open our /proc entry to walk
935 * our stack. It also helps when we want to dump core.
936 */
937 become_root();
938
939 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
940 names[i] = namebuf + (i * NAMESIZE);
941 }
942
943 levels = trace_back_stack(0, addrs, names,
944 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
945
946 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
947 for (i = 0; i < levels; i++) {
948 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
949 }
950 #undef NAMESIZE
951
952 #else
953 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
954 #endif
955 }
956
957 /*******************************************************************
958 A readdir wrapper which just returns the file name.
959 ********************************************************************/
960
961 const char *readdirname(DIR *p)
962 {
963 struct dirent *ptr;
964 char *dname;
965
966 if (!p)
967 return(NULL);
968
969 ptr = (struct dirent *)readdir(p);
970 if (!ptr)
971 return(NULL);
972
973 dname = ptr->d_name;
974
975 #ifdef NEXT2
976 if (telldir(p) < 0)
977 return(NULL);
978 #endif
979
980 #ifdef HAVE_BROKEN_READDIR_NAME
981 /* using /usr/ucb/cc is BAD */
982 dname = dname - 2;
983 #endif
984
985 return talloc_strdup(talloc_tos(), dname);
986 }
987
988 /*******************************************************************
989 Utility function used to decide if the last component
990 of a path matches a (possibly wildcarded) entry in a namelist.
991 ********************************************************************/
992
993 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
994 {
995 const char *last_component;
996
997 /* if we have no list it's obviously not in the path */
998 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
999 return False;
1000 }
1001
1002 DEBUG(8, ("is_in_path: %s\n", name));
1003
1004 /* Get the last component of the unix name. */
1005 last_component = strrchr_m(name, '/');
1006 if (!last_component) {
1007 last_component = name;
1008 } else {
1009 last_component++; /* Go past '/' */
1010 }
1011
1012 for(; namelist->name != NULL; namelist++) {
1013 if(namelist->is_wild) {
1014 if (mask_match(last_component, namelist->name, case_sensitive)) {
1015 DEBUG(8,("is_in_path: mask match succeeded\n"));
1016 return True;
1017 }
1018 } else {
1019 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1020 (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
1021 DEBUG(8,("is_in_path: match succeeded\n"));
1022 return True;
1023 }
1024 }
1025 }
1026 DEBUG(8,("is_in_path: match not found\n"));
1027 return False;
1028 }
1029
1030 /*******************************************************************
1031 Strip a '/' separated list into an array of
1032 name_compare_enties structures suitable for
1033 passing to is_in_path(). We do this for
1034 speed so we can pre-parse all the names in the list
1035 and don't do it for each call to is_in_path().
1036 We also check if the entry contains a wildcard to
1037 remove a potentially expensive call to mask_match
1038 if possible.
1039 ********************************************************************/
1040
1041 void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
1042 {
1043 char *name_end;
1044 char *namelist;
1045 char *namelist_end;
1046 char *nameptr;
1047 int num_entries = 0;
1048 int i;
1049
1050 (*ppname_array) = NULL;
1051
1052 if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0')))
1053 return;
1054
1055 namelist = talloc_strdup(talloc_tos(), namelist_in);
1056 if (namelist == NULL) {
1057 DEBUG(0,("set_namearray: talloc fail\n"));
1058 return;
1059 }
1060 nameptr = namelist;
1061
1062 namelist_end = &namelist[strlen(namelist)];
1063
1064 /* We need to make two passes over the string. The
1065 first to count the number of elements, the second
1066 to split it.
1067 */
1068
1069 while(nameptr <= namelist_end) {
1070 if ( *nameptr == '/' ) {
1071 /* cope with multiple (useless) /s) */
1072 nameptr++;
1073 continue;
1074 }
1075 /* anything left? */
1076 if ( *nameptr == '\0' )
1077 break;
1078
1079 /* find the next '/' or consume remaining */
1080 name_end = strchr_m(nameptr, '/');
1081 if (name_end == NULL) {
1082 /* Point nameptr at the terminating '\0' */
1083 nameptr += strlen(nameptr);
1084 } else {
1085 /* next segment please */
1086 nameptr = name_end + 1;
1087 }
1088 num_entries++;
1089 }
1090
1091 if(num_entries == 0) {
1092 talloc_free(namelist);
1093 return;
1094 }
1095
1096 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1097 DEBUG(0,("set_namearray: malloc fail\n"));
1098 talloc_free(namelist);
1099 return;
1100 }
1101
1102 /* Now copy out the names */
1103 nameptr = namelist;
1104 i = 0;
1105 while(nameptr <= namelist_end) {
1106 if ( *nameptr == '/' ) {
1107 /* cope with multiple (useless) /s) */
1108 nameptr++;
1109 continue;
1110 }
1111 /* anything left? */
1112 if ( *nameptr == '\0' )
1113 break;
1114
1115 /* find the next '/' or consume remaining */
1116 name_end = strchr_m(nameptr, '/');
1117 if (name_end != NULL) {
1118 *name_end = '\0';
1119 }
1120
1121 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1122 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1123 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1124 talloc_free(namelist);
1125 return;
1126 }
1127
1128 if (name_end == NULL) {
1129 /* Point nameptr at the terminating '\0' */
1130 nameptr += strlen(nameptr);
1131 } else {
1132 /* next segment please */
1133 nameptr = name_end + 1;
1134 }
1135 i++;
1136 }
1137
1138 (*ppname_array)[i].name = NULL;
1139
1140 talloc_free(namelist);
1141 return;
1142 }
1143
1144 #undef DBGC_CLASS
1145 #define DBGC_CLASS DBGC_LOCKING
1146
1147 /****************************************************************************
1148 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1149 is dealt with in posix.c
1150 Returns True if we have information regarding this lock region (and returns
1151 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1152 ****************************************************************************/
1153
1154 bool fcntl_getlock(int fd, int op, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
1155 {
1156 struct flock lock;
1157 int ret;
1158
1159 DEBUG(8,("fcntl_getlock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1160 fd,op,(double)*poffset,(double)*pcount,*ptype));
1161
1162 lock.l_type = *ptype;
1163 lock.l_whence = SEEK_SET;
1164 lock.l_start = *poffset;
1165 lock.l_len = *pcount;
1166 lock.l_pid = 0;
1167
1168 ret = sys_fcntl_ptr(fd,op,&lock);
1169
1170 if (ret == -1) {
1171 int sav = errno;
1172 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1173 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1174 errno = sav;
1175 return False;
1176 }
1177
1178 *ptype = lock.l_type;
1179 *poffset = lock.l_start;
1180 *pcount = lock.l_len;
1181 *ppid = lock.l_pid;
1182
1183 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1184 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1185 return True;
1186 }
1187
1188 #if defined(HAVE_OFD_LOCKS)
1189 int map_process_lock_to_ofd_lock(int op, bool *use_ofd_locks)
1190 {
1191 switch (op) {
1192 case F_GETLK:
1193 case F_OFD_GETLK:
1194 op = F_OFD_GETLK;
1195 break;
1196 case F_SETLK:
1197 case F_OFD_SETLK:
1198 op = F_OFD_SETLK;
1199 break;
1200 case F_SETLKW:
1201 case F_OFD_SETLKW:
1202 op = F_OFD_SETLKW;
1203 break;
1204 default:
1205 *use_ofd_locks = false;
1206 return -1;
1207 }
1208 *use_ofd_locks = true;
1209 return op;
1210 }
1211 #else /* HAVE_OFD_LOCKS */
1212 int map_process_lock_to_ofd_lock(int op, bool *use_ofd_locks)
1213 {
1214 *use_ofd_locks = false;
1215 return op;
1216 }
1217 #endif /* HAVE_OFD_LOCKS */
1218
1219 #undef DBGC_CLASS
1220 #define DBGC_CLASS DBGC_ALL
1221
1222 /*******************************************************************
1223 Is the name specified one of my netbios names.
1224 Returns true if it is equal, false otherwise.
1225 ********************************************************************/
1226
1227 bool is_myname(const char *s)
1228 {
1229 int n;
1230 bool ret = False;
1231
1232 for (n=0; my_netbios_names(n); n++) {
1233 const char *nbt_name = my_netbios_names(n);
1234
1235 if (strncasecmp_m(nbt_name, s, MAX_NETBIOSNAME_LEN-1) == 0) {
1236 ret=True;
1237 break;
1238 }
1239 }
1240 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1241 return(ret);
1242 }
1243
1244 /*******************************************************************
1245 we distinguish between 2K and XP by the "Native Lan Manager" string
1246 WinXP => "Windows 2002 5.1"
1247 WinXP 64bit => "Windows XP 5.2"
1248 Win2k => "Windows 2000 5.0"
1249 NT4 => "Windows NT 4.0"
1250 Win9x => "Windows 4.0"
1251 Windows 2003 doesn't set the native lan manager string but
1252 they do set the domain to "Windows 2003 5.2" (probably a bug).
1253 ********************************************************************/
1254
1255 void ra_lanman_string( const char *native_lanman )
1256 {
1257 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1258 set_remote_arch( RA_WINXP );
1259 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1260 set_remote_arch( RA_WINXP64 );
1261 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1262 set_remote_arch( RA_WIN2K3 );
1263 }
1264
1265 static const char *remote_arch_strings[] = {
1266 [RA_UNKNOWN] = "UNKNOWN",
1267 [RA_WFWG] = "WfWg",
1268 [RA_OS2] = "OS2",
1269 [RA_WIN95] = "Win95",
1270 [RA_WINNT] = "WinNT",
1271 [RA_WIN2K] = "Win2K",
1272 [RA_WINXP] = "WinXP",
1273 [RA_WIN2K3] = "Win2K3",
1274 [RA_VISTA] = "Vista",
1275 [RA_SAMBA] = "Samba",
1276 [RA_CIFSFS] = "CIFSFS",
1277 [RA_WINXP64] = "WinXP64",
1278 [RA_OSX] = "OSX",
1279 };
1280
1281 const char *get_remote_arch_str(void)
1282 {
1283 if (ra_type >= ARRAY_SIZE(remote_arch_strings)) {
1284 /*
1285 * set_remote_arch() already checks this so ra_type
1286 * should be in the allowed range, but anyway, let's
1287 * do another bound check here.
1288 */
1289 DBG_ERR("Remote arch info out of sync [%d] missing\n", ra_type);
1290 ra_type = RA_UNKNOWN;
1291 }
1292 return remote_arch_strings[ra_type];
1293 }
1294
1295 enum remote_arch_types get_remote_arch_from_str(const char *remote_arch_string)
1296 {
1297 int i;
1298
1299 for (i = 0; i < ARRAY_SIZE(remote_arch_strings); i++) {
1300 if (strcmp(remote_arch_string, remote_arch_strings[i]) == 0) {
1301 return i;
1302 }
1303 }
1304 return RA_UNKNOWN;
1305 }
1306
1307 /*******************************************************************
1308 Set the horrid remote_arch string based on an enum.
1309 ********************************************************************/
1310
1311 void set_remote_arch(enum remote_arch_types type)
1312 {
1313 if (ra_type >= ARRAY_SIZE(remote_arch_strings)) {
1314 /*
1315 * This protects against someone adding values to enum
1316 * remote_arch_types without updating
1317 * remote_arch_strings array.
1318 */
1319 DBG_ERR("Remote arch info out of sync [%d] missing\n", ra_type);
1320 ra_type = RA_UNKNOWN;
1321 return;
1322 }
1323
1324 ra_type = type;
1325 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1326 get_remote_arch_str()));
1327 }
1328
1329 /*******************************************************************
1330 Get the remote_arch type.
1331 ********************************************************************/
1332
1333 enum remote_arch_types get_remote_arch(void)
1334 {
1335 return ra_type;
1336 }
1337
1338 #define RA_CACHE_TTL 7*24*3600
1339
1340 static bool remote_arch_cache_key(const struct GUID *client_guid,
1341 fstring key)
1342 {
1343 struct GUID_txt_buf guid_buf;
1344 const char *guid_string = NULL;
1345
1346 guid_string = GUID_buf_string(client_guid, &guid_buf);
1347 if (guid_string == NULL) {
1348 return false;
1349 }
1350
1351 fstr_sprintf(key, "RA/%s", guid_string);
1352 return true;
1353 }
1354
1355 struct ra_parser_state {
1356 bool found;
1357 enum remote_arch_types ra;
1358 };
1359
1360 static void ra_parser(time_t timeout, DATA_BLOB blob, void *priv_data)
1361 {
1362 struct ra_parser_state *state = (struct ra_parser_state *)priv_data;
1363 const char *ra_str = NULL;
1364
1365 if (timeout <= time(NULL)) {
1366 return;
1367 }
1368
1369 if ((blob.length == 0) || (blob.data[blob.length-1] != '\0')) {
1370 DBG_ERR("Remote arch cache key not a string\n");
1371 return;
1372 }
1373
1374 ra_str = (const char *)blob.data;
1375 DBG_INFO("Got remote arch [%s] from cache\n", ra_str);
1376
1377 state->ra = get_remote_arch_from_str(ra_str);
1378 state->found = true;
1379 return;
1380 }
1381
1382 static bool remote_arch_cache_get(const struct GUID *client_guid)
1383 {
1384 bool ok;
1385 fstring ra_key;
1386 struct ra_parser_state state = (struct ra_parser_state) {
1387 .found = false,
1388 .ra = RA_UNKNOWN,
1389 };
1390
1391 ok = remote_arch_cache_key(client_guid, ra_key);
1392 if (!ok) {
1393 return false;
1394 }
1395
1396 ok = gencache_parse(ra_key, ra_parser, &state);
1397 if (!ok || !state.found) {
1398 return true;
1399 }
1400
1401 if (state.ra == RA_UNKNOWN) {
1402 return true;
1403 }
1404
1405 set_remote_arch(state.ra);
1406 return true;
1407 }
1408
1409 static bool remote_arch_cache_set(const struct GUID *client_guid)
1410 {
1411 bool ok;
1412 fstring ra_key;
1413 const char *ra_str = NULL;
1414
1415 if (get_remote_arch() == RA_UNKNOWN) {
1416 return true;
1417 }
1418
1419 ok = remote_arch_cache_key(client_guid, ra_key);
1420 if (!ok) {
1421 return false;
1422 }
1423
1424 ra_str = get_remote_arch_str();
1425 if (ra_str == NULL) {
1426 return false;
1427 }
1428
1429 ok = gencache_set(ra_key, ra_str, time(NULL) + RA_CACHE_TTL);
1430 if (!ok) {
1431 return false;
1432 }
1433
1434 return true;
1435 }
1436
1437 bool remote_arch_cache_update(const struct GUID *client_guid)
1438 {
1439 bool ok;
1440
1441 if (get_remote_arch() == RA_UNKNOWN) {
1442
1443 become_root();
1444 ok = remote_arch_cache_get(client_guid);
1445 unbecome_root();
1446
1447 return ok;
1448 }
1449
1450 become_root();
1451 ok = remote_arch_cache_set(client_guid);
1452 unbecome_root();
1453
1454 return ok;
1455 }
1456
1457 bool remote_arch_cache_delete(const struct GUID *client_guid)
1458 {
1459 bool ok;
1460 fstring ra_key;
1461
1462 ok = remote_arch_cache_key(client_guid, ra_key);
1463 if (!ok) {
1464 return false;
1465 }
1466
1467 become_root();
1468 ok = gencache_del(ra_key);
1469 unbecome_root();
1470
1471 if (!ok) {
1472 return false;
1473 }
1474
1475 return true;
1476 }
1477
1478 const char *tab_depth(int level, int depth)
1479 {
1480 if( CHECK_DEBUGLVL(level) ) {
1481 dbgtext("%*s", depth*4, "");
1482 }
1483 return "";
1484 }
1485
1486 /*****************************************************************************
1487 Provide a checksum on a string
1488
1489 Input: s - the null-terminated character string for which the checksum
1490 will be calculated.
1491
1492 Output: The checksum value calculated for s.
1493 *****************************************************************************/
1494
1495 int str_checksum(const char *s)
1496 {
1497 TDB_DATA key;
1498 if (s == NULL)
1499 return 0;
1500
1501 key = (TDB_DATA) { .dptr = discard_const_p(uint8_t, s),
1502 .dsize = strlen(s) };
1503
1504 return tdb_jenkins_hash(&key);
1505 }
1506
1507 /*****************************************************************
1508 Zero a memory area then free it. Used to catch bugs faster.
1509 *****************************************************************/
1510
1511 void zero_free(void *p, size_t size)
1512 {
1513 memset(p, 0, size);
1514 SAFE_FREE(p);
1515 }
1516
1517 /*****************************************************************
1518 Set our open file limit to a requested max and return the limit.
1519 *****************************************************************/
1520
1521 int set_maxfiles(int requested_max)
1522 {
1523 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1524 struct rlimit rlp;
1525 int saved_current_limit;
1526
1527 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1528 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1529 strerror(errno) ));
1530 /* just guess... */
1531 return requested_max;
1532 }
1533
1534 /*
1535 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1536 * account for the extra fd we need
1537 * as well as the log files and standard
1538 * handles etc. Save the limit we want to set in case
1539 * we are running on an OS that doesn't support this limit (AIX)
1540 * which always returns RLIM_INFINITY for rlp.rlim_max.
1541 */
1542
1543 /* Try raising the hard (max) limit to the requested amount. */
1544
1545 #if defined(RLIM_INFINITY)
1546 if (rlp.rlim_max != RLIM_INFINITY) {
1547 int orig_max = rlp.rlim_max;
1548
1549 if ( rlp.rlim_max < requested_max )
1550 rlp.rlim_max = requested_max;
1551
1552 /* This failing is not an error - many systems (Linux) don't
1553 support our default request of 10,000 open files. JRA. */
1554
1555 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1556 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
1557 (int)rlp.rlim_max, strerror(errno) ));
1558
1559 /* Set failed - restore original value from get. */
1560 rlp.rlim_max = orig_max;
1561 }
1562 }
1563 #endif
1564
1565 /* Now try setting the soft (current) limit. */
1566
1567 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1568
1569 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1570 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
1571 (int)rlp.rlim_cur, strerror(errno) ));
1572 /* just guess... */
1573 return saved_current_limit;
1574 }
1575
1576 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1577 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1578 strerror(errno) ));
1579 /* just guess... */
1580 return saved_current_limit;
1581 }
1582
1583 #if defined(RLIM_INFINITY)
1584 if(rlp.rlim_cur == RLIM_INFINITY)
1585 return saved_current_limit;
1586 #endif
1587
1588 if((int)rlp.rlim_cur > saved_current_limit)
1589 return saved_current_limit;
1590
1591 return rlp.rlim_cur;
1592 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1593 /*
1594 * No way to know - just guess...
1595 */
1596 return requested_max;
1597 #endif
1598 }
1599
1600 /*****************************************************************
1601 malloc that aborts with smb_panic on fail or zero size.
1602 *****************************************************************/
1603
1604 void *smb_xmalloc_array(size_t size, unsigned int count)
1605 {
1606 void *p;
1607 if (size == 0) {
1608 smb_panic("smb_xmalloc_array: called with zero size");
1609 }
1610 if (count >= MAX_ALLOC_SIZE/size) {
1611 smb_panic("smb_xmalloc_array: alloc size too large");
1612 }
1613 if ((p = SMB_MALLOC(size*count)) == NULL) {
1614 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
1615 (unsigned long)size, (unsigned long)count));
1616 smb_panic("smb_xmalloc_array: malloc failed");
1617 }
1618 return p;
1619 }
1620
1621 /*
1622 vasprintf that aborts on malloc fail
1623 */
1624
1625 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
1626 {
1627 int n;
1628 va_list ap2;
1629
1630 va_copy(ap2, ap);
1631
1632 n = vasprintf(ptr, format, ap2);
1633 va_end(ap2);
1634 if (n == -1 || ! *ptr) {
1635 smb_panic("smb_xvasprintf: out of memory");
1636 }
1637 return n;
1638 }
1639
1640 /*****************************************************************
1641 Get local hostname and cache result.
1642 *****************************************************************/
1643
1644 char *myhostname(void)
1645 {
1646 static char *ret;
1647 if (ret == NULL) {
1648 ret = get_myname(NULL);
1649 }
1650 return ret;
1651 }
1652
1653 /*****************************************************************
1654 Get local hostname and cache result.
1655 *****************************************************************/
1656
1657 char *myhostname_upper(void)
1658 {
1659 static char *ret;
1660 if (ret == NULL) {
1661 char *name = get_myname(NULL);
1662 if (name == NULL) {
1663 return NULL;
1664 }
1665 ret = strupper_talloc(NULL, name);
1666 talloc_free(name);
1667 }
1668 return ret;
1669 }
1670
1671 /*******************************************************************
1672 Given a filename - get its directory name
1673 ********************************************************************/
1674
1675 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
1676 const char **name)
1677 {
1678 char *p;
1679 ptrdiff_t len;
1680
1681 p = strrchr_m(dir, '/'); /* Find final '/', if any */
1682
1683 if (p == NULL) {
1684 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
1685 return False;
1686 }
1687 if (name) {
1688 *name = dir;
1689 }
1690 return True;
1691 }
1692
1693 len = p-dir;
1694
1695 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
1696 return False;
1697 }
1698 (*parent)[len] = '\0';
1699
1700 if (name) {
1701 *name = p+1;
1702 }
1703 return True;
1704 }
1705
1706 /*******************************************************************
1707 Determine if a pattern contains any Microsoft wildcard characters.
1708 *******************************************************************/
1709
1710 bool ms_has_wild(const char *s)
1711 {
1712 char c;
1713
1714 while ((c = *s++)) {
1715 switch (c) {
1716 case '*':
1717 case '?':
1718 case '<':
1719 case '>':
1720 case '"':
1721 return True;
1722 }
1723 }
1724 return False;
1725 }
1726
1727 bool ms_has_wild_w(const smb_ucs2_t *s)
1728 {
1729 smb_ucs2_t c;
1730 if (!s) return False;
1731 while ((c = *s++)) {
1732 switch (c) {
1733 case UCS2_CHAR('*'):
1734 case UCS2_CHAR('?'):
1735 case UCS2_CHAR('<'):
1736 case UCS2_CHAR('>'):
1737 case UCS2_CHAR('"'):
1738 return True;
1739 }
1740 }
1741 return False;
1742 }
1743
1744 /*******************************************************************
1745 A wrapper that handles case sensitivity and the special handling
1746 of the ".." name.
1747 *******************************************************************/
1748
1749 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
1750 {
1751 if (ISDOTDOT(string))
1752 string = ".";
1753 if (ISDOT(pattern))
1754 return False;
1755
1756 return ms_fnmatch_protocol(pattern, string, Protocol, is_case_sensitive) == 0;
1757 }
1758
1759 /*******************************************************************
1760 A wrapper that handles case sensitivity and the special handling
1761 of the ".." name. Varient that is only called by old search code which requires
1762 pattern translation.
1763 *******************************************************************/
1764
1765 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
1766 {
1767 if (ISDOTDOT(string))
1768 string = ".";
1769 if (ISDOT(pattern))
1770 return False;
1771
1772 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
1773 }
1774
1775 /*******************************************************************
1776 A wrapper that handles a list of patters and calls mask_match()
1777 on each. Returns True if any of the patterns match.
1778 *******************************************************************/
1779
1780 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
1781 {
1782 while (listLen-- > 0) {
1783 if (mask_match(string, *list++, is_case_sensitive))
1784 return True;
1785 }
1786 return False;
1787 }
1788
1789 /**********************************************************************
1790 Converts a name to a fully qualified domain name.
1791 Returns true if lookup succeeded, false if not (then fqdn is set to name)
1792 Uses getaddrinfo() with AI_CANONNAME flag to obtain the official
1793 canonical name of the host. getaddrinfo() may use a variety of sources
1794 including /etc/hosts to obtain the domainname. It expects aliases in
1795 /etc/hosts to NOT be the FQDN. The FQDN should come first.
1796 ************************************************************************/
1797
1798 bool name_to_fqdn(fstring fqdn, const char *name)
1799 {
1800 char *full = NULL;
1801 struct addrinfo hints;
1802 struct addrinfo *result;
1803 int s;
1804
1805 /* Configure hints to obtain canonical name */
1806
1807 memset(&hints, 0, sizeof(struct addrinfo));
1808 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
1809 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
1810 hints.ai_flags = AI_CANONNAME; /* Get host's FQDN */
1811 hints.ai_protocol = 0; /* Any protocol */
1812
1813 s = getaddrinfo(name, NULL, &hints, &result);
1814 if (s != 0) {
1815 DEBUG(1, ("getaddrinfo: %s\n", gai_strerror(s)));
1816 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
1817 fstrcpy(fqdn, name);
1818 return false;
1819 }
1820 full = result->ai_canonname;
1821
1822 /* Find out if the FQDN is returned as an alias
1823 * to cope with /etc/hosts files where the first
1824 * name is not the FQDN but the short name.
1825 * getaddrinfo provides no easy way of handling aliases
1826 * in /etc/hosts. Users should make sure the FQDN
1827 * comes first in /etc/hosts. */
1828 if (full && (! strchr_m(full, '.'))) {
1829 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1830 DEBUGADD(1, (" Full qualified domain names (FQDNs) should not be specified\n"));
1831 DEBUGADD(1, (" as an alias in /etc/hosts. FQDN should be the first name\n"));
1832 DEBUGADD(1, (" prior to any aliases.\n"));
1833 }
1834 if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
1835 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1836 DEBUGADD(1, (" Specifying the machine hostname for address 127.0.0.1 may lead\n"));
1837 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
1838 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
1839 }
1840
1841 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
1842 fstrcpy(fqdn, full);
1843 freeaddrinfo(result); /* No longer needed */
1844 return true;
1845 }
1846
1847 uint32_t map_share_mode_to_deny_mode(uint32_t share_access, uint32_t private_options)
1848 {
1849 switch (share_access & ~FILE_SHARE_DELETE) {
1850 case FILE_SHARE_NONE:
1851 return DENY_ALL;
1852 case FILE_SHARE_READ:
1853 return DENY_WRITE;
1854 case FILE_SHARE_WRITE:
1855 return DENY_READ;
1856 case FILE_SHARE_READ|FILE_SHARE_WRITE:
1857 return DENY_NONE;
1858 }
1859 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
1860 return DENY_DOS;
1861 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
1862 return DENY_FCB;
1863 }
1864
1865 return (uint32_t)-1;
1866 }
1867
1868 struct server_id interpret_pid(const char *pid_string)
1869 {
1870 return server_id_from_string(get_my_vnn(), pid_string);
1871 }
1872
1873 /****************************************************************
1874 Check if an offset into a buffer is safe.
1875 If this returns True it's safe to indirect into the byte at
1876 pointer ptr+off.
1877 ****************************************************************/
1878
1879 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
1880 {
1881 const char *end_base = buf_base + buf_len;
1882 char *end_ptr = ptr + off;
1883
1884 if (!buf_base || !ptr) {
1885 return False;
1886 }
1887
1888 if (end_base < buf_base || end_ptr < ptr) {
1889 return False; /* wrap. */
1890 }
1891
1892 if (end_ptr < end_base) {
1893 return True;
1894 }
1895 return False;
1896 }
1897
1898 /****************************************************************
1899 Return a safe pointer into a buffer, or NULL.
1900 ****************************************************************/
1901
1902 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
1903 {
1904 return is_offset_safe(buf_base, buf_len, ptr, off) ?
1905 ptr + off : NULL;
1906 }
1907
1908 /****************************************************************
1909 Return a safe pointer into a string within a buffer, or NULL.
1910 ****************************************************************/
1911
1912 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
1913 {
1914 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
1915 return NULL;
1916 }
1917 /* Check if a valid string exists at this offset. */
1918 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
1919 return NULL;
1920 }
1921 return ptr + off;
1922 }
1923
1924 /****************************************************************
1925 Return an SVAL at a pointer, or failval if beyond the end.
1926 ****************************************************************/
1927
1928 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
1929 {
1930 /*
1931 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
1932 * NOT ptr[2].
1933 */
1934 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
1935 return failval;
1936 }
1937 return SVAL(ptr,off);
1938 }
1939
1940 /****************************************************************
1941 Return an IVAL at a pointer, or failval if beyond the end.
1942 ****************************************************************/
1943
1944 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
1945 {
1946 /*
1947 * Note we use off+3 here, not off+4 as IVAL accesses
1948 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
1949 */
1950 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
1951 return failval;
1952 }
1953 return IVAL(ptr,off);
1954 }
1955
1956 /****************************************************************
1957 Split DOM\user into DOM and user. Do not mix with winbind variants of that
1958 call (they take care of winbind separator and other winbind specific settings).
1959 ****************************************************************/
1960
1961 bool split_domain_user(TALLOC_CTX *mem_ctx,
1962 const char *full_name,
1963 char **domain,
1964 char **user)
1965 {
1966 const char *p = NULL;
1967
1968 p = strchr_m(full_name, '\\');
1969
1970 if (p != NULL) {
1971 *domain = talloc_strndup(mem_ctx, full_name,
1972 PTR_DIFF(p, full_name));
1973 if (*domain == NULL) {
1974 return false;
1975 }
1976 *user = talloc_strdup(mem_ctx, p+1);
1977 if (*user == NULL) {
1978 TALLOC_FREE(*domain);
1979 return false;
1980 }
1981 } else {
1982 *domain = NULL;
1983 *user = talloc_strdup(mem_ctx, full_name);
1984 if (*user == NULL) {
1985 return false;
1986 }
1987 }
1988
1989 return true;
1990 }
1991
1992 /****************************************************************
1993 strip off leading '\\' from a hostname
1994 ****************************************************************/
1995
1996 const char *strip_hostname(const char *s)
1997 {
1998 if (!s) {
1999 return NULL;
2000 }
2001
2002 if (strlen_m(s) < 3) {
2003 return s;
2004 }
2005
2006 if (s[0] == '\\') s++;
2007 if (s[0] == '\\') s++;
2008
2009 return s;
2010 }
2011
2012 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2013 {
2014 if (!NT_STATUS_IS_OK(err1)) {
2015 *result = err1;
2016 return true;
2017 }
2018 if (!NT_STATUS_IS_OK(err2)) {
2019 *result = err2;
2020 return true;
2021 }
2022 return false;
2023 }
2024
2025 int timeval_to_msec(struct timeval t)
2026 {
2027 return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2028 }
2029
2030 /*******************************************************************
2031 Check a given DOS pathname is valid for a share.
2032 ********************************************************************/
2033
2034 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
2035 {
2036 char *ptr = NULL;
2037
2038 if (!dos_pathname) {
2039 return NULL;
2040 }
2041
2042 ptr = talloc_strdup(ctx, dos_pathname);
2043 if (!ptr) {
2044 return NULL;
2045 }
2046 /* Convert any '\' paths to '/' */
2047 unix_format(ptr);
2048 ptr = unix_clean_name(ctx, ptr);
2049 if (!ptr) {
2050 return NULL;
2051 }
2052
2053 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
2054 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
2055 ptr += 2;
2056
2057 /* Only absolute paths allowed. */
2058 if (*ptr != '/')
2059 return NULL;
2060
2061 return ptr;
2062 }
2063
2064 /*******************************************************************
2065 Return True if the filename is one of the special executable types.
2066 ********************************************************************/
2067
2068 bool is_executable(const char *fname)
2069 {
2070 if ((fname = strrchr_m(fname,'.'))) {
2071 if (strequal(fname,".com") ||
2072 strequal(fname,".dll") ||
2073 strequal(fname,".exe") ||
2074 strequal(fname,".sym")) {
2075 return True;
2076 }
2077 }
2078 return False;
2079 }
2080
2081 /****************************************************************************
2082 Open a file with a share mode - old openX method - map into NTCreate.
2083 ****************************************************************************/
2084
2085 bool map_open_params_to_ntcreate(const char *smb_base_fname,
2086 int deny_mode, int open_func,
2087 uint32_t *paccess_mask,
2088 uint32_t *pshare_mode,
2089 uint32_t *pcreate_disposition,
2090 uint32_t *pcreate_options,
2091 uint32_t *pprivate_flags)
2092 {
2093 uint32_t access_mask;
2094 uint32_t share_mode;
2095 uint32_t create_disposition;
2096 uint32_t create_options = FILE_NON_DIRECTORY_FILE;
2097 uint32_t private_flags = 0;
2098
2099 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
2100 "open_func = 0x%x\n",
2101 smb_base_fname, (unsigned int)deny_mode,
2102 (unsigned int)open_func ));
2103
2104 /* Create the NT compatible access_mask. */
2105 switch (GET_OPENX_MODE(deny_mode)) {
2106 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
2107 case DOS_OPEN_RDONLY:
2108 access_mask = FILE_GENERIC_READ;
2109 break;
2110 case DOS_OPEN_WRONLY:
2111 access_mask = FILE_GENERIC_WRITE;
2112 break;
2113 case DOS_OPEN_RDWR:
2114 case DOS_OPEN_FCB:
2115 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
2116 break;
2117 default:
2118 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
2119 (unsigned int)GET_OPENX_MODE(deny_mode)));
2120 return False;
2121 }
2122
2123 /* Create the NT compatible create_disposition. */
2124 switch (open_func) {
2125 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
2126 create_disposition = FILE_CREATE;
2127 break;
2128
2129 case OPENX_FILE_EXISTS_OPEN:
2130 create_disposition = FILE_OPEN;
2131 break;
2132
2133 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
2134 create_disposition = FILE_OPEN_IF;
2135 break;
2136
2137 case OPENX_FILE_EXISTS_TRUNCATE:
2138 create_disposition = FILE_OVERWRITE;
2139 break;
2140
2141 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
2142 create_disposition = FILE_OVERWRITE_IF;
2143 break;
2144
2145 default:
2146 /* From samba4 - to be confirmed. */
2147 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
2148 create_disposition = FILE_CREATE;
2149 break;
2150 }
2151 DEBUG(10,("map_open_params_to_ntcreate: bad "
2152 "open_func 0x%x\n", (unsigned int)open_func));
2153 return False;
2154 }
2155
2156 /* Create the NT compatible share modes. */
2157 switch (GET_DENY_MODE(deny_mode)) {
2158 case DENY_ALL:
2159 share_mode = FILE_SHARE_NONE;
2160 break;
2161
2162 case DENY_WRITE:
2163 share_mode = FILE_SHARE_READ;
2164 break;
2165
2166 case DENY_READ:
2167 share_mode = FILE_SHARE_WRITE;
2168 break;
2169
2170 case DENY_NONE:
2171 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2172 break;
2173
2174 case DENY_DOS:
2175 private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
2176 if (is_executable(smb_base_fname)) {
2177 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2178 } else {
2179 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
2180 share_mode = FILE_SHARE_READ;
2181 } else {
2182 share_mode = FILE_SHARE_NONE;
2183 }
2184 }
2185 break;
2186
2187 case DENY_FCB:
2188 private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
2189 share_mode = FILE_SHARE_NONE;
2190 break;
2191
2192 default:
2193 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
2194 (unsigned int)GET_DENY_MODE(deny_mode) ));
2195 return False;
2196 }
2197
2198 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
2199 "share_mode = 0x%x, create_disposition = 0x%x, "
2200 "create_options = 0x%x private_flags = 0x%x\n",
2201 smb_base_fname,
2202 (unsigned int)access_mask,
2203 (unsigned int)share_mode,
2204 (unsigned int)create_disposition,
2205 (unsigned int)create_options,
2206 (unsigned int)private_flags));
2207
2208 if (paccess_mask) {
2209 *paccess_mask = access_mask;
2210 }
2211 if (pshare_mode) {
2212 *pshare_mode = share_mode;
2213 }
2214 if (pcreate_disposition) {
2215 *pcreate_disposition = create_disposition;
2216 }
2217 if (pcreate_options) {
2218 *pcreate_options = create_options;
2219 }
2220 if (pprivate_flags) {
2221 *pprivate_flags = private_flags;
2222 }
2223
2224 return True;
2225
2226 }
2227
2228 /*************************************************************************
2229 Return a talloced copy of a struct security_unix_token. NULL on fail.
2230 *************************************************************************/
2231
2232 struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
2233 {
2234 struct security_unix_token *cpy;
2235
2236 cpy = talloc(ctx, struct security_unix_token);
2237 if (!cpy) {
2238 return NULL;
2239 }
2240
2241 cpy->uid = tok->uid;
2242 cpy->gid = tok->gid;
2243 cpy->ngroups = tok->ngroups;
2244 if (tok->ngroups) {
2245 /* Make this a talloc child of cpy. */
2246 cpy->groups = (gid_t *)talloc_memdup(
2247 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
2248 if (!cpy->groups) {
2249 TALLOC_FREE(cpy);
2250 return NULL;
2251 }
2252 } else {
2253 cpy->groups = NULL;
2254 }
2255 return cpy;
2256 }
2257
2258 /****************************************************************************
2259 Check that a file matches a particular file type.
2260 ****************************************************************************/
2261
2262 bool dir_check_ftype(uint32_t mode, uint32_t dirtype)
2263 {
2264 uint32_t mask;
2265
2266 /* Check the "may have" search bits. */
2267 if (((mode & ~dirtype) &
2268 (FILE_ATTRIBUTE_HIDDEN |
2269 FILE_ATTRIBUTE_SYSTEM |
2270 FILE_ATTRIBUTE_DIRECTORY)) != 0) {
2271 return false;
2272 }
2273
2274 /* Check the "must have" bits,
2275 which are the may have bits shifted eight */
2276 /* If must have bit is set, the file/dir can
2277 not be returned in search unless the matching
2278 file attribute is set */
2279 mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|
2280 FILE_ATTRIBUTE_ARCHIVE|
2281 FILE_ATTRIBUTE_READONLY|
2282 FILE_ATTRIBUTE_HIDDEN|
2283 FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
2284 if(mask) {
2285 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|
2286 FILE_ATTRIBUTE_ARCHIVE|
2287 FILE_ATTRIBUTE_READONLY|
2288 FILE_ATTRIBUTE_HIDDEN|
2289 FILE_ATTRIBUTE_SYSTEM))) == mask) {
2290 /* check if matching attribute present */
2291 return true;
2292 } else {
2293 return false;
2294 }
2295 }
2296
2297 return true;
2298 }
Samba GIT mirror