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