source/lib/system.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba system utilities
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25
  26 /*
  27    The idea is that this file will eventually have wrappers around all
  28    important system calls in samba. The aims are:
  29
  30    - to enable easier porting by putting OS dependent stuff in here
  31
  32    - to allow for hooks into other "pseudo-filesystems"
  33
  34    - to allow easier integration of things like the japanese extensions
  35
  36    - to support the philosophy of Samba to expose the features of
  37      the OS within the SMB model. In general whatever file/printer/variable
  38      expansions/etc make sense to the OS should be acceptable to Samba.
  39 */
  40
  41
  42
  43 /*******************************************************************
  44  A wrapper for usleep in case we don't have one.
  45 ********************************************************************/
  46
  47 int sys_usleep(long usecs)
  48 {
  49 #ifndef HAVE_USLEEP
  50   struct timeval tval;
  51 #endif
  52
  53   /*
  54    * We need this braindamage as the glibc usleep
  55    * is not SPEC1170 complient... grumble... JRA.
  56    */
  57
  58   if(usecs < 0 || usecs > 1000000) {
  59     errno = EINVAL;
  60     return -1;
  61   }
  62
  63 #if HAVE_USLEEP
  64   usleep(usecs);
  65   return 0;
  66 #else /* HAVE_USLEEP */
  67   /*
  68    * Fake it with select...
  69    */
  70   tval.tv_sec = 0;
  71   tval.tv_usec = usecs/1000;
  72   select(0,NULL,NULL,NULL,&tval);
  73   return 0;
  74 #endif /* HAVE_USLEEP */
  75 }
  76
  77 /*******************************************************************
  78 A stat() wrapper that will deal with 64 bit filesizes.
  79 ********************************************************************/
  80
  81 int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
  82 {
  83         int ret;
  84 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
  85         ret = stat64(fname, sbuf);
  86 #else
  87         ret = stat(fname, sbuf);
  88 #endif
  89         /* we always want directories to appear zero size */
  90         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
  91         return ret;
  92 }
  93
  94 /*******************************************************************
  95  An fstat() wrapper that will deal with 64 bit filesizes.
  96 ********************************************************************/
  97
  98 int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
  99 {
 100         int ret;
 101 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
 102         ret = fstat64(fd, sbuf);
 103 #else
 104         ret = fstat(fd, sbuf);
 105 #endif
 106         /* we always want directories to appear zero size */
 107         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 108         return ret;
 109 }
 110
 111 /*******************************************************************
 112  An lstat() wrapper that will deal with 64 bit filesizes.
 113 ********************************************************************/
 114
 115 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
 116 {
 117         int ret;
 118 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
 119         ret = lstat64(fname, sbuf);
 120 #else
 121         ret = lstat(fname, sbuf);
 122 #endif
 123         /* we always want directories to appear zero size */
 124         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 125         return ret;
 126 }
 127
 128 /*******************************************************************
 129  An ftruncate() wrapper that will deal with 64 bit filesizes.
 130 ********************************************************************/
 131
 132 int sys_ftruncate(int fd, SMB_OFF_T offset)
 133 {
 134 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
 135   return ftruncate64(fd, offset);
 136 #else
 137   return ftruncate(fd, offset);
 138 #endif
 139 }
 140
 141 /*******************************************************************
 142  An lseek() wrapper that will deal with 64 bit filesizes.
 143 ********************************************************************/
 144
 145 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
 146 {
 147 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
 148   return lseek64(fd, offset, whence);
 149 #else
 150   return lseek(fd, offset, whence);
 151 #endif
 152 }
 153
 154 /*******************************************************************
 155  An fseek() wrapper that will deal with 64 bit filesizes.
 156 ********************************************************************/
 157
 158 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
 159 {
 160 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
 161   return fseek64(fp, offset, whence);
 162 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
 163   return fseeko64(fp, offset, whence);
 164 #else
 165   return fseek(fp, offset, whence);
 166 #endif
 167 }
 168
 169 /*******************************************************************
 170  An ftell() wrapper that will deal with 64 bit filesizes.
 171 ********************************************************************/
 172
 173 SMB_OFF_T sys_ftell(FILE *fp)
 174 {
 175 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
 176   return (SMB_OFF_T)ftell64(fp);
 177 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
 178   return (SMB_OFF_T)ftello64(fp);
 179 #else
 180   return (SMB_OFF_T)ftell(fp);
 181 #endif
 182 }
 183
 184 /*******************************************************************
 185  A creat() wrapper that will deal with 64 bit filesizes.
 186 ********************************************************************/
 187
 188 int sys_creat(const char *path, mode_t mode)
 189 {
 190 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
 191   return creat64(path, mode);
 192 #else
 193   /*
 194    * If creat64 isn't defined then ensure we call a potential open64.
 195    * JRA.
 196    */
 197   return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
 198 #endif
 199 }
 200
 201 /*******************************************************************
 202  An open() wrapper that will deal with 64 bit filesizes.
 203 ********************************************************************/
 204
 205 int sys_open(const char *path, int oflag, mode_t mode)
 206 {
 207 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
 208   return open64(path, oflag, mode);
 209 #else
 210   return open(path, oflag, mode);
 211 #endif
 212 }
 213
 214 /*******************************************************************
 215  An fopen() wrapper that will deal with 64 bit filesizes.
 216 ********************************************************************/
 217
 218 FILE *sys_fopen(const char *path, const char *type)
 219 {
 220 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
 221   return fopen64(path, type);
 222 #else
 223   return fopen(path, type);
 224 #endif
 225 }
 226
 227 /*******************************************************************
 228  A readdir wrapper that will deal with 64 bit filesizes.
 229 ********************************************************************/
 230
 231 SMB_STRUCT_DIRENT *sys_readdir(DIR *dirp)
 232 {
 233 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
 234   return readdir64(dirp);
 235 #else
 236   return readdir(dirp);
 237 #endif
 238 }
 239
 240 /*******************************************************************
 241 The wait() calls vary between systems
 242 ********************************************************************/
 243
 244 int sys_waitpid(pid_t pid,int *status,int options)
 245 {
 246 #ifdef HAVE_WAITPID
 247   return waitpid(pid,status,options);
 248 #else /* HAVE_WAITPID */
 249   return wait4(pid, status, options, NULL);
 250 #endif /* HAVE_WAITPID */
 251 }
 252
 253 /*******************************************************************
 254 system wrapper for getwd
 255 ********************************************************************/
 256 char *sys_getwd(char *s)
 257 {
 258     char *wd;
 259 #ifdef HAVE_GETCWD
 260     wd = (char *)getcwd(s, sizeof (pstring));
 261 #else
 262     wd = (char *)getwd(s);
 263 #endif
 264     return wd;
 265 }
 266
 267 /*******************************************************************
 268 chown isn't used much but OS/2 doesn't have it
 269 ********************************************************************/
 270
 271 int sys_chown(const char *fname,uid_t uid,gid_t gid)
 272 {
 273 #ifndef HAVE_CHOWN
 274         static int done;
 275         if (!done) {
 276                 DEBUG(1,("WARNING: no chown!\n"));
 277                 done=1;
 278         }
 279 #else
 280         return(chown(fname,uid,gid));
 281 #endif
 282 }
 283
 284 /*******************************************************************
 285 os/2 also doesn't have chroot
 286 ********************************************************************/
 287 int sys_chroot(const char *dname)
 288 {
 289 #ifndef HAVE_CHROOT
 290         static int done;
 291         if (!done) {
 292                 DEBUG(1,("WARNING: no chroot!\n"));
 293                 done=1;
 294         }
 295         errno = ENOSYS;
 296         return -1;
 297 #else
 298         return(chroot(dname));
 299 #endif
 300 }
 301
 302 /**************************************************************************
 303 A wrapper for gethostbyname() that tries avoids looking up hostnames
 304 in the root domain, which can cause dial-on-demand links to come up for no
 305 apparent reason.
 306 ****************************************************************************/
 307 struct hostent *sys_gethostbyname(const char *name)
 308 {
 309 #ifdef REDUCE_ROOT_DNS_LOOKUPS
 310   char query[256], hostname[256];
 311   char *domain;
 312
 313   /* Does this name have any dots in it? If so, make no change */
 314
 315   if (strchr(name, '.'))
 316     return(gethostbyname(name));
 317
 318   /* Get my hostname, which should have domain name
 319      attached. If not, just do the gethostname on the
 320      original string.
 321   */
 322
 323   gethostname(hostname, sizeof(hostname) - 1);
 324   hostname[sizeof(hostname) - 1] = 0;
 325   if ((domain = strchr(hostname, '.')) == NULL)
 326     return(gethostbyname(name));
 327
 328   /* Attach domain name to query and do modified query.
 329      If names too large, just do gethostname on the
 330      original string.
 331   */
 332
 333   if((strlen(name) + strlen(domain)) >= sizeof(query))
 334     return(gethostbyname(name));
 335
 336   slprintf(query, sizeof(query)-1, "%s%s", name, domain);
 337   return(gethostbyname(query));
 338 #else /* REDUCE_ROOT_DNS_LOOKUPS */
 339   return(gethostbyname(name));
 340 #endif /* REDUCE_ROOT_DNS_LOOKUPS */
 341 }
 342
 343
 344 #if defined(HAVE_IRIX_SPECIFIC_CAPABILITIES)
 345 /**************************************************************************
 346  Try and abstract process capabilities (for systems that have them).
 347 ****************************************************************************/
 348 static BOOL set_process_capability( uint32 cap_flag, BOOL enable )
 349 {
 350   if(cap_flag == KERNEL_OPLOCK_CAPABILITY)
 351   {
 352     cap_t cap = cap_get_proc();
 353
 354     if (cap == NULL) {
 355       DEBUG(0,("set_process_capability: cap_get_proc failed. Error was %s\n",
 356             strerror(errno)));
 357       return False;
 358     }
 359
 360     if(enable)
 361       cap->cap_effective |= CAP_NETWORK_MGT;
 362     else
 363       cap->cap_effective &= ~CAP_NETWORK_MGT;
 364
 365     if (cap_set_proc(cap) == -1) {
 366       DEBUG(0,("set_process_capability: cap_set_proc failed. Error was %s\n",
 367             strerror(errno)));
 368       cap_free(cap);
 369       return False;
 370     }
 371
 372     cap_free(cap);
 373
 374     DEBUG(10,("set_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
 375   }
 376   return True;
 377 }
 378
 379 /**************************************************************************
 380  Try and abstract inherited process capabilities (for systems that have them).
 381 ****************************************************************************/
 382
 383 static BOOL set_inherited_process_capability( uint32 cap_flag, BOOL enable )
 384 {
 385   if(cap_flag == KERNEL_OPLOCK_CAPABILITY)
 386   {
 387     cap_t cap = cap_get_proc();
 388
 389     if (cap == NULL) {
 390       DEBUG(0,("set_inherited_process_capability: cap_get_proc failed. Error was %s\n",
 391             strerror(errno)));
 392       return False;
 393     }
 394
 395     if(enable)
 396       cap->cap_inheritable |= CAP_NETWORK_MGT;
 397     else
 398       cap->cap_inheritable &= ~CAP_NETWORK_MGT;
 399
 400     if (cap_set_proc(cap) == -1) {
 401       DEBUG(0,("set_inherited_process_capability: cap_set_proc failed. Error was %s\n",
 402             strerror(errno)));
 403       cap_free(cap);
 404       return False;
 405     }
 406
 407     cap_free(cap);
 408
 409     DEBUG(10,("set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
 410   }
 411   return True;
 412 }
 413 #endif
 414
 415 /****************************************************************************
 416 gain the oplock capability from the kernel if possible
 417 ****************************************************************************/
 418 void oplock_set_capability(BOOL this_process, BOOL inherit)
 419 {
 420 #if HAVE_KERNEL_OPLOCKS_IRIX
 421         set_process_capability(KERNEL_OPLOCK_CAPABILITY,this_process);
 422         set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY,inherit);
 423 #endif
 424 }
 425
 426 /**************************************************************************
 427  Wrapper for random().
 428 ****************************************************************************/
 429
 430 long sys_random(void)
 431 {
 432 #if defined(HAVE_RANDOM)
 433   return (long)random();
 434 #elif defined(HAVE_RAND)
 435   return (long)rand();
 436 #else
 437   DEBUG(0,("Error - no random function available !\n"));
 438   exit(1);
 439 #endif
 440 }
 441
 442 /**************************************************************************
 443  Wrapper for srandom().
 444 ****************************************************************************/
 445
 446 void sys_srandom(unsigned int seed)
 447 {
 448 #if defined(HAVE_SRANDOM)
 449   srandom(seed);
 450 #elif defined(HAVE_SRAND)
 451   srand(seed);
 452 #else
 453   DEBUG(0,("Error - no srandom function available !\n"));
 454   exit(1);
 455 #endif
 456 }
 457
 458 /**************************************************************************
 459  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 460 ****************************************************************************/
 461
 462 int groups_max(void)
 463 {
 464 #if defined(SYSCONF_SC_NGROUPS_MAX)
 465   int ret = sysconf(_SC_NGROUPS_MAX);
 466   return (ret == -1) ? NGROUPS_MAX : ret;
 467 #else
 468   return NGROUPS_MAX;
 469 #endif
 470 }
 471
 472 /**************************************************************************
 473  Wrapper for getgroups. Deals with broken (int) case.
 474 ****************************************************************************/
 475
 476 int sys_getgroups(int setlen, gid_t *gidset)
 477 {
 478 #if !defined(HAVE_BROKEN_GETGROUPS)
 479   return getgroups(setlen, gidset);
 480 #else
 481
 482   GID_T gid;
 483   GID_T *group_list;
 484   int i, ngroups;
 485
 486   if(setlen == 0) {
 487     return getgroups(setlen, &gid);
 488   }
 489
 490   /*
 491    * Broken case. We need to allocate a
 492    * GID_T array of size setlen.
 493    */
 494
 495   if(setlen < 0) {
 496     errno = EINVAL;
 497     return -1;
 498   }
 499
 500   if (setlen == 0)
 501     setlen = groups_max();
 502
 503   if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
 504     DEBUG(0,("sys_getgroups: Malloc fail.\n"));
 505     return -1;
 506   }
 507
 508   if((ngroups = getgroups(setlen, group_list)) < 0) {
 509     int saved_errno = errno;
 510     free((char *)group_list);
 511     errno = saved_errno;
 512     return -1;
 513   }
 514
 515   for(i = 0; i < ngroups; i++)
 516     gidset[i] = (gid_t)group_list[i];
 517
 518   free((char *)group_list);
 519   return ngroups;
 520 #endif /* HAVE_BROKEN_GETGROUPS */
 521 }
 522
 523 #ifdef HAVE_SETGROUPS
 524
 525 /**************************************************************************
 526  Wrapper for setgroups. Deals with broken (int) case. Automatically used
 527  if we have broken getgroups.
 528 ****************************************************************************/
 529
 530 int sys_setgroups(int setlen, gid_t *gidset)
 531 {
 532 #if !defined(HAVE_BROKEN_GETGROUPS)
 533   return setgroups(setlen, gidset);
 534 #else
 535
 536   GID_T *group_list;
 537   int i ;
 538
 539   if (setlen == 0)
 540     return 0 ;
 541
 542   if (setlen < 0 || setlen > groups_max()) {
 543     errno = EINVAL;
 544     return -1;
 545   }
 546
 547   /*
 548    * Broken case. We need to allocate a
 549    * GID_T array of size setlen.
 550    */
 551
 552   if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
 553     DEBUG(0,("sys_setgroups: Malloc fail.\n"));
 554     return -1;
 555   }
 556
 557   for(i = 0; i < setlen; i++)
 558     group_list[i] = (GID_T) gidset[i];
 559
 560   if(setgroups(setlen, group_list) != 0) {
 561     int saved_errno = errno;
 562     free((char *)group_list);
 563     errno = saved_errno;
 564     return -1;
 565   }
 566
 567   free((char *)group_list);
 568   return 0 ;
 569 #endif /* HAVE_BROKEN_GETGROUPS */
 570 }
 571
 572 #endif /* HAVE_SETGROUPS */
 573
 574 /*
 575  * We only wrap pw_name and pw_passwd for now as these
 576  * are the only potentially modified fields.
 577  */
 578
 579 /**************************************************************************
 580  Helper function for getpwnam/getpwuid wrappers.
 581 ****************************************************************************/
 582
 583 struct saved_pw {
 584         fstring         pw_name;
 585         fstring         pw_passwd;
 586         fstring         pw_gecos;
 587         pstring         pw_dir;
 588         pstring         pw_shell;
 589         struct passwd pass;
 590 };
 591
 592 static struct saved_pw pw_mod; /* This is the structure returned - can be modified. */
 593 static struct saved_pw pw_cache; /* This is the structure saved - used to check cache. */
 594
 595 static int num_lookups; /* Counter so we don't always use cache. */
 596 #ifndef PW_RET_CACHE_MAX_LOOKUPS
 597 #define PW_RET_CACHE_MAX_LOOKUPS 100
 598 #endif
 599
 600 static void copy_pwent(struct saved_pw *dst, struct passwd *pass)
 601 {
 602         memcpy((char *)&dst->pass, pass, sizeof(struct passwd));
 603
 604         fstrcpy(dst->pw_name, pass->pw_name);
 605         dst->pass.pw_name = dst->pw_name;
 606
 607         fstrcpy(dst->pw_passwd, pass->pw_passwd);
 608         dst->pass.pw_passwd = dst->pw_passwd;
 609
 610         fstrcpy(dst->pw_gecos, pass->pw_gecos);
 611         dst->pass.pw_gecos = dst->pw_gecos;
 612
 613         pstrcpy(dst->pw_dir, pass->pw_dir);
 614         dst->pass.pw_dir = dst->pw_dir;
 615
 616         pstrcpy(dst->pw_shell, pass->pw_shell);
 617         dst->pass.pw_shell = dst->pw_shell;
 618 }
 619
 620 static struct passwd *setup_pwret(struct passwd *pass)
 621 {
 622         if (pass == NULL) {
 623                 /* Clear the caches. */
 624                 memset(&pw_cache, '\0', sizeof(struct saved_pw));
 625                 memset(&pw_mod, '\0', sizeof(struct saved_pw));
 626                 num_lookups = 0;
 627                 return NULL;
 628         }
 629
 630         copy_pwent( &pw_mod, pass);
 631
 632         if (pass != &pw_cache.pass) {
 633
 634                 /* If it's a cache miss we must also refill the cache. */
 635
 636                 copy_pwent( &pw_cache, pass);
 637                 num_lookups = 1;
 638
 639         } else {
 640
 641                 /* Cache hit. */
 642
 643                 num_lookups++;
 644                 num_lookups = (num_lookups % PW_RET_CACHE_MAX_LOOKUPS);
 645         }
 646
 647         return &pw_mod.pass;
 648 }
 649
 650 /**************************************************************************
 651  Wrappers for setpwent(), getpwent() and endpwent()
 652 ****************************************************************************/
 653
 654 void sys_setpwent(void)
 655 {
 656         setup_pwret(NULL); /* Clear cache. */
 657         setpwent();
 658 }
 659
 660 struct passwd *sys_getpwent(void)
 661 {
 662         return setup_pwret(getpwent());
 663 }
 664
 665 void sys_endpwent(void)
 666 {
 667         setup_pwret(NULL); /* Clear cache. */
 668         endpwent();
 669 }
 670
 671 /**************************************************************************
 672  Wrapper for getpwnam(). Always returns a static that can be modified.
 673 ****************************************************************************/
 674
 675 struct passwd *sys_getpwnam(const char *name)
 676 {
 677         if (!name || !name[0])
 678                 return NULL;
 679
 680         /* check for a cache hit first */
 681         if (num_lookups && pw_cache.pass.pw_name && !strcmp(name, pw_cache.pass.pw_name)) {
 682                 return setup_pwret(&pw_cache.pass);
 683         }
 684
 685         return setup_pwret(getpwnam(name));
 686 }
 687
 688 /**************************************************************************
 689  Wrapper for getpwuid(). Always returns a static that can be modified.
 690 ****************************************************************************/
 691
 692 struct passwd *sys_getpwuid(uid_t uid)
 693 {
 694         if (num_lookups && pw_cache.pass.pw_name && (uid == pw_cache.pass.pw_uid)) {
 695                 return setup_pwret(&pw_cache.pass);
 696         }
 697
 698         return setup_pwret(getpwuid(uid));
 699 }
 700
 701 /**************************************************************************
 702  The following are the UNICODE versions of *all* system interface functions
 703  called within Samba. Ok, ok, the exceptions are the gethostbyXX calls,
 704  which currently are left as ascii as they are not used other than in name
 705  resolution.
 706 ****************************************************************************/
 707
 708 /**************************************************************************
 709  Wide stat. Just narrow and call sys_xxx.
 710 ****************************************************************************/
 711
 712 int wsys_stat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
 713 {
 714         pstring fname;
 715         return sys_stat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
 716 }
 717
 718 /**************************************************************************
 719  Wide lstat. Just narrow and call sys_xxx.
 720 ****************************************************************************/
 721
 722 int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
 723 {
 724         pstring fname;
 725         return sys_lstat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
 726 }
 727
 728 /**************************************************************************
 729  Wide creat. Just narrow and call sys_xxx.
 730 ****************************************************************************/
 731
 732 int wsys_creat(const smb_ucs2_t *wfname, mode_t mode)
 733 {
 734         pstring fname;
 735         return sys_creat(unicode_to_unix(fname,wfname,sizeof(fname)), mode);
 736 }
 737
 738 /**************************************************************************
 739  Wide open. Just narrow and call sys_xxx.
 740 ****************************************************************************/
 741
 742 int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode)
 743 {
 744         pstring fname;
 745         return sys_open(unicode_to_unix(fname,wfname,sizeof(fname)), oflag, mode);
 746 }
 747
 748 /**************************************************************************
 749  Wide fopen. Just narrow and call sys_xxx.
 750 ****************************************************************************/
 751
 752 FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type)
 753 {
 754         pstring fname;
 755         return sys_fopen(unicode_to_unix(fname,wfname,sizeof(fname)), type);
 756 }
 757
 758 /**************************************************************************
 759  Wide opendir. Just narrow and call sys_xxx.
 760 ****************************************************************************/
 761
 762 DIR *wsys_opendir(const smb_ucs2_t *wfname)
 763 {
 764         pstring fname;
 765         return opendir(unicode_to_unix(fname,wfname,sizeof(fname)));
 766 }
 767
 768 /**************************************************************************
 769  Wide readdir. Return a structure pointer containing a wide filename.
 770 ****************************************************************************/
 771
 772 SMB_STRUCT_WDIRENT *wsys_readdir(DIR *dirp)
 773 {
 774         static SMB_STRUCT_WDIRENT retval;
 775         SMB_STRUCT_DIRENT *dirval = sys_readdir(dirp);
 776
 777         if(!dirval)
 778                 return NULL;
 779
 780         /*
 781          * The only POSIX defined member of this struct is d_name.
 782          */
 783
 784         unix_to_unicode(retval.d_name,dirval->d_name,sizeof(retval.d_name));
 785
 786         return &retval;
 787 }
 788
 789 /**************************************************************************
 790  Wide getwd. Call sys_xxx and widen. Assumes s points to a wpstring.
 791 ****************************************************************************/
 792
 793 smb_ucs2_t *wsys_getwd(smb_ucs2_t *s)
 794 {
 795         pstring fname;
 796         char *p = sys_getwd(fname);
 797
 798         if(!p)
 799                 return NULL;
 800
 801         return unix_to_unicode(s, p, sizeof(wpstring));
 802 }
 803
 804 /**************************************************************************
 805  Wide chown. Just narrow and call sys_xxx.
 806 ****************************************************************************/
 807
 808 int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid)
 809 {
 810         pstring fname;
 811         return chown(unicode_to_unix(fname,wfname,sizeof(fname)), uid, gid);
 812 }
 813
 814 /**************************************************************************
 815  Wide chroot. Just narrow and call sys_xxx.
 816 ****************************************************************************/
 817
 818 int wsys_chroot(const smb_ucs2_t *wfname)
 819 {
 820         pstring fname;
 821         return chroot(unicode_to_unix(fname,wfname,sizeof(fname)));
 822 }
 823
 824 /**************************************************************************
 825  Wide getpwnam. Return a structure pointer containing wide names.
 826 ****************************************************************************/
 827
 828 SMB_STRUCT_WPASSWD *wsys_getpwnam(const smb_ucs2_t *wname)
 829 {
 830         static SMB_STRUCT_WPASSWD retval;
 831         fstring name;
 832         struct passwd *pwret = sys_getpwnam(unicode_to_unix(name,wname,sizeof(name)));
 833
 834         if(!pwret)
 835                 return NULL;
 836
 837         unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name));
 838         retval.pw_passwd = pwret->pw_passwd;
 839         retval.pw_uid = pwret->pw_uid;
 840         retval.pw_gid = pwret->pw_gid;
 841         unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos));
 842         unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir));
 843         unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell));
 844
 845         return &retval;
 846 }
 847
 848 /**************************************************************************
 849  Wide getpwuid. Return a structure pointer containing wide names.
 850 ****************************************************************************/
 851
 852 SMB_STRUCT_WPASSWD *wsys_getpwuid(uid_t uid)
 853 {
 854         static SMB_STRUCT_WPASSWD retval;
 855         struct passwd *pwret = sys_getpwuid(uid);
 856
 857         if(!pwret)
 858                 return NULL;
 859
 860         unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name));
 861         retval.pw_passwd = pwret->pw_passwd;
 862         retval.pw_uid = pwret->pw_uid;
 863         retval.pw_gid = pwret->pw_gid;
 864         unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos));
 865         unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir));
 866         unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell));
 867
 868         return &retval;
 869 }
 870
 871 /**************************************************************************
 872  Extract a command into an arg list. Uses a static pstring for storage.
 873  Caller frees returned arg list (which contains pointers into the static pstring).
 874 ****************************************************************************/
 875
 876 static char **extract_args(const char *command)
 877 {
 878         static pstring trunc_cmd;
 879         char *ptr;
 880         int argcl;
 881         char **argl = NULL;
 882         int i;
 883
 884         pstrcpy(trunc_cmd, command);
 885
 886         if(!(ptr = strtok(trunc_cmd, " \t"))) {
 887                 errno = EINVAL;
 888                 return NULL;
 889         }
 890
 891         /*
 892          * Count the args.
 893          */
 894
 895         for( argcl = 1; ptr; ptr = strtok(NULL, " \t"))
 896                 argcl++;
 897
 898         if((argl = (char **)malloc((argcl + 1) * sizeof(char *))) == NULL)
 899                 return NULL;
 900
 901         /*
 902          * Now do the extraction.
 903          */
 904
 905         pstrcpy(trunc_cmd, command);
 906
 907         ptr = strtok(trunc_cmd, " \t");
 908         i = 0;
 909         argl[i++] = ptr;
 910
 911         while((ptr = strtok(NULL, " \t")) != NULL)
 912                 argl[i++] = ptr;
 913
 914         argl[i++] = NULL;
 915         return argl;
 916 }
 917
 918 /**************************************************************************
 919  Wrapper for fork. Ensures that mypid is reset. Used so we can write
 920  a sys_getpid() that only does a system call *once*.
 921 ****************************************************************************/
 922
 923 static pid_t mypid = (pid_t)-1;
 924
 925 pid_t sys_fork(void)
 926 {
 927         pid_t forkret = fork();
 928
 929         if (forkret == (pid_t)0) /* Child - reset mypid so sys_getpid does a system call. */
 930                 mypid = (pid_t) -1;
 931
 932         return forkret;
 933 }
 934
 935 /**************************************************************************
 936  Wrapper for getpid. Ensures we only do a system call *once*.
 937 ****************************************************************************/
 938
 939 pid_t sys_getpid(void)
 940 {
 941         if (mypid == (pid_t)-1)
 942                 mypid = getpid();
 943
 944         return mypid;
 945 }
 946
 947 /**************************************************************************
 948  Wrapper for popen. Safer as it doesn't search a path.
 949  Modified from the glibc sources.
 950  modified by tridge to return a file descriptor. We must kick our FILE* habit
 951 ****************************************************************************/
 952
 953 typedef struct _popen_list
 954 {
 955         int fd;
 956         pid_t child_pid;
 957         struct _popen_list *next;
 958 } popen_list;
 959
 960 static popen_list *popen_chain;
 961
 962 int sys_popen(const char *command)
 963 {
 964         int parent_end, child_end;
 965         int pipe_fds[2];
 966         popen_list *entry = NULL;
 967         char **argl = NULL;
 968
 969         if (pipe(pipe_fds) < 0)
 970                 return -1;
 971
 972         parent_end = pipe_fds[0];
 973         child_end = pipe_fds[1];
 974
 975         if (!*command) {
 976                 errno = EINVAL;
 977                 goto err_exit;
 978         }
 979
 980         if((entry = (popen_list *)malloc(sizeof(popen_list))) == NULL)
 981                 goto err_exit;
 982
 983         ZERO_STRUCTP(entry);
 984
 985         /*
 986          * Extract the command and args into a NULL terminated array.
 987          */
 988
 989         if(!(argl = extract_args(command)))
 990                 goto err_exit;
 991
 992         entry->child_pid = sys_fork();
 993
 994         if (entry->child_pid == -1) {
 995                 goto err_exit;
 996         }
 997
 998         if (entry->child_pid == 0) {
 999
1000                 /*
1001                  * Child !
1002                  */
1003
1004                 int child_std_end = STDOUT_FILENO;
1005                 popen_list *p;
1006
1007                 close(parent_end);
1008                 if (child_end != child_std_end) {
1009                         dup2 (child_end, child_std_end);
1010                         close (child_end);
1011                 }
1012
1013                 /*
1014                  * POSIX.2:  "popen() shall ensure that any streams from previous
1015                  * popen() calls that remain open in the parent process are closed
1016                  * in the new child process."
1017                  */
1018
1019                 for (p = popen_chain; p; p = p->next)
1020                         close(p->fd);
1021
1022                 execv(argl[0], argl);
1023                 _exit (127);
1024         }
1025
1026         /*
1027          * Parent.
1028          */
1029
1030         close (child_end);
1031         free((char *)argl);
1032
1033         /* Link into popen_chain. */
1034         entry->next = popen_chain;
1035         popen_chain = entry;
1036         entry->fd = parent_end;
1037
1038         return entry->fd;
1039
1040 err_exit:
1041
1042         if(entry)
1043                 free((char *)entry);
1044         if(argl)
1045                 free((char *)argl);
1046         close(pipe_fds[0]);
1047         close(pipe_fds[1]);
1048         return -1;
1049 }
1050
1051 /**************************************************************************
1052  Wrapper for pclose. Modified from the glibc sources.
1053 ****************************************************************************/
1054 int sys_pclose(int fd)
1055 {
1056         int wstatus;
1057         popen_list **ptr = &popen_chain;
1058         popen_list *entry = NULL;
1059         pid_t wait_pid;
1060         int status = -1;
1061
1062         /* Unlink from popen_chain. */
1063         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1064                 if ((*ptr)->fd == fd) {
1065                         entry = *ptr;
1066                         *ptr = (*ptr)->next;
1067                         status = 0;
1068                         break;
1069                 }
1070         }
1071
1072         if (status < 0 || close(entry->fd) < 0)
1073                 return -1;
1074
1075         /*
1076          * As Samba is catching and eating child process
1077          * exits we don't really care about the child exit
1078          * code, a -1 with errno = ECHILD will do fine for us.
1079          */
1080
1081         do {
1082                 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1083         } while (wait_pid == -1 && errno == EINTR);
1084
1085         free((char *)entry);
1086
1087         if (wait_pid == -1)
1088                 return -1;
1089         return wstatus;
1090 }
1091
1092 /**************************************************************************
1093  Wrappers for dlopen, dlsym, dlclose.
1094 ****************************************************************************/
1095
1096 void *sys_dlopen(const char *name, int flags)
1097 {
1098 #ifdef HAVE_LIBDL
1099         return dlopen(name, flags);
1100 #else
1101         return NULL;
1102 #endif
1103 }
1104
1105 void *sys_dlsym(void *handle, char *symbol)
1106 {
1107 #ifdef HAVE_LIBDL
1108     return dlsym(handle, symbol);
1109 #else
1110     return NULL;
1111 #endif
1112 }
1113
1114 int sys_dlclose (void *handle)
1115 {
1116 #ifdef HAVE_LIBDL
1117         return dlclose(handle);
1118 #else
1119         return 0;
1120 #endif
1121 }