9eaf6b4b0e2f4457d6b084f9467b33e1fd78d0b4
[wimlib] / src / symlink.c
1 /*
2  * symlink.c
3  *
4  * Code to read and set symbolic links in WIM files.
5  */
6
7 /*
8  * Copyright (C) 2012, 2013 Eric Biggers
9  *
10  * This file is part of wimlib, a library for working with WIM files.
11  *
12  * wimlib is free software; you can redistribute it and/or modify it under the
13  * terms of the GNU General Public License as published by the Free
14  * Software Foundation; either version 3 of the License, or (at your option)
15  * any later version.
16  *
17  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
19  * A PARTICULAR PURPOSE. See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with wimlib; if not, see http://www.gnu.org/licenses/.
24  */
25
26 #include "dentry.h"
27 #include "buffer_io.h"
28 #include "lookup_table.h"
29 #include "sha1.h"
30 #include <errno.h>
31
32 /* None of this file is ever needed in Win32 builds because the reparse point
33  * buffers are not parsed. */
34 #if !defined(__WIN32__)
35
36 /*
37  * Find the symlink target of a symbolic link or junction point in the WIM.
38  *
39  * See http://msdn.microsoft.com/en-us/library/cc232006(v=prot.10).aspx for a
40  * description of the format of the so-called "reparse point data buffers".
41  *
42  * But, in the WIM format, the first 8 bytes of the reparse point data buffer
43  * are omitted, presumably because we already know the reparse tag from the
44  * dentry, and we already know the reparse tag length from the lookup table
45  * entry resource length.
46  */
47 static ssize_t
48 get_symlink_name(const void *resource, size_t resource_len, char *buf,
49                  size_t buf_len, u32 reparse_tag)
50 {
51         const void *p = resource;
52         u16 substitute_name_offset;
53         u16 substitute_name_len;
54         u16 print_name_offset;
55         u16 print_name_len;
56         char *link_target;
57         size_t link_target_len;
58         ssize_t ret;
59         unsigned header_size;
60         char *translated_target;
61         bool is_absolute;
62         u32 flags;
63
64         if (resource_len < 12)
65                 return -EIO;
66         p = get_u16(p, &substitute_name_offset);
67         p = get_u16(p, &substitute_name_len);
68         p = get_u16(p, &print_name_offset);
69         p = get_u16(p, &print_name_len);
70         get_u32(p, &flags);
71
72         wimlib_assert(reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
73                       reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT);
74
75         if (reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT) {
76                 header_size = 8;
77         } else {
78                 is_absolute = (flags & 1) ? false : true;
79                 header_size = 12;
80                 p += 4;
81         }
82         if (header_size + substitute_name_offset + substitute_name_len > resource_len)
83                 return -EIO;
84
85         ret = utf16le_to_tstr((const utf16lechar*)(p + substitute_name_offset),
86                               substitute_name_len,
87                               &link_target, &link_target_len);
88         if (ret)
89                 return -errno;
90
91         if (link_target_len + 1 > buf_len) {
92                 ret = -ENAMETOOLONG;
93                 goto out;
94         }
95
96         translated_target = link_target;
97         if (reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT || is_absolute) {
98                 if (link_target_len < 7
99                       || memcmp(translated_target, "\\??\\", 4) != 0
100                       || translated_target[4] == '\0'
101                       || translated_target[5] != ':'
102                       || translated_target[6] != '\\') {
103                         ret = -EIO;
104                         goto out;
105                 }
106                 translated_target += 4;
107                 link_target_len -= 4;
108                 /* There's a drive letter, so just leave the backslashes since
109                  * it won't go anyhwere on UNIX anyway...
110                  *
111                  * XXX
112                  * NTFS-3g tries to re-map these links to actually point to
113                  * something, so maybe we could do something like that here
114                  * XXX*/
115         } else {
116                 for (size_t i = 0; i < link_target_len; i++)
117                         if (translated_target[i] == '\\')
118                                 translated_target[i] = '/';
119         }
120
121         memcpy(buf, translated_target, link_target_len + 1);
122         ret = link_target_len;
123 out:
124         FREE(link_target);
125         return ret;
126 }
127
128 static int
129 make_symlink_reparse_data_buf(const char *symlink_target,
130                               size_t *len_ret, void **buf_ret)
131 {
132         utf16lechar *name_utf16le;
133         size_t name_utf16le_nbytes;
134         int ret;
135
136         ret = tstr_to_utf16le(symlink_target, strlen(symlink_target),
137                               &name_utf16le, &name_utf16le_nbytes);
138         if (ret != 0)
139                 return ret;
140
141         for (size_t i = 0; i < name_utf16le_nbytes / 2; i++)
142                 if (name_utf16le[i] == cpu_to_le16('/'))
143                         name_utf16le[i] = cpu_to_le16('\\');
144
145         size_t len = 12 + name_utf16le_nbytes * 2;
146         void *buf = MALLOC(len);
147         if (buf) {
148                 void *p = buf;
149                 p = put_u16(p, name_utf16le_nbytes); /* Substitute name offset */
150                 p = put_u16(p, name_utf16le_nbytes); /* Substitute name length */
151                 p = put_u16(p, 0); /* Print name offset */
152                 p = put_u16(p, name_utf16le_nbytes); /* Print name length */
153                 p = put_u32(p, 1); /* flags: 0 iff *full* target, including drive letter??? */
154                 p = put_bytes(p, name_utf16le_nbytes, name_utf16le);
155                 p = put_bytes(p, name_utf16le_nbytes, name_utf16le);
156                 *len_ret = len;
157                 *buf_ret = buf;
158                 ret = 0;
159         } else {
160                 ret = WIMLIB_ERR_NOMEM;
161         }
162         FREE(name_utf16le);
163         return ret;
164 }
165
166 /* Get the symlink target from a WIM inode.
167  *
168  * The inode may be either a "real" symlink (reparse tag
169  * WIM_IO_REPARSE_TAG_SYMLINK), or it may be a junction point (reparse tag
170  * WIM_IO_REPARSE_TAG_MOUNT_POINT).
171  */
172 ssize_t
173 inode_readlink(const struct wim_inode *inode, char *buf, size_t buf_len,
174                const WIMStruct *w, bool threadsafe)
175 {
176         const struct wim_lookup_table_entry *lte;
177         int ret;
178
179         wimlib_assert(inode_is_symlink(inode));
180
181         lte = inode_unnamed_lte(inode, w->lookup_table);
182         if (!lte)
183                 return -EIO;
184
185         if (wim_resource_size(lte) > REPARSE_POINT_MAX_SIZE)
186                 return -EIO;
187
188         u8 res_buf[wim_resource_size(lte)];
189         ret = read_full_resource_into_buf(lte, res_buf, threadsafe);
190         if (ret != 0)
191                 return -EIO;
192         return get_symlink_name(res_buf, wim_resource_size(lte), buf,
193                                 buf_len, inode->i_reparse_tag);
194 }
195
196 /*
197  * Sets @inode to be a symbolic link pointing to @target.
198  *
199  * A lookup table entry for the symbolic link data buffer is created and
200  * inserted into @lookup_table, unless there is an existing lookup table entry
201  * for the exact same data, in which its reference count is incremented.
202  *
203  * The lookup table entry is returned in @lte_ret.
204  *
205  * On failure @dentry and @lookup_table are not modified.
206  */
207 int
208 inode_set_symlink(struct wim_inode *inode,
209                   const char *target,
210                   struct wim_lookup_table *lookup_table,
211                   struct wim_lookup_table_entry **lte_ret)
212
213 {
214         int ret;
215         size_t symlink_buf_len;
216         struct wim_lookup_table_entry *lte = NULL, *existing_lte;
217         u8 symlink_buf_hash[SHA1_HASH_SIZE];
218         void *symlink_buf;
219
220         ret = make_symlink_reparse_data_buf(target, &symlink_buf_len,
221                                             &symlink_buf);
222         if (ret)
223                 return ret;
224
225         DEBUG("Made symlink reparse data buf (len = %zu, name len = %zu)",
226                         symlink_buf_len, symlink_buf_len);
227
228         sha1_buffer(symlink_buf, symlink_buf_len, symlink_buf_hash);
229
230         existing_lte = __lookup_resource(lookup_table, symlink_buf_hash);
231
232         if (existing_lte) {
233                 lte = existing_lte;
234                 FREE(symlink_buf);
235                 symlink_buf = NULL;
236         } else {
237                 DEBUG("Creating new lookup table entry for symlink buf");
238                 lte = new_lookup_table_entry();
239                 if (!lte) {
240                         ret = WIMLIB_ERR_NOMEM;
241                         goto out_free_symlink_buf;
242                 }
243                 lte->resource_location            = RESOURCE_IN_ATTACHED_BUFFER;
244                 lte->attached_buffer              = symlink_buf;
245                 lte->resource_entry.original_size = symlink_buf_len;
246                 copy_hash(lte->hash, symlink_buf_hash);
247         }
248
249         inode->i_lte = lte;
250         inode->i_resolved = 1;
251
252         DEBUG("Loaded symlink buf");
253
254         if (existing_lte)
255                 lte->refcnt++;
256         else
257                 lookup_table_insert(lookup_table, lte);
258         if (lte_ret)
259                 *lte_ret = lte;
260         return 0;
261 out_free_symlink_buf:
262         FREE(symlink_buf);
263         return ret;
264 }
265
266 #endif /* !defined(__WIN32__) */