xref: /freebsd/contrib/libarchive/cpio/test/test_format_newc.c (revision cddbc3b40812213ff00041f79174cac0be360a2a)
1 /*-
2  * Copyright (c) 2003-2007 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25 #include "test.h"
26 __FBSDID("$FreeBSD$");
27 
28 /* Number of bytes needed to pad 'n' to multiple of 'block', assuming
29  * that 'block' is a power of two. This trick can be more easily
30  * remembered as -n & (block - 1), but many compilers quite reasonably
31  * warn about "-n" when n is an unsigned value.  (~(n) + 1) is the
32  * same thing, but written in a way that won't offend anyone. */
33 #define PAD(n, block)  ((~(n) + 1) & ((block) - 1))
34 
35 static int
36 is_hex(const char *p, size_t l)
37 {
38 	while (l > 0) {
39 		if ((*p >= '0' && *p <= '9')
40 		    || (*p >= 'a' && *p <= 'f')
41 		    || (*p >= 'A' && *p <= 'F'))
42 		{
43 			--l;
44 			++p;
45 		} else
46 			return (0);
47 
48 	}
49 	return (1);
50 }
51 
52 static int
53 from_hex(const char *p, size_t l)
54 {
55 	int r = 0;
56 
57 	while (l > 0) {
58 		r *= 16;
59 		if (*p >= 'a' && *p <= 'f')
60 			r += *p + 10 - 'a';
61 		else if (*p >= 'A' && *p <= 'F')
62 			r += *p + 10 - 'A';
63 		else
64 			r += *p - '0';
65 		--l;
66 		++p;
67 	}
68 	return (r);
69 }
70 
71 #if !defined(_WIN32) || defined(__CYGWIN__)
72 static int
73 nlinks(const char *p)
74 {
75 	struct stat st;
76 	assertEqualInt(0, stat(p, &st));
77 	return st.st_nlink;
78 }
79 #endif
80 
81 DEFINE_TEST(test_format_newc)
82 {
83 	FILE *list;
84 	int r;
85 	int devmajor, devminor, ino, gid;
86 	int uid = -1;
87 	time_t t, t2, now;
88 	char *p, *e;
89 	size_t s, fs, ns;
90 	char result[1024];
91 
92 	assertUmask(0);
93 
94 #if !defined(_WIN32)
95 	uid = getuid();
96 #endif
97 
98 	/*
99 	 * Create an assortment of files.
100 	 * TODO: Extend this to cover more filetypes.
101 	 */
102 	list = fopen("list", "w");
103 
104 	/* "file1" */
105 	assertMakeFile("file1", 0644, "1234567890");
106 	fprintf(list, "file1\n");
107 
108 	/* "hardlink" */
109 	assertMakeHardlink("hardlink", "file1");
110 	fprintf(list, "hardlink\n");
111 
112 	/* Another hardlink, but this one won't be archived. */
113 	assertMakeHardlink("hardlink2", "file1");
114 
115 	/* "symlink" */
116 	if (canSymlink()) {
117 		assertMakeSymlink("symlink", "file1");
118 		fprintf(list, "symlink\n");
119 	}
120 
121 	/* "dir" */
122 	assertMakeDir("dir", 0775);
123 	fprintf(list, "dir\n");
124 
125 	/* Setup result message. */
126 	memset(result, 0, sizeof(result));
127 	if (is_LargeInode("file1")) {
128 		strncat(result,
129 		    "bsdcpio: file1: large inode number truncated: ",
130 		    sizeof(result) - strlen(result) -1);
131 		strncat(result, strerror(ERANGE),
132 		    sizeof(result) - strlen(result) -1);
133 		strncat(result, "\n",
134 		    sizeof(result) - strlen(result) -1);
135 	}
136 	if (canSymlink() && is_LargeInode("symlink")) {
137 		strncat(result,
138 		    "bsdcpio: symlink: large inode number truncated: ",
139 		    sizeof(result) - strlen(result) -1);
140 		strncat(result, strerror(ERANGE),
141 		    sizeof(result) - strlen(result) -1);
142 		strncat(result, "\n",
143 		    sizeof(result) - strlen(result) -1);
144 	}
145 	if (is_LargeInode("dir")) {
146 		strncat(result,
147 		    "bsdcpio: dir: large inode number truncated: ",
148 		    sizeof(result) - strlen(result) -1);
149 		strncat(result, strerror(ERANGE),
150 		    sizeof(result) - strlen(result) -1);
151 		strncat(result, "\n",
152 		    sizeof(result) - strlen(result) -1);
153 	}
154 	if (is_LargeInode("hardlink")) {
155 		strncat(result,
156 		    "bsdcpio: hardlink: large inode number truncated: ",
157 		    sizeof(result) - strlen(result) -1);
158 		strncat(result, strerror(ERANGE),
159 		    sizeof(result) - strlen(result) -1);
160 		strncat(result, "\n",
161 		    sizeof(result) - strlen(result) -1);
162 	}
163 
164 	/* Record some facts about what we just created: */
165 	now = time(NULL); /* They were all created w/in last two seconds. */
166 
167 	/* Use the cpio program to create an archive. */
168 	fclose(list);
169 	r = systemf("%s -o --format=newc <list >newc.out 2>newc.err",
170 	    testprog);
171 	if (!assertEqualInt(r, 0))
172 		return;
173 
174 	/* Verify that nothing went to stderr. */
175 	if (canSymlink()) {
176 		strncat(result, "2 blocks\n", sizeof(result) - strlen(result) -1);
177 	} else {
178 		strncat(result, "1 block\n", sizeof(result) - strlen(result) -1);
179 	}
180 	assertTextFileContents(result, "newc.err");
181 
182 	/* Verify that stdout is a well-formed cpio file in "newc" format. */
183 	p = slurpfile(&s, "newc.out");
184 	assertEqualInt(s, canSymlink() ? 1024 : 512);
185 	e = p;
186 
187 	/*
188 	 * Some of these assertions could be stronger, but it's
189 	 * a little tricky because they depend on the local environment.
190 	 */
191 
192 	/* First entry is "file1" */
193 	assert(is_hex(e, 110)); /* Entire header is octal digits. */
194 	assertEqualMem(e + 0, "070701", 6); /* Magic */
195 	ino = from_hex(e + 6, 8); /* ino */
196 #if defined(_WIN32) && !defined(__CYGWIN__)
197 	/* Group members bits and others bits do not work. */
198 	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
199 #else
200 	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */
201 #endif
202 	if (uid < 0)
203 		uid = from_hex(e + 22, 8);
204 	assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
205 	gid = from_hex(e + 30, 8); /* gid */
206 	assertEqualMem(e + 38, "00000003", 8); /* nlink */
207 	t = from_hex(e + 46, 8); /* mtime */
208 	failure("t=0x%08x now=0x%08x=%d", t, now, now);
209 	assert(t <= now); /* File wasn't created in future. */
210 	failure("t=0x%08x now - 2=0x%08x = %d", t, now - 2, now - 2);
211 	assert(t >= now - 2); /* File was created w/in last 2 secs. */
212 	failure("newc format stores body only with last appearance of a link\n"
213 	    "       first appearance should be empty, so this file size\n"
214 	    "       field should be zero");
215 	assertEqualInt(0, from_hex(e + 54, 8)); /* File size */
216 	fs = from_hex(e + 54, 8);
217 	fs += PAD(fs, 4);
218 	devmajor = from_hex(e + 62, 8); /* devmajor */
219 	devminor = from_hex(e + 70, 8); /* devminor */
220 	assert(is_hex(e + 78, 8)); /* rdevmajor */
221 	assert(is_hex(e + 86, 8)); /* rdevminor */
222 	assertEqualMem(e + 94, "00000006", 8); /* Name size */
223 	ns = from_hex(e + 94, 8);
224 	ns += PAD(ns + 2, 4);
225 	assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
226 	assertEqualMem(e + 110, "file1\0", 6); /* Name contents */
227 	/* Since there's another link, no file contents here. */
228 	/* But add in file size so that an error here doesn't cascade. */
229 	e += 110 + fs + ns;
230 
231 	if (canSymlink()) {
232 		/* "symlink" pointing to "file1" */
233 		assert(is_hex(e, 110));
234 		assertEqualMem(e + 0, "070701", 6); /* Magic */
235 		assert(is_hex(e + 6, 8)); /* ino */
236 		assertEqualInt(0xa1ff, from_hex(e + 14, 8)); /* Mode */
237 		assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
238 		assertEqualInt(gid, from_hex(e + 30, 8)); /* gid */
239 		assertEqualMem(e + 38, "00000001", 8); /* nlink */
240 		t2 = from_hex(e + 46, 8); /* mtime */
241 		failure("First entry created at t=0x%08x this entry created at t2=0x%08x", t, t2);
242 		assert(t2 == t || t2 == t + 1); /* Almost same as first entry. */
243 		assertEqualMem(e + 54, "00000005", 8); /* File size */
244 		fs = from_hex(e + 54, 8);
245 		fs += PAD(fs, 4);
246 		assertEqualInt(devmajor, from_hex(e + 62, 8)); /* devmajor */
247 		assertEqualInt(devminor, from_hex(e + 70, 8)); /* devminor */
248 		assert(is_hex(e + 78, 8)); /* rdevmajor */
249 		assert(is_hex(e + 86, 8)); /* rdevminor */
250 		assertEqualMem(e + 94, "00000008", 8); /* Name size */
251 		ns = from_hex(e + 94, 8);
252 		ns += PAD(ns + 2, 4);
253 		assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
254 		assertEqualMem(e + 110, "symlink\0\0\0", 10); /* Name contents */
255 		assertEqualMem(e + 110 + ns, "file1\0\0\0", 8); /* symlink target */
256 		e += 110 + fs + ns;
257 	}
258 
259 	/* "dir" */
260 	assert(is_hex(e, 110));
261 	assertEqualMem(e + 0, "070701", 6); /* Magic */
262 	assert(is_hex(e + 6, 8)); /* ino */
263 #if defined(_WIN32) && !defined(__CYGWIN__)
264 	/* Group members bits and others bits do not work. */
265 	assertEqualInt(0x41c0, from_hex(e + 14, 8) & 0xffc0); /* Mode */
266 #else
267 	/* Mode: sgid bit sometimes propagates from parent dirs, ignore it. */
268 	assertEqualInt(040775, from_hex(e + 14, 8) & ~02000);
269 #endif
270 	assertEqualInt(uid, from_hex(e + 22, 8)); /* uid */
271 	assertEqualInt(gid, from_hex(e + 30, 8)); /* gid */
272 #if !defined(_WIN32) || defined(__CYGWIN__)
273 	assertEqualInt(nlinks("dir"), from_hex(e + 38, 8)); /* nlinks */
274 #endif
275 	t2 = from_hex(e + 46, 8); /* mtime */
276 	failure("First entry created at t=0x%08x this entry created at t2=0x%08x", t, t2);
277 	assert(t2 == t || t2 == t + 1); /* Almost same as first entry. */
278 	assertEqualMem(e + 54, "00000000", 8); /* File size */
279 	fs = from_hex(e + 54, 8);
280 	fs += PAD(fs, 4);
281 	assertEqualInt(devmajor, from_hex(e + 62, 8)); /* devmajor */
282 	assertEqualInt(devminor, from_hex(e + 70, 8)); /* devminor */
283 	assert(is_hex(e + 78, 8)); /* rdevmajor */
284 	assert(is_hex(e + 86, 8)); /* rdevminor */
285 	assertEqualMem(e + 94, "00000004", 8); /* Name size */
286 	ns = from_hex(e + 94, 8);
287 	ns += PAD(ns + 2, 4);
288 	assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
289 	assertEqualMem(e + 110, "dir\0\0\0", 6); /* Name contents */
290 	e += 110 + fs + ns;
291 
292 	/* Hardlink identical to "file1" */
293 	/* Since we only wrote two of the three links to this
294 	 * file, this link should get deferred by the hardlink logic. */
295 	assert(is_hex(e, 110));
296 	assertEqualMem(e + 0, "070701", 6); /* Magic */
297 	failure("If these aren't the same, then the hardlink detection failed to match them.");
298 	assertEqualInt(ino, from_hex(e + 6, 8)); /* ino */
299 #if defined(_WIN32) && !defined(__CYGWIN__)
300 	/* Group members bits and others bits do not work. */
301 	assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
302 #else
303 	assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */
304 #endif
305 	assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
306 	assertEqualInt(gid, from_hex(e + 30, 8)); /* gid */
307 	assertEqualMem(e + 38, "00000003", 8); /* nlink */
308 	t2 = from_hex(e + 46, 8); /* mtime */
309 	failure("First entry created at t=0x%08x this entry created at t2=0x%08x", t, t2);
310 	assert(t2 == t || t2 == t + 1); /* Almost same as first entry. */
311 	assertEqualInt(10, from_hex(e + 54, 8)); /* File size */
312 	fs = from_hex(e + 54, 8);
313 	fs += PAD(fs, 4);
314 	assertEqualInt(devmajor, from_hex(e + 62, 8)); /* devmajor */
315 	assertEqualInt(devminor, from_hex(e + 70, 8)); /* devminor */
316 	assert(is_hex(e + 78, 8)); /* rdevmajor */
317 	assert(is_hex(e + 86, 8)); /* rdevminor */
318 	assertEqualMem(e + 94, "00000009", 8); /* Name size */
319 	ns = from_hex(e + 94, 8);
320 	ns += PAD(ns + 2, 4);
321 	assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
322 	assertEqualMem(e + 110, "hardlink\0\0", 10); /* Name contents */
323 	assertEqualMem(e + 110 + ns, "1234567890\0\0", 12); /* File contents */
324 	e += 110 + ns + fs;
325 
326 	/* Last entry is end-of-archive marker. */
327 	assert(is_hex(e, 110));
328 	assertEqualMem(e + 0, "070701", 6); /* Magic */
329 	assertEqualMem(e + 8, "00000000", 8); /* ino */
330 	assertEqualMem(e + 14, "00000000", 8); /* mode */
331 	assertEqualMem(e + 22, "00000000", 8); /* uid */
332 	assertEqualMem(e + 30, "00000000", 8); /* gid */
333 	assertEqualMem(e + 38, "00000001", 8); /* nlink */
334 	assertEqualMem(e + 46, "00000000", 8); /* mtime */
335 	assertEqualMem(e + 54, "00000000", 8); /* size */
336 	assertEqualMem(e + 62, "00000000", 8); /* devmajor */
337 	assertEqualMem(e + 70, "00000000", 8); /* devminor */
338 	assertEqualMem(e + 78, "00000000", 8); /* rdevmajor */
339 	assertEqualMem(e + 86, "00000000", 8); /* rdevminor */
340 	assertEqualInt(11, from_hex(e + 94, 8)); /* name size */
341 	assertEqualMem(e + 102, "00000000", 8); /* check field */
342 	assertEqualMem(e + 110, "TRAILER!!!\0\0", 12); /* Name */
343 
344 	free(p);
345 }
346