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     ! 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: }