Fix from richard.kettlewell@kewill.com for leapyear bugs.
[ira/wip.git] / source3 / lib / replace.c
index c7340bbadd2246ed80bf7eae28ccc0e3a1c44931..b0adb72fd24ea4b564e00430bc34d18bd1b87660 100644 (file)
@@ -2,7 +2,7 @@
    Unix SMB/Netbios implementation.
    Version 1.9.
    replacement routines for broken systems
-   Copyright (C) Andrew Tridgell 1992-1995
+   Copyright (C) Andrew Tridgell 1992-1998
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
 extern int DEBUGLEVEL;
 
+ void replace_dummy(void);
+ void replace_dummy(void) {}
 
- void replace_dummy(void) 
-{}
 
-#ifdef REPLACE_STRLEN
-/****************************************************************************
-a replacement strlen() that returns int for solaris
-****************************************************************************/
- int Strlen(char *s)
-{
-  int ret=0;
-  if (!s) return(0);
-  while (*s++) ret++;
-  return(ret);
-}
-#endif
-
-#ifdef NO_FTRUNCATE
+#ifndef HAVE_FTRUNCATE
  /*******************************************************************
 ftruncate for operating systems that don't have it
 ********************************************************************/
- int ftruncate(int f,long l)
+ int ftruncate(int f,SMB_OFF_T l)
 {
       struct  flock   fl;
 
@@ -57,47 +44,31 @@ ftruncate for operating systems that don't have it
 #endif
 
 
-#ifdef REPLACE_STRSTR
-/****************************************************************************
-Mips version of strstr doesn't seem to work correctly.
-There is a #define in includes.h to redirect calls to this function.
-****************************************************************************/
-char *Strstr(char *s, char *p)
-{
-       int len = strlen(p);
-
-       while ( *s != '\0' ) {
-               if ( strncmp(s, p, len) == 0 )
-               return s;
-               s++;
-       }
-
-       return NULL;
-}
-#endif /* REPLACE_STRSTR */
-
-
-#ifdef REPLACE_MKTIME
+#ifndef HAVE_MKTIME
 /*******************************************************************
 a mktime() replacement for those who don't have it - contributed by 
 C.A. Lademann <cal@zls.com>
+Corrections by richard.kettlewell@kewill.com
 ********************************************************************/
+
 #define  MINUTE  60
 #define  HOUR    60*MINUTE
 #define  DAY             24*HOUR
 #define  YEAR    365*DAY
-time_t Mktime(struct tm      *t)
+ time_t mktime(struct tm *t)
 {
   struct tm       *u;
   time_t  epoch = 0;
+  int n;
   int             mon [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
   y, m, i;
 
   if(t->tm_year < 70)
     return((time_t)-1);
 
+  n = t->tm_year + 1900 - 1;
   epoch = (t->tm_year - 70) * YEAR + 
-    (t->tm_year / 4 - 70 / 4 - t->tm_year / 100) * DAY;
+    ((n / 4 - n / 100 + n / 400) - (1969 / 4 - 1969 / 100 + 1969 / 400)) * DAY;
 
   y = t->tm_year;
   m = 0;
@@ -126,22 +97,17 @@ time_t Mktime(struct tm      *t)
     t->tm_wday = u->tm_wday;
     t->tm_yday = u->tm_yday;
     t->tm_isdst = u->tm_isdst;
-#ifndef NO_TM_NAME
-    memcpy(t->tm_name, u->tm_name, LTZNMAX);
-#endif
   }
 
   return(epoch);
 }
-#endif /* REPLACE_MKTIME */
+#endif /* !HAVE_MKTIME */
 
 
 
-#ifdef REPLACE_RENAME
+#ifndef HAVE_RENAME
 /* Rename a file. (from libiberty in GNU binutils)  */
- int rename (zfrom, zto)
-     const char *zfrom;
-     const char *zto;
+ int rename(const char *zfrom, const char *zto)
 {
   if (link (zfrom, zto) < 0)
     {
@@ -156,73 +122,70 @@ time_t Mktime(struct tm      *t)
 #endif
 
 
-#ifdef REPLACE_INNETGR
+#ifndef HAVE_INNETGR
 /*
  * Search for a match in a netgroup. This replaces it on broken systems.
  */
-int InNetGr(char *group,char *host,char *user,char *dom)
+ int innetgr(char *group,char *host,char *user,char *dom)
 {
-  char *hst, *usr, *dm;
+       char *hst, *usr, *dm;
   
-  setnetgrent(group);
-  while (getnetgrent(&hst, &usr, &dm))
-    if (((host == 0) || (hst == 0) || !strcmp(host, hst)) &&
-       ((user == 0) || (usr == 0) || !strcmp(user, usr)) &&
-       ((dom == 0) || (dm == 0) || !strcmp(dom, dm))) {
-      endnetgrent();
-      return (1);
-    }
-  endnetgrent();
-  return (0);
+       setnetgrent(group);
+       while (getnetgrent(&hst, &usr, &dm)) {
+               if (((host == 0) || (hst == 0) || !strcmp(host, hst)) &&
+                   ((user == 0) || (usr == 0) || !strcmp(user, usr)) &&
+                   ((dom == 0) || (dm == 0) || !strcmp(dom, dm))) {
+                       endnetgrent();
+                       return (1);
+               }
+       }
+       endnetgrent();
+       return (0);
 }
 #endif
 
 
 
-#ifdef NO_INITGROUPS
-#include <sys/types.h>
-#include <limits.h>
-#include <grp.h>
-
-#ifndef NULL
-#define NULL (void *)0
-#endif
-
+#ifndef HAVE_INITGROUPS
 /****************************************************************************
  some systems don't have an initgroups call 
 ****************************************************************************/
  int initgroups(char *name,gid_t id)
 {
-#ifdef NO_SETGROUPS
-  /* yikes! no SETGROUPS or INITGROUPS? how can this work? */
-  return(0);
+#ifndef HAVE_SETGROUPS
+       static int done;
+       if (!done) {
+               DEBUG(1,("WARNING: running without setgroups\n"));
+               done=1;
+       }
+       /* yikes! no SETGROUPS or INITGROUPS? how can this work? */
+       return(0);
 #else
-  gid_t  grouplst[NGROUPS_MAX];
-  int    i,j;
-  struct group *g;
-  char   *gr;
-
-  grouplst[0] = id;
-  i = 1;
-  while (i < NGROUPS_MAX && 
-        ((g = (struct group *)getgrent()) != (struct group *)NULL)) 
-    {
-      if (g->gr_gid == id)
-       continue;
-      j = 0;
-      gr = g->gr_mem[0];
-      while (gr && (*gr != (char)NULL)) {
-       if (strcmp(name,gr) == 0) {
-         grouplst[i] = g->gr_gid;
-         i++;
-         gr = (char *)NULL;
-         break;
+       gid_t  grouplst[NGROUPS_MAX];
+       int    i,j;
+       struct group *g;
+       char   *gr;
+       
+       grouplst[0] = id;
+       i = 1;
+       while (i < NGROUPS_MAX && 
+              ((g = (struct group *)getgrent()) != (struct group *)NULL)) {
+               if (g->gr_gid == id)
+                       continue;
+               j = 0;
+               gr = g->gr_mem[0];
+               while (gr && (*gr != (char)NULL)) {
+                       if (strcmp(name,gr) == 0) {
+                               grouplst[i] = g->gr_gid;
+                               i++;
+                               gr = (char *)NULL;
+                               break;
+                       }
+                       gr = g->gr_mem[++j];
+               }
        }
-       gr = g->gr_mem[++j];
-      }
-    }
-  endgrent();
-  return(setgroups(i,grouplst));
+       endgrent();
+       return(setgroups(i,grouplst));
 #endif
 }
 #endif
@@ -232,94 +195,105 @@ int InNetGr(char *group,char *host,char *user,char *dom)
 /* This is needed due to needing the nap() function but we don't want
    to include the Xenix libraries since that will break other things...
    BTW: system call # 0x0c28 is the same as calling nap() */
-long nap(long milliseconds) {
-  return syscall(0x0c28, milliseconds);
-}
+ long nap(long milliseconds) {
+        return syscall(0x0c28, milliseconds);
+ }
 #endif
 
 
+#ifndef HAVE_MEMMOVE
+/*******************************************************************
+safely copies memory, ensuring no overlap problems.
+this is only used if the machine does not have it's own memmove().
+this is not the fastest algorithm in town, but it will do for our
+needs.
+********************************************************************/
+ void *memmove(void *dest,const void *src,int size)
+{
+       unsigned long d,s;
+       int i;
+       if (dest==src || !size) return(dest);
 
-#if WRAP_MALLOC
+       d = (unsigned long)dest;
+       s = (unsigned long)src;
 
-/* undo the wrapping temporarily */
-#undef malloc
-#undef realloc
-#undef free
+       if ((d >= (s+size)) || (s >= (d+size))) {
+               /* no overlap */
+               memcpy(dest,src,size);
+               return(dest);
+       }
 
-/****************************************************************************
-wrapper for malloc() to catch memory errors
-****************************************************************************/
-void *malloc_wrapped(int size,char *file,int line)
-{
-#ifdef xx_old_malloc
-  void *res = xx_old_malloc(size);
-#else
-  void *res = malloc(size);
-#endif
-  DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n",
-       file,line,
-       size,(unsigned int)res));
-  return(res);
+       if (d < s) {
+               /* we can forward copy */
+               if (s-d >= sizeof(int) && 
+                   !(s%sizeof(int)) && 
+                   !(d%sizeof(int)) && 
+                   !(size%sizeof(int))) {
+                       /* do it all as words */
+                       int *idest = (int *)dest;
+                       int *isrc = (int *)src;
+                       size /= sizeof(int);
+                       for (i=0;i<size;i++) idest[i] = isrc[i];
+               } else {
+                       /* simplest */
+                       char *cdest = (char *)dest;
+                       char *csrc = (char *)src;
+                       for (i=0;i<size;i++) cdest[i] = csrc[i];
+               }
+       } else {
+               /* must backward copy */
+               if (d-s >= sizeof(int) && 
+                   !(s%sizeof(int)) && 
+                   !(d%sizeof(int)) && 
+                   !(size%sizeof(int))) {
+                       /* do it all as words */
+                       int *idest = (int *)dest;
+                       int *isrc = (int *)src;
+                       size /= sizeof(int);
+                       for (i=size-1;i>=0;i--) idest[i] = isrc[i];
+               } else {
+                       /* simplest */
+                       char *cdest = (char *)dest;
+                       char *csrc = (char *)src;
+                       for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
+               }      
+       }
+       return(dest);
 }
-
-/****************************************************************************
-wrapper for realloc() to catch memory errors
-****************************************************************************/
-void *realloc_wrapped(void *ptr,int size,char *file,int line)
-{
-#ifdef xx_old_realloc
-  void *res = xx_old_realloc(ptr,size);
-#else
-  void *res = realloc(ptr,size);
 #endif
-  DEBUG(3,("Realloc\n"));
-  DEBUG(3,("free called from %s(%d) with ptr=0x%X\n",
-       file,line,
-       (unsigned int)ptr));
-  DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n",
-       file,line,
-       size,(unsigned int)res));
-  return(res);
-}
 
+#ifndef HAVE_STRDUP
 /****************************************************************************
-wrapper for free() to catch memory errors
+duplicate a string
 ****************************************************************************/
-void free_wrapped(void *ptr,char *file,int line)
+ char *strdup(const char *s)
 {
-#ifdef xx_old_free
-  xx_old_free(ptr);
-#else
-  free(ptr);
-#endif
-  DEBUG(3,("free called from %s(%d) with ptr=0x%X\n",
-       file,line,(unsigned int)ptr));
-  return;
-}
+       int len;
+       char *ret;
 
-/* and re-do the define for spots lower in this file */
-#define malloc(size) malloc_wrapped(size,__FILE__,__LINE__)
-#define realloc(ptr,size) realloc_wrapped(ptr,size,__FILE__,__LINE__)
-#define free(ptr) free_wrapped(ptr,__FILE__,__LINE__)
+       if (!s) return(NULL);
 
+       len = strlen(s)+1;
+       ret = (char *)malloc(len);
+       if (!ret) return(NULL);
+       memcpy(ret,s,len);
+       return(ret);
+}
 #endif
 
