← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rsync/trusty

« back to all changes in this revision

Viewing changes to util2.c

  • Committer: Package Import Robot
  • Author(s): Paul Slootman
  • Date: 2013-10-27 12:01:10 UTC
  • mfrom: (1.3.2)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: package-import@ubuntu.com-20131027120110-eyksys8yzm1siekf
Tags: upstream-3.1.0
Import upstream version 3.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
util2.c
 
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
}