Return to compat.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / lib

Annotation of embedaddon/rsync/lib/compat.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Reimplementations of standard functions for platforms that don't have them.
                      3:  *
                      4:  * Copyright (C) 1998 Andrew Tridgell
                      5:  * Copyright (C) 2002 Martin Pool
                      6:  * Copyright (C) 2004, 2005, 2006 Wayne Davison
                      7:  *
                      8:  * This program is free software; you can redistribute it and/or modify
                      9:  * it under the terms of the GNU General Public License as published by
                     10:  * the Free Software Foundation; either version 3 of the License, or
                     11:  * (at your option) any later version.
                     12:  *
                     13:  * This program is distributed in the hope that it will be useful,
                     14:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                     15:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     16:  * GNU General Public License for more details.
                     17:  *
                     18:  * You should have received a copy of the GNU General Public License along
                     19:  * with this program; if not, visit the http://fsf.org website.
                     20:  */
                     21: 
                     22: #include "rsync.h"
                     23: 
                     24: #ifndef HAVE_STRDUP
                     25:  char *strdup(char *s)
                     26: {
                     27:        int len = strlen(s) + 1;
                     28:        char *ret = (char *)malloc(len);
                     29:        if (ret)
                     30:                memcpy(ret, s, len);
                     31:        return ret;
                     32: }
                     33: #endif
                     34: 
                     35: #ifndef HAVE_GETCWD
                     36:  char *getcwd(char *buf, int size)
                     37: {
                     38:        return getwd(buf);
                     39: }
                     40: #endif
                     41: 
                     42: 
                     43: #ifndef HAVE_WAITPID
                     44:  pid_t waitpid(pid_t pid, int *statptr, int options)
                     45: {
                     46: #ifdef HAVE_WAIT4
                     47:        return wait4(pid, statptr, options, NULL);
                     48: #else
                     49:        /* If wait4 is also not available, try wait3 for SVR3 variants */
                     50:        /* Less ideal because can't actually request a specific pid */
                     51:        /* At least the WNOHANG option is supported */
                     52:        /* Code borrowed from apache fragment written by dwd@bell-labs.com */
                     53:        int tmp_pid, dummystat;;
                     54:        if (kill(pid, 0) == -1) {
                     55:                errno = ECHILD;
                     56:                return -1;
                     57:        }
                     58:        if (statptr == NULL)
                     59:                statptr = &dummystat;
                     60:        while (((tmp_pid = wait3(statptr, options, 0)) != pid) &&
                     61:                    (tmp_pid != -1) && (tmp_pid != 0) && (pid != -1))
                     62:            ;
                     63:        return tmp_pid;
                     64: #endif
                     65: }
                     66: #endif
                     67: 
                     68: 
                     69: #ifndef HAVE_MEMMOVE
                     70:  void *memmove(void *dest, const void *src, size_t n)
                     71: {
                     72:        bcopy((char *) src, (char *) dest, n);
                     73:        return dest;
                     74: }
                     75: #endif
                     76: 
                     77: #ifndef HAVE_STRPBRK
                     78: /**
                     79:  * Find the first ocurrence in @p s of any character in @p accept.
                     80:  *
                     81:  * Derived from glibc
                     82:  **/
                     83:  char *strpbrk(const char *s, const char *accept)
                     84: {
                     85:        while (*s != '\0')  {
                     86:                const char *a = accept;
                     87:                while (*a != '\0') {
                     88:                        if (*a++ == *s) return (char *)s;
                     89:                }
                     90:                ++s;
                     91:        }
                     92: 
                     93:        return NULL;
                     94: }
                     95: #endif
                     96: 
                     97: 
                     98: #ifndef HAVE_STRLCPY
                     99: /**
                    100:  * Like strncpy but does not 0 fill the buffer and always null
                    101:  * terminates.
                    102:  *
                    103:  * @param bufsize is the size of the destination buffer.
                    104:  *
                    105:  * @return index of the terminating byte.
                    106:  **/
                    107:  size_t strlcpy(char *d, const char *s, size_t bufsize)
                    108: {
                    109:        size_t len = strlen(s);
                    110:        size_t ret = len;
                    111:        if (bufsize > 0) {
                    112:                if (len >= bufsize)
                    113:                        len = bufsize-1;
                    114:                memcpy(d, s, len);
                    115:                d[len] = 0;
                    116:        }
                    117:        return ret;
                    118: }
                    119: #endif
                    120: 
                    121: #ifndef HAVE_STRLCAT
                    122: /**
                    123:  * Like strncat() but does not 0 fill the buffer and always null
                    124:  * terminates.
                    125:  *
                    126:  * @param bufsize length of the buffer, which should be one more than
                    127:  * the maximum resulting string length.
                    128:  **/
                    129:  size_t strlcat(char *d, const char *s, size_t bufsize)
                    130: {
                    131:        size_t len1 = strlen(d);
                    132:        size_t len2 = strlen(s);
                    133:        size_t ret = len1 + len2;
                    134: 
                    135:        if (len1 < bufsize - 1) {
                    136:                if (len2 >= bufsize - len1)
                    137:                        len2 = bufsize - len1 - 1;
                    138:                memcpy(d+len1, s, len2);
                    139:                d[len1+len2] = 0;
                    140:        }
                    141:        return ret;
                    142: }
                    143: #endif
                    144: 
                    145: /* some systems don't take the 2nd argument */
                    146: int sys_gettimeofday(struct timeval *tv)
                    147: {
                    148: #ifdef HAVE_GETTIMEOFDAY_TZ
                    149:        return gettimeofday(tv, NULL);
                    150: #else
                    151:        return gettimeofday(tv);
                    152: #endif
                    153: }