source/lib/replace.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    replacement routines for broken systems
   5    Copyright (C) Andrew Tridgell 1992-1997
   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  void replace_dummy(void)
  28 {}
  29
  30 #ifdef REPLACE_STRLEN
  31 /****************************************************************************
  32 a replacement strlen() that returns int for solaris
  33 ****************************************************************************/
  34  int Strlen(char *s)
  35 {
  36   int ret=0;
  37   if (!s) return(0);
  38   while (*s++) ret++;
  39   return(ret);
  40 }
  41 #endif
  42
  43 #ifdef NO_FTRUNCATE
  44  /*******************************************************************
  45 ftruncate for operating systems that don't have it
  46 ********************************************************************/
  47  int ftruncate(int f,long l)
  48 {
  49       struct  flock   fl;
  50
  51       fl.l_whence = 0;
  52       fl.l_len = 0;
  53       fl.l_start = l;
  54       fl.l_type = F_WRLCK;
  55       return fcntl(f, F_FREESP, &fl);
  56 }
  57 #endif
  58
  59
  60 #ifdef REPLACE_STRSTR
  61 /****************************************************************************
  62 Mips version of strstr doesn't seem to work correctly.
  63 There is a #define in includes.h to redirect calls to this function.
  64 ****************************************************************************/
  65 char *Strstr(char *s, char *p)
  66 {
  67         int len = strlen(p);
  68
  69         while ( *s != '\0' ) {
  70                 if ( strncmp(s, p, len) == 0 )
  71                 return s;
  72                 s++;
  73         }
  74
  75         return NULL;
  76 }
  77 #endif /* REPLACE_STRSTR */
  78
  79
  80 #ifdef REPLACE_MKTIME
  81 /*******************************************************************
  82 a mktime() replacement for those who don't have it - contributed by
  83 C.A. Lademann <cal@zls.com>
  84 ********************************************************************/
  85 #define  MINUTE  60
  86 #define  HOUR    60*MINUTE
  87 #define  DAY             24*HOUR
  88 #define  YEAR    365*DAY
  89 time_t Mktime(struct tm      *t)
  90 {
  91   struct tm       *u;
  92   time_t  epoch = 0;
  93   int             mon [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  94   y, m, i;
  95
  96   if(t->tm_year < 70)
  97     return((time_t)-1);
  98
  99   epoch = (t->tm_year - 70) * YEAR +
 100     (t->tm_year / 4 - 70 / 4 - t->tm_year / 100) * DAY;
 101
 102   y = t->tm_year;
 103   m = 0;
 104
 105   for(i = 0; i < t->tm_mon; i++) {
 106     epoch += mon [m] * DAY;
 107     if(m == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
 108       epoch += DAY;
 109
 110     if(++m > 11) {
 111       m = 0;
 112       y++;
 113     }
 114   }
 115
 116   epoch += (t->tm_mday - 1) * DAY;
 117   epoch += t->tm_hour * HOUR + t->tm_min * MINUTE + t->tm_sec;
 118
 119   if((u = localtime(&epoch)) != NULL) {
 120     t->tm_sec = u->tm_sec;
 121     t->tm_min = u->tm_min;
 122     t->tm_hour = u->tm_hour;
 123     t->tm_mday = u->tm_mday;
 124     t->tm_mon = u->tm_mon;
 125     t->tm_year = u->tm_year;
 126     t->tm_wday = u->tm_wday;
 127     t->tm_yday = u->tm_yday;
 128     t->tm_isdst = u->tm_isdst;
 129 #ifndef NO_TM_NAME
 130     memcpy(t->tm_name, u->tm_name, LTZNMAX);
 131 #endif
 132   }
 133
 134   return(epoch);
 135 }
 136 #endif /* REPLACE_MKTIME */
 137
 138
 139
 140 #ifdef REPLACE_RENAME
 141 /* Rename a file. (from libiberty in GNU binutils)  */
 142  int rename (zfrom, zto)
 143      const char *zfrom;
 144      const char *zto;
 145 {
 146   if (link (zfrom, zto) < 0)
 147     {
 148       if (errno != EEXIST)
 149         return -1;
 150       if (unlink (zto) < 0
 151           || link (zfrom, zto) < 0)
 152         return -1;
 153     }
 154   return unlink (zfrom);
 155 }
 156 #endif
 157
 158
 159 #ifdef REPLACE_INNETGR
 160 /*
 161  * Search for a match in a netgroup. This replaces it on broken systems.
 162  */
 163 int InNetGr(char *group,char *host,char *user,char *dom)
 164 {
 165   char *hst, *usr, *dm;
 166
 167   setnetgrent(group);
 168   while (getnetgrent(&hst, &usr, &dm))
 169     if (((host == 0) || (hst == 0) || !strcmp(host, hst)) &&
 170         ((user == 0) || (usr == 0) || !strcmp(user, usr)) &&
 171         ((dom == 0) || (dm == 0) || !strcmp(dom, dm))) {
 172       endnetgrent();
 173       return (1);
 174     }
 175   endnetgrent();
 176   return (0);
 177 }
 178 #endif
 179
 180
 181
 182 #ifdef NO_INITGROUPS
 183 #include <sys/types.h>
 184 #include <limits.h>
 185 #include <grp.h>
 186
 187 #ifndef NULL
 188 #define NULL (void *)0
 189 #endif
 190
 191 /****************************************************************************
 192  some systems don't have an initgroups call
 193 ****************************************************************************/
 194  int initgroups(char *name,gid_t id)
 195 {
 196 #ifdef NO_SETGROUPS
 197   /* yikes! no SETGROUPS or INITGROUPS? how can this work? */
 198   return(0);
 199 #else
 200   gid_t  grouplst[NGROUPS_MAX];
 201   int    i,j;
 202   struct group *g;
 203   char   *gr;
 204
 205   grouplst[0] = id;
 206   i = 1;
 207   while (i < NGROUPS_MAX &&
 208          ((g = (struct group *)getgrent()) != (struct group *)NULL))
 209     {
 210       if (g->gr_gid == id)
 211         continue;
 212       j = 0;
 213       gr = g->gr_mem[0];
 214       while (gr && (*gr != (char)NULL)) {
 215         if (strcmp(name,gr) == 0) {
 216           grouplst[i] = g->gr_gid;
 217           i++;
 218           gr = (char *)NULL;
 219           break;
 220         }
 221         gr = g->gr_mem[++j];
 222       }
 223     }
 224   endgrent();
 225   return(setgroups(i,grouplst));
 226 #endif
 227 }
 228 #endif
 229
 230
 231 #if (defined(SecureWare) && defined(SCO))
 232 /* This is needed due to needing the nap() function but we don't want
 233    to include the Xenix libraries since that will break other things...
 234    BTW: system call # 0x0c28 is the same as calling nap() */
 235 long nap(long milliseconds) {
 236   return syscall(0x0c28, milliseconds);
 237 }
 238 #endif
 239
 240
 241
 242 #if WRAP_MALLOC
 243
 244 /* undo the wrapping temporarily */
 245 #undef malloc
 246 #undef realloc
 247 #undef free
 248
 249 /****************************************************************************
 250 wrapper for malloc() to catch memory errors
 251 ****************************************************************************/
 252 void *malloc_wrapped(int size,char *file,int line)
 253 {
 254 #ifdef xx_old_malloc
 255   void *res = xx_old_malloc(size);
 256 #else
 257   void *res = malloc(size);
 258 #endif
 259   DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n",
 260         file,line,
 261         size,(unsigned int)res));
 262   return(res);
 263 }
 264
 265 /****************************************************************************
 266 wrapper for realloc() to catch memory errors
 267 ****************************************************************************/
 268 void *realloc_wrapped(void *ptr,int size,char *file,int line)
 269 {
 270 #ifdef xx_old_realloc
 271   void *res = xx_old_realloc(ptr,size);
 272 #else
 273   void *res = realloc(ptr,size);
 274 #endif
 275   DEBUG(3,("Realloc\n"));
 276   DEBUG(3,("free called from %s(%d) with ptr=0x%X\n",
 277         file,line,
 278         (unsigned int)ptr));
 279   DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n",
 280         file,line,
 281         size,(unsigned int)res));
 282   return(res);
 283 }
 284
 285 /****************************************************************************
 286 wrapper for free() to catch memory errors
 287 ****************************************************************************/
 288 void free_wrapped(void *ptr,char *file,int line)
 289 {
 290 #ifdef xx_old_free
 291   xx_old_free(ptr);
 292 #else
 293   free(ptr);
 294 #endif
 295   DEBUG(3,("free called from %s(%d) with ptr=0x%X\n",
 296         file,line,(unsigned int)ptr));
 297   return;
 298 }
 299
 300 /* and re-do the define for spots lower in this file */
 301 #define malloc(size) malloc_wrapped(size,__FILE__,__LINE__)
 302 #define realloc(ptr,size) realloc_wrapped(ptr,size,__FILE__,__LINE__)
 303 #define free(ptr) free_wrapped(ptr,__FILE__,__LINE__)
 304
 305 #endif
 306
 307
 308 #if WRAP_MEMCPY
 309 #undef memcpy
 310 /*******************************************************************
 311 a wrapper around memcpy for diagnostic purposes
 312 ********************************************************************/
 313 void *memcpy_wrapped(void *d,void *s,int l,char *fname,int line)
 314 {
 315   if (l>64 && (((int)d)%4) != (((int)s)%4))
 316     DEBUG(4,("Misaligned memcpy(0x%X,0x%X,%d) at %s(%d)\n",d,s,l,fname,line));
 317 #ifdef xx_old_memcpy
 318   return(xx_old_memcpy(d,s,l));
 319 #else
 320   return(memcpy(d,s,l));
 321 #endif
 322 }
 323 #define memcpy(d,s,l) memcpy_wrapped(d,s,l,__FILE__,__LINE__)
 324 #endif
 325