← Back to branch summary

~nova-coresec/ubuntu/maverick/libvirt/nova-ppa

« back to all changes in this revision

Viewing changes to src/uuid.c

  • Committer: James Westby
  • Author(s): Guido Günther, Laurent Léonard, Guido Günther
  • Date: 2009-11-06 01:44:21 UTC
  • mfrom: (0.1.3 experimental)
  • mto: (3.4.9 squeeze)
  • mto: This revision was merged to the branch mainline in revision 58.
  • Revision ID: james.westby@canonical.com-20091106014421-dt3mlgmcukyggxex
Tags: 0.7.2-2
http://bugs.debian.org/549949
[ Laurent Léonard ]
* [a9ea205] Change requirement of libvirt-bin in libvirt- suspendonreboot.
* [a4db804] Update debian/patches/0006-Don-t-let-parent-of-daemon-
  exit-until-basic-initiali.patch. Fix use of an uninitialized variable that
  was causing a bug on i386 systems.
* [59e1e53] Redo patches.

[ Guido Günther ]
* upload to unstable
* [43f106a] Only remove masquerade roles for VIR_NETWORK_FORWARD_NAT
  (Closes: #549949) - thanks to Rob S. Wolfram for testing

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/uuid.c
1
 
/*
2
 
 * Copyright (C) 2007, 2008, 2009 Red Hat, Inc.
3
 
 *
4
 
 * This library is free software; you can redistribute it and/or
5
 
 * modify it under the terms of the GNU Lesser General Public
6
 
 * License as published by the Free Software Foundation; either
7
 
 * version 2.1 of the License, or (at your option) any later version.
8
 
 *
9
 
 * This library is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 
 * Lesser General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU Lesser General Public
15
 
 * License along with this library; if not, write to the Free Software
16
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
17
 
 *
18
 
 * Authors:
19
 
 *     Mark McLoughlin <markmc@redhat.com>
20
 
 */
21
 
 
22
 
#include <config.h>
23
 
 
24
 
#include "uuid.h"
25
 
 
26
 
#include <errno.h>
27
 
#include <fcntl.h>
28
 
#include <stdlib.h>
29
 
#include <stdio.h>
30
 
#include <string.h>
31
 
#include <sys/types.h>
32
 
#include <sys/stat.h>
33
 
#include <time.h>
34
 
#include <unistd.h>
35
 
 
36
 
#include "c-ctype.h"
37
 
#include "internal.h"
38
 
#include "util.h"
39
 
#include "virterror_internal.h"
40
 
#include "logging.h"
41
 
 
42
 
#ifndef ENODATA
43
 
#define ENODATA EIO
44
 
#endif
45
 
 
46
 
static int
47
 
virUUIDGenerateRandomBytes(unsigned char *buf,
48
 
                           int buflen)
49
 
{
50
 
    int fd;
51
 
 
52
 
    if ((fd = open("/dev/urandom", O_RDONLY)) < 0)
53
 
        return errno;
54
 
 
55
 
    while (buflen > 0) {
56
 
        int n;
57
 
 
58
 
        if ((n = read(fd, buf, buflen)) <= 0) {
59
 
            if (errno == EINTR)
60
 
                continue;
61
 
            close(fd);
62
 
            return n < 0 ? errno : ENODATA;
63
 
        }
64
 
 
65
 
        buf += n;
66
 
        buflen -= n;
67
 
    }
68
 
 
69
 
    close(fd);
70
 
 
71
 
    return 0;
72
 
}
73
 
 
74
 
static int
75
 
virUUIDGeneratePseudoRandomBytes(unsigned char *buf,
76
 
                                 int buflen)
77
 
{
78
 
    while (buflen > 0) {
79
 
        *buf = virRandom(256);
80
 
        buflen--;
81
 
    }
82
 
 
83
 
    return 0;
84
 
}
85
 
 
86
 
/**
87
 
 * virUUIDGenerate:
88
 
 * @uuid: array of VIR_UUID_BUFLEN bytes to store the new UUID
89
 
 *
90
 
 * Generates a randomized unique identifier.
91
 
 *
92
 
 * Returns 0 in case of success and -1 in case of failure
93
 
 */
94
 
int
95
 
virUUIDGenerate(unsigned char *uuid)
96
 
{
97
 
    int err;
98
 
 
99
 
    if (uuid == NULL)
100
 
        return(-1);
101
 
 
102
 
    if ((err = virUUIDGenerateRandomBytes(uuid, VIR_UUID_BUFLEN))) {
103
 
        char ebuf[1024];
104
 
        VIR_WARN(_("Falling back to pseudorandom UUID,"
105
 
                   " failed to generate random bytes: %s"),
106
 
                 virStrerror(err, ebuf, sizeof ebuf));
107
 
    }
108
 
 
109
 
    return virUUIDGeneratePseudoRandomBytes(uuid, VIR_UUID_BUFLEN);
110
 
}
111
 
 
112
 
/* Convert C from hexadecimal character to integer.  */
113
 
static int
114
 
hextobin (unsigned char c)
115
 
{
116
 
  switch (c)
117
 
    {
118
 
    default: return c - '0';
119
 
    case 'a': case 'A': return 10;
120
 
    case 'b': case 'B': return 11;
121
 
    case 'c': case 'C': return 12;
122
 
    case 'd': case 'D': return 13;
123
 
    case 'e': case 'E': return 14;
124
 
    case 'f': case 'F': return 15;
125
 
    }
126
 
}
127
 
 
128
 
/**
129
 
 * virUUIDParse:
130
 
 * @uuidstr: zero terminated string representation of the UUID
131
 
 * @uuid: array of VIR_UUID_BUFLEN bytes to store the raw UUID
132
 
 *
133
 
 * Parses the external string representation, allowing spaces and '-'
134
 
 * character in the sequence, and storing the result as a raw UUID
135
 
 *
136
 
 * Returns 0 in case of success and -1 in case of error.
137
 
 */
138
 
int
139
 
virUUIDParse(const char *uuidstr, unsigned char *uuid) {
140
 
    const char *cur;
141
 
    int i;
142
 
 
143
 
    if ((uuidstr == NULL) || (uuid == NULL))
144
 
        return(-1);
145
 
 
146
 
    /*
147
 
     * do a liberal scan allowing '-' and ' ' anywhere between character
148
 
     * pairs as long as there is 32 of them in the end.
149
 
     */
150
 
    cur = uuidstr;
151
 
    for (i = 0;i < VIR_UUID_BUFLEN;) {
152
 
        uuid[i] = 0;
153
 
        if (*cur == 0)
154
 
            goto error;
155
 
        if ((*cur == '-') || (*cur == ' ')) {
156
 
            cur++;
157
 
            continue;
158
 
        }
159
 
        if (!c_isxdigit(*cur))
160
 
            goto error;
161
 
        uuid[i] = hextobin(*cur);
162
 
        uuid[i] *= 16;
163
 
        cur++;
164
 
        if (*cur == 0)
165
 
            goto error;
166
 
        if (!c_isxdigit(*cur))
167
 
            goto error;
168
 
        uuid[i] += hextobin(*cur);
169
 
        i++;
170
 
        cur++;
171
 
    }
172
 
 
173
 
    return 0;
174
 
 
175
 
 error:
176
 
    return -1;
177
 
}
178
 
 
179
 
/**
180
 
 * virUUIDFormat:
181
 
 * @uuid: array of VIR_UUID_RAW_LEN bytes to store the raw UUID
182
 
 * @uuidstr: array of VIR_UUID_STRING_BUFLEN bytes to store the
183
 
 * string representation of the UUID in. The resulting string
184
 
 * will be NULL terminated.
185
 
 *
186
 
 * Converts the raw UUID into printable format, with embedded '-'
187
 
 *
188
 
 * Returns 0 in case of success and -1 in case of error.
189
 
 */
190
 
void virUUIDFormat(const unsigned char *uuid, char *uuidstr)
191
 
{
192
 
    snprintf(uuidstr, VIR_UUID_STRING_BUFLEN,
193
 
             "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
194
 
             uuid[0], uuid[1], uuid[2], uuid[3],
195
 
             uuid[4], uuid[5], uuid[6], uuid[7],
196
 
             uuid[8], uuid[9], uuid[10], uuid[11],
197
 
             uuid[12], uuid[13], uuid[14], uuid[15]);
198
 
    uuidstr[VIR_UUID_STRING_BUFLEN-1] = '\0';
199
 
}