| 1 | /* test 2 */
|
|---|
| 2 |
|
|---|
| 3 | #include <sys/types.h>
|
|---|
| 4 | #include <sys/times.h>
|
|---|
| 5 | #include <sys/wait.h>
|
|---|
| 6 | #include <errno.h>
|
|---|
| 7 | #include <signal.h>
|
|---|
| 8 | #include <stdlib.h>
|
|---|
| 9 | #include <unistd.h>
|
|---|
| 10 | #include <time.h>
|
|---|
| 11 | #include <stdio.h>
|
|---|
| 12 |
|
|---|
| 13 | #define ITERATIONS 5
|
|---|
| 14 | #define MAX_ERROR 4
|
|---|
| 15 |
|
|---|
| 16 | int is, array[4], parsigs, parcum, sigct, cumsig, errct, subtest;
|
|---|
| 17 | int iteration, kk = 0, errct = 0;
|
|---|
| 18 | char buf[2048];
|
|---|
| 19 |
|
|---|
| 20 | _PROTOTYPE(int main, (int argc, char *argv []));
|
|---|
| 21 | _PROTOTYPE(void test2a, (void));
|
|---|
| 22 | _PROTOTYPE(void test2b, (void));
|
|---|
| 23 | _PROTOTYPE(void test2c, (void));
|
|---|
| 24 | _PROTOTYPE(void test2d, (void));
|
|---|
| 25 | _PROTOTYPE(void test2e, (void));
|
|---|
| 26 | _PROTOTYPE(void test2f, (void));
|
|---|
| 27 | _PROTOTYPE(void test2g, (void));
|
|---|
| 28 | _PROTOTYPE(void test2h, (void));
|
|---|
| 29 | _PROTOTYPE(void sigpip, (int s));
|
|---|
| 30 | _PROTOTYPE(void quit, (void));
|
|---|
| 31 | _PROTOTYPE(void e, (int n));
|
|---|
| 32 |
|
|---|
| 33 | int main(argc, argv)
|
|---|
| 34 | int argc;
|
|---|
| 35 | char *argv[];
|
|---|
| 36 | {
|
|---|
| 37 | int i, m = 0xFFFF;
|
|---|
| 38 |
|
|---|
| 39 | sync();
|
|---|
| 40 |
|
|---|
| 41 | if (argc == 2) m = atoi(argv[1]);
|
|---|
| 42 |
|
|---|
| 43 | printf("Test 2 ");
|
|---|
| 44 | fflush(stdout); /* have to flush for child's benefit */
|
|---|
| 45 |
|
|---|
| 46 | system("rm -rf DIR_02; mkdir DIR_02");
|
|---|
| 47 | chdir("DIR_02");
|
|---|
| 48 |
|
|---|
| 49 | for (i = 0; i < ITERATIONS; i++) {
|
|---|
| 50 | iteration = i;
|
|---|
| 51 | if (m & 0001) test2a();
|
|---|
| 52 | if (m & 0002) test2b();
|
|---|
| 53 | if (m & 0004) test2c();
|
|---|
| 54 | if (m & 0010) test2d();
|
|---|
| 55 | if (m & 0020) test2e();
|
|---|
| 56 | if (m & 0040) test2f();
|
|---|
| 57 | if (m & 0100) test2g();
|
|---|
| 58 | if (m & 0200) test2h();
|
|---|
| 59 | }
|
|---|
| 60 | subtest = 100;
|
|---|
| 61 | if (cumsig != ITERATIONS) e(101);
|
|---|
| 62 | quit();
|
|---|
| 63 | return(-1); /* impossible */
|
|---|
| 64 | }
|
|---|
| 65 |
|
|---|
| 66 | void test2a()
|
|---|
| 67 | {
|
|---|
| 68 | /* Test pipes */
|
|---|
| 69 |
|
|---|
| 70 | int fd[2];
|
|---|
| 71 | int n, i, j, q = 0;
|
|---|
| 72 |
|
|---|
| 73 | subtest = 1;
|
|---|
| 74 | if (pipe(fd) < 0) {
|
|---|
| 75 | printf("pipe error. errno= %d\n", errno);
|
|---|
| 76 | errct++;
|
|---|
| 77 | quit();
|
|---|
| 78 | }
|
|---|
| 79 | i = fork();
|
|---|
| 80 | if (i < 0) {
|
|---|
| 81 | printf("fork failed\n");
|
|---|
| 82 | errct++;
|
|---|
| 83 | quit();
|
|---|
| 84 | }
|
|---|
| 85 | if (i != 0) {
|
|---|
| 86 | /* Parent code */
|
|---|
| 87 | close(fd[0]);
|
|---|
| 88 | for (i = 0; i < 2048; i++) buf[i] = i & 0377;
|
|---|
| 89 | for (q = 0; q < 8; q++) {
|
|---|
| 90 | if (write(fd[1], buf, 2048) < 0) {
|
|---|
| 91 | printf("write pipe err. errno=%d\n", errno);
|
|---|
| 92 | errct++;
|
|---|
| 93 | quit();
|
|---|
| 94 | }
|
|---|
| 95 | }
|
|---|
| 96 | close(fd[1]);
|
|---|
| 97 | wait(&q);
|
|---|
| 98 | if (q != 256 * 58) {
|
|---|
| 99 | printf("wrong exit code %d\n", q);
|
|---|
| 100 | errct++;
|
|---|
| 101 | quit();
|
|---|
| 102 | }
|
|---|
| 103 | } else {
|
|---|
| 104 | /* Child code */
|
|---|
| 105 | close(fd[1]);
|
|---|
| 106 | for (q = 0; q < 32; q++) {
|
|---|
| 107 | n = read(fd[0], buf, 512);
|
|---|
| 108 | if (n != 512) {
|
|---|
| 109 | printf("read yielded %d bytes, not 512\n", n);
|
|---|
| 110 | errct++;
|
|---|
| 111 | quit();
|
|---|
| 112 | }
|
|---|
| 113 | for (j = 0; j < n; j++)
|
|---|
| 114 | if ((buf[j] & 0377) != (kk & 0377)) {
|
|---|
| 115 | printf("wrong data: %d %d %d \n ",
|
|---|
| 116 | j, buf[j] & 0377, kk & 0377);
|
|---|
| 117 | } else {
|
|---|
| 118 | kk++;
|
|---|
| 119 | }
|
|---|
| 120 | }
|
|---|
| 121 | exit(58);
|
|---|
| 122 | }
|
|---|
| 123 | }
|
|---|
| 124 |
|
|---|
| 125 | void test2b()
|
|---|
| 126 | {
|
|---|
| 127 | int fd[2], n;
|
|---|
| 128 | char buf[4];
|
|---|
| 129 |
|
|---|
| 130 | subtest = 2;
|
|---|
| 131 | sigct = 0;
|
|---|
| 132 | signal(SIGPIPE, sigpip);
|
|---|
| 133 | pipe(fd);
|
|---|
| 134 | if (fork()) {
|
|---|
| 135 | /* Parent */
|
|---|
| 136 | close(fd[0]);
|
|---|
| 137 | while (sigct == 0) {
|
|---|
| 138 | write(fd[1], buf, 1);
|
|---|
| 139 | }
|
|---|
| 140 | wait(&n);
|
|---|
| 141 | } else {
|
|---|
| 142 | /* Child */
|
|---|
| 143 | close(fd[0]);
|
|---|
| 144 | close(fd[1]);
|
|---|
| 145 | exit(0);
|
|---|
| 146 | }
|
|---|
| 147 | }
|
|---|
| 148 |
|
|---|
| 149 | void test2c()
|
|---|
| 150 | {
|
|---|
| 151 | int n;
|
|---|
| 152 |
|
|---|
| 153 | subtest = 3;
|
|---|
| 154 | signal(SIGINT, SIG_DFL);
|
|---|
| 155 | is = 0;
|
|---|
| 156 | if ((array[is++] = fork()) > 0) {
|
|---|
| 157 | if ((array[is++] = fork()) > 0) {
|
|---|
| 158 | if ((array[is++] = fork()) > 0) {
|
|---|
| 159 | if ((array[is++] = fork()) > 0) {
|
|---|
| 160 | signal(SIGINT, SIG_IGN);
|
|---|
| 161 | kill(array[0], SIGINT);
|
|---|
| 162 | kill(array[1], SIGINT);
|
|---|
| 163 | kill(array[2], SIGINT);
|
|---|
| 164 | kill(array[3], SIGINT);
|
|---|
| 165 | wait(&n);
|
|---|
| 166 | wait(&n);
|
|---|
| 167 | wait(&n);
|
|---|
| 168 | wait(&n);
|
|---|
| 169 | } else {
|
|---|
| 170 | pause();
|
|---|
| 171 | }
|
|---|
| 172 | } else {
|
|---|
| 173 | pause();
|
|---|
| 174 | }
|
|---|
| 175 | } else {
|
|---|
| 176 | pause();
|
|---|
| 177 | }
|
|---|
| 178 | } else {
|
|---|
| 179 | pause();
|
|---|
| 180 | }
|
|---|
| 181 | }
|
|---|
| 182 |
|
|---|
| 183 | void test2d()
|
|---|
| 184 | {
|
|---|
| 185 |
|
|---|
| 186 | int pid, stat_loc, s;
|
|---|
| 187 |
|
|---|
| 188 | /* Test waitpid. */
|
|---|
| 189 | subtest = 4;
|
|---|
| 190 |
|
|---|
| 191 | /* Test waitpid(pid, arg2, 0) */
|
|---|
| 192 | pid = fork();
|
|---|
| 193 | if (pid < 0) e(1);
|
|---|
| 194 | if (pid > 0) {
|
|---|
| 195 | /* Parent. */
|
|---|
| 196 | s = waitpid(pid, &stat_loc, 0);
|
|---|
| 197 | if (s != pid) e(2);
|
|---|
| 198 | if (WIFEXITED(stat_loc) == 0) e(3);
|
|---|
| 199 | if (WIFSIGNALED(stat_loc) != 0) e(4);
|
|---|
| 200 | if (WEXITSTATUS(stat_loc) != 22) e(5);
|
|---|
| 201 | } else {
|
|---|
| 202 | /* Child */
|
|---|
| 203 | exit(22);
|
|---|
| 204 | }
|
|---|
| 205 |
|
|---|
| 206 | /* Test waitpid(-1, arg2, 0) */
|
|---|
| 207 | pid = fork();
|
|---|
| 208 | if (pid < 0) e(6);
|
|---|
| 209 | if (pid > 0) {
|
|---|
| 210 | /* Parent. */
|
|---|
| 211 | s = waitpid(-1, &stat_loc, 0);
|
|---|
| 212 | if (s != pid) e(7);
|
|---|
| 213 | if (WIFEXITED(stat_loc) == 0) e(8);
|
|---|
| 214 | if (WIFSIGNALED(stat_loc) != 0) e(9);
|
|---|
| 215 | if (WEXITSTATUS(stat_loc) != 33) e(10);
|
|---|
| 216 | } else {
|
|---|
| 217 | /* Child */
|
|---|
| 218 | exit(33);
|
|---|
| 219 | }
|
|---|
| 220 |
|
|---|
| 221 | /* Test waitpid(0, arg2, 0) */
|
|---|
| 222 | pid = fork();
|
|---|
| 223 | if (pid < 0) e(11);
|
|---|
| 224 | if (pid > 0) {
|
|---|
| 225 | /* Parent. */
|
|---|
| 226 | s = waitpid(0, &stat_loc, 0);
|
|---|
| 227 | if (s != pid) e(12);
|
|---|
| 228 | if (WIFEXITED(stat_loc) == 0) e(13);
|
|---|
| 229 | if (WIFSIGNALED(stat_loc) != 0) e(14);
|
|---|
| 230 | if (WEXITSTATUS(stat_loc) != 44) e(15);
|
|---|
| 231 | } else {
|
|---|
| 232 | /* Child */
|
|---|
| 233 | exit(44);
|
|---|
| 234 | }
|
|---|
| 235 |
|
|---|
| 236 | /* Test waitpid(0, arg2, WNOHANG) */
|
|---|
| 237 | signal(SIGTERM, SIG_DFL);
|
|---|
| 238 | pid = fork();
|
|---|
| 239 | if (pid < 0) e(16);
|
|---|
| 240 | if (pid > 0) {
|
|---|
| 241 | /* Parent. */
|
|---|
| 242 | s = waitpid(0, &stat_loc, WNOHANG);
|
|---|
| 243 | if (s != 0) e(17);
|
|---|
| 244 | if (kill(pid, SIGTERM) != 0) e(18);
|
|---|
| 245 | if (waitpid(pid, &stat_loc, 0) != pid) e(19);
|
|---|
| 246 | if (WIFEXITED(stat_loc) != 0) e(20);
|
|---|
| 247 | if (WIFSIGNALED(stat_loc) == 0) e(21);
|
|---|
| 248 | if (WTERMSIG(stat_loc) != SIGTERM) e(22);
|
|---|
| 249 | } else {
|
|---|
| 250 | /* Child */
|
|---|
| 251 | pause();
|
|---|
| 252 | }
|
|---|
| 253 |
|
|---|
| 254 | /* Test some error conditions. */
|
|---|
| 255 | errno = 9999;
|
|---|
| 256 | if (waitpid(0, &stat_loc, 0) != -1) e(23);
|
|---|
| 257 | if (errno != ECHILD) e(24);
|
|---|
| 258 | errno = 9999;
|
|---|
| 259 | if (waitpid(0, &stat_loc, WNOHANG) != -1) e(25);
|
|---|
| 260 | if (errno != ECHILD) e(26);
|
|---|
| 261 | }
|
|---|
| 262 |
|
|---|
| 263 | void test2e()
|
|---|
| 264 | {
|
|---|
| 265 |
|
|---|
| 266 | int pid1, pid2, stat_loc, s;
|
|---|
| 267 |
|
|---|
| 268 | /* Test waitpid with two children. */
|
|---|
| 269 | subtest = 5;
|
|---|
| 270 | if (iteration > 1) return; /* slow test, don't do it too much */
|
|---|
| 271 | if ( (pid1 = fork())) {
|
|---|
| 272 | /* Parent. */
|
|---|
| 273 | if ( (pid2 = fork()) ) {
|
|---|
| 274 | /* Parent. Collect second child first. */
|
|---|
| 275 | s = waitpid(pid2, &stat_loc, 0);
|
|---|
| 276 | if (s != pid2) e(1);
|
|---|
| 277 | if (WIFEXITED(stat_loc) == 0) e(2);
|
|---|
| 278 | if (WIFSIGNALED(stat_loc) != 0) e(3);
|
|---|
| 279 | if (WEXITSTATUS(stat_loc) != 222) e(4);
|
|---|
| 280 |
|
|---|
| 281 | /* Now collect first child. */
|
|---|
| 282 | s = waitpid(pid1, &stat_loc, 0);
|
|---|
| 283 | if (s != pid1) e(5);
|
|---|
| 284 | if (WIFEXITED(stat_loc) == 0) e(6);
|
|---|
| 285 | if (WIFSIGNALED(stat_loc) != 0) e(7);
|
|---|
| 286 | if (WEXITSTATUS(stat_loc) != 111) e(8);
|
|---|
| 287 | } else {
|
|---|
| 288 | /* Child 2. */
|
|---|
| 289 | sleep(2); /* child 2 delays before exiting. */
|
|---|
| 290 | exit(222);
|
|---|
| 291 | }
|
|---|
| 292 | } else {
|
|---|
| 293 | /* Child 1. */
|
|---|
| 294 | exit(111); /* child 1 exits immediately */
|
|---|
| 295 | }
|
|---|
| 296 |
|
|---|
| 297 | }
|
|---|
| 298 |
|
|---|
| 299 | void test2f()
|
|---|
| 300 | {
|
|---|
| 301 | /* test getpid, getppid, getuid, etc. */
|
|---|
| 302 |
|
|---|
| 303 | pid_t pid, pid1, ppid, cpid, stat_loc, err;
|
|---|
| 304 |
|
|---|
| 305 | subtest = 6;
|
|---|
| 306 | errno = -2000;
|
|---|
| 307 | err = 0;
|
|---|
| 308 | pid = getpid();
|
|---|
| 309 | if ( (pid1 = fork())) {
|
|---|
| 310 | /* Parent. Do nothing. */
|
|---|
| 311 | if (wait(&stat_loc) != pid1) e(1);
|
|---|
| 312 | if (WEXITSTATUS(stat_loc) != (pid1 & 0377)) e(2);
|
|---|
| 313 | } else {
|
|---|
| 314 | /* Child. Get ppid. */
|
|---|
| 315 | cpid = getpid();
|
|---|
| 316 | ppid = getppid();
|
|---|
| 317 | if (ppid != pid) err = 3;
|
|---|
| 318 | if (cpid == ppid) err = 4;
|
|---|
| 319 | exit(cpid & 0377);
|
|---|
| 320 | }
|
|---|
| 321 | if (err != 0) e(err);
|
|---|
| 322 | }
|
|---|
| 323 |
|
|---|
| 324 | void test2g()
|
|---|
| 325 | {
|
|---|
| 326 | /* test time(), times() */
|
|---|
| 327 |
|
|---|
| 328 | time_t t1, t2;
|
|---|
| 329 | clock_t t3, t4;
|
|---|
| 330 | struct tms tmsbuf;
|
|---|
| 331 |
|
|---|
| 332 | subtest = 7;
|
|---|
| 333 | errno = -7000;
|
|---|
| 334 |
|
|---|
| 335 | /* First time(). */
|
|---|
| 336 | t1 = -1;
|
|---|
| 337 | t2 = -2;
|
|---|
| 338 | t1 = time(&t2);
|
|---|
| 339 | if (t1 < 650000000L) e(1); /* 650000000 is Sept. 1990 */
|
|---|
| 340 | if (t1 != t2) e(2);
|
|---|
| 341 | t1 = -1;
|
|---|
| 342 | t1 = time( (time_t *) NULL);
|
|---|
| 343 | if (t1 < 650000000L) e(3);
|
|---|
| 344 | t3 = times(&tmsbuf);
|
|---|
| 345 | sleep(1);
|
|---|
| 346 | t2 = time( (time_t *) NULL);
|
|---|
| 347 | if (t2 < 0L) e(4);
|
|---|
| 348 | if (t2 - t1 < 1) e(5);
|
|---|
| 349 |
|
|---|
| 350 | /* Now times(). */
|
|---|
| 351 | t4 = times(&tmsbuf);
|
|---|
| 352 | if ( t4 == (clock_t) -1) e(6);
|
|---|
| 353 | if (t4 - t3 < CLOCKS_PER_SEC) e(7);
|
|---|
| 354 | if (tmsbuf.tms_utime < 0) e(8);
|
|---|
| 355 | if (tmsbuf.tms_stime < 0) e(9);
|
|---|
| 356 | if (tmsbuf.tms_cutime < 0) e(10);
|
|---|
| 357 | if (tmsbuf.tms_cstime < 0) e(11);
|
|---|
| 358 | }
|
|---|
| 359 |
|
|---|
| 360 | void test2h()
|
|---|
| 361 | {
|
|---|
| 362 | /* Test getgroups(). */
|
|---|
| 363 |
|
|---|
| 364 | gid_t g[10];
|
|---|
| 365 |
|
|---|
| 366 | subtest = 8;
|
|---|
| 367 | errno = -8000;
|
|---|
| 368 | if (getgroups(10, g) != 0) e(1);
|
|---|
| 369 | if (getgroups(1, g) != 0) e(2);
|
|---|
| 370 | if (getgroups(0, g) != 0) e(3);
|
|---|
| 371 | }
|
|---|
| 372 |
|
|---|
| 373 | void sigpip(s)
|
|---|
| 374 | int s; /* for ANSI */
|
|---|
| 375 | {
|
|---|
| 376 | sigct++;
|
|---|
| 377 | cumsig++;
|
|---|
| 378 | }
|
|---|
| 379 |
|
|---|
| 380 | void quit()
|
|---|
| 381 | {
|
|---|
| 382 |
|
|---|
| 383 | chdir("..");
|
|---|
| 384 | system("rm -rf DIR*");
|
|---|
| 385 |
|
|---|
| 386 | if (errct == 0) {
|
|---|
| 387 | printf("ok\n");
|
|---|
| 388 | exit(0);
|
|---|
| 389 | } else {
|
|---|
| 390 | printf("%d errors\n", errct);
|
|---|
| 391 | exit(4);
|
|---|
| 392 | }
|
|---|
| 393 | }
|
|---|
| 394 |
|
|---|
| 395 | void e(n)
|
|---|
| 396 | int n;
|
|---|
| 397 | {
|
|---|
| 398 | int err_num = errno; /* save errno in case printf clobbers it */
|
|---|
| 399 |
|
|---|
| 400 | printf("Subtest %d, error %d errno=%d ", subtest, n, errno);
|
|---|
| 401 | errno = err_num; /* restore errno, just in case */
|
|---|
| 402 | perror("");
|
|---|
| 403 | if (errct++ > MAX_ERROR) {
|
|---|
| 404 | printf("Too many errors; test aborted\n");
|
|---|
| 405 | chdir("..");
|
|---|
| 406 | system("rm -rf DIR*");
|
|---|
| 407 | exit(1);
|
|---|
| 408 | }
|
|---|
| 409 | }
|
|---|
