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