-
-#if WRAP_MEMCPY
-#undef memcpy
-/*******************************************************************
-a wrapper around memcpy for diagnostic purposes
-********************************************************************/
-void *memcpy_wrapped(void *d,void *s,int l,char *fname,int line)
+#ifdef REPLACE_INET_NTOA
+char *rep_inet_ntoa(struct in_addr ip)
 {
-  if (l>64 && (((int)d)%4) != (((int)s)%4))
-    DEBUG(4,("Misaligned memcpy(0x%X,0x%X,%d) at %s(%d)\n",d,s,l,fname,line));
-#ifdef xx_old_memcpy  
-  return(xx_old_memcpy(d,s,l));
+       unsigned char *p = (unsigned char *)&ip.s_addr;
+       static char buf[18];
+#if WORDS_BIGENDIAN
+       slprintf(buf, 17, "%d.%d.%d.%d", 
+                (int)p[0], (int)p[1], (int)p[2], (int)p[3]);
 #else
-  return(memcpy(d,s,l));
+       slprintf(buf, 17, "%d.%d.%d.%d", 
+                (int)p[3], (int)p[2], (int)p[1], (int)p[0]);
 #endif
+       return buf;
 }
-#define memcpy(d,s,l) memcpy_wrapped(d,s,l,__FILE__,__LINE__)
 #endif