| 1 | /* test23: chdir(), getcwd() Author: Jan-Mark Wams (jms@cs.vu.nl) */
|
|---|
| 2 |
|
|---|
| 3 | #include <sys/types.h>
|
|---|
| 4 | #include <sys/stat.h>
|
|---|
| 5 | #include <sys/dir.h>
|
|---|
| 6 | #include <limits.h>
|
|---|
| 7 | #include <errno.h>
|
|---|
| 8 | #include <unistd.h>
|
|---|
| 9 | #include <stdlib.h>
|
|---|
| 10 | #include <string.h>
|
|---|
| 11 | #include <fcntl.h>
|
|---|
| 12 | #include <stdio.h>
|
|---|
| 13 |
|
|---|
| 14 | #define MAX_ERROR 4
|
|---|
| 15 | #define ITERATIONS 3
|
|---|
| 16 |
|
|---|
| 17 | #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
|
|---|
| 18 | #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
|
|---|
| 19 |
|
|---|
| 20 | int errct;
|
|---|
| 21 | int subtest;
|
|---|
| 22 | int superuser; /* True if we are root. */
|
|---|
| 23 |
|
|---|
| 24 | char cwd[PATH_MAX]; /* Space for path names. */
|
|---|
| 25 | char cwd2[PATH_MAX];
|
|---|
| 26 | char buf[PATH_MAX];
|
|---|
| 27 | char MaxName[NAME_MAX + 1]; /* Name of maximum length */
|
|---|
| 28 | char MaxPath[PATH_MAX]; /* Same for path */
|
|---|
| 29 | char ToLongName[NAME_MAX + 2]; /* Name of maximum +1 length */
|
|---|
| 30 | char ToLongPath[PATH_MAX + 1]; /* Same for path, both too long */
|
|---|
| 31 |
|
|---|
| 32 | _PROTOTYPE(void main, (int argc, char *argv[]));
|
|---|
| 33 | _PROTOTYPE(void test23a, (void));
|
|---|
| 34 | _PROTOTYPE(void test23b, (void));
|
|---|
| 35 | _PROTOTYPE(void test23c, (void));
|
|---|
| 36 | _PROTOTYPE(void makelongnames, (void)); /* Fill MaxName etc. */
|
|---|
| 37 | _PROTOTYPE(char *last_index, (char *string, int ch));
|
|---|
| 38 | _PROTOTYPE(char *my_getcwd, (char *buf, int size));
|
|---|
| 39 | _PROTOTYPE(void e, (int number));
|
|---|
| 40 | _PROTOTYPE(void quit, (void));
|
|---|
| 41 |
|
|---|
| 42 | void main(argc, argv)
|
|---|
| 43 | int argc;
|
|---|
| 44 | char *argv[];
|
|---|
| 45 | {
|
|---|
| 46 | int i, m = 0xFFFF;
|
|---|
| 47 |
|
|---|
| 48 | sync();
|
|---|
| 49 | if (argc == 2) m = atoi(argv[1]);
|
|---|
| 50 | printf("Test 23 ");
|
|---|
| 51 | fflush(stdout);
|
|---|
| 52 | System("rm -rf DIR_23; mkdir DIR_23");
|
|---|
| 53 | Chdir("DIR_23");
|
|---|
| 54 | makelongnames();
|
|---|
| 55 | superuser = (geteuid() == 0);
|
|---|
| 56 |
|
|---|
| 57 | for (i = 0; i < ITERATIONS; i++) {
|
|---|
| 58 | if (m & 0001) test23a(); /* Test normal operation */
|
|---|
| 59 | if (m & 0002) test23b(); /* Test critical operation */
|
|---|
| 60 | if (m & 0004) test23c(); /* Test error operation */
|
|---|
| 61 | }
|
|---|
| 62 |
|
|---|
| 63 | quit();
|
|---|
| 64 | }
|
|---|
| 65 |
|
|---|
| 66 | void test23a()
|
|---|
| 67 | { /* Test normal operation. */
|
|---|
| 68 | register int i;
|
|---|
| 69 |
|
|---|
| 70 | subtest = 1;
|
|---|
| 71 |
|
|---|
| 72 | System("rm -rf ../DIR_23/*");
|
|---|
| 73 |
|
|---|
| 74 | /* Let's do some fiddeling with path names. */
|
|---|
| 75 | if (getcwd(cwd, PATH_MAX) != cwd) e(1);
|
|---|
| 76 | if (chdir(cwd) != 0) e(2);
|
|---|
| 77 | if (getcwd(buf, PATH_MAX) != buf) e(3);
|
|---|
| 78 | if (strcmp(buf, cwd) != 0) e(4);
|
|---|
| 79 | if (chdir(".") != 0) e(5);
|
|---|
| 80 | if (getcwd(buf, PATH_MAX) != buf) e(6);
|
|---|
| 81 | if (strcmp(buf, cwd) != 0) e(7);
|
|---|
| 82 | if (chdir("./././.") != 0) e(8);
|
|---|
| 83 | if (getcwd(buf, PATH_MAX) != buf) e(9);
|
|---|
| 84 | if (strcmp(buf, cwd) != 0) e(10);
|
|---|
| 85 |
|
|---|
| 86 | /* Creat a working dir named "foo", remove any previous residues. */
|
|---|
| 87 | System("rm -rf foo");
|
|---|
| 88 | if (mkdir("foo", 0777) != 0) e(11);
|
|---|
| 89 |
|
|---|
| 90 | /* Do some more fiddeling with path names. */
|
|---|
| 91 | if (chdir("foo/.././foo/..") != 0) e(12); /* change to cwd */
|
|---|
| 92 | if (getcwd(buf, PATH_MAX) != buf) e(13);
|
|---|
| 93 | if (strcmp(buf, cwd) != 0) e(13);
|
|---|
| 94 | if (chdir("foo") != 0) e(14); /* change to foo */
|
|---|
| 95 | if (chdir("..") != 0) e(15); /* and back again */
|
|---|
| 96 | if (getcwd(buf, PATH_MAX) != buf) e(16);
|
|---|
| 97 | if (strcmp(buf, cwd) != 0) e(17);
|
|---|
| 98 |
|
|---|
| 99 | /* Make 30 sub dirs, eg. ./bar/bar/bar/bar/bar...... */
|
|---|
| 100 | System("rm -rf bar"); /* get ridd of bar */
|
|---|
| 101 | for (i = 0; i < 30; i++) {
|
|---|
| 102 | if (mkdir("bar", 0777) != 0) e(18);
|
|---|
| 103 | if (chdir("bar") != 0) e(19); /* change to bar */
|
|---|
| 104 | }
|
|---|
| 105 | for (i = 0; i < 30; i++) {
|
|---|
| 106 | if (chdir("..") != 0) e(20); /* and back again */
|
|---|
| 107 | if (rmdir("bar") != 0) e(21);
|
|---|
| 108 | }
|
|---|
| 109 |
|
|---|
| 110 | /* Make sure we are back where we started. */
|
|---|
| 111 | if (getcwd(buf, PATH_MAX) != buf) e(22);
|
|---|
| 112 | if (strcmp(buf, cwd) != 0) e(23);
|
|---|
| 113 | System("rm -rf bar"); /* just incase */
|
|---|
| 114 |
|
|---|
| 115 | /* Do some normal checks on `Chdir()' and `getcwd()' */
|
|---|
| 116 | if (chdir("/") != 0) e(24);
|
|---|
| 117 | if (getcwd(buf, PATH_MAX) != buf) e(25);
|
|---|
| 118 | if (strcmp(buf, "/") != 0) e(26);
|
|---|
| 119 | if (chdir("..") != 0) e(27); /* go to parent of / */
|
|---|
| 120 | if (getcwd(buf, PATH_MAX) != buf) e(28);
|
|---|
| 121 | if (strcmp(buf, "/") != 0) e(29);
|
|---|
| 122 | if (chdir(cwd) != 0) e(30);
|
|---|
| 123 | if (getcwd(buf, PATH_MAX) != buf) e(31);
|
|---|
| 124 | if (strcmp(buf, cwd) != 0) e(32);
|
|---|
| 125 | if (chdir("/etc") != 0) e(33); /* /etc might be on RAM */
|
|---|
| 126 | if (getcwd(buf, PATH_MAX) != buf) e(34); /* might make a difference */
|
|---|
| 127 | if (strcmp(buf, "/etc") != 0) e(35);
|
|---|
| 128 | if (chdir(cwd) != 0) e(36);
|
|---|
| 129 | if (getcwd(buf, PATH_MAX) != buf) e(37);
|
|---|
| 130 | if (strcmp(buf, cwd) != 0) e(38);
|
|---|
| 131 | if (chdir(".//.//") != 0) e(39); /* .//.// == current dir */
|
|---|
| 132 | if (getcwd(buf, PATH_MAX) != buf) e(40);
|
|---|
| 133 | if (strcmp(buf, cwd) != 0) e(41); /* we might be at '/' */
|
|---|
| 134 | #ifdef _MINIX
|
|---|
| 135 | /* XXX - my_getcwd() is old rubbish. It reads the directory directly instead
|
|---|
| 136 | * of through the directory library. It uses a fixed size buffer instead of
|
|---|
| 137 | * a size related to PATH_MAX, NAME_MAX or the size required.
|
|---|
| 138 | */
|
|---|
| 139 | if (my_getcwd(buf, PATH_MAX) != buf) e(42); /* get cwd my way */
|
|---|
| 140 | if (strcmp(cwd, buf) != 0) e(43);
|
|---|
| 141 | #endif
|
|---|
| 142 | System("rm -rf foo");
|
|---|
| 143 | }
|
|---|
| 144 |
|
|---|
| 145 | void test23b()
|
|---|
| 146 | { /* Test critical values. */
|
|---|
| 147 | subtest = 2;
|
|---|
| 148 |
|
|---|
| 149 | System("rm -rf ../DIR_23/*");
|
|---|
| 150 |
|
|---|
| 151 | /* Fiddle with the size (2nt) parameter of `getcwd ()'. */
|
|---|
| 152 | if (getcwd(cwd, PATH_MAX) != cwd) e(1); /* get cwd */
|
|---|
| 153 | if (getcwd(buf, strlen(cwd)) != (char *) 0) e(2); /* size 1 to small */
|
|---|
| 154 | if (errno != ERANGE) e(3);
|
|---|
| 155 | if (getcwd(buf, PATH_MAX) != buf) e(4);
|
|---|
| 156 | if (strcmp(buf, cwd) != 0) e(5);
|
|---|
| 157 | Chdir(cwd); /* getcwd might cd / */
|
|---|
| 158 | if (getcwd(buf, strlen(cwd) + 1) != buf) e(6); /* size just ok */
|
|---|
| 159 | if (getcwd(buf, PATH_MAX) != buf) e(7);
|
|---|
| 160 | if (strcmp(buf, cwd) != 0) e(8);
|
|---|
| 161 |
|
|---|
| 162 | /* Let's see how "MaxName" and "ToLongName" are handled. */
|
|---|
| 163 | if (mkdir(MaxName, 0777) != 0) e(9);
|
|---|
| 164 | if (chdir(MaxName) != 0) e(10);
|
|---|
| 165 | if (chdir("..") != 0) e(11);
|
|---|
| 166 | if (rmdir(MaxName) != 0) e(12);
|
|---|
| 167 | if (getcwd(buf, PATH_MAX) != buf) e(13);
|
|---|
| 168 | if (strcmp(buf, cwd) != 0) e(14);
|
|---|
| 169 | if (chdir(MaxPath) != 0) e(15);
|
|---|
| 170 | if (getcwd(buf, PATH_MAX) != buf) e(16);
|
|---|
| 171 | if (strcmp(buf, cwd) != 0) e(17);
|
|---|
| 172 |
|
|---|
| 173 | if (chdir(ToLongName) != -1) e(18);
|
|---|
| 174 | #ifdef _POSIX_NO_TRUNC
|
|---|
| 175 | # if _POSIX_NO_TRUNC - 0 != -1
|
|---|
| 176 | if (errno != ENAMETOOLONG) e(20);
|
|---|
| 177 | # else
|
|---|
| 178 | if (errno != ENOENT) e(20);
|
|---|
| 179 | # endif
|
|---|
| 180 | #else
|
|---|
| 181 | # include "error, this case requires dynamic checks and is not handled"
|
|---|
| 182 | #endif
|
|---|
| 183 |
|
|---|
| 184 | if (getcwd(buf, PATH_MAX) != buf) e(21);
|
|---|
| 185 | if (strcmp(buf, cwd) != 0) e(22);
|
|---|
| 186 | if (chdir(ToLongPath) != -1) e(23);
|
|---|
| 187 | if (errno != ENAMETOOLONG) e(24);
|
|---|
| 188 | if (getcwd(buf, PATH_MAX) != buf) e(25);
|
|---|
| 189 | if (strcmp(buf, cwd) != 0) e(26);
|
|---|
| 190 | }
|
|---|
| 191 |
|
|---|
| 192 | void test23c()
|
|---|
| 193 | { /* Check reaction to errors */
|
|---|
| 194 | subtest = 3;
|
|---|
| 195 |
|
|---|
| 196 | System("rm -rf ../DIR_23/*");
|
|---|
| 197 |
|
|---|
| 198 | if (getcwd(cwd, PATH_MAX) != cwd) e(1); /* get cwd */
|
|---|
| 199 |
|
|---|
| 200 | /* Creat a working dir named "foo", remove any previous residues. */
|
|---|
| 201 | System("rm -rf foo; mkdir foo");
|
|---|
| 202 |
|
|---|
| 203 | /* Check some obviouse errors. */
|
|---|
| 204 | if (chdir("") != -1) e(2);
|
|---|
| 205 | if (errno != ENOENT) e(3);
|
|---|
| 206 | if (getcwd(buf, PATH_MAX) != buf) e(4);
|
|---|
| 207 | if (strcmp(buf, cwd) != 0) e(5);
|
|---|
| 208 | if (getcwd(buf, 0) != (char *) 0) e(6);
|
|---|
| 209 | if (errno != EINVAL) e(7);
|
|---|
| 210 | if (getcwd(buf, PATH_MAX) != buf) e(8);
|
|---|
| 211 | if (strcmp(buf, cwd) != 0) e(9);
|
|---|
| 212 | if (getcwd(buf, 0) != (char *) 0) e(10);
|
|---|
| 213 | if (errno != EINVAL) e(11);
|
|---|
| 214 | if (getcwd(buf, PATH_MAX) != buf) e(12);
|
|---|
| 215 | if (strcmp(buf, cwd) != 0) e(13);
|
|---|
| 216 | if (chdir(cwd) != 0) e(14); /* getcwd might be buggy. */
|
|---|
| 217 |
|
|---|
| 218 | /* Change the mode of foo, and check the effect. */
|
|---|
| 219 | if (chdir("foo") != 0) e(15); /* change to foo */
|
|---|
| 220 | if (mkdir("bar", 0777) != 0) e(16); /* make a new dir bar */
|
|---|
| 221 | if (getcwd(cwd2, PATH_MAX) != cwd2) e(17); /* get the new cwd */
|
|---|
| 222 | if (getcwd(buf, 3) != (char *) 0) e(18); /* size is too small */
|
|---|
| 223 | if (errno != ERANGE) e(19);
|
|---|
| 224 | if (getcwd(buf, PATH_MAX) != buf) e(20);
|
|---|
| 225 | if (strcmp(buf, cwd2) != 0) e(21);
|
|---|
| 226 | Chdir(cwd2); /* getcwd() might cd / */
|
|---|
| 227 | System("chmod 377 ."); /* make foo unreadable */
|
|---|
| 228 | if (getcwd(buf, PATH_MAX) != buf) e(22); /* dir not readable */
|
|---|
| 229 | if (getcwd(buf, PATH_MAX) != buf) e(23);
|
|---|
| 230 | if (strcmp(buf, cwd2) != 0) e(24);
|
|---|
| 231 | if (chdir("bar") != 0) e(25); /* at .../foo/bar */
|
|---|
| 232 | if (!superuser) {
|
|---|
| 233 | if (getcwd(buf, PATH_MAX) != (char *) 0) e(26);
|
|---|
| 234 | if (errno != EACCES) e(27);
|
|---|
| 235 | }
|
|---|
| 236 | if (superuser) {
|
|---|
| 237 | if (getcwd(buf, PATH_MAX) != buf) e(28);
|
|---|
| 238 | }
|
|---|
| 239 | if (chdir(cwd2) != 0) e(29);
|
|---|
| 240 | if (getcwd(buf, PATH_MAX) != buf) e(30);
|
|---|
| 241 | if (strcmp(buf, cwd2) != 0) e(31);
|
|---|
| 242 | System("chmod 677 ."); /* make foo inaccessable */
|
|---|
| 243 | if (!superuser) {
|
|---|
| 244 | if (getcwd(buf, PATH_MAX) != (char *) 0) e(32); /* try to get cwd */
|
|---|
| 245 | if (errno != EACCES) e(33); /* but no access */
|
|---|
| 246 | if (chdir("..") != -1) e(34); /* try to get back */
|
|---|
| 247 | if (errno != EACCES) e(35); /* again no access */
|
|---|
| 248 | if (chdir(cwd) != 0) e(36); /* get back to cwd */
|
|---|
| 249 | /* `Chdir()' might do path optimizing, it shouldn't. */
|
|---|
| 250 | if (chdir("foo/..") != -1) e(37); /* no op */
|
|---|
| 251 | if (chdir("foo") != -1) e(38); /* try to cd to foo */
|
|---|
| 252 | if (errno != EACCES) e(39); /* no have access */
|
|---|
| 253 | if (getcwd(buf, PATH_MAX) != buf) e(40);
|
|---|
| 254 | if (strcmp(buf, cwd) != 0) e(41);
|
|---|
| 255 | }
|
|---|
| 256 | if (superuser) {
|
|---|
| 257 | if (getcwd(buf, PATH_MAX) != buf) e(42);
|
|---|
| 258 | if (strcmp(buf, cwd2) != 0) e(43);
|
|---|
| 259 | if (chdir("..") != 0) e(44); /* get back to cwd */
|
|---|
| 260 | if (chdir("foo") != 0) e(45); /* get back to foo */
|
|---|
| 261 | if (chdir(cwd) != 0) e(46); /* get back to cwd */
|
|---|
| 262 | }
|
|---|
| 263 | if (getcwd(buf, PATH_MAX) != buf) e(47); /* check we are */
|
|---|
| 264 | if (strcmp(buf, cwd) != 0) e(48); /* back at cwd. */
|
|---|
| 265 | Chdir(cwd); /* just in case... */
|
|---|
| 266 |
|
|---|
| 267 | if (chdir("/etc/passwd") != -1) e(49); /* try to change to a file */
|
|---|
| 268 | if (errno != ENOTDIR) e(50);
|
|---|
| 269 | if (getcwd(buf, PATH_MAX) != buf) e(51);
|
|---|
| 270 | if (strcmp(buf, cwd) != 0) e(52);
|
|---|
| 271 | if (chdir("/notexist") != -1) e(53);
|
|---|
| 272 | if (errno != ENOENT) e(54);
|
|---|
| 273 | if (getcwd(buf, PATH_MAX) != buf) e(55);
|
|---|
| 274 | if (strcmp(buf, cwd) != 0) e(56);
|
|---|
| 275 | System("chmod 777 foo");
|
|---|
| 276 | if (chdir("foo") != 0) e(57);
|
|---|
| 277 |
|
|---|
| 278 | /* XXX - this comment was botched by 'pretty'. */
|
|---|
| 279 | /* * Since `foo' is the cwd, it should not be removeable but * if it
|
|---|
| 280 | * were, this code would be found here; *
|
|---|
| 281 | *
|
|---|
| 282 | * System ("cd .. ; rm -rf foo"); remove foo * if (chdir (".")
|
|---|
| 283 | * != -1) e(); try go to. * if (errno != ENOENT) e();
|
|---|
| 284 | * hould not be an entry * if (chdir ("..") != -1) e(); try
|
|---|
| 285 | * to get back * if (errno != ENOENT) e(); should not be
|
|---|
| 286 | * an entry * if (getcwd (buf, PATH_MAX) != (char *)0) e(); don't
|
|---|
| 287 | * know where we are *
|
|---|
| 288 | *
|
|---|
| 289 | * What should errno be now ? The cwd might be gone if te superuser *
|
|---|
| 290 | * removed the cwd. (Might even have linked it first.) But this *
|
|---|
| 291 | * testing should be done by the test program for `rmdir()'. */
|
|---|
| 292 | if (chdir(cwd) != 0) e(58);
|
|---|
| 293 | }
|
|---|
| 294 |
|
|---|
| 295 | void makelongnames()
|
|---|
| 296 | {
|
|---|
| 297 | register int i;
|
|---|
| 298 |
|
|---|
| 299 | memset(MaxName, 'a', NAME_MAX);
|
|---|
| 300 | MaxName[NAME_MAX] = '\0';
|
|---|
| 301 | for (i = 0; i < PATH_MAX - 1; i++) { /* idem path */
|
|---|
| 302 | MaxPath[i++] = '.';
|
|---|
| 303 | MaxPath[i] = '/';
|
|---|
| 304 | }
|
|---|
| 305 | MaxPath[PATH_MAX - 1] = '\0';
|
|---|
| 306 |
|
|---|
| 307 | strcpy(ToLongName, MaxName); /* copy them Max to ToLong */
|
|---|
| 308 | strcpy(ToLongPath, MaxPath);
|
|---|
| 309 |
|
|---|
| 310 | ToLongName[NAME_MAX] = 'a';
|
|---|
| 311 | ToLongName[NAME_MAX + 1] = '\0'; /* extend ToLongName by one too many */
|
|---|
| 312 | ToLongPath[PATH_MAX - 1] = '/';
|
|---|
| 313 | ToLongPath[PATH_MAX] = '\0'; /* inc ToLongPath by one */
|
|---|
| 314 | }
|
|---|
| 315 |
|
|---|
| 316 | /* The following code, is take from pwd written by Adri Koppes */
|
|---|
| 317 |
|
|---|
| 318 | /* My_getcwd() helper. */
|
|---|
| 319 | char *last_index(string, ch)
|
|---|
| 320 | char *string;
|
|---|
| 321 | char ch;
|
|---|
| 322 | {
|
|---|
| 323 | register char *retval = '\0';
|
|---|
| 324 |
|
|---|
| 325 | while (*string != '\0') {
|
|---|
| 326 | if (*string == ch) retval = string;
|
|---|
| 327 | string++;
|
|---|
| 328 | }
|
|---|
| 329 | return(retval);
|
|---|
| 330 | }
|
|---|
| 331 |
|
|---|
| 332 | char *my_getcwd(buf, size)
|
|---|
| 333 | char *buf;
|
|---|
| 334 | int size;
|
|---|
| 335 | { /* should be like getcwd() */
|
|---|
| 336 | int sd;
|
|---|
| 337 | register int fd;
|
|---|
| 338 | register char *n;
|
|---|
| 339 | char name[128];
|
|---|
| 340 | struct stat s, st, sk;
|
|---|
| 341 | struct direct d;
|
|---|
| 342 |
|
|---|
| 343 | if (size <= 0) return(char *) 0;
|
|---|
| 344 |
|
|---|
| 345 | *buf = '\0';
|
|---|
| 346 | *name = '\0';
|
|---|
| 347 | stat(".", &s);
|
|---|
| 348 | do {
|
|---|
| 349 | if ((fd = open("..", O_RDONLY)) < 0) return(char *) 0;
|
|---|
| 350 | st.st_dev = s.st_dev;
|
|---|
| 351 | st.st_ino = s.st_ino;
|
|---|
| 352 | stat("..", &s);
|
|---|
| 353 | Chdir("..");
|
|---|
| 354 | sd = sizeof(struct direct);
|
|---|
| 355 | if (s.st_dev == st.st_dev) {
|
|---|
| 356 | do {
|
|---|
| 357 | if (read(fd, (char *) &d, sd) < sd) return(char *) 0;
|
|---|
| 358 | } while (d.d_ino != st.st_ino);
|
|---|
| 359 | } else {
|
|---|
| 360 | do {
|
|---|
| 361 | if (read(fd, (char *) &d, sd) < sd) return(char *) 0;
|
|---|
| 362 | stat(d.d_name, &sk);
|
|---|
| 363 | } while ((sk.st_dev != st.st_dev) ||
|
|---|
| 364 | (sk.st_ino != st.st_ino));
|
|---|
| 365 | }
|
|---|
| 366 | close(fd);
|
|---|
| 367 | if (strcmp(".", d.d_name) != 0) {
|
|---|
| 368 | strcat(name, "/");
|
|---|
| 369 | strcat(name, d.d_name);
|
|---|
| 370 | }
|
|---|
| 371 | } while ((s.st_ino != st.st_ino) || (s.st_dev != st.st_dev));
|
|---|
| 372 | if (*name == '\0')
|
|---|
| 373 | strncat(buf, "/", size);
|
|---|
| 374 | else
|
|---|
| 375 | while ((n = last_index(name, '/')) != NULL) {
|
|---|
| 376 | n[NAME_MAX] = '\0';
|
|---|
| 377 | strncat(buf, n, size - strlen(buf));
|
|---|
| 378 | *n = '\0';
|
|---|
| 379 | }
|
|---|
| 380 | strncat(buf, name, size - strlen(buf));
|
|---|
| 381 | buf[size - 1] = '\0';
|
|---|
| 382 | Chdir(buf); /* get back there */
|
|---|
| 383 | return buf;
|
|---|
| 384 | }
|
|---|
| 385 |
|
|---|
| 386 | void e(n)
|
|---|
| 387 | int n;
|
|---|
| 388 | {
|
|---|
| 389 | int err_num = errno; /* Save in case printf clobbers it. */
|
|---|
| 390 |
|
|---|
| 391 | printf("Subtest %d, error %d errno=%d: ", subtest, n, errno);
|
|---|
| 392 | errno = err_num;
|
|---|
| 393 | perror("");
|
|---|
| 394 | if (errct++ > MAX_ERROR) {
|
|---|
| 395 | printf("Too many errors; test aborted\n");
|
|---|
| 396 | chdir("..");
|
|---|
| 397 | system("rm -rf DIR*");
|
|---|
| 398 | exit(1);
|
|---|
| 399 | }
|
|---|
| 400 | errno = 0;
|
|---|
| 401 | }
|
|---|
| 402 |
|
|---|
| 403 | void quit()
|
|---|
| 404 | {
|
|---|
| 405 | Chdir("..");
|
|---|
| 406 | System("rm -rf DIR_23");
|
|---|
| 407 |
|
|---|
| 408 | if (errct == 0) {
|
|---|
| 409 | printf("ok\n");
|
|---|
| 410 | exit(0);
|
|---|
| 411 | } else {
|
|---|
| 412 | printf("%d errors\n", errct);
|
|---|
| 413 | exit(1);
|
|---|
| 414 | }
|
|---|
| 415 | }
|
|---|
