2 Unix SMB/CIFS implementation.
3 replacement routines for broken systems
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jelmer Vernooij 2005-2008
7 ** NOTE! The following LGPL license applies to the replace
8 ** library. This does NOT imply that all of Samba is released
11 This library is free software; you can redistribute it and/or
12 modify it under the terms of the GNU Lesser General Public
13 License as published by the Free Software Foundation; either
14 version 3 of the License, or (at your option) any later version.
16 This library is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 Lesser General Public License for more details.
21 You should have received a copy of the GNU Lesser General Public
22 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 #include "system/filesys.h"
28 #include "system/time.h"
29 #include "system/passwd.h"
30 #include "system/syslog.h"
31 #include "system/locale.h"
32 #include "system/wait.h"
35 #define mkdir(d,m) _mkdir(d)
38 void replace_dummy(void);
39 void replace_dummy(void) {}
41 #ifndef HAVE_FTRUNCATE
42 /*******************************************************************
43 ftruncate for operating systems that don't have it
44 ********************************************************************/
45 int rep_ftruncate(int f
, off_t l
)
49 #elif defined(F_FREESP)
56 return fcntl(f
, F_FREESP
, &fl
);
58 #error "you must have a ftruncate function"
61 #endif /* HAVE_FTRUNCATE */
65 /* like strncpy but does not 0 fill the buffer and always null
66 terminates. bufsize is the size of the destination buffer */
67 size_t rep_strlcpy(char *d
, const char *s
, size_t bufsize
)
69 size_t len
= strlen(s
);
71 if (bufsize
<= 0) return 0;
72 if (len
>= bufsize
) len
= bufsize
-1;
80 /* like strncat but does not 0 fill the buffer and always null
81 terminates. bufsize is the length of the buffer, which should
82 be one more than the maximum resulting string length */
83 size_t rep_strlcat(char *d
, const char *s
, size_t bufsize
)
85 size_t len1
= strlen(d
);
86 size_t len2
= strlen(s
);
87 size_t ret
= len1
+ len2
;
89 if (len1
+len2
>= bufsize
) {
90 if (bufsize
< (len1
+1)) {
93 len2
= bufsize
- (len1
+1);
96 memcpy(d
+len1
, s
, len2
);
104 /*******************************************************************
105 a mktime() replacement for those who don't have it - contributed by
106 C.A. Lademann <cal@zls.com>
107 Corrections by richard.kettlewell@kewill.com
108 ********************************************************************/
111 #define HOUR 60*MINUTE
114 time_t rep_mktime(struct tm
*t
)
119 int mon
[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
125 n
= t
->tm_year
+ 1900 - 1;
126 epoch
= (t
->tm_year
- 70) * YEAR
+
127 ((n
/ 4 - n
/ 100 + n
/ 400) - (1969 / 4 - 1969 / 100 + 1969 / 400)) * DAY
;
129 y
= t
->tm_year
+ 1900;
132 for(i
= 0; i
< t
->tm_mon
; i
++) {
133 epoch
+= mon
[m
] * DAY
;
134 if(m
== 1 && y
% 4 == 0 && (y
% 100 != 0 || y
% 400 == 0))
143 epoch
+= (t
->tm_mday
- 1) * DAY
;
144 epoch
+= t
->tm_hour
* HOUR
+ t
->tm_min
* MINUTE
+ t
->tm_sec
;
146 if((u
= localtime(&epoch
)) != NULL
) {
147 t
->tm_sec
= u
->tm_sec
;
148 t
->tm_min
= u
->tm_min
;
149 t
->tm_hour
= u
->tm_hour
;
150 t
->tm_mday
= u
->tm_mday
;
151 t
->tm_mon
= u
->tm_mon
;
152 t
->tm_year
= u
->tm_year
;
153 t
->tm_wday
= u
->tm_wday
;
154 t
->tm_yday
= u
->tm_yday
;
155 t
->tm_isdst
= u
->tm_isdst
;
160 #endif /* !HAVE_MKTIME */
163 #ifndef HAVE_INITGROUPS
164 /****************************************************************************
165 some systems don't have an initgroups call
166 ****************************************************************************/
167 int rep_initgroups(char *name
, gid_t id
)
169 #ifndef HAVE_SETGROUPS
170 /* yikes! no SETGROUPS or INITGROUPS? how can this work? */
173 #else /* HAVE_SETGROUPS */
177 gid_t
*grouplst
= NULL
;
178 int max_gr
= NGROUPS_MAX
;
184 if((grouplst
= malloc(sizeof(gid_t
) * max_gr
)) == NULL
) {
191 while (i
< max_gr
&& ((g
= (struct group
*)getgrent()) != (struct group
*)NULL
)) {
196 while (gr
&& (*gr
!= (char)NULL
)) {
197 if (strcmp(name
,gr
) == 0) {
198 grouplst
[i
] = g
->gr_gid
;
207 ret
= setgroups(i
, grouplst
);
210 #endif /* HAVE_SETGROUPS */
212 #endif /* HAVE_INITGROUPS */
215 #if (defined(SecureWare) && defined(SCO))
216 /* This is needed due to needing the nap() function but we don't want
217 to include the Xenix libraries since that will break other things...
218 BTW: system call # 0x0c28 is the same as calling nap() */
219 long nap(long milliseconds
) {
220 return syscall(0x0c28, milliseconds
);
226 /*******************************************************************
227 safely copies memory, ensuring no overlap problems.
228 this is only used if the machine does not have its own memmove().
229 this is not the fastest algorithm in town, but it will do for our
231 ********************************************************************/
232 void *rep_memmove(void *dest
,const void *src
,int size
)
236 if (dest
==src
|| !size
) return(dest
);
238 d
= (unsigned long)dest
;
239 s
= (unsigned long)src
;
241 if ((d
>= (s
+size
)) || (s
>= (d
+size
))) {
243 memcpy(dest
,src
,size
);
248 /* we can forward copy */
249 if (s
-d
>= sizeof(int) &&
252 !(size
%sizeof(int))) {
253 /* do it all as words */
254 int *idest
= (int *)dest
;
255 int *isrc
= (int *)src
;
257 for (i
=0;i
<size
;i
++) idest
[i
] = isrc
[i
];
260 char *cdest
= (char *)dest
;
261 char *csrc
= (char *)src
;
262 for (i
=0;i
<size
;i
++) cdest
[i
] = csrc
[i
];
265 /* must backward copy */
266 if (d
-s
>= sizeof(int) &&
269 !(size
%sizeof(int))) {
270 /* do it all as words */
271 int *idest
= (int *)dest
;
272 int *isrc
= (int *)src
;
274 for (i
=size
-1;i
>=0;i
--) idest
[i
] = isrc
[i
];
277 char *cdest
= (char *)dest
;
278 char *csrc
= (char *)src
;
279 for (i
=size
-1;i
>=0;i
--) cdest
[i
] = csrc
[i
];
284 #endif /* HAVE_MEMMOVE */
287 /****************************************************************************
289 ****************************************************************************/
290 char *rep_strdup(const char *s
)
295 if (!s
) return(NULL
);
298 ret
= (char *)malloc(len
);
299 if (!ret
) return(NULL
);
303 #endif /* HAVE_STRDUP */
305 #ifndef HAVE_SETLINEBUF
306 void rep_setlinebuf(FILE *stream
)
308 setvbuf(stream
, (char *)NULL
, _IOLBF
, 0);
310 #endif /* HAVE_SETLINEBUF */
314 void rep_vsyslog (int facility_priority
, const char *format
, va_list arglist
)
317 vasprintf(&msg
, format
, arglist
);
320 syslog(facility_priority
, "%s", msg
);
323 #endif /* HAVE_SYSLOG */
324 #endif /* HAVE_VSYSLOG */
328 Some platforms don't have strnlen
330 size_t rep_strnlen(const char *s
, size_t max
)
334 for (len
= 0; len
< max
; len
++) {
335 if (s
[len
] == '\0') {
345 Some platforms don't have strndup.
347 char *rep_strndup(const char *s
, size_t n
)
362 #if !defined(HAVE_WAITPID) && defined(HAVE_WAIT4)
363 int rep_waitpid(pid_t pid
,int *status
,int options
)
365 return wait4(pid
, status
, options
, NULL
);
370 int rep_seteuid(uid_t euid
)
372 #ifdef HAVE_SETRESUID
373 return setresuid(-1, euid
, -1);
382 int rep_setegid(gid_t egid
)
384 #ifdef HAVE_SETRESGID
385 return setresgid(-1, egid
, -1);
393 /*******************************************************************
394 os/2 also doesn't have chroot
395 ********************************************************************/
397 int rep_chroot(const char *dname
)
404 /*****************************************************************
405 Possibly replace mkstemp if it is broken.
406 *****************************************************************/
408 #ifndef HAVE_SECURE_MKSTEMP
409 int rep_mkstemp(char *template)
411 /* have a reasonable go at emulating it. Hope that
412 the system mktemp() isn't completly hopeless */
413 char *p
= mktemp(template);
416 return open(p
, O_CREAT
|O_EXCL
|O_RDWR
, 0600);
421 char *rep_mkdtemp(char *template)
425 if ((dname
= mktemp(template))) {
426 if (mkdir(dname
, 0700) >= 0) {
435 /*****************************************************************
436 Watch out: this is not thread safe.
437 *****************************************************************/
440 ssize_t
rep_pread(int __fd
, void *__buf
, size_t __nbytes
, off_t __offset
)
442 if (lseek(__fd
, __offset
, SEEK_SET
) != __offset
) {
445 return read(__fd
, __buf
, __nbytes
);
449 /*****************************************************************
450 Watch out: this is not thread safe.
451 *****************************************************************/
454 ssize_t
rep_pwrite(int __fd
, const void *__buf
, size_t __nbytes
, off_t __offset
)
456 if (lseek(__fd
, __offset
, SEEK_SET
) != __offset
) {
459 return write(__fd
, __buf
, __nbytes
);
463 #ifndef HAVE_STRCASESTR
464 char *rep_strcasestr(const char *haystack
, const char *needle
)
467 size_t nlen
= strlen(needle
);
468 for (s
=haystack
;*s
;s
++) {
469 if (toupper(*needle
) == toupper(*s
) &&
470 strncasecmp(s
, needle
, nlen
) == 0) {
471 return (char *)((uintptr_t)s
);
478 #ifndef HAVE_STRTOK_R
479 /* based on GLIBC version, copyright Free Software Foundation */
480 char *rep_strtok_r(char *s
, const char *delim
, char **save_ptr
)
484 if (s
== NULL
) s
= *save_ptr
;
486 s
+= strspn(s
, delim
);
493 s
= strpbrk(token
, delim
);
495 *save_ptr
= token
+ strlen(token
);
506 long long int rep_strtoll(const char *str
, char **endptr
, int base
)
509 return strtoq(str
, endptr
, base
);
510 #elif defined(HAVE___STRTOLL)
511 return __strtoll(str
, endptr
, base
);
512 #elif SIZEOF_LONG == SIZEOF_LONG_LONG
513 return (long long int) strtol(str
, endptr
, base
);
515 # error "You need a strtoll function"
521 #ifndef HAVE_STRTOULL
522 unsigned long long int rep_strtoull(const char *str
, char **endptr
, int base
)
525 return strtouq(str
, endptr
, base
);
526 #elif defined(HAVE___STRTOULL)
527 return __strtoull(str
, endptr
, base
);
528 #elif SIZEOF_LONG == SIZEOF_LONG_LONG
529 return (unsigned long long int) strtoul(str
, endptr
, base
);
531 # error "You need a strtoull function"
537 int rep_setenv(const char *name
, const char *value
, int overwrite
)
543 if (!overwrite
&& getenv(name
)) {
556 memcpy(p
+l1
+1, value
, l2
);
568 #ifndef HAVE_UNSETENV
569 int rep_unsetenv(const char *name
)
571 extern char **environ
;
572 size_t len
= strlen(name
);
575 if (environ
== NULL
|| getenv(name
) == NULL
) {
579 for (i
=0;environ
[i
];i
++) /* noop */ ;
584 if (strncmp(environ
[i
], name
, len
) == 0 && environ
[i
][len
] == '=') {
585 /* note: we do _not_ free the old variable here. It is unsafe to
586 do so, as the pointer may not have come from malloc */
587 memmove(&environ
[i
], &environ
[i
+1], (count
-i
)*sizeof(char *));
599 int rep_utime(const char *filename
, const struct utimbuf
*buf
)
607 int rep_utimes(const char *filename
, const struct timeval tv
[2])
611 u
.actime
= tv
[0].tv_sec
;
612 if (tv
[0].tv_usec
> 500000) {
616 u
.modtime
= tv
[1].tv_sec
;
617 if (tv
[1].tv_usec
> 500000) {
621 return utime(filename
, &u
);
626 int rep_dup2(int oldfd
, int newfd
)
635 chown isn't used much but OS/2 doesn't have it
637 int rep_chown(const char *fname
, uid_t uid
, gid_t gid
)
645 int rep_link(const char *oldpath
, const char *newpath
)
652 #ifndef HAVE_READLINK
653 int rep_readlink(const char *path
, char *buf
, size_t bufsiz
)
661 int rep_symlink(const char *oldpath
, const char *newpath
)
669 int rep_lchown(const char *fname
,uid_t uid
,gid_t gid
)
676 #ifndef HAVE_REALPATH
677 char *rep_realpath(const char *path
, char *resolved_path
)
679 /* As realpath is not a system call we can't return ENOSYS. */