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 27 #define UMASK 022 28 /* 29 * When comparing mode values, ignore high-order bits 30 * that are set on some OSes. This should cover the bits 31 * we're interested in (standard mode bits + file type bits) 32 * while ignoring extra markers such as Haiku/BeOS index 33 * flags. 34 */ 35 #define MODE_MASK 0777777 36 37 static void create(struct archive_entry *ae, const char *msg) 38 { 39 struct archive *ad; 40 struct stat st; 41 42 /* Write the entry to disk. */ 43 assert((ad = archive_write_disk_new()) != NULL); 44 failure("%s", msg); 45 assertEqualIntA(ad, 0, archive_write_header(ad, ae)); 46 assertEqualIntA(ad, 0, archive_write_finish_entry(ad)); 47 assertEqualInt(0, archive_write_free(ad)); 48 49 /* Test the entries on disk. */ 50 assert(0 == stat(archive_entry_pathname(ae), &st)); 51 failure("%s", msg); 52 53 #if !defined(_WIN32) || defined(__CYGWIN__) 54 /* When verifying a dir, ignore the S_ISGID bit, as some systems set 55 * that automatically. */ 56 if (archive_entry_filetype(ae) == AE_IFDIR) 57 st.st_mode &= ~S_ISGID; 58 assertEqualInt(st.st_mode & MODE_MASK, 59 archive_entry_mode(ae) & ~UMASK & MODE_MASK); 60 #endif 61 } 62 63 static void create_reg_file(struct archive_entry *ae, const char *msg) 64 { 65 static const char data[]="abcdefghijklmnopqrstuvwxyz"; 66 struct archive *ad; 67 68 /* Write the entry to disk. */ 69 assert((ad = archive_write_disk_new()) != NULL); 70 archive_write_disk_set_options(ad, ARCHIVE_EXTRACT_TIME); 71 failure("%s", msg); 72 /* 73 * A touchy API design issue: archive_write_data() does (as of 74 * 2.4.12) enforce the entry size as a limit on the data 75 * written to the file. This was not enforced prior to 76 * 2.4.12. The change was prompted by the refined 77 * hardlink-restore semantics introduced at that time. In 78 * short, libarchive needs to know whether a "hardlink entry" 79 * is going to overwrite the contents so that it can know 80 * whether or not to open the file for writing. This implies 81 * that there is a fundamental semantic difference between an 82 * entry with a zero size and one with a non-zero size in the 83 * case of hardlinks and treating the hardlink case 84 * differently from the regular file case is just asking for 85 * trouble. So, a zero size must always mean that no data 86 * will be accepted, which is consistent with the file size in 87 * the entry being a maximum size. 88 */ 89 archive_entry_set_size(ae, sizeof(data)); 90 archive_entry_set_mtime(ae, 123456789, 0); 91 assertEqualIntA(ad, 0, archive_write_header(ad, ae)); 92 assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data))); 93 assertEqualIntA(ad, 0, archive_write_finish_entry(ad)); 94 assertEqualInt(0, archive_write_free(ad)); 95 96 /* Test the entries on disk. */ 97 assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777); 98 assertFileSize(archive_entry_pathname(ae), sizeof(data)); 99 /* test_write_disk_times has more detailed tests of this area. */ 100 assertFileMtime(archive_entry_pathname(ae), 123456789, 0); 101 failure("No atime given, so atime should get set to current time"); 102 assertFileAtimeRecent(archive_entry_pathname(ae)); 103 } 104 105 static void create_reg_file2(struct archive_entry *ae, const char *msg) 106 { 107 const int datasize = 100000; 108 char *data; 109 struct archive *ad; 110 int i; 111 112 data = malloc(datasize); 113 for (i = 0; i < datasize; i++) 114 data[i] = (char)(i % 256); 115 116 /* Write the entry to disk. */ 117 assert((ad = archive_write_disk_new()) != NULL); 118 failure("%s", msg); 119 /* 120 * See above for an explanation why this next call 121 * is necessary. 122 */ 123 archive_entry_set_size(ae, datasize); 124 assertEqualIntA(ad, 0, archive_write_header(ad, ae)); 125 for (i = 0; i < datasize - 999; i += 1000) { 126 assertEqualIntA(ad, ARCHIVE_OK, 127 archive_write_data_block(ad, data + i, 1000, i)); 128 } 129 assertEqualIntA(ad, 0, archive_write_finish_entry(ad)); 130 assertEqualInt(0, archive_write_free(ad)); 131 132 /* Test the entries on disk. */ 133 assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777); 134 assertFileSize(archive_entry_pathname(ae), i); 135 assertFileContents(data, datasize, archive_entry_pathname(ae)); 136 free(data); 137 } 138 139 static void create_reg_file3(struct archive_entry *ae, const char *msg) 140 { 141 static const char data[]="abcdefghijklmnopqrstuvwxyz"; 142 struct archive *ad; 143 struct stat st; 144 145 /* Write the entry to disk. */ 146 assert((ad = archive_write_disk_new()) != NULL); 147 failure("%s", msg); 148 /* Set the size smaller than the data and verify the truncation. */ 149 archive_entry_set_size(ae, 5); 150 assertEqualIntA(ad, 0, archive_write_header(ad, ae)); 151 assertEqualInt(5, archive_write_data(ad, data, sizeof(data))); 152 assertEqualIntA(ad, 0, archive_write_finish_entry(ad)); 153 assertEqualInt(0, archive_write_free(ad)); 154 155 /* Test the entry on disk. */ 156 assert(0 == stat(archive_entry_pathname(ae), &st)); 157 failure("st.st_mode=%o archive_entry_mode(ae)=%o", 158 st.st_mode, archive_entry_mode(ae)); 159 #if !defined(_WIN32) || defined(__CYGWIN__) 160 assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK)); 161 #endif 162 assertEqualInt(st.st_size, 5); 163 } 164 165 166 static void create_reg_file4(struct archive_entry *ae, const char *msg) 167 { 168 static const char data[]="abcdefghijklmnopqrstuvwxyz"; 169 struct archive *ad; 170 struct stat st; 171 172 /* Write the entry to disk. */ 173 assert((ad = archive_write_disk_new()) != NULL); 174 /* Leave the size unset. The data should not be truncated. */ 175 assertEqualIntA(ad, 0, archive_write_header(ad, ae)); 176 assertEqualInt(ARCHIVE_OK, 177 archive_write_data_block(ad, data, sizeof(data), 0)); 178 assertEqualIntA(ad, 0, archive_write_finish_entry(ad)); 179 assertEqualInt(0, archive_write_free(ad)); 180 181 /* Test the entry on disk. */ 182 assert(0 == stat(archive_entry_pathname(ae), &st)); 183 failure("st.st_mode=%o archive_entry_mode(ae)=%o", 184 st.st_mode, archive_entry_mode(ae)); 185 #if !defined(_WIN32) || defined(__CYGWIN__) 186 assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK)); 187 #endif 188 failure("%s", msg); 189 assertEqualInt(st.st_size, sizeof(data)); 190 } 191 192 #if defined(_WIN32) && !defined(__CYGWIN__) 193 static void create_reg_file_win(struct archive_entry *ae, const char *msg) 194 { 195 static const char data[]="abcdefghijklmnopqrstuvwxyz"; 196 struct archive *ad; 197 struct _stat st; 198 wchar_t *p, *fname; 199 size_t l; 200 201 /* Write the entry to disk. */ 202 assert((ad = archive_write_disk_new()) != NULL); 203 archive_write_disk_set_options(ad, ARCHIVE_EXTRACT_TIME); 204 failure("%s", msg); 205 archive_entry_set_size(ae, sizeof(data)); 206 archive_entry_set_mtime(ae, 123456789, 0); 207 assertEqualIntA(ad, 0, archive_write_header(ad, ae)); 208 assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data))); 209 assertEqualIntA(ad, 0, archive_write_finish_entry(ad)); 210 assertEqualInt(0, archive_write_free(ad)); 211 212 /* Test the entries on disk. */ 213 l = wcslen(archive_entry_pathname_w(ae)); 214 fname = malloc((l + 1) * sizeof(wchar_t)); 215 assert(NULL != fname); 216 wcscpy(fname, archive_entry_pathname_w(ae)); 217 p = fname; 218 /* Skip leading drive letter from archives created 219 * on Windows. */ 220 if (((p[0] >= L'a' && p[0] <= L'z') || 221 (p[0] >= L'A' && p[0] <= L'Z')) && 222 p[1] == L':' && p[2] == L'\\') { 223 p += 3; 224 } 225 /* Replace unusable characters in Windows to '_' */ 226 for (; *p != L'\0'; p++) 227 if (*p == L':' || *p == L'*' || *p == L'?' || 228 *p == L'"' || *p == L'<' || *p == L'>' || *p == L'|') 229 *p = '_'; 230 assert(0 == _wstat(fname, &st)); 231 failure("st.st_mode=%o archive_entry_mode(ae)=%o", 232 st.st_mode, archive_entry_mode(ae)); 233 assertEqualInt(st.st_size, sizeof(data)); 234 free(fname); 235 } 236 #endif /* _WIN32 && !__CYGWIN__ */ 237 238 DEFINE_TEST(test_write_disk) 239 { 240 struct archive_entry *ae; 241 #if defined(_WIN32) && !defined(__CYGWIN__) 242 wchar_t *fullpath; 243 DWORD l; 244 #endif 245 246 /* Force the umask to something predictable. */ 247 assertUmask(UMASK); 248 249 /* A regular file. */ 250 assert((ae = archive_entry_new()) != NULL); 251 archive_entry_copy_pathname(ae, "file"); 252 archive_entry_set_mode(ae, S_IFREG | 0755); 253 create_reg_file(ae, "Test creating a regular file"); 254 archive_entry_free(ae); 255 256 /* Another regular file. */ 257 assert((ae = archive_entry_new()) != NULL); 258 archive_entry_copy_pathname(ae, "file2"); 259 archive_entry_set_mode(ae, S_IFREG | 0755); 260 create_reg_file2(ae, "Test creating another regular file"); 261 archive_entry_free(ae); 262 263 /* A regular file with a size restriction */ 264 assert((ae = archive_entry_new()) != NULL); 265 archive_entry_copy_pathname(ae, "file3"); 266 archive_entry_set_mode(ae, S_IFREG | 0755); 267 create_reg_file3(ae, "Regular file with size restriction"); 268 archive_entry_free(ae); 269 270 /* A regular file with an unspecified size */ 271 assert((ae = archive_entry_new()) != NULL); 272 archive_entry_copy_pathname(ae, "file3"); 273 archive_entry_set_mode(ae, S_IFREG | 0755); 274 create_reg_file4(ae, "Regular file with unspecified size"); 275 archive_entry_free(ae); 276 277 /* A regular file over an existing file */ 278 assert((ae = archive_entry_new()) != NULL); 279 archive_entry_copy_pathname(ae, "file"); 280 archive_entry_set_mode(ae, S_IFREG | 0724); 281 create(ae, "Test creating a file over an existing file."); 282 archive_entry_free(ae); 283 284 /* A directory. */ 285 assert((ae = archive_entry_new()) != NULL); 286 archive_entry_copy_pathname(ae, "dir"); 287 archive_entry_set_mode(ae, S_IFDIR | 0555); 288 create(ae, "Test creating a regular dir."); 289 archive_entry_free(ae); 290 291 /* A directory over an existing file. */ 292 assert((ae = archive_entry_new()) != NULL); 293 archive_entry_copy_pathname(ae, "file"); 294 archive_entry_set_mode(ae, S_IFDIR | 0742); 295 create(ae, "Test creating a dir over an existing file."); 296 archive_entry_free(ae); 297 298 /* A file over an existing dir. */ 299 assert((ae = archive_entry_new()) != NULL); 300 archive_entry_copy_pathname(ae, "file"); 301 archive_entry_set_mode(ae, S_IFREG | 0744); 302 create(ae, "Test creating a file over an existing dir."); 303 archive_entry_free(ae); 304 305 #if defined(_WIN32) && !defined(__CYGWIN__) 306 /* A file with unusable characters in its file name. */ 307 assert((ae = archive_entry_new()) != NULL); 308 archive_entry_copy_pathname_w(ae, L"f:i*l?e\"f<i>l|e"); 309 archive_entry_set_mode(ae, S_IFREG | 0755); 310 create_reg_file_win(ae, "Test creating a regular file" 311 " with unusable characters in its file name"); 312 archive_entry_free(ae); 313 314 /* A file with unusable characters in its directory name. */ 315 assert((ae = archive_entry_new()) != NULL); 316 archive_entry_copy_pathname_w(ae, L"d:i*r?e\"c<t>o|ry/file1"); 317 archive_entry_set_mode(ae, S_IFREG | 0755); 318 create_reg_file_win(ae, "Test creating a regular file" 319 " with unusable characters in its file name"); 320 archive_entry_free(ae); 321 322 /* A full-path file with unusable characters in its file name. */ 323 assert((l = GetCurrentDirectoryW(0, NULL)) != 0); 324 assert((fullpath = malloc((l + 20) * sizeof(wchar_t))) != NULL); 325 assert((l = GetCurrentDirectoryW(l, fullpath)) != 0); 326 wcscat(fullpath, L"\\f:i*l?e\"f<i>l|e"); 327 assert((ae = archive_entry_new()) != NULL); 328 archive_entry_copy_pathname_w(ae, fullpath); 329 archive_entry_set_mode(ae, S_IFREG | 0755); 330 create_reg_file_win(ae, "Test creating a regular file" 331 " with unusable characters in its file name"); 332 archive_entry_free(ae); 333 free(fullpath); 334 335 /* A full-path file with unusable characters in its directory name. */ 336 assert((l = GetCurrentDirectoryW(0, NULL)) != 0); 337 assert((fullpath = malloc((l + 30) * sizeof(wchar_t))) != NULL); 338 assert((l = GetCurrentDirectoryW(l, fullpath)) != 0); 339 wcscat(fullpath, L"\\d:i*r?e\"c<t>o|ry/file1"); 340 assert((ae = archive_entry_new()) != NULL); 341 archive_entry_copy_pathname_w(ae, fullpath); 342 archive_entry_set_mode(ae, S_IFREG | 0755); 343 create_reg_file_win(ae, "Test creating a regular file" 344 " with unusable characters in its file name"); 345 archive_entry_free(ae); 346 free(fullpath); 347 #endif /* _WIN32 && !__CYGWIN__ */ 348 } 349