source: trunk/samba/source/lib/replace/replace.c @ 30

Last change on this file since 30 was 30, checked in by Paul Smedley, 14 years ago

Code updated to Samba 3.0.25rc2 level

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