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