tagged_items.c: Include header size when searching items
[wimlib] / src / tagged_items.c
1 /*
2  * tagged_items.c
3  *
4  * Support for tagged metadata items that can be appended to WIM directory
5  * entries.
6  */
7
8 /*
9  * Copyright (C) 2014 Eric Biggers
10  *
11  * This file is part of wimlib, a library for working with WIM files.
12  *
13  * wimlib is free software; you can redistribute it and/or modify it under the
14  * terms of the GNU General Public License as published by the Free
15  * Software Foundation; either version 3 of the License, or (at your option)
16  * any later version.
17  *
18  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
20  * A PARTICULAR PURPOSE. See the GNU General Public License for more
21  * details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with wimlib; if not, see http://www.gnu.org/licenses/.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 #  include "config.h"
29 #endif
30
31 #include "wimlib/endianness.h"
32 #include "wimlib/inode.h"
33 #include "wimlib/types.h"
34 #include "wimlib/unix_data.h"
35
36 /* Used by the Microsoft implementation.  */
37 #define TAG_OBJECT_ID           0x00000001
38
39 /* Random number that we'll use for tagging our UNIX data items.  */
40 #define TAG_WIMLIB_UNIX_DATA    0x337DD873
41
42 /* Header that begins each tagged metadata item in the metadata resource  */
43 struct tagged_item_header {
44
45         /* Unique identifier for this item.  */
46         le32 tag;
47
48         /* Size of the data of this tagged item, in bytes.  This excludes this
49          * header and should be a multiple of 8.
50          *
51          * (Actually, the MS implementation seems to round this up to an 8 byte
52          * boundary when calculating the offset to the next tagged item, but
53          * uses this length unmodified when validating the item.  We might as
54          * well do the same.)  */
55         le32 length;
56
57         /* Variable length data  */
58         u8 data[];
59 };
60
61 struct object_id_disk {
62         u8 object_id[16];
63         u8 birth_volume_id[16];
64         u8 birth_object_id[16];
65         u8 domain_id[16];
66 };
67
68 struct wimlib_unix_data_disk {
69         le32 uid;
70         le32 gid;
71         le32 mode;
72         le32 rdev;
73 };
74
75 /* Retrieves the first tagged item with the specified tag and minimum length
76  * from the WIM inode.  Returns a pointer to the tagged data, which can be read
77  * and/or modified in place.  Or, if no matching tagged item is found, returns
78  * NULL.  */
79 static void *
80 inode_get_tagged_item(const struct wim_inode *inode,
81                       u32 desired_tag, u32 min_data_len)
82 {
83         size_t minlen_with_hdr = sizeof(struct tagged_item_header) + min_data_len;
84         size_t len_remaining = inode->i_extra_size;
85         u8 *p = inode->i_extra;
86
87         /* Iterate through the tagged items.  */
88         while (len_remaining >= minlen_with_hdr) {
89                 struct tagged_item_header *hdr;
90                 u32 tag;
91                 u32 len;
92
93                 hdr = (struct tagged_item_header *)p;
94                 tag = le32_to_cpu(hdr->tag);
95                 len = le32_to_cpu(hdr->length);
96
97                 if (tag == desired_tag && len >= min_data_len)
98                         return hdr->data;
99
100                 len = (len + 7) & ~7;
101                 if (len_remaining <= sizeof(struct tagged_item_header) + len)
102                         return NULL;
103                 len_remaining -= sizeof(struct tagged_item_header) + len;
104                 p += sizeof(struct tagged_item_header) + len;
105         }
106         return NULL;
107 }
108
109 /* Adds a tagged item to a WIM inode and returns a pointer to its uninitialized
110  * data, which must be initialized in-place by the caller.  */
111 static void *
112 inode_add_tagged_item(struct wim_inode *inode, u32 tag, u32 len)
113 {
114         size_t itemsize;
115         size_t newsize;
116         u8 *buf;
117         struct tagged_item_header *hdr;
118
119         /* We prepend the item instead of appending it because it's easier.  */
120
121         itemsize = sizeof(struct tagged_item_header) + len;
122         newsize = itemsize + inode->i_extra_size;
123
124         buf = MALLOC(newsize);
125         if (!buf)
126                 return NULL;
127
128         if (inode->i_extra_size) {
129                 memcpy(buf + itemsize, inode->i_extra, inode->i_extra_size);
130                 FREE(inode->i_extra);
131         }
132         inode->i_extra = buf;
133         inode->i_extra_size = newsize;
134
135         hdr = (struct tagged_item_header *)buf;
136         hdr->tag = cpu_to_le32(tag);
137         hdr->length = cpu_to_le32(len);
138         return hdr->data;
139 }
140
141 static inline struct wimlib_unix_data_disk *
142 inode_get_unix_data_disk(const struct wim_inode *inode)
143 {
144         return inode_get_tagged_item(inode, TAG_WIMLIB_UNIX_DATA,
145                                      sizeof(struct wimlib_unix_data_disk));
146 }
147
148 static inline struct wimlib_unix_data_disk *
149 inode_add_unix_data_disk(struct wim_inode *inode)
150 {
151         return inode_add_tagged_item(inode, TAG_WIMLIB_UNIX_DATA,
152                                      sizeof(struct wimlib_unix_data_disk));
153 }
154
155 /* Returns %true if the specified WIM inode has UNIX data; otherwise %false.
156  * This is a wimlib extension.  */
157 bool
158 inode_has_unix_data(const struct wim_inode *inode)
159 {
160         return inode_get_unix_data_disk(inode) != NULL;
161 }
162
163 /* Retrieves UNIX data from the specified WIM inode.
164  * This is a wimlib extension.
165  *
166  * Returns %true and fills @unix_data if the inode has UNIX data.
167  * Otherwise returns %false.  */
168 bool
169 inode_get_unix_data(const struct wim_inode *inode,
170                     struct wimlib_unix_data *unix_data)
171 {
172         const struct wimlib_unix_data_disk *p;
173
174         p = inode_get_unix_data_disk(inode);
175         if (!p)
176                 return false;
177
178         unix_data->uid = le32_to_cpu(p->uid);
179         unix_data->gid = le32_to_cpu(p->gid);
180         unix_data->mode = le32_to_cpu(p->mode);
181         unix_data->rdev = le32_to_cpu(p->rdev);
182         return true;
183 }
184
185 /* Sets UNIX data on the specified WIM inode.
186  * This is a wimlib extension.
187  *
188  * Callers must specify all members in @unix_data.  If the inode does not yet
189  * have UNIX data, it is given these values.  Otherwise, only the values that
190  * also have the corresponding flags in @which set are changed.
191  *
192  * Returns %true if successful, %false if failed (out of memory).  */
193 bool
194 inode_set_unix_data(struct wim_inode *inode, struct wimlib_unix_data *unix_data,
195                     int which)
196 {
197         struct wimlib_unix_data_disk *p;
198
199         p = inode_get_unix_data_disk(inode);
200         if (!p) {
201                 p = inode_add_unix_data_disk(inode);
202                 if (!p)
203                         return false;
204                 which = UNIX_DATA_ALL;
205         }
206         if (which & UNIX_DATA_UID)
207                 p->uid = cpu_to_le32(unix_data->uid);
208         if (which & UNIX_DATA_GID)
209                 p->gid = cpu_to_le32(unix_data->gid);
210         if (which & UNIX_DATA_MODE)
211                 p->mode = cpu_to_le32(unix_data->mode);
212         if (which & UNIX_DATA_RDEV)
213                 p->rdev = cpu_to_le32(unix_data->rdev);
214         return true;
215 }