busybox/util-linux/volume_id/get_devname.c
Denis Vlasenko 5415c856ea libbb: [x]fopen_for_{read,write} introduced and used.
(by Valdimir)

function                                             old     new   delta
config_open2                                           -      41     +41
config_read                                          507     542     +35
find_pair                                            169     187     +18
fopen_for_write                                        -      14     +14
fopen_for_read                                         -      14     +14
find_main                                            406     418     +12
xfopen_for_write                                       -      10     +10
xfopen_for_read                                        -      10     +10
popstring                                            134     140      +6
parse_inittab                                        396     401      +5
next_token                                           923     928      +5
pack_gzip                                           1659    1661      +2
bb__parsespent                                       117     119      +2
fallbackSort                                        1719    1717      -2
evalvar                                             1376    1374      -2
qrealloc                                              36      33      -3
...
...
...
...
singlemount                                         4579    4569     -10
process_stdin                                        443     433     -10
patch_main                                          1111    1101     -10
ifupdown_main                                       2175    2165     -10
file_action_grep                                      90      80     -10
uuidcache_init                                       649     637     -12
hush_main                                            797     785     -12
read_config                                          230     217     -13
dpkg_main                                           3835    3820     -15
read_line_input                                     3134    3110     -24
sysctl_main                                          232     203     -29
config_open                                           40      10     -30
WARN_BAD_LINE                                         44       -     -44
login_main                                          1714    1575    -139
------------------------------------------------------------------------------
(add/remove: 5/1 grow/shrink: 8/74 up/down: 174/-737)        Total: -563 bytes
2008-07-21 23:05:26 +00:00

430 lines
9.0 KiB
C

