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