source/lib/replace/replace.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    replacement routines for broken systems
   4    Copyright (C) Andrew Tridgell 1992-1998
   5
   6      ** NOTE! The following LGPL license applies to the replace
   7      ** library. This does NOT imply that all of Samba is released
   8      ** under the LGPL
   9
  10    This library is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU Lesser General Public
  12    License as published by the Free Software Foundation; either
  13    version 3 of the License, or (at your option) any later version.
  14
  15    This library 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 GNU
  18    Lesser General Public License for more details.
  19
  20    You should have received a copy of the GNU Lesser General Public
  21    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "replace.h"
  25
  26 #include "system/filesys.h"
  27 #include "system/time.h"
  28 #include "system/passwd.h"
  29 #include "system/syslog.h"
  30 #include "system/network.h"
  31 #include "system/locale.h"
  32 #include "system/wait.h"
  33
  34 void replace_dummy(void);
  35 void replace_dummy(void) {}
  36
  37 #ifndef HAVE_FTRUNCATE
  38  /*******************************************************************
  39 ftruncate for operating systems that don't have it
  40 ********************************************************************/
  41 int rep_ftruncate(int f, off_t l)
  42 {
  43 #ifdef HAVE_CHSIZE
  44       return chsize(f,l);
  45 #elif defined(F_FREESP)
  46       struct  flock   fl;
  47
  48       fl.l_whence = 0;
  49       fl.l_len = 0;
  50       fl.l_start = l;
  51       fl.l_type = F_WRLCK;
  52       return fcntl(f, F_FREESP, &fl);
  53 #else
  54 #error "you must have a ftruncate function"
  55 #endif
  56 }
  57 #endif /* HAVE_FTRUNCATE */
  58
  59
  60 #ifndef HAVE_STRLCPY
  61 /* like strncpy but does not 0 fill the buffer and always null
  62    terminates. bufsize is the size of the destination buffer */
  63 size_t rep_strlcpy(char *d, const char *s, size_t bufsize)
  64 {
  65         size_t len = strlen(s);
  66         size_t ret = len;
  67         if (bufsize <= 0) return 0;
  68         if (len >= bufsize) len = bufsize-1;
  69         memcpy(d, s, len);
  70         d[len] = 0;
  71         return ret;
  72 }
  73 #endif
  74
  75 #ifndef HAVE_STRLCAT
  76 /* like strncat but does not 0 fill the buffer and always null
  77    terminates. bufsize is the length of the buffer, which should
  78    be one more than the maximum resulting string length */
  79 size_t rep_strlcat(char *d, const char *s, size_t bufsize)
  80 {
  81         size_t len1 = strlen(d);
  82         size_t len2 = strlen(s);
  83         size_t ret = len1 + len2;
  84
  85         if (len1+len2 >= bufsize) {
  86                 len2 = bufsize - (len1+1);
  87         }
  88         if (len2 > 0) {
  89                 memcpy(d+len1, s, len2);
  90                 d[len1+len2] = 0;
  91         }
  92         return ret;
  93 }
  94 #endif
  95
  96 #ifndef HAVE_MKTIME
  97 /*******************************************************************
  98 a mktime() replacement for those who don't have it - contributed by
  99 C.A. Lademann <cal@zls.com>
 100 Corrections by richard.kettlewell@kewill.com
 101 ********************************************************************/
 102
 103 #define  MINUTE  60
 104 #define  HOUR    60*MINUTE
 105 #define  DAY             24*HOUR
 106 #define  YEAR    365*DAY
 107 time_t rep_mktime(struct tm *t)
 108 {
 109   struct tm       *u;
 110   time_t  epoch = 0;
 111   int n;
 112   int             mon [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
 113   y, m, i;
 114
 115   if(t->tm_year < 70)
 116     return((time_t)-1);
 117
 118   n = t->tm_year + 1900 - 1;
 119   epoch = (t->tm_year - 70) * YEAR +
 120     ((n / 4 - n / 100 + n / 400) - (1969 / 4 - 1969 / 100 + 1969 / 400)) * DAY;
 121
 122   y = t->tm_year + 1900;
 123   m = 0;
 124
 125   for(i = 0; i < t->tm_mon; i++) {
 126     epoch += mon [m] * DAY;
 127     if(m == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
 128       epoch += DAY;
 129
 130     if(++m > 11) {
 131       m = 0;
 132       y++;
 133     }
 134   }
 135
 136   epoch += (t->tm_mday - 1) * DAY;
 137   epoch += t->tm_hour * HOUR + t->tm_min * MINUTE + t->tm_sec;
 138
 139   if((u = localtime(&epoch)) != NULL) {
 140     t->tm_sec = u->tm_sec;
 141     t->tm_min = u->tm_min;
 142     t->tm_hour = u->tm_hour;
 143     t->tm_mday = u->tm_mday;
 144     t->tm_mon = u->tm_mon;
 145     t->tm_year = u->tm_year;
 146     t->tm_wday = u->tm_wday;
 147     t->tm_yday = u->tm_yday;
 148     t->tm_isdst = u->tm_isdst;
 149   }
 150
 151   return(epoch);
 152 }
 153 #endif /* !HAVE_MKTIME */
 154
 155
 156 #ifndef HAVE_INITGROUPS
 157 /****************************************************************************
 158  some systems don't have an initgroups call
 159 ****************************************************************************/
 160 int rep_initgroups(char *name, gid_t id)
 161 {
 162 #ifndef HAVE_SETGROUPS
 163         /* yikes! no SETGROUPS or INITGROUPS? how can this work? */
 164         errno = ENOSYS;
 165         return -1;
 166 #else /* HAVE_SETGROUPS */
 167
 168 #include <grp.h>
 169
 170         gid_t *grouplst = NULL;
 171         int max_gr = 32;
 172         int ret;
 173         int    i,j;
 174         struct group *g;
 175         char   *gr;
 176
 177         if((grouplst = malloc(sizeof(gid_t) * max_gr)) == NULL) {
 178                 errno = ENOMEM;
 179                 return -1;
 180         }
 181
 182         grouplst[0] = id;
 183         i = 1;
 184         while (i < max_gr && ((g = (struct group *)getgrent()) != (struct group *)NULL)) {
 185                 if (g->gr_gid == id)
 186                         continue;
 187                 j = 0;
 188                 gr = g->gr_mem[0];
 189                 while (gr && (*gr != (char)NULL)) {
 190                         if (strcmp(name,gr) == 0) {
 191                                 grouplst[i] = g->gr_gid;
 192                                 i++;
 193                                 gr = (char *)NULL;
 194                                 break;
 195                         }
 196                         gr = g->gr_mem[++j];
 197                 }
 198         }
 199         endgrent();
 200         ret = setgroups(i, grouplst);
 201         free(grouplst);
 202         return ret;
 203 #endif /* HAVE_SETGROUPS */
 204 }
 205 #endif /* HAVE_INITGROUPS */
 206
 207
 208 #if (defined(SecureWare) && defined(SCO))
 209 /* This is needed due to needing the nap() function but we don't want
 210    to include the Xenix libraries since that will break other things...
 211    BTW: system call # 0x0c28 is the same as calling nap() */
 212 long nap(long milliseconds) {
 213          return syscall(0x0c28, milliseconds);
 214  }
 215 #endif
 216
 217
 218 #ifndef HAVE_MEMMOVE
 219 /*******************************************************************
 220 safely copies memory, ensuring no overlap problems.
 221 this is only used if the machine does not have its own memmove().
 222 this is not the fastest algorithm in town, but it will do for our
 223 needs.
 224 ********************************************************************/
 225 void *rep_memmove(void *dest,const void *src,int size)
 226 {
 227         unsigned long d,s;
 228         int i;
 229         if (dest==src || !size) return(dest);
 230
 231         d = (unsigned long)dest;
 232         s = (unsigned long)src;
 233
 234         if ((d >= (s+size)) || (s >= (d+size))) {
 235                 /* no overlap */
 236                 memcpy(dest,src,size);
 237                 return(dest);
 238         }
 239
 240         if (d < s) {
 241                 /* we can forward copy */
 242                 if (s-d >= sizeof(int) &&
 243                     !(s%sizeof(int)) &&
 244                     !(d%sizeof(int)) &&
 245                     !(size%sizeof(int))) {
 246                         /* do it all as words */
 247                         int *idest = (int *)dest;
 248                         int *isrc = (int *)src;
 249                         size /= sizeof(int);
 250                         for (i=0;i<size;i++) idest[i] = isrc[i];
 251                 } else {
 252                         /* simplest */
 253                         char *cdest = (char *)dest;
 254                         char *csrc = (char *)src;
 255                         for (i=0;i<size;i++) cdest[i] = csrc[i];
 256                 }
 257         } else {
 258                 /* must backward copy */
 259                 if (d-s >= sizeof(int) &&
 260                     !(s%sizeof(int)) &&
 261                     !(d%sizeof(int)) &&
 262                     !(size%sizeof(int))) {
 263                         /* do it all as words */
 264                         int *idest = (int *)dest;
 265                         int *isrc = (int *)src;
 266                         size /= sizeof(int);
 267                         for (i=size-1;i>=0;i--) idest[i] = isrc[i];
 268                 } else {
 269                         /* simplest */
 270                         char *cdest = (char *)dest;
 271                         char *csrc = (char *)src;
 272                         for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
 273                 }
 274         }
 275         return(dest);
 276 }
 277 #endif /* HAVE_MEMMOVE */
 278
 279 #ifndef HAVE_STRDUP
 280 /****************************************************************************
 281 duplicate a string
 282 ****************************************************************************/
 283 char *rep_strdup(const char *s)
 284 {
 285         size_t len;
 286         char *ret;
 287
 288         if (!s) return(NULL);
 289
 290         len = strlen(s)+1;
 291         ret = (char *)malloc(len);
 292         if (!ret) return(NULL);
 293         memcpy(ret,s,len);
 294         return(ret);
 295 }
 296 #endif /* HAVE_STRDUP */
 297
 298 #ifndef HAVE_SETLINEBUF
 299 void rep_setlinebuf(FILE *stream)
 300 {
 301         setvbuf(stream, (char *)NULL, _IOLBF, 0);
 302 }
 303 #endif /* HAVE_SETLINEBUF */
 304
 305 #ifndef HAVE_VSYSLOG
 306 #ifdef HAVE_SYSLOG
 307 void rep_vsyslog (int facility_priority, const char *format, va_list arglist)
 308 {
 309         char *msg = NULL;
 310         vasprintf(&msg, format, arglist);
 311         if (!msg)
 312                 return;
 313         syslog(facility_priority, "%s", msg);
 314         free(msg);
 315 }
 316 #endif /* HAVE_SYSLOG */
 317 #endif /* HAVE_VSYSLOG */
 318
 319 #ifndef HAVE_STRNLEN
 320 /**
 321  Some platforms don't have strnlen
 322 **/
 323  size_t rep_strnlen(const char *s, size_t max)
 324 {
 325         size_t len;
 326
 327         for (len = 0; len < max; len++) {
 328                 if (s[len] == '\0') {
 329                         break;
 330                 }
 331         }
 332         return len;
 333 }
 334 #endif
 335
 336 #ifndef HAVE_STRNDUP
 337 /**
 338  Some platforms don't have strndup.
 339 **/
 340 char *rep_strndup(const char *s, size_t n)
 341 {
 342         char *ret;
 343
 344         n = strnlen(s, n);
 345         ret = malloc(n+1);
 346         if (!ret)
 347                 return NULL;
 348         memcpy(ret, s, n);
 349         ret[n] = 0;
 350
 351         return ret;
 352 }
 353 #endif
 354
 355 #ifndef HAVE_WAITPID
 356 int rep_waitpid(pid_t pid,int *status,int options)
 357 {
 358   return wait4(pid, status, options, NULL);
 359 }
 360 #endif
 361
 362 #ifndef HAVE_SETEUID
 363 int rep_seteuid(uid_t euid)
 364 {
 365 #ifdef HAVE_SETRESUID
 366         return setresuid(-1, euid, -1);
 367 #else
 368 #  error "You need a seteuid function"
 369 #endif
 370 }
 371 #endif
 372
 373 #ifndef HAVE_SETEGID
 374 int rep_setegid(gid_t egid)
 375 {
 376 #ifdef HAVE_SETRESGID
 377         return setresgid(-1, egid, -1);
 378 #else
 379 #  error "You need a setegid function"
 380 #endif
 381 }
 382 #endif
 383
 384 /*******************************************************************
 385 os/2 also doesn't have chroot
 386 ********************************************************************/
 387 #ifndef HAVE_CHROOT
 388 int rep_chroot(const char *dname)
 389 {
 390         errno = ENOSYS;
 391         return -1;
 392 }
 393 #endif
 394
 395 /*****************************************************************
 396  Possibly replace mkstemp if it is broken.
 397 *****************************************************************/
 398
 399 #ifndef HAVE_SECURE_MKSTEMP
 400 int rep_mkstemp(char *template)
 401 {
 402         /* have a reasonable go at emulating it. Hope that
 403            the system mktemp() isn't completly hopeless */
 404         char *p = mktemp(template);
 405         if (!p)
 406                 return -1;
 407         return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
 408 }
 409 #endif
 410
 411 #ifndef HAVE_MKDTEMP
 412 char *rep_mkdtemp(char *template)
 413 {
 414         char *dname;
 415
 416         if ((dname = mktemp(template))) {
 417                 if (mkdir(dname, 0700) >= 0) {
 418                         return dname;
 419                 }
 420         }
 421
 422         return NULL;
 423 }
 424 #endif
 425
 426 /*****************************************************************
 427  Watch out: this is not thread safe.
 428 *****************************************************************/
 429
 430 #ifndef HAVE_PREAD
 431 ssize_t rep_pread(int __fd, void *__buf, size_t __nbytes, off_t __offset)
 432 {
 433         if (lseek(__fd, __offset, SEEK_SET) != __offset) {
 434                 return -1;
 435         }
 436         return read(__fd, __buf, __nbytes);
 437 }
 438 #endif
 439
 440 /*****************************************************************
 441  Watch out: this is not thread safe.
 442 *****************************************************************/
 443
 444 #ifndef HAVE_PWRITE
 445 ssize_t rep_pwrite(int __fd, const void *__buf, size_t __nbytes, off_t __offset)
 446 {
 447         if (lseek(__fd, __offset, SEEK_SET) != __offset) {
 448                 return -1;
 449         }
 450         return write(__fd, __buf, __nbytes);
 451 }
 452 #endif
 453
 454 #ifndef HAVE_STRCASESTR
 455 char *rep_strcasestr(const char *haystack, const char *needle)
 456 {
 457         const char *s;
 458         size_t nlen = strlen(needle);
 459         for (s=haystack;*s;s++) {
 460                 if (toupper(*needle) == toupper(*s) &&
 461                     strncasecmp(s, needle, nlen) == 0) {
 462                         return (char *)((intptr_t)s);
 463                 }
 464         }
 465         return NULL;
 466 }
 467 #endif
 468
 469 #ifndef HAVE_STRTOK_R
 470 /* based on GLIBC version, copyright Free Software Foundation */
 471 char *rep_strtok_r(char *s, const char *delim, char **save_ptr)
 472 {
 473         char *token;
 474
 475         if (s == NULL) s = *save_ptr;
 476
 477         s += strspn(s, delim);
 478         if (*s == '\0') {
 479                 *save_ptr = s;
 480                 return NULL;
 481         }
 482
 483         token = s;
 484         s = strpbrk(token, delim);
 485         if (s == NULL) {
 486                 *save_ptr = token + strlen(token);
 487         } else {
 488                 *s = '\0';
 489                 *save_ptr = s + 1;
 490         }
 491
 492         return token;
 493 }
 494 #endif
 495
 496 #ifndef HAVE_STRTOLL
 497 long long int rep_strtoll(const char *str, char **endptr, int base)
 498 {
 499 #ifdef HAVE_STRTOQ
 500         return strtoq(str, endptr, base);
 501 #elif defined(HAVE___STRTOLL)
 502         return __strtoll(str, endptr, base);
 503 #elif SIZEOF_LONG == SIZEOF_LONG_LONG
 504         return (long long int) strtol(str, endptr, base);
 505 #else
 506 # error "You need a strtoll function"
 507 #endif
 508 }
 509 #endif
 510
 511
 512 #ifndef HAVE_STRTOULL
 513 unsigned long long int rep_strtoull(const char *str, char **endptr, int base)
 514 {
 515 #ifdef HAVE_STRTOUQ
 516         return strtouq(str, endptr, base);
 517 #elif defined(HAVE___STRTOULL)
 518         return __strtoull(str, endptr, base);
 519 #elif SIZEOF_LONG == SIZEOF_LONG_LONG
 520         return (unsigned long long int) strtoul(str, endptr, base);
 521 #else
 522 # error "You need a strtoull function"
 523 #endif
 524 }
 525 #endif
 526
 527 #ifndef HAVE_SETENV
 528 int rep_setenv(const char *name, const char *value, int overwrite)
 529 {
 530         char *p;
 531         size_t l1, l2;
 532         int ret;
 533
 534         if (!overwrite && getenv(name)) {
 535                 return 0;
 536         }
 537
 538         l1 = strlen(name);
 539         l2 = strlen(value);
 540
 541         p = malloc(l1+l2+2);
 542         if (p == NULL) {
 543                 return -1;
 544         }
 545         memcpy(p, name, l1);
 546         p[l1] = '=';
 547         memcpy(p+l1+1, value, l2);
 548         p[l1+l2+1] = 0;
 549
 550         ret = putenv(p);
 551         if (ret != 0) {
 552                 free(p);
 553         }
 554
 555         return ret;
 556 }
 557 #endif
 558
 559 #ifndef HAVE_UNSETENV
 560 int rep_unsetenv(const char *name)
 561 {
 562         extern char **environ;
 563         size_t len = strlen(name);
 564         size_t i, count;
 565
 566         if (environ == NULL || getenv(name) == NULL) {
 567                 return 0;
 568         }
 569
 570         for (i=0;environ[i];i++) /* noop */ ;
 571
 572         count=i;
 573
 574         for (i=0;i<count;) {
 575                 if (strncmp(environ[i], name, len) == 0 && environ[i][len] == '=') {
 576                         /* note: we do _not_ free the old variable here. It is unsafe to
 577                            do so, as the pointer may not have come from malloc */
 578                         memmove(&environ[i], &environ[i+1], (count-i)*sizeof(char *));
 579                         count--;
 580                 } else {
 581                         i++;
 582                 }
 583         }
 584
 585         return 0;
 586 }
 587 #endif