← Back to branch summary

~ubuntu-branches/ubuntu/maverick/util-linux/maverick-security

« back to all changes in this revision

Viewing changes to shlibs/blkid/src/superblocks/udf.c

Tags: 2.17-0ubuntu1
https://launchpad.net/bugs/383697
* Merge from Debian experimental, remaining changes:
  - Since udev is required in Ubuntu, the hwclock.sh init script is
    not called on startup and the hwclockfirst.sh init script is
    removed.
  - Remove /etc/adjtime on upgrade if it was not used.
  - Install custom blkid.conf to use /dev/.blkid.tab since we don't
    expect device names to survive a reboot
  - No lsb_release call in mount.preinst since we'd need Pre-Depends
    (LP: #383697).
  - Do not install initramfs hook, since our initramfs already handles
    including blkid.
  - Mention mountall(8) in fstab(5) manpages, along with its special
    options.

Show diffs side-by-side

added added

removed removed

Lines of Context:
shlibs/blkid/src/superblocks/udf.c
 
1
/*
 
2
 * Copyright (C) 1999 by Andries Brouwer
 
3
 * Copyright (C) 1999, 2000, 2003 by Theodore Ts'o
 
4
 * Copyright (C) 2001 by Andreas Dilger
 
5
 * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
 
6
 * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
 
7
 *
 
8
 * This file may be redistributed under the terms of the
 
9
 * GNU Lesser General Public License.
 
10
 */
 
11
#include <stdio.h>
 
12
#include <stdlib.h>
 
13
#include <unistd.h>
 
14
#include <string.h>
 
15
#include <errno.h>
 
16
#include <ctype.h>
 
17
#include <stdint.h>
 
18
 
 
19
#include "superblocks.h"
 
20
 
 
21
struct volume_descriptor {
 
22
        struct descriptor_tag {
 
23
                uint16_t        id;
 
24
                uint16_t        version;
 
25
                uint8_t         checksum;
 
26
                uint8_t         reserved;
 
27
                uint16_t        serial;
 
28
                uint16_t        crc;
 
29
                uint16_t        crc_len;
 
30
                uint32_t        location;
 
31
        } __attribute__((packed)) tag;
 
32
 
 
33
        union {
 
34
                struct anchor_descriptor {
 
35
                        uint32_t        length;
 
36
                        uint32_t        location;
 
37
                } __attribute__((packed)) anchor;
 
38
 
 
39
                struct primary_descriptor {
 
40
                        uint32_t        seq_num;
 
41
                        uint32_t        desc_num;
 
42
                        struct dstring {
 
43
                                uint8_t clen;
 
44
                                uint8_t c[31];
 
45
                        } __attribute__((packed)) ident;
 
46
                } __attribute__((packed)) primary;
 
47
 
 
48
        } __attribute__((packed)) type;
 
49
 
 
50
} __attribute__((packed));
 
51
 
 
52
struct volume_structure_descriptor {
 
53
        uint8_t         type;
 
54
        uint8_t         id[5];
 
55
        uint8_t         version;
 
56
} __attribute__((packed));
 
57
 
 
58
#define UDF_VSD_OFFSET                  0x8000
 
59
 
 
60
static int probe_udf(blkid_probe pr, const struct blkid_idmag *mag)
 
61
{
 
62
        struct volume_descriptor *vd;
 
63
        struct volume_structure_descriptor *vsd;
 
64
        unsigned int bs;
 
65
        unsigned int b;
 
66
        unsigned int type;
 
67
        unsigned int count;
 
68
        unsigned int loc;
 
69
 
 
70
        /* search Volume Sequence Descriptor (VSD) to get the logical
 
71
         * block size of the volume */
 
72
        for (bs = 0x800; bs < 0x8000; bs += 0x800) {
 
73
                vsd = (struct volume_structure_descriptor *)
 
74
                        blkid_probe_get_buffer(pr,
 
75
                                        UDF_VSD_OFFSET + bs,
 
76
                                        sizeof(*vsd));
 
77
                if (!vsd)
 
78
                        return 1;
 
79
                if (vsd->id[0] != '\0')
 
80
                        goto nsr;
 
81
        }
 
82
        return -1;
 
83
 
 
84
nsr:
 
85
        /* search the list of VSDs for a NSR descriptor */
 
86
        for (b = 0; b < 64; b++) {
 
87
                vsd = (struct volume_structure_descriptor *)
 
88
                        blkid_probe_get_buffer(pr,
 
89
                                        UDF_VSD_OFFSET + (b * bs),
 
90
                                        sizeof(*vsd));
 
91
                if (!vsd)
 
92
                        return -1;
 
93
                if (vsd->id[0] == '\0')
 
94
                        return -1;
 
95
                if (memcmp(vsd->id, "NSR02", 5) == 0)
 
96
                        goto anchor;
 
97
                if (memcmp(vsd->id, "NSR03", 5) == 0)
 
98
                        goto anchor;
 
99
        }
 
100
        return -1;
 
101
 
 
102
anchor:
 
103
        /* read Anchor Volume Descriptor (AVDP) */
 
104
        vd = (struct volume_descriptor *)
 
105
                blkid_probe_get_buffer(pr, 256 * bs, sizeof(*vd));
 
106
        if (!vd)
 
107
                return -1;
 
108
 
 
109
        type = le16_to_cpu(vd->tag.id);
 
110
        if (type != 2) /* TAG_ID_AVDP */
 
111
                return 0;
 
112
 
 
113
        /* get desriptor list address and block count */
 
114
        count = le32_to_cpu(vd->type.anchor.length) / bs;
 
115
        loc = le32_to_cpu(vd->type.anchor.location);
 
116
 
 
117
        /* pick the primary descriptor from the list */
 
118
        for (b = 0; b < count; b++) {
 
119
                vd = (struct volume_descriptor *)
 
120
                        blkid_probe_get_buffer(pr, (loc + b) * bs, sizeof(*vd));
 
121
                if (!vd)
 
122
                        return -1;
 
123
 
 
124
                type = le16_to_cpu(vd->tag.id);
 
125
                if (type == 0)
 
126
                        break;
 
127
                if (le32_to_cpu(vd->tag.location) != loc + b)
 
128
                        break;
 
129
                if (type == 1) { /* TAG_ID_PVD */
 
130
                        uint8_t clen = vd->type.primary.ident.clen;
 
131
 
 
132
                        if (clen == 8)
 
133
                                blkid_probe_set_label(pr,
 
134
                                                vd->type.primary.ident.c, 31);
 
135
                        else if (clen == 16)
 
136
                                blkid_probe_set_utf8label(pr,
 
137
                                                vd->type.primary.ident.c,
 
138
                                                31, BLKID_ENC_UTF16BE);
 
139
                }
 
140
        }
 
141
 
 
142
        return 0;
 
143
}
 
144
 
 
145
 
 
146
const struct blkid_idinfo udf_idinfo =
 
147
{
 
148
        .name           = "udf",
 
149
        .usage          = BLKID_USAGE_FILESYSTEM,
 
150
        .probefunc      = probe_udf,
 
151
        .flags          = BLKID_IDINFO_TOLERANT,
 
152
        .magics         =
 
153
        {
 
154
                { .magic = "BEA01", .len = 5, .kboff = 32, .sboff = 1 },
 
155
                { .magic = "BOOT2", .len = 5, .kboff = 32, .sboff = 1 },
 
156
                { .magic = "CD001", .len = 5, .kboff = 32, .sboff = 1 },
 
157
                { .magic = "CDW02", .len = 5, .kboff = 32, .sboff = 1 },
 
158
                { .magic = "NSR02", .len = 5, .kboff = 32, .sboff = 1 },
 
159
                { .magic = "NSR03", .len = 5, .kboff = 32, .sboff = 1 },
 
160
                { .magic = "TEA01", .len = 5, .kboff = 32, .sboff = 1 },
 
161
                { NULL }
 
162
        }
 
163
};