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