Return to util2.c CVS log

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

Annotation of embedaddon/rsync/util2.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Utility routines used in rsync.
        !             3:  *
        !             4:  * Copyright (C) 1996-2000 Andrew Tridgell
        !             5:  * Copyright (C) 1996 Paul Mackerras
        !             6:  * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
        !             7:  * Copyright (C) 2003-2013 Wayne Davison
        !             8:  *
        !             9:  * This program is free software; you can redistribute it and/or modify
        !            10:  * it under the terms of the GNU General Public License as published by
        !            11:  * the Free Software Foundation; either version 3 of the License, or
        !            12:  * (at your option) any later version.
        !            13:  *
        !            14:  * This program is distributed in the hope that it will be useful,
        !            15:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            17:  * GNU General Public License for more details.
        !            18:  *
        !            19:  * You should have received a copy of the GNU General Public License along
        !            20:  * with this program; if not, visit the http://fsf.org website.
        !            21:  */
        !            22: 
        !            23: #include "rsync.h"
        !            24: #include "ifuncs.h"
        !            25: #include "itypes.h"
        !            26: #include "inums.h"
        !            27: 
        !            28: extern int checksum_len;
        !            29: 
        !            30: /**
        !            31:  * Sleep for a specified number of milliseconds.
        !            32:  *
        !            33:  * Always returns TRUE.  (In the future it might return FALSE if
        !            34:  * interrupted.)
        !            35:  **/
        !            36: int msleep(int t)
        !            37: {
        !            38:        int tdiff = 0;
        !            39:        struct timeval tval, t1, t2;
        !            40: 
        !            41:        gettimeofday(&t1, NULL);
        !            42: 
        !            43:        while (tdiff < t) {
        !            44:                tval.tv_sec = (t-tdiff)/1000;
        !            45:                tval.tv_usec = 1000*((t-tdiff)%1000);
        !            46: 
        !            47:                errno = 0;
        !            48:                select(0,NULL,NULL, NULL, &tval);
        !            49: 
        !            50:                gettimeofday(&t2, NULL);
        !            51:                if (t2.tv_sec < t1.tv_sec)
        !            52:                        t1 = t2; /* Time went backwards, so start over. */
        !            53:                tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
        !            54:                        (t2.tv_usec - t1.tv_usec)/1000;
        !            55:        }
        !            56: 
        !            57:        return True;
        !            58: }
        !            59: 
        !            60: #define MALLOC_MAX 0x40000000
        !            61: 
        !            62: void *_new_array(unsigned long num, unsigned int size, int use_calloc)
        !            63: {
        !            64:        if (num >= MALLOC_MAX/size)
        !            65:                return NULL;
        !            66:        return use_calloc ? calloc(num, size) : malloc(num * size);
        !            67: }
        !            68: 
        !            69: void *_realloc_array(void *ptr, unsigned int size, size_t num)
        !            70: {
        !            71:        if (num >= MALLOC_MAX/size)
        !            72:                return NULL;
        !            73:        if (!ptr)
        !            74:                return malloc(size * num);
        !            75:        return realloc(ptr, size * num);
        !            76: }
        !            77: 
        !            78: const char *sum_as_hex(const char *sum)
        !            79: {
        !            80:        static char buf[MAX_DIGEST_LEN*2+1];
        !            81:        int i, x1, x2;
        !            82:        char *c = buf + checksum_len*2;
        !            83: 
        !            84:        assert(c - buf < (int)sizeof buf);
        !            85: 
        !            86:        *c = '\0';
        !            87: 
        !            88:        for (i = checksum_len; --i >= 0; ) {
        !            89:                x1 = CVAL(sum, i);
        !            90:                x2 = x1 >> 4;
        !            91:                x1 &= 0xF;
        !            92:                *--c = x1 <= 9 ? x1 + '0' : x1 + 'a' - 10;
        !            93:                *--c = x2 <= 9 ? x2 + '0' : x2 + 'a' - 10;
        !            94:        }
        !            95: 
        !            96:        return buf;
        !            97: }
        !            98: 
        !            99: NORETURN void out_of_memory(const char *str)
        !           100: {
        !           101:        rprintf(FERROR, "ERROR: out of memory in %s [%s]\n", str, who_am_i());
        !           102:        exit_cleanup(RERR_MALLOC);
        !           103: }
        !           104: 
        !           105: NORETURN void overflow_exit(const char *str)
        !           106: {
        !           107:        rprintf(FERROR, "ERROR: buffer overflow in %s [%s]\n", str, who_am_i());
        !           108:        exit_cleanup(RERR_MALLOC);
        !           109: }