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 #if defined(__CYGWIN__) 29 # include <limits.h> 30 # include <sys/cygwin.h> 31 #endif 32 33 /* 34 * Try to figure out how deep we can go in our tests. Assumes that 35 * the first call to this function has the longest starting cwd (which 36 * is currently "<testdir>/original"). This is mostly to work around 37 * limits in our Win32 support. 38 * 39 * Background: On Posix systems, PATH_MAX is merely a limit on the 40 * length of the string passed into a system call. By repeatedly 41 * calling chdir(), you can work with arbitrarily long paths on such 42 * systems. In contrast, Win32 APIs apply PATH_MAX limits to the full 43 * absolute path, so the permissible length of a system call argument 44 * varies with the cwd. Some APIs actually enforce limits 45 * significantly less than PATH_MAX to ensure that you can create 46 * files within the current working directory. The Win32 limits also 47 * apply to Cygwin before 1.7. 48 * 49 * Someday, I want to convert the Win32 support to use newer 50 * wide-character paths with '\\?\' prefix, which has a 32k PATH_MAX 51 * instead of the rather anemic 260 character limit of the older 52 * system calls. Then we can drop this mess (unless we want to 53 * continue to special-case Cygwin 1.5 and earlier). 54 */ 55 static int 56 compute_loop_max(void) 57 { 58 #if defined(_WIN32) && !defined(__CYGWIN__) 59 static int LOOP_MAX = 0; 60 char buf[MAX_PATH]; 61 size_t cwdlen; 62 63 if (LOOP_MAX == 0) { 64 assert(_getcwd(buf, MAX_PATH) != NULL); 65 cwdlen = strlen(buf); 66 /* 12 characters = length of 8.3 filename */ 67 /* 4 characters = length of "/../" used in symlink tests */ 68 /* 1 character = length of extra "/" separator */ 69 LOOP_MAX = MAX_PATH - (int)cwdlen - 12 - 4 - 1; 70 } 71 return LOOP_MAX; 72 #elif defined(__CYGWIN__) && !defined(HAVE_CYGWIN_CONV_PATH) 73 static int LOOP_MAX = 0; 74 if (LOOP_MAX == 0) { 75 char wbuf[PATH_MAX]; 76 char pbuf[PATH_MAX]; 77 size_t wcwdlen; 78 size_t pcwdlen; 79 size_t cwdlen; 80 assert(getcwd(pbuf, PATH_MAX) != NULL); 81 pcwdlen = strlen(pbuf); 82 cygwin_conv_to_full_win32_path(pbuf, wbuf); 83 wcwdlen = strlen(wbuf); 84 cwdlen = ((wcwdlen > pcwdlen) ? wcwdlen : pcwdlen); 85 /* Cygwin helper needs an extra few characters. */ 86 LOOP_MAX = PATH_MAX - (int)cwdlen - 12 - 4 - 4; 87 } 88 return LOOP_MAX; 89 #else 90 /* cygwin-1.7 ends up here, along with "normal" unix */ 91 return 200; /* restore pre-r278 depth */ 92 #endif 93 } 94 95 /* filenames[i] is a distinctive filename of length i. */ 96 /* To simplify interpreting failures, each filename ends with a 97 * decimal integer which is the length of the filename. E.g., A 98 * filename ending in "_92" is 92 characters long. To detect errors 99 * which drop or misplace characters, the filenames use a repeating 100 * "abcdefghijklmnopqrstuvwxyz..." pattern. */ 101 static char *filenames[201]; 102 103 static void 104 compute_filenames(void) 105 { 106 char buff[250]; 107 size_t i,j; 108 109 filenames[0] = strdup(""); 110 filenames[1] = strdup("1"); 111 filenames[2] = strdup("a2"); 112 for (i = 3; i < sizeof(filenames)/sizeof(filenames[0]); ++i) { 113 /* Fill with "abcdefghij..." */ 114 for (j = 0; j < i; ++j) 115 buff[j] = 'a' + (j % 26); 116 buff[j--] = '\0'; 117 /* Work from the end to fill in the number portion. */ 118 buff[j--] = '0' + (i % 10); 119 if (i > 9) { 120 buff[j--] = '0' + ((i / 10) % 10); 121 if (i > 99) 122 buff[j--] = '0' + (i / 100); 123 } 124 buff[j] = '_'; 125 /* Guard against obvious screwups in the above code. */ 126 assertEqualInt(strlen(buff), i); 127 filenames[i] = strdup(buff); 128 } 129 } 130 131 static void 132 create_tree(void) 133 { 134 char buff[260]; 135 char buff2[260]; 136 int i; 137 int LOOP_MAX; 138 139 compute_filenames(); 140 141 /* Log that we'll be omitting some checks. */ 142 if (!canSymlink()) { 143 skipping("Symlink checks"); 144 } 145 146 assertMakeDir("original", 0775); 147 assertEqualInt(0, chdir("original")); 148 LOOP_MAX = compute_loop_max(); 149 150 assertMakeDir("f", 0775); 151 assertMakeDir("l", 0775); 152 assertMakeDir("m", 0775); 153 assertMakeDir("s", 0775); 154 assertMakeDir("d", 0775); 155 156 for (i = 1; i < LOOP_MAX; i++) { 157 failure("Internal sanity check failed: i = %d", i); 158 assert(filenames[i] != NULL); 159 160 sprintf(buff, "f/%s", filenames[i]); 161 assertMakeFile(buff, 0777, buff); 162 163 /* Create a link named "l/abcdef..." to the above. */ 164 sprintf(buff2, "l/%s", filenames[i]); 165 assertMakeHardlink(buff2, buff); 166 167 /* Create a link named "m/abcdef..." to the above. */ 168 sprintf(buff2, "m/%s", filenames[i]); 169 assertMakeHardlink(buff2, buff); 170 171 if (canSymlink()) { 172 /* Create a symlink named "s/abcdef..." to the above. */ 173 sprintf(buff, "s/%s", filenames[i]); 174 sprintf(buff2, "../f/%s", filenames[i]); 175 failure("buff=\"%s\" buff2=\"%s\"", buff, buff2); 176 assertMakeSymlink(buff, buff2); 177 } 178 /* Create a dir named "d/abcdef...". */ 179 buff[0] = 'd'; 180 failure("buff=\"%s\"", buff); 181 assertMakeDir(buff, 0775); 182 } 183 184 assertEqualInt(0, chdir("..")); 185 } 186 187 #define LIMIT_NONE 200 188 #define LIMIT_USTAR 100 189 190 static void 191 verify_tree(size_t limit) 192 { 193 char name1[260]; 194 char name2[260]; 195 size_t i, LOOP_MAX; 196 197 LOOP_MAX = compute_loop_max(); 198 199 /* Generate the names we know should be there and verify them. */ 200 for (i = 1; i < LOOP_MAX; i++) { 201 /* Verify a file named "f/abcdef..." */ 202 sprintf(name1, "f/%s", filenames[i]); 203 if (i <= limit) { 204 assertFileExists(name1); 205 assertFileContents(name1, strlen(name1), name1); 206 } 207 208 sprintf(name2, "l/%s", filenames[i]); 209 if (i + 2 <= limit) { 210 /* Verify hardlink "l/abcdef..." */ 211 assertIsHardlink(name1, name2); 212 /* Verify hardlink "m/abcdef..." */ 213 name2[0] = 'm'; 214 assertIsHardlink(name1, name2); 215 } 216 217 if (canSymlink()) { 218 /* Verify symlink "s/abcdef..." */ 219 sprintf(name1, "s/%s", filenames[i]); 220 sprintf(name2, "../f/%s", filenames[i]); 221 if (strlen(name2) <= limit) 222 assertIsSymlink(name1, name2); 223 } 224 225 /* Verify dir "d/abcdef...". */ 226 sprintf(name1, "d/%s", filenames[i]); 227 if (i + 1 <= limit) { /* +1 for trailing slash */ 228 if (assertIsDir(name1, -1)) { 229 /* TODO: opendir/readdir this 230 * directory and make sure 231 * it's empty. 232 */ 233 } 234 } 235 } 236 237 #if !defined(_WIN32) || defined(__CYGWIN__) 238 { 239 const char *dp; 240 /* Now make sure nothing is there that shouldn't be. */ 241 for (dp = "dflms"; *dp != '\0'; ++dp) { 242 DIR *d; 243 struct dirent *de; 244 char dir[2]; 245 dir[0] = *dp; dir[1] = '\0'; 246 d = opendir(dir); 247 failure("Unable to open dir '%s'", dir); 248 if (!assert(d != NULL)) 249 continue; 250 while ((de = readdir(d)) != NULL) { 251 char *p = de->d_name; 252 if (p[0] == '.') 253 continue; 254 switch(dp[0]) { 255 case 'l': case 'm': case 'd': 256 failure("strlen(p)=%d", strlen(p)); 257 assert(strlen(p) < limit); 258 assertEqualString(p, 259 filenames[strlen(p)]); 260 break; 261 case 'f': case 's': 262 failure("strlen(p)=%d", strlen(p)); 263 assert(strlen(p) < limit + 1); 264 assertEqualString(p, 265 filenames[strlen(p)]); 266 break; 267 default: 268 failure("File %s shouldn't be here", p); 269 assert(0); 270 } 271 } 272 closedir(d); 273 } 274 } 275 #endif 276 } 277 278 static void 279 copy_basic(void) 280 { 281 int r; 282 283 /* NOTE: for proper operation on cygwin-1.5 and windows, the 284 * length of the name of the directory below, "plain", must be 285 * less than or equal to the lengthe of the name of the original 286 * directory, "original" This restriction derives from the 287 * extremely limited pathname lengths on those platforms. 288 */ 289 assertMakeDir("plain", 0775); 290 assertEqualInt(0, chdir("plain")); 291 292 /* 293 * Use the tar program to create an archive. 294 */ 295 r = systemf("%s cf archive -C ../original f d l m s >pack.out 2>pack.err", 296 testprog); 297 failure("Error invoking \"%s cf\"", testprog); 298 assertEqualInt(r, 0); 299 300 /* Verify that nothing went to stdout or stderr. */ 301 assertEmptyFile("pack.err"); 302 assertEmptyFile("pack.out"); 303 304 /* 305 * Use tar to unpack the archive into another directory. 306 */ 307 r = systemf("%s xf archive >unpack.out 2>unpack.err", testprog); 308 failure("Error invoking %s xf archive", testprog); 309 assertEqualInt(r, 0); 310 311 /* Verify that nothing went to stdout or stderr. */ 312 assertEmptyFile("unpack.err"); 313 assertEmptyFile("unpack.out"); 314 315 verify_tree(LIMIT_NONE); 316 assertEqualInt(0, chdir("..")); 317 } 318 319 static void 320 copy_ustar(void) 321 { 322 const char *target = "ustar"; 323 int r; 324 325 /* NOTE: for proper operation on cygwin-1.5 and windows, the 326 * length of the name of the directory below, "ustar", must be 327 * less than or equal to the lengthe of the name of the original 328 * directory, "original" This restriction derives from the 329 * extremely limited pathname lengths on those platforms. 330 */ 331 assertMakeDir(target, 0775); 332 assertEqualInt(0, chdir(target)); 333 334 /* 335 * Use the tar program to create an archive. 336 */ 337 r = systemf("%s cf archive --format=ustar -C ../original f d l m s >pack.out 2>pack.err", 338 testprog); 339 failure("Error invoking \"%s cf archive --format=ustar\"", testprog); 340 assertEqualInt(r, 0); 341 342 /* Verify that nothing went to stdout. */ 343 assertEmptyFile("pack.out"); 344 /* Stderr is non-empty, since there are a bunch of files 345 * with filenames too long to archive. */ 346 347 /* 348 * Use tar to unpack the archive into another directory. 349 */ 350 r = systemf("%s xf archive >unpack.out 2>unpack.err", testprog); 351 failure("Error invoking %s xf archive", testprog); 352 assertEqualInt(r, 0); 353 354 /* Verify that nothing went to stdout or stderr. */ 355 assertEmptyFile("unpack.err"); 356 assertEmptyFile("unpack.out"); 357 358 verify_tree(LIMIT_USTAR); 359 assertEqualInt(0, chdir("../..")); 360 } 361 362 DEFINE_TEST(test_copy) 363 { 364 assertUmask(0); 365 create_tree(); /* Create sample files in "original" dir. */ 366 367 /* Test simple "tar -c | tar -x" pipeline copy. */ 368 copy_basic(); 369 370 /* Same, but constrain to ustar format. */ 371 copy_ustar(); 372 } 373