/* vi: set sw=4 ts=4: */
/*
* Support functions for mounting devices by label/uuid
*
* Copyright (C) 2006 by Jason Schoon <floydpink@gmail.com>
* Some portions cribbed from e2fsprogs, util-linux, dosfstools
*
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
#include "volume_id_internal.h"
//#define BLKGETSIZE64 _IOR(0x12,114,size_t)
static struct uuidCache_s {
struct uuidCache_s *next;
// int major, minor;
char *device;
char *label;
char *uc_uuid; /* prefix makes it easier to grep for */
} *uuidCache;
/* Returns !0 on error.
* Otherwise, returns malloc'ed strings for label and uuid
* (and they can't be NULL, although they can be "") */
#if !ENABLE_FEATURE_VOLUMEID_ISO9660
#define get_label_uuid(device, label, uuid, iso_only) \
get_label_uuid(device, label, uuid)
#endif
static int
get_label_uuid(const char *device, char **label, char **uuid, int iso_only)
{
int rv = 1;
uint64_t size;
struct volume_id *vid;
vid = volume_id_open_node(device);
if (!vid)
return rv;
if (ioctl(vid->fd, BLKGETSIZE64, &size) != 0)
size = 0;
#if ENABLE_FEATURE_VOLUMEID_ISO9660
if ((iso_only ?
volume_id_probe_iso9660(vid, 0) :
volume_id_probe_all(vid, 0, size)
) != 0
) {
goto ret;
}
#else
if (volume_id_probe_all(vid, 0, size) != 0) {
goto ret;
}
#endif
if (vid->label[0] != '\0' || vid->uuid[0] != '\0') {
*label = xstrndup(vid->label, sizeof(vid->label));
*uuid = xstrndup(vid->uuid, sizeof(vid->uuid));
dbg("found label '%s', uuid '%s' on %s", *label, *uuid, device);
rv = 0;
}
ret:
free_volume_id(vid);
return rv;
}
/* NB: we take ownership of (malloc'ed) label and uuid */
static void
uuidcache_addentry(char *device, /*int major, int minor,*/ char *label, char *uuid)
{
struct uuidCache_s *last;
if (!uuidCache) {
last = uuidCache = xzalloc(sizeof(*uuidCache));
} else {
for (last = uuidCache; last->next; last = last->next)
continue;
last->next = xzalloc(sizeof(*uuidCache));
last = last->next;
}
/*last->next = NULL; - xzalloc did it*/
// last->major = major;
// last->minor = minor;
last->device = device;
last->label = label;
last->uc_uuid = uuid;
}
/* If get_label_uuid() on device_name returns success,
* add a cache entry for this device.
* If device node does not exist, it will be temporarily created. */
#if !ENABLE_FEATURE_VOLUMEID_ISO9660
#define uuidcache_check_device(device_name, ma, mi, iso_only) \
uuidcache_check_device(device_name, ma, mi)
#endif
static void
uuidcache_check_device(const char *device_name, int ma, int mi, int iso_only)
{
char *device, *last_slash;
char *uuid, *label;
char *ptr;
int must_remove = 0;
int added = 0;
last_slash = NULL;
device = xasprintf("/dev/%s", device_name);
if (access(device, F_OK) != 0) {
/* device does not exist, temporarily create */
int slash_cnt = 0;
if ((ma | mi) < 0)
goto ret; /* we don't know major:minor! */
ptr = device;
while (*ptr)
if (*ptr++ == '/')
slash_cnt++;
if (slash_cnt > 2) {
// BUG: handles only slash_cnt == 3 case
last_slash = strrchr(device, '/');
*last_slash = '\0';
if (mkdir(device, 0644)) {
bb_perror_msg("can't create directory %s", device);
*last_slash = '/';
last_slash = NULL; /* prevents rmdir */
} else {
*last_slash = '/';
}
}
mknod(device, S_IFBLK | 0600, makedev(ma, mi));
must_remove = 1;
}
uuid = NULL;
label = NULL;
if (get_label_uuid(device, &label, &uuid, iso_only) == 0) {
uuidcache_addentry(device, /*ma, mi,*/ label, uuid);
/* "device" is owned by cache now, don't free */
added = 1;
}
if (must_remove)
unlink(device);
if (last_slash) {
*last_slash = '\0';
rmdir(device);
}
ret:
if (!added)
free(device);
}
/* Run uuidcache_check_device() for every device mentioned
* in /proc/partitions */
static void
uuidcache_init_partitions(void)
{
char line[100];
int ma, mi;
unsigned long long sz;
FILE *procpt;
int firstPass;
int handleOnFirst;
char *chptr;
procpt = xfopen_for_read("/proc/partitions");
/*
# cat /proc/partitions
major minor #blocks name
8 0 293036184 sda
8 1 6835626 sda1
8 2 1 sda2
8 5 979933 sda5
8 6 15623181 sda6
8 7 97659103 sda7
8 8 171935631 sda8
*/
for (firstPass = 1; firstPass >= 0; firstPass--) {
fseek(procpt, 0, SEEK_SET);
while (fgets(line, sizeof(line), procpt)) {
/* The original version of this code used sscanf, but
diet's sscanf is quite limited */
chptr = line;
if (*chptr != ' ') continue;
chptr = skip_whitespace(chptr);
ma = bb_strtou(chptr, &chptr, 0);
if (ma < 0) continue;
chptr = skip_whitespace(chptr);
mi = bb_strtou(chptr, &chptr, 0);
if (mi < 0) continue;
chptr = skip_whitespace(chptr);
sz = bb_strtoull(chptr, &chptr, 0);
if ((long long)sz == -1LL) continue;
chptr = skip_whitespace(chptr);
/* skip extended partitions (heuristic: size 1) */
if (sz == 1)
continue;
*strchrnul(chptr, '\n') = '\0';
/* now chptr => device name */
dbg("/proc/partitions: maj:%d min:%d sz:%llu name:'%s'",
ma, mi, sz, chptr);
if (!chptr[0])
continue;
/* look only at md devices on first pass */
handleOnFirst = (chptr[0] == 'm' && chptr[1] == 'd');
if (firstPass != handleOnFirst)
continue;
/* heuristic: partition name ends in a digit */
if (isdigit(chptr[strlen(chptr) - 1])) {
uuidcache_check_device(chptr, ma, mi, 0);
}
}
}
fclose(procpt);
}
static void
dev_get_major_minor(char *device_name, int *major, int *minor)
{
char dev[16];
char *dev_path;
char *colon;
int sz;
dev_path = xasprintf("/sys/block/%s/dev", device_name);
sz = open_read_close(dev_path, dev, sizeof(dev) - 1);
if (sz < 0)
goto ret;
dev[sz] = '\0';
colon = strchr(dev, ':');
if (!colon)
goto ret;
*major = bb_strtou(dev, NULL, 10);
*minor = bb_strtou(colon + 1, NULL, 10);
ret:
free(dev_path);
return;
}
static void
uuidcache_init_cdroms(void)
{
#define PROC_CDROMS "/proc/sys/dev/cdrom/info"
char line[100];
int ma, mi;
FILE *proccd;
proccd = fopen_for_read(PROC_CDROMS);
if (!proccd) {
// static smallint warn = 0;
// if (!warn) {
// warn = 1;
// bb_error_msg("can't open %s, UUID and LABEL "
// "conversion cannot be done for CD-Roms",
// PROC_CDROMS);
// }
return;
}
while (fgets(line, sizeof(line), proccd)) {
static const char drive_name_string[] ALIGN1 = "drive name:";
if (strncmp(line, drive_name_string, sizeof(drive_name_string) - 1) == 0) {
char *device_name;
device_name = strtok(skip_whitespace(line + sizeof(drive_name_string) - 1), " \t\n");
while (device_name && device_name[0]) {
ma = mi = -1;
dev_get_major_minor(device_name, &ma, &mi);
uuidcache_check_device(device_name, ma, mi, 1);
device_name = strtok(NULL, " \t\n");
}
break;
}
}
fclose(proccd);
}
static void
uuidcache_init(void)
{
if (uuidCache)
return;
uuidcache_init_partitions();
uuidcache_init_cdroms();
}
#define UUID 1
#define VOL 2
#ifdef UNUSED
static char *
get_spec_by_x(int n, const char *t, int *majorPtr, int *minorPtr)
{
struct uuidCache_s *uc;
uuidcache_init();
uc = uuidCache;
while (uc) {
switch (n) {
case UUID:
if (strcmp(t, uc->uc_uuid) == 0) {
*majorPtr = uc->major;
*minorPtr = uc->minor;
return uc->device;
}
break;
case VOL:
if (strcmp(t, uc->label) == 0) {
*majorPtr = uc->major;
*minorPtr = uc->minor;
return uc->device;
}
break;
}
uc = uc->next;
}
return NULL;
}
static unsigned char
fromhex(char c)
{
if (isdigit(c))
return (c - '0');
return ((c|0x20) - 'a' + 10);
}
static char *
get_spec_by_uuid(const char *s, int *major, int *minor)
{
unsigned char uuid[16];
int i;
if (strlen(s) != 36 || s[8] != '-' || s[13] != '-'
|| s[18] != '-' || s[23] != '-'
) {
goto bad_uuid;
}
for (i = 0; i < 16; i++) {
if (*s == '-')
s++;
if (!isxdigit(s[0]) || !isxdigit(s[1]))
goto bad_uuid;
uuid[i] = ((fromhex(s[0]) << 4) | fromhex(s[1]));
s += 2;
}
return get_spec_by_x(UUID, (char *)uuid, major, minor);
bad_uuid:
fprintf(stderr, _("mount: bad UUID"));
return 0;
}
static char *
get_spec_by_volume_label(const char *s, int *major, int *minor)
{
return get_spec_by_x(VOL, s, major, minor);
}
static int display_uuid_cache(void)
{
struct uuidCache_s *u;
size_t i;
uuidcache_init();
u = uuidCache;
while (u) {
printf("%s %s %s\n", u->device, u->label, u->uc_uuid);
u = u->next;
}
return 0;
}
#endif // UNUSED
/* Used by mount and findfs */
char *get_devname_from_label(const char *spec)
{
struct uuidCache_s *uc;
int spec_len = strlen(spec);
uuidcache_init();
uc = uuidCache;
while (uc) {
// FIXME: empty label ("LABEL=") matches anything??!
if (uc->label[0] && strncmp(spec, uc->label, spec_len) == 0) {
return xstrdup(uc->device);
}
uc = uc->next;
}
return NULL;
}
char *get_devname_from_uuid(const char *spec)
{
struct uuidCache_s *uc;
uuidcache_init();
uc = uuidCache;
while (uc) {
/* case of hex numbers doesn't matter */
if (strcasecmp(spec, uc->uc_uuid) == 0) {
return xstrdup(uc->device);
}
uc = uc->next;
}
return NULL;
}