'The mother of all checkins' :-). Jeremy Allison (jallison@whistle.com)
[ira/wip.git] / source3 / 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