source3/lib/util.c

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