1 /* Many of the tests require 1.6.n, n > 16, so we may as well assume that 2 * POSIX signals are implemented. 3 */ 4 #define SIGACTION 5 6 /* test38: read(), write() Author: Jan-Mark Wams (jms@cs.vu.nl) */ 7 8 #include <sys/types.h> 9 #include <sys/stat.h> 10 #include <sys/wait.h> 11 #include <stdlib.h> 12 #include <unistd.h> 13 #include <string.h> 14 #include <fcntl.h> 15 #include <limits.h> 16 #include <errno.h> 17 #include <time.h> 18 #include <signal.h> 19 #include <stdio.h> 20 21 int max_error = 4; 22 #include "common.h" 23 24 #define ITERATIONS 3 25 #define BUF_SIZE 1024 26 27 #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) 28 #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) 29 #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) 30 31 32 int superuser; 33 int signumber = 0; 34 35 void test38a(void); 36 void test38b(void); 37 void test38c(void); 38 void setsignumber(int _signumber); 39 40 int main(int argc, char *argv[]) 41 { 42 int i, m = 0xFFFF; 43 44 sync(); 45 start(38); 46 47 if (argc == 2) m = atoi(argv[1]); 48 superuser = (geteuid() == 0); 49 umask(0000); 50 51 for (i = 0; i < ITERATIONS; i++) { 52 if (m & 0001) test38a(); 53 if (m & 0002) test38b(); 54 if (m & 0004) test38c(); 55 } 56 quit(); 57 58 return(-1); /* Unreachable */ 59 } 60 61 void test38a() 62 { /* Try normal operation. */ 63 int fd1; 64 struct stat st1, st2; 65 time_t time1; 66 char buf[BUF_SIZE]; 67 int stat_loc; 68 int i, j; 69 int tube[2]; 70 71 subtest = 1; 72 System("rm -rf ../DIR_38/*"); 73 74 /* Let's open bar. */ 75 if ((fd1 = open("bar", O_RDWR | O_CREAT, 0777)) != 3) e(1); 76 Stat("bar", &st1); 77 78 /* Writing nothing should not affect the file at all. */ 79 if (write(fd1, "", 0) != 0) e(2); 80 Stat("bar", &st2); 81 if (st1.st_uid != st2.st_uid) e(3); 82 if (st1.st_gid != st2.st_gid) e(4); /* should be same */ 83 if (st1.st_mode != st2.st_mode) e(5); 84 if (st1.st_size != st2.st_size) e(6); 85 if (st1.st_nlink != st2.st_nlink) e(7); 86 if (st1.st_mtime != st2.st_mtime) e(8); 87 if (st1.st_ctime != st2.st_ctime) e(9); 88 if (st1.st_atime != st2.st_atime) e(10); 89 90 /* A write should update some status fields. */ 91 time(&time1); 92 while (time1 >= time((time_t *)0)) 93 ; 94 if (write(fd1, "foo", 4) != 4) e(11); 95 Stat("bar", &st2); 96 if (st1.st_mode != st2.st_mode) e(12); 97 if (st1.st_size >= st2.st_size) e(13); 98 if ((off_t) 4 != st2.st_size) e(14); 99 if (st1.st_nlink != st2.st_nlink) e(15); 100 if (st1.st_mtime >= st2.st_mtime) e(16); 101 if (st1.st_ctime >= st2.st_ctime) e(17); 102 if (st1.st_atime != st2.st_atime) e(18); 103 104 /* Lseeks should not change the file status. */ 105 if (lseek(fd1, (off_t) - 2, SEEK_END) != 2) e(19); 106 Stat("bar", &st1); 107 if (st1.st_mode != st2.st_mode) e(20); 108 if (st1.st_size != st2.st_size) e(21); 109 if (st1.st_nlink != st2.st_nlink) e(22); 110 if (st1.st_mtime != st2.st_mtime) e(23); 111 if (st1.st_ctime != st2.st_ctime) e(24); 112 if (st1.st_atime != st2.st_atime) e(25); 113 114 /* Writing should start at the current (2) position. */ 115 if (write(fd1, "foo", 4) != 4) e(26); 116 Stat("bar", &st2); 117 if (st1.st_mode != st2.st_mode) e(27); 118 if (st1.st_size >= st2.st_size) e(28); 119 if ((off_t) 6 != st2.st_size) e(29); 120 if (st1.st_nlink != st2.st_nlink) e(30); 121 if (st1.st_mtime > st2.st_mtime) e(31); 122 if (st1.st_ctime > st2.st_ctime) e(32); 123 if (st1.st_atime != st2.st_atime) e(33); 124 125 /* A read of zero bytes should not affect anything. */ 126 if (read(fd1, buf, 0) != 0) e(34); 127 Stat("bar", &st1); 128 if (st1.st_uid != st2.st_uid) e(35); 129 if (st1.st_gid != st2.st_gid) e(36); /* should be same */ 130 if (st1.st_mode != st2.st_mode) e(37); 131 if (st1.st_size != st2.st_size) e(38); 132 if (st1.st_nlink != st2.st_nlink) e(39); 133 if (st1.st_mtime != st2.st_mtime) e(40); 134 if (st1.st_ctime != st2.st_ctime) e(41); 135 if (st1.st_atime != st2.st_atime) e(42); 136 137 /* The file now should contain ``fofoo\0'' Let's check that. */ 138 if (lseek(fd1, (off_t) 0, SEEK_SET) != 0) e(43); 139 if (read(fd1, buf, BUF_SIZE) != 6) e(44); 140 if (strcmp(buf, "fofoo") != 0) e(45); 141 142 /* Only the Access Time should be updated. */ 143 Stat("bar", &st2); 144 if (st1.st_mtime != st2.st_mtime) e(46); 145 if (st1.st_ctime != st2.st_ctime) e(47); 146 if (st1.st_atime >= st2.st_atime) e(48); 147 148 /* A read of zero bytes should do nothing even at the end of the file. */ 149 time(&time1); 150 while (time1 >= time((time_t *)0)) 151 ; 152 if (read(fd1, buf, 0) != 0) e(49); 153 Stat("bar", &st1); 154 if (st1.st_size != st2.st_size) e(50); 155 if (st1.st_mtime != st2.st_mtime) e(51); 156 if (st1.st_ctime != st2.st_ctime) e(52); 157 if (st1.st_atime != st2.st_atime) e(53); 158 159 /* Reading should be done from the current offset. */ 160 if (read(fd1, buf, BUF_SIZE) != 0) e(54); 161 if (lseek(fd1, (off_t) 2, SEEK_SET) != 2) e(55); 162 if (read(fd1, buf, BUF_SIZE) != 4) e(56); 163 if (strcmp(buf, "foo") != 0) e(57); 164 165 /* Reading should effect the current file position. */ 166 if (lseek(fd1, (off_t) 2, SEEK_SET) != 2) e(58); 167 if (read(fd1, buf, 1) != 1) e(59); 168 if (*buf != 'f') e(60); 169 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 3) e(61); 170 if (read(fd1, buf, 1) != 1) e(62); 171 if (*buf != 'o') e(63); 172 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 4) e(64); 173 if (read(fd1, buf, 1) != 1) e(65); 174 if (*buf != 'o') e(66); 175 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 5) e(67); 176 if (read(fd1, buf, 1) != 1) e(68); 177 if (*buf != '\0') e(69); 178 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 6) e(70); 179 180 /* Read's at EOF should return 0. */ 181 if (read(fd1, buf, BUF_SIZE) != 0) e(71); 182 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 6) e(72); 183 if (read(fd1, buf, BUF_SIZE) != 0) e(73); 184 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 6) e(74); 185 if (read(fd1, buf, BUF_SIZE) != 0) e(75); 186 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 6) e(76); 187 if (read(fd1, buf, BUF_SIZE) != 0) e(77); 188 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 6) e(78); 189 if (read(fd1, buf, BUF_SIZE) != 0) e(79); 190 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 6) e(80); 191 192 /* Writing should not always change the file size. */ 193 if (lseek(fd1, (off_t) 2, SEEK_SET) != 2) e(81); 194 if (write(fd1, "ba", 2) != 2) e(82); 195 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 4) e(83); 196 Stat("bar", &st1); 197 if (st1.st_size != 6) e(84); 198 199 /* Kill the \0 at the end. */ 200 if (lseek(fd1, (off_t) 5, SEEK_SET) != 5) e(85); 201 if (write(fd1, "x", 1) != 1) e(86); 202 203 /* And close the bar. */ 204 if (close(fd1) != 0) e(87); 205 206 /* Try some stuff with O_APPEND. Bar contains ``fobaox'' */ 207 if ((fd1 = open("bar", O_RDWR | O_APPEND)) != 3) e(88); 208 209 /* No matter what the file position is. Writes should append. */ 210 if (lseek(fd1, (off_t) 2, SEEK_SET) != 2) e(89); 211 if (write(fd1, "y", 1) != 1) e(90); 212 Stat("bar", &st1); 213 if (st1.st_size != (off_t) 7) e(91); 214 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 7) e(92); 215 if (lseek(fd1, (off_t) 2, SEEK_SET) != 2) e(93); 216 if (write(fd1, "z", 2) != 2) e(94); 217 218 /* The file should contain ``fobaoxyz\0'' == 9 chars long. */ 219 Stat("bar", &st1); 220 if (st1.st_size != (off_t) 9) e(95); 221 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 9) e(96); 222 223 /* Reading on a O_APPEND flag should be from the current offset. */ 224 if (lseek(fd1, (off_t) 0, SEEK_SET) != 0) e(97); 225 if (read(fd1, buf, BUF_SIZE) != 9) e(98); 226 if (strcmp(buf, "fobaoxyz") != 0) e(99); 227 if (lseek(fd1, (off_t) 0, SEEK_CUR) != 9) e(100); 228 229 if (close(fd1) != 0) e(101); 230 231 /* Let's test fifo writes. First blocking. */ 232 if (mkfifo("fifo", 0777) != 0) e(102); 233 234 /* Read from fifo but no writer. */ 235 System("rm -rf /tmp/sema.38a"); 236 switch (fork()) { 237 case -1: printf("Can't fork\n"); break; 238 239 case 0: 240 alarm(20); 241 if ((fd1 = open("fifo", O_RDONLY)) != 3) e(103); 242 system("> /tmp/sema.38a"); 243 system("while test -f /tmp/sema.38a; do sleep 1; done"); 244 errno =0; 245 if (read(fd1, buf, BUF_SIZE) != 0) e(104); 246 if (read(fd1, buf, BUF_SIZE) != 0) e(105); 247 if (read(fd1, buf, BUF_SIZE) != 0) e(106); 248 if (close(fd1) != 0) e(107); 249 exit(0); 250 251 default: 252 if ((fd1 = open("fifo", O_WRONLY)) != 3) e(108); 253 while (stat("/tmp/sema.38a", &st1) != 0) sleep(1); 254 if (close(fd1) != 0) e(109); 255 unlink("/tmp/sema.38a"); 256 if (wait(&stat_loc) == -1) e(110); 257 if (stat_loc != 0) e(111); /* Alarm? */ 258 } 259 260 /* Read from fifo should wait for writer. */ 261 switch (fork()) { 262 case -1: printf("Can't fork\n"); break; 263 264 case 0: 265 alarm(20); 266 if ((fd1 = open("fifo", O_RDONLY)) != 3) e(112); 267 if (read(fd1, buf, BUF_SIZE) != 10) e(113); 268 if (strcmp(buf, "Hi reader") != 0) e(114); 269 if (close(fd1) != 0) e(115); 270 exit(0); 271 272 default: 273 if ((fd1 = open("fifo", O_WRONLY)) != 3) e(116); 274 sleep(1); 275 if (write(fd1, "Hi reader", 10) != 10) e(117); 276 if (close(fd1) != 0) e(118); 277 if (wait(&stat_loc) == -1) e(119); 278 if (stat_loc != 0) e(120); /* Alarm? */ 279 } 280 281 #if DEAD_CODE 282 /* Does this test test what it is supposed to test??? */ 283 284 /* Read from fifo should wait for all writers to close. */ 285 switch (fork()) { 286 case -1: printf("Can't fork\n"); break; 287 288 case 0: 289 alarm(60); 290 switch (fork()) { 291 case -1: printf("Can't fork\n"); break; 292 case 0: 293 alarm(20); 294 if ((fd1 = open("fifo", O_WRONLY)) != 3) e(121); 295 printf("C2 did open\n"); 296 if (close(fd1) != 0) e(122); 297 printf("C2 did close\n"); 298 exit(0); 299 default: 300 printf("C1 scheduled\n"); 301 if ((fd1 = open("fifo", O_WRONLY)) != 3) e(123); 302 printf("C1 did open\n"); 303 sleep(2); 304 if (close(fd1) != 0) e(124); 305 printf("C1 did close\n"); 306 sleep(1); 307 if (wait(&stat_loc) == -1) e(125); 308 if (stat_loc != 0) e(126); /* Alarm? */ 309 } 310 exit(stat_loc); 311 312 default: { 313 int wait_status; 314 printf("Parent running\n"); 315 sleep(1); /* open in childs first */ 316 if ((fd1 = open("fifo", O_RDONLY)) != 3) e(127); 317 if (read(fd1, buf, BUF_SIZE) != 0) e(128); 318 if (close(fd1) != 0) e(129); 319 printf("Parent closed\n"); 320 if ((wait_status=wait(&stat_loc)) == -1) e(130); 321 322 printf("wait_status %d, stat_loc %d:", wait_status, stat_loc); 323 if (WIFSIGNALED(stat_loc)) { 324 printf(" killed, signal number %d\n", WTERMSIG(stat_loc)); 325 } 326 else if (WIFEXITED(stat_loc)) { 327 printf(" normal exit, status %d\n", WEXITSTATUS(stat_loc)); 328 } 329 330 if (stat_loc != 0) e(131); /* Alarm? */ 331 } 332 } 333 #endif 334 335 /* PIPE_BUF has to have a nice value. */ 336 if (PIPE_BUF < 5) e(132); 337 if (BUF_SIZE < 1000) e(133); 338 339 /* Writes of blocks smaller than PIPE_BUF should be atomic. */ 340 System("rm -rf /tmp/sema.38b;> /tmp/sema.38b"); 341 switch (fork()) { 342 case -1: printf("Can't fork\n"); break; 343 344 case 0: 345 alarm(20); 346 switch (fork()) { 347 case -1: printf("Can't fork\n"); break; 348 349 case 0: 350 alarm(20); 351 if ((fd1 = open("fifo", O_WRONLY)) != 3) e(134); 352 for (i = 0; i < 100; i++) write(fd1, "1234 ", 5); 353 system("while test -f /tmp/sema.38b; do sleep 1; done"); 354 if (close(fd1) != 0) e(135); 355 exit(0); 356 357 default: 358 if ((fd1 = open("fifo", O_WRONLY)) != 3) e(136); 359 for (i = 0; i < 100; i++) write(fd1, "1234 ", 5); 360 while (stat("/tmp/sema.38b", &st1) == 0) sleep(1); 361 if (close(fd1) != 0) e(137); 362 if (wait(&stat_loc) == -1) e(138); 363 if (stat_loc != 0) e(139); /* Alarm? */ 364 } 365 exit(stat_loc); 366 367 default: 368 if ((fd1 = open("fifo", O_RDONLY)) != 3) e(140); 369 i = 0; 370 memset(buf, '\0', BUF_SIZE); 371 372 /* Read buffer full or till EOF. */ 373 do { 374 j = read(fd1, buf + i, BUF_SIZE - i); 375 if (j > 0) { 376 if (j % 5 != 0) e(141); 377 i += j; 378 } 379 } while (j > 0 && i < 1000); 380 381 /* Signal the children to close write ends. This should not be */ 382 /* Necessary. But due to a bug in 1.16.6 this is necessary. */ 383 unlink("/tmp/sema.38b"); 384 if (j < 0) e(142); 385 if (i != 1000) e(143); 386 if (wait(&stat_loc) == -1) e(144); 387 if (stat_loc != 0) e(145); /* Alarm? */ 388 389 /* Check 200 times 1234. */ 390 for (i = 0; i < 200; i++) 391 if (strncmp(buf + (i * 5), "1234 ", 5) != 0) break; 392 if (i != 200) e(146); 393 if (buf[1000] != '\0') e(147); 394 if (buf[1005] != '\0') e(148); 395 if (buf[1010] != '\0') e(149); 396 if (read(fd1, buf, BUF_SIZE) != 0) e(150); 397 if (close(fd1) != 0) e(151); 398 } 399 400 /* Read from pipe should wait for writer. */ 401 if (pipe(tube) != 0) e(152); 402 switch (fork()) { 403 case -1: printf("Can't fork\n"); break; 404 case 0: 405 alarm(20); 406 if (close(tube[1]) != 0) e(153); 407 if (read(tube[0], buf, BUF_SIZE) != 10) e(154); 408 if (strcmp(buf, "Hi reader") != 0) e(155); 409 if (close(tube[0]) != 0) e(156); 410 exit(0); 411 default: 412 if (close(tube[0]) != 0) e(157); 413 sleep(1); 414 if (write(tube[1], "Hi reader", 10) != 10) e(158); 415 if (close(tube[1]) != 0) e(159); 416 if (wait(&stat_loc) == -1) e(160); 417 if (stat_loc != 0) e(161); /* Alarm? */ 418 } 419 420 /* Read from pipe should wait for all writers to close. */ 421 if (pipe(tube) != 0) e(162); 422 switch (fork()) { 423 case -1: printf("Can't fork\n"); break; 424 case 0: 425 alarm(20); 426 if (close(tube[0]) != 0) e(163); 427 switch (fork()) { 428 case -1: printf("Can't fork\n"); break; 429 case 0: 430 alarm(20); 431 if (close(tube[1]) != 0) e(164); 432 exit(0); 433 default: 434 sleep(1); 435 if (close(tube[1]) != 0) e(165); 436 if (wait(&stat_loc) == -1) e(166); 437 if (stat_loc != 0) e(167); /* Alarm? */ 438 } 439 exit(stat_loc); 440 default: 441 if (close(tube[1]) != 0) e(168); 442 if (read(tube[0], buf, BUF_SIZE) != 0) e(169); 443 if (close(tube[0]) != 0) e(170); 444 if (wait(&stat_loc) == -1) e(171); 445 if (stat_loc != 0) e(172); /* Alarm? */ 446 } 447 448 /* Writes of blocks smaller than PIPE_BUF should be atomic. */ 449 System("rm -rf /tmp/sema.38c;> /tmp/sema.38c"); 450 if (pipe(tube) != 0) e(173); 451 switch (fork()) { 452 case -1: printf("Can't fork\n"); break; 453 case 0: 454 alarm(20); 455 if (close(tube[0]) != 0) e(174); 456 switch (fork()) { 457 case -1: printf("Can't fork\n"); break; 458 case 0: 459 alarm(20); 460 for (i = 0; i < 100; i++) write(tube[1], "1234 ", 5); 461 system("while test -f /tmp/sema.38c; do sleep 1; done"); 462 if (close(tube[1]) != 0) e(175); 463 exit(0); 464 default: 465 for (i = 0; i < 100; i++) write(tube[1], "1234 ", 5); 466 while (stat("/tmp/sema.38c", &st1) == 0) sleep(1); 467 if (close(tube[1]) != 0) e(176); 468 if (wait(&stat_loc) == -1) e(177); 469 if (stat_loc != 0) e(178); /* Alarm? */ 470 } 471 exit(stat_loc); 472 default: 473 i = 0; 474 if (close(tube[1]) != 0) e(179); 475 memset(buf, '\0', BUF_SIZE); 476 do { 477 j = read(tube[0], buf + i, BUF_SIZE - i); 478 if (j > 0) { 479 if (j % 5 != 0) e(180); 480 i += j; 481 } else 482 break; /* EOF seen. */ 483 } while (i < 1000); 484 unlink("/tmp/sema.38c"); 485 if (j < 0) e(181); 486 if (i != 1000) e(182); 487 if (close(tube[0]) != 0) e(183); 488 if (wait(&stat_loc) == -1) e(184); 489 if (stat_loc != 0) e(185); /* Alarm? */ 490 491 /* Check 200 times 1234. */ 492 for (i = 0; i < 200; i++) 493 if (strncmp(buf + (i * 5), "1234 ", 5) != 0) break; 494 if (i != 200) e(186); 495 } 496 } 497 498 void test38b() 499 { 500 int i, fd, stat_loc; 501 char buf[BUF_SIZE]; 502 char buf2[BUF_SIZE]; 503 struct stat st; 504 505 subtest = 2; 506 System("rm -rf ../DIR_38/*"); 507 508 /* Lets try sequential writes. */ 509 system("rm -rf /tmp/sema.38d"); 510 System("> testing"); 511 switch (fork()) { 512 case -1: printf("Can't fork\n"); break; 513 case 0: 514 alarm(20); 515 if ((fd = open("testing", O_WRONLY | O_APPEND)) != 3) e(1); 516 if (write(fd, "one ", 4) != 4) e(2); 517 if (close(fd) != 0) e(3); 518 system("> /tmp/sema.38d"); 519 system("while test -f /tmp/sema.38d; do sleep 1; done"); 520 if ((fd = open("testing", O_WRONLY | O_APPEND)) != 3) e(4); 521 if (write(fd, "three ", 6) != 6) e(5); 522 if (close(fd) != 0) e(6); 523 system("> /tmp/sema.38d"); 524 exit(0); 525 default: 526 while (stat("/tmp/sema.38d", &st) != 0) sleep(1); 527 if ((fd = open("testing", O_WRONLY | O_APPEND)) != 3) e(7); 528 if (write(fd, "two ", 4) != 4) e(8); 529 if (close(fd) != 0) e(9); 530 unlink("/tmp/sema.38d"); 531 while (stat("/tmp/sema.38d", &st) != 0) sleep(1); 532 if ((fd = open("testing", O_WRONLY | O_APPEND)) != 3) e(10); 533 if (write(fd, "four", 5) != 5) e(11); 534 if (close(fd) != 0) e(12); 535 if (wait(&stat_loc) == -1) e(13); 536 if (stat_loc != 0) e(14); /* The alarm went off? */ 537 unlink("/tmp/sema.38d"); 538 } 539 if ((fd = open("testing", O_RDONLY)) != 3) e(15); 540 if (read(fd, buf, BUF_SIZE) != 19) e(16); 541 if (strcmp(buf, "one two three four") != 0) e(17); 542 if (close(fd) != 0) e(18); 543 544 /* Non written bytes in regular files should be zero. */ 545 memset(buf2, '\0', BUF_SIZE); 546 if ((fd = open("bigfile", O_RDWR | O_CREAT, 0644)) != 3) e(19); 547 if (lseek(fd, (off_t) 102400, SEEK_SET) != (off_t) 102400L) e(20); 548 if (read(fd, buf, BUF_SIZE) != 0) e(21); 549 if (write(fd, ".", 1) != 1) e(22); 550 Stat("bigfile", &st); 551 if (st.st_size != (off_t) 102401) e(23); 552 if (lseek(fd, (off_t) 0, SEEK_SET) != 0) e(24); 553 for (i = 0; i < 102400 / BUF_SIZE; i++) { 554 if (read(fd, buf, BUF_SIZE) != BUF_SIZE) e(25); 555 if (memcmp(buf, buf2, BUF_SIZE) != 0) e(26); 556 } 557 if (close(fd) != 0) e(27); 558 } 559 560 void test38c() 561 { /* Test correct error behavior. */ 562 char buf[BUF_SIZE]; 563 int fd, tube[2], stat_loc; 564 struct stat st; 565 pid_t pid; 566 #ifdef SIGACTION 567 struct sigaction act, oact; 568 #else 569 void (*oldfunc) (int); 570 #endif 571 572 subtest = 3; 573 System("rm -rf ../DIR_38/*"); 574 575 /* To test if writing processes on closed pipes are signumbered. */ 576 #ifdef SIGACTION 577 act.sa_handler = setsignumber; 578 sigemptyset(&act.sa_mask); 579 act.sa_flags = 0; 580 if (sigaction(SIGPIPE, &act, &oact) != 0) e(1); 581 #else 582 oldfunc = signal(SIGPIPE, setsignumber); 583 #endif 584 585 /* Non valid file descriptors should be an error. */ 586 for (fd = -111; fd < 0; fd++) { 587 errno = 0; 588 if (read(fd, buf, BUF_SIZE) != -1) e(2); 589 if (errno != EBADF) e(3); 590 } 591 for (fd = 3; fd < 111; fd++) { 592 errno = 0; 593 if (read(fd, buf, BUF_SIZE) != -1) e(4); 594 if (errno != EBADF) e(5); 595 } 596 for (fd = -111; fd < 0; fd++) { 597 errno = 0; 598 if (write(fd, buf, BUF_SIZE) != -1) e(6); 599 if (errno != EBADF) e(7); 600 } 601 for (fd = 3; fd < 111; fd++) { 602 errno = 0; 603 if (write(fd, buf, BUF_SIZE) != -1) e(8); 604 if (errno != EBADF) e(9); 605 } 606 607 /* Writing a pipe with no readers should trigger SIGPIPE. */ 608 if (pipe(tube) != 0) e(10); 609 close(tube[0]); 610 switch (fork()) { 611 case -1: printf("Can't fork\n"); break; 612 case 0: 613 alarm(20); 614 signumber = 0; 615 if (write(tube[1], buf, BUF_SIZE) != -1) e(11); 616 if (errno != EPIPE) e(12); 617 if (signumber != SIGPIPE) e(13); 618 if (close(tube[1]) != 0) e(14); 619 exit(0); 620 default: 621 close(tube[1]); 622 if (wait(&stat_loc) == -1) e(15); 623 if (stat_loc != 0) e(16); /* Alarm? */ 624 } 625 626 /* Writing a fifo with no readers should trigger SIGPIPE. */ 627 System("> /tmp/sema.38e"); 628 if (mkfifo("fifo", 0666) != 0) e(17); 629 switch (fork()) { 630 case -1: printf("Can't fork\n"); break; 631 case 0: 632 alarm(20); 633 if ((fd = open("fifo", O_WRONLY)) != 3) e(18); 634 system("while test -f /tmp/sema.38e; do sleep 1; done"); 635 signumber = 0; 636 if (write(fd, buf, BUF_SIZE) != -1) e(19); 637 if (errno != EPIPE) e(20); 638 if (signumber != SIGPIPE) e(21); 639 if (close(fd) != 0) e(22); 640 exit(0); 641 default: 642 if ((fd = open("fifo", O_RDONLY)) != 3) e(23); 643 if (close(fd) != 0) e(24); 644 unlink("/tmp/sema.38e"); 645 if (wait(&stat_loc) == -1) e(25); 646 if (stat_loc != 0) e(26); /* Alarm? */ 647 } 648 649 #ifdef SIGACTION 650 /* Restore normal (re)action to SIGPIPE. */ 651 if (sigaction(SIGPIPE, &oact, NULL) != 0) e(27); 652 #else 653 signal(SIGPIPE, oldfunc); 654 #endif 655 656 /* Read from fifo should return -1 and set errno to EAGAIN. */ 657 System("rm -rf /tmp/sema.38[fgh]"); 658 switch (fork()) { 659 case -1: printf("Can't fork\n"); break; 660 case 0: 661 alarm(20); 662 system("while test ! -f /tmp/sema.38f; do sleep 1; done"); 663 System("rm -rf /tmp/sema.38f"); 664 if ((fd = open("fifo", O_WRONLY | O_NONBLOCK)) != 3) e(28); 665 close(creat("/tmp/sema.38g", 0666)); 666 system("while test ! -f /tmp/sema.38h; do sleep 1; done"); 667 if (close(fd) != 0) e(38); 668 System("rm -rf /tmp/sema.38h"); 669 exit(0); 670 default: 671 if ((fd = open("fifo", O_RDONLY | O_NONBLOCK)) != 3) e(30); 672 close(creat("/tmp/sema.38f", 0666)); 673 system("while test ! -f /tmp/sema.38g; do sleep 1; done"); 674 System("rm -rf /tmp/sema.38g"); 675 if (read(fd, buf, BUF_SIZE) != -1) e(31); 676 if (errno != EAGAIN) e(32); 677 if (read(fd, buf, BUF_SIZE) != -1) e(33); 678 if (errno != EAGAIN) e(34); 679 if (read(fd, buf, BUF_SIZE) != -1) e(35); 680 if (errno != EAGAIN) e(36); 681 close(creat("/tmp/sema.38h", 0666)); 682 while (stat("/tmp/sema.38h", &st) == 0) sleep(1); 683 if (read(fd, buf, BUF_SIZE) != 0) e(37); 684 if (close(fd) != 0) e(38); 685 if (wait(&stat_loc) == -1) e(39); 686 if (stat_loc != 0) e(40); /* Alarm? */ 687 } 688 System("rm -rf fifo"); 689 690 /* If a read is interrupted by a SIGNAL. */ 691 if (pipe(tube) != 0) e(41); 692 switch (pid = fork()) { 693 case -1: printf("Can't fork\n"); break; 694 case 0: 695 alarm(20); 696 #ifdef SIGACTION 697 act.sa_handler = setsignumber; 698 sigemptyset(&act.sa_mask); 699 act.sa_flags = 0; 700 if (sigaction(SIGUSR1, &act, &oact) != 0) e(42); 701 #else 702 oldfunc = signal(SIGUSR1, setsignumber); 703 #endif 704 if (read(tube[0], buf, BUF_SIZE) != -1) e(43); 705 if (errno != EINTR) e(44); 706 if (signumber != SIGUSR1) e(45); 707 #ifdef SIGACTION 708 /* Restore normal (re)action to SIGPIPE. */ 709 if (sigaction(SIGUSR1, &oact, NULL) != 0) e(46); 710 #else 711 signal(SIGUSR1, oldfunc); 712 #endif 713 close(tube[0]); 714 close(tube[1]); 715 exit(0); 716 default: 717 /* The sleep 1 should give the child time to start the read. */ 718 sleep(1); 719 close(tube[0]); 720 kill(pid, SIGUSR1); 721 wait(&stat_loc); 722 if (stat_loc != 0) e(47); /* Alarm? */ 723 close(tube[1]); 724 } 725 } 726 727 void setsignumber(signum) 728 int signum; 729 { 730 signumber = signum; 731 } 732 733