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