![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jobs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / korn|
Return to jobs.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / korn |
1.1 ! root 1: /* ! 2: * Process and job control ! 3: */ ! 4: ! 5: static char *RCSid = "$Header: /newbits/usr/bin/korn/RCS/jobs.c,v 1.2 91/08/01 12:40:37 bin Exp Locker: bin $"; ! 6: ! 7: /* ! 8: * based on version by Ron Natalie, BRL ! 9: * ! 10: * TODO: ! 11: * change Proc table to Job table, with array of pids. ! 12: * make %+ be jobs, %- be jobs->next. ! 13: * do not JFREE members of pipeline. ! 14: * consider procs[] related critical sections. ! 15: * signal(SIGCHLD, j_sigchld) should be ! 16: * sigaction(SIGCHLD, sigchld, NULL), ! 17: * with sigchld.sa_flags = SA_RESTART. ! 18: * There is a simple work-around if there is no SA_RESTART. ! 19: */ ! 20: ! 21: #include <stddef.h> ! 22: #include <stdlib.h> ! 23: #include <string.h> ! 24: #include <stdio.h> ! 25: #include <errno.h> ! 26: #include <unistd.h> ! 27: #include <signal.h> ! 28: #include <setjmp.h> ! 29: #include <sys/types.h> ! 30: #include <sys/times.h> ! 31: #include <wait.h> ! 32: #if JOBS ! 33: #if _BSD ! 34: #include <sys/ioctl.h> ! 35: #else ! 36: #include "termios.h" ! 37: #endif ! 38: #endif ! 39: #include "sh.h" ! 40: #include "tree.h" ! 41: ! 42: #ifndef WIFCORED ! 43: #define WIFCORED(x) (!!((x)&0x80)) /* non-standard */ ! 44: #endif ! 45: ! 46: /* as of P1003.1 Draft 12.3: ! 47: * pid_t getpgrp(void); // Get process group id ! 48: * pid_t setsid(void); // Create session and Set process group id ! 49: * int setpgid(pid_t pid, pid_t pgid); // Set process group id for job control ! 50: */ ! 51: ! 52: #if JOBS ! 53: #if _BSD /* _BSD 4.* */ ! 54: #define setpgid(p, pg) setpgrp(p, pg) ! 55: #define getpgid(p) getpgrp(p) ! 56: #define tcsetpgrp(fd,p) ioctl(fd, TIOCSPGRP, &(p)) ! 57: #else /* POSIX-compatible */ ! 58: #define getpgid(p) getpgrp() /* 1003.1 stupidity */ ! 59: #define killpg(p, s) kill(-(p), s) ! 60: #endif ! 61: #endif ! 62: ! 63: #ifndef SIGCHLD ! 64: #define SIGCHLD SIGCLD ! 65: #endif ! 66: ! 67: typedef struct Proc Proc; ! 68: struct Proc { ! 69: Proc *next; /* `procs' list link */ ! 70: int job; /* job number: %n */ ! 71: short Volatile state; /* proc state */ ! 72: short Volatile notify; /* proc state has changed */ ! 73: Proc *prev; /* prev member of pipeline */ ! 74: pid_t proc; /* process id */ ! 75: pid_t pgrp; /* process group if flag[FMONITOR] */ ! 76: short flags; /* execute flags */ ! 77: int status; /* wait status */ ! 78: clock_t utime, stime; /* user/system time when JDONE */ ! 79: char com [48]; /* command */ ! 80: }; ! 81: ! 82: /* proc states */ ! 83: #define JFREE 0 /* unused proc */ ! 84: #define JRUN 1 /* foreground */ ! 85: #define JEXIT 2 /* exit termination */ ! 86: #define JSIGNAL 3 /* signal termination */ ! 87: #define JSTOP 4 /* stopped */ ! 88: ! 89: static Proc *procs = NULL; /* job/process table */ ! 90: ! 91: clock_t j_utime, j_stime; /* user and system time for last job a-waited */ ! 92: #if JOBS ! 93: static int sm_default, sm_sigchld; /* signal masks */ ! 94: static int our_pgrp; /* shell's pgrp */ ! 95: #endif ! 96: static Proc *j_lastj; /* last proc created by exchild */ ! 97: static int j_lastjob = 0; /* last created job */ ! 98: static int j_current = 0; /* current job */ ! 99: static int j_previous = 0; /* previous job */ ! 100: ! 101: static int j_newjob ARGS((void)); ! 102: static void j_print ARGS((Proc *j)); ! 103: static Proc *j_search ARGS((int job)); ! 104: static int j_waitj ARGS((Proc *j, int intr)); ! 105: static void j_sigchld ARGS((int sig)); ! 106: ! 107: /* initialize job control */ ! 108: void ! 109: j_init() ! 110: { ! 111: #if JOBS ! 112: #ifdef NTTYDISC ! 113: int ldisc = NTTYDISC; /* BSD brain damage */ ! 114: ! 115: if (ttyfd >= 0) ! 116: ioctl(ttyfd, TIOCSETD, &ldisc); ! 117: #endif ! 118: our_pgrp = getpgid(0); ! 119: sm_default = 0; ! 120: sm_sigchld = sigmask(SIGCHLD); ! 121: #endif ! 122: } ! 123: ! 124: /* job cleanup before shell exit */ ! 125: void ! 126: j_exit() ! 127: { ! 128: register Proc *j; ! 129: int killed = 0; ! 130: ! 131: #if JOBS ! 132: /* kill stopped jobs */ ! 133: for (j = procs; j != NULL; j = j->next) ! 134: if (j->state == JSTOP) { ! 135: killed ++; ! 136: killpg(j->pgrp, SIGHUP); ! 137: killpg(j->pgrp, SIGCONT); ! 138: } ! 139: if (killed) ! 140: sleep(1); ! 141: #endif ! 142: j_notify(); ! 143: ! 144: #if JOBS ! 145: if (flag[FMONITOR]) { ! 146: flag[FMONITOR] = 0; ! 147: j_change(); ! 148: } ! 149: #endif ! 150: } ! 151: ! 152: #if JOBS ! 153: /* turn job control on or off according to flag[FMONITOR] */ ! 154: void ! 155: j_change() ! 156: { ! 157: static handler_t old_tstp, old_ttin, old_ttou; ! 158: ! 159: if (flag[FMONITOR]) { ! 160: if (ttyfd < 0) { ! 161: flag[FMONITOR] = 0; ! 162: shellf("job control requires tty\n"); ! 163: return; ! 164: } ! 165: #if !COHERENT ! 166: (void) signal(SIGCHLD, j_sigchld); ! 167: sigtraps[SIGCHLD].sig_dfl = 1; /* restore on fork */ ! 168: old_tstp = signal(SIGTSTP, SIG_IGN); ! 169: sigtraps[SIGTSTP].sig_dfl = 1; ! 170: old_ttin = signal(SIGTTIN, SIG_IGN); ! 171: sigtraps[SIGTTIN].sig_dfl = 1; ! 172: old_ttou = signal(SIGTTOU, SIG_IGN); ! 173: sigtraps[SIGTTOU].sig_dfl = 1; ! 174: #endif ! 175: sigsetmask(sm_default); ! 176: tcsetpgrp(ttyfd, our_pgrp); ! 177: } else { ! 178: (void) signal(SIGCHLD, SIG_DFL); ! 179: (void) signal(SIGTSTP, old_tstp); ! 180: sigtraps[SIGTSTP].sig_dfl = 0; ! 181: (void) signal(SIGTTIN, old_ttin); ! 182: sigtraps[SIGTTIN].sig_dfl = 0; ! 183: (void) signal(SIGTTOU, old_ttou); ! 184: sigtraps[SIGTTOU].sig_dfl = 0; ! 185: } ! 186: } ! 187: #endif ! 188: ! 189: /* execute tree in child subprocess */ ! 190: int ! 191: exchild(t, flags) ! 192: struct op *t; ! 193: int flags; ! 194: { ! 195: register int i; ! 196: register Proc *j; ! 197: int rv = 0; ! 198: ! 199: flags &= ~XFORK; ! 200: if ((flags&XEXEC)) ! 201: return execute(t, flags); ! 202: ! 203: /* get free Proc entry */ ! 204: for (j = procs; j != NULL; j = j->next) ! 205: if (j->state == JFREE) ! 206: goto Found; ! 207: j = alloc(sizeof(Proc), APERM); ! 208: j->next = procs; ! 209: j->state = JFREE; ! 210: procs = j; ! 211: Found: ! 212: ! 213: j->prev = ((flags&XPIPEI)) ? j_lastj : NULL; ! 214: j->proc = j->pgrp = 0; ! 215: j->flags = flags; ! 216: j->job = (flags&XPIPEI) ? j_lastjob : j_newjob(); ! 217: snptreef(j->com, sizeof(j->com), "%T", t); /* save proc's command */ ! 218: j->com[sizeof(j->com)-1] = '\0'; ! 219: j->state = JRUN; ! 220: ! 221: /* stdio buffer must be flushed and invalidated */ ! 222: for (i = 0; i < NUFILE; i++) ! 223: flushshf(i); ! 224: ! 225: /* create child process */ ! 226: if ((i = fork()) < 0) { ! 227: /* todo: try a few times with exp-incr delay */ ! 228: j->state = JFREE; ! 229: errorf("cannot fork - try again\n"); ! 230: } ! 231: j->proc = (i != 0) ? i : getpid(); ! 232: ! 233: #if JOBS ! 234: /* job control set up */ ! 235: if (flag[FMONITOR] && !(flags&XXCOM)) { ! 236: j->pgrp = !(flags&XPIPEI) ? j->proc : j_lastj->pgrp; ! 237: /* do in both parent and child to avoid fork race condition */ ! 238: if (!(flags&XBGND)) ! 239: tcsetpgrp(ttyfd, j->pgrp); /* could be trouble */ ! 240: setpgid(j->proc, j->pgrp); ! 241: } ! 242: #endif ! 243: j_lastj = j; ! 244: ! 245: if (i == 0) { /* child */ ! 246: e.oenv = NULL; ! 247: if (flag[FTALKING]) ! 248: restoresigs(); /* set back to default */ ! 249: if ((flags&XBGND) && !flag[FMONITOR]) { ! 250: signal(SIGINT, SIG_IGN); ! 251: signal(SIGQUIT, SIG_IGN); ! 252: if (flag[FTALKING]) ! 253: signal(SIGTERM, SIG_DFL); ! 254: #if COHERENT ! 255: if (!(flags & XPIPEI)) { ! 256: i = open("/dev/null", 0); ! 257: (void) dup2(i, 0); ! 258: close(i); ! 259: } ! 260: #endif ! 261: } ! 262: for (j = procs; j != NULL; j = j->next) ! 263: j->state = JFREE; ! 264: ttyfd = -1; ! 265: flag[FMONITOR] = flag[FTALKING] = 0; ! 266: cleartraps(); ! 267: execute(t, flags|XEXEC); /* no return */ ! 268: /* NOTREACHED */ ! 269: } ! 270: ! 271: /* shell (parent) stuff */ ! 272: if ((flags&XBGND)) { /* async statement */ ! 273: async = j->proc; ! 274: j_previous = j_current; ! 275: j_current = j->job; ! 276: if (flag[FTALKING]) ! 277: j_print(j); ! 278: } else { /* sync statement */ ! 279: if (!(flags&XPIPE)) ! 280: rv = j_waitj(j, 0); ! 281: } ! 282: ! 283: return rv; ! 284: } ! 285: ! 286: /* wait for last job: pipeline or $() sub-process */ ! 287: int ! 288: waitlast() ! 289: { ! 290: return j_waitj(j_lastj, 0); ! 291: } ! 292: ! 293: /* wait for job to complete or change state */ ! 294: static int ! 295: j_waitj(aj, intr) ! 296: Proc *aj; ! 297: int intr; /* interruptable */ ! 298: { ! 299: register Proc *j; ! 300: int rv = 1; ! 301: int ttysig = 0; ! 302: ! 303: #if JOBS ! 304: if (flag[FMONITOR]) ! 305: sigsetmask(sm_sigchld); ! 306: #endif ! 307: /* wait for all members of pipeline */ ! 308: for (j = aj; j != NULL; j = j->prev) { ! 309: /* wait for job to finish, stop, or ^C of built-in wait */ ! 310: while (j->state == JRUN) { ! 311: #if JOBS ! 312: if (flag[FMONITOR]) ! 313: sigpause(sm_default); ! 314: else ! 315: #endif ! 316: #if COHERENT ! 317: j_sigchld(-1); ! 318: #else ! 319: j_sigchld(SIGCHLD); ! 320: #endif ! 321: if (sigtraps[SIGINT].set && intr) ! 322: goto Break; ! 323: } ! 324: if (j->state == JEXIT) { /* exit termination */ ! 325: if (!(j->flags&XPIPEO)) ! 326: rv = WEXITSTATUS(j->status); ! 327: j->notify = 0; ! 328: } else ! 329: if (j->state == JSIGNAL) { /* signalled to death */ ! 330: if (WTERMSIG(j->status) == SIGINT || ! 331: WTERMSIG(j->status) == SIGPIPE && (j->flags&XPIPEO)) ! 332: j->notify = 0; ! 333: if (WTERMSIG(j->status) == SIGINT || ! 334: WTERMSIG(j->status) == SIGQUIT) ! 335: ttysig = 1; ! 336: } else ! 337: #if JOBS ! 338: if (j->state == JSTOP) ! 339: if (WSTOPSIG(j->status) == SIGTSTP) ! 340: ttysig = 1; ! 341: #else ! 342: ; ! 343: #endif ! 344: } ! 345: ! 346: /* compute total child time for time statement */ ! 347: for (j = aj; j != NULL; j = j->prev) ! 348: j_utime += j->utime, j_stime += j->stime; ! 349: ! 350: /* find new current job */ ! 351: #if JOBS ! 352: if (aj->state == JSTOP) { ! 353: j_previous = j_current; ! 354: j_current = aj->job; ! 355: } else { ! 356: #else ! 357: if (1) { ! 358: #endif ! 359: int hijob = 0; ! 360: ! 361: /* todo: this needs to be done in j_notify */ ! 362: /* todo: figure out what to do with j_previous */ ! 363: j_current = 0; ! 364: for (j = procs; j != NULL; j = j->next) ! 365: if ((j->state == JRUN || j->state == JSTOP) ! 366: && j->job > hijob) { ! 367: hijob = j->job; ! 368: j_current = j->job; ! 369: } ! 370: } ! 371: ! 372: Break: ! 373: #if JOBS ! 374: if (flag[FMONITOR]) { ! 375: /* reset shell job control state */ ! 376: sigsetmask(sm_default); ! 377: tcsetpgrp(ttyfd, our_pgrp); ! 378: } ! 379: #endif ! 380: if (ttysig) ! 381: fputc('\n', shlout); ! 382: j_notify(); ! 383: ! 384: return rv; ! 385: } ! 386: ! 387: /* SIGCHLD handler to reap children */ ! 388: static void ! 389: j_sigchld(sig) ! 390: int sig; ! 391: { ! 392: int errno_ = errno; ! 393: struct tms t0, t1; ! 394: ! 395: (void) times(&t0); ! 396: do { ! 397: register Proc *j; ! 398: int pid, status; ! 399: #if JOBS ! 400: if (flag[FMONITOR]) ! 401: pid = waitpid(-1, &status, (WNOHANG|WUNTRACED)); ! 402: else ! 403: #endif ! 404: pid = wait(&status); ! 405: if (pid <= 0) /* return if would block (0) ... */ ! 406: break; /* ... or no children or interrupted (-1) */ ! 407: (void) times(&t1); ! 408: ! 409: for (j = procs; j != NULL; j = j->next) ! 410: if (j->state != JFREE && pid == j->proc) ! 411: goto Found; ! 412: continue; ! 413: ! 414: Found: ! 415: j->notify = 1; ! 416: j->status = status; ! 417: #if JOBS ! 418: if (WIFSTOPPED(status)) ! 419: j->state = JSTOP; ! 420: else ! 421: #endif ! 422: if (WIFEXITED(status)) ! 423: j->state = JEXIT; ! 424: else ! 425: if (WIFSIGNALED(status)) ! 426: j->state = JSIGNAL; ! 427: ! 428: /* compute child's time */ ! 429: /* todo: what does a stopped job do? */ ! 430: j->utime = t1.tms_cutime - t0.tms_cutime; ! 431: j->stime = t1.tms_cstime - t0.tms_cstime; ! 432: t0 = t1; ! 433: #if JOBS ! 434: } while (flag[FMONITOR]); ! 435: #else ! 436: } while (0); /* only once if wait()ing */ ! 437: #endif ! 438: ! 439: errno = errno_; ! 440: } ! 441: ! 442: /* wait for child, interruptable */ ! 443: int ! 444: waitfor(job) ! 445: int job; ! 446: { ! 447: register Proc *j; ! 448: ! 449: if (job == 0 && j_current == 0) ! 450: errorf("no current job\n"); ! 451: j = j_search((job == 0) ? j_current : job); ! 452: if (j == NULL) ! 453: errorf("no such job: %d\n", job); ! 454: if (flag[FTALKING]) ! 455: j_print(j); ! 456: if (e.interactive) { /* flush stdout, shlout */ ! 457: fflush(shf[1]); ! 458: fflush(shf[2]); ! 459: } ! 460: return j_waitj(j, 1); ! 461: } ! 462: ! 463: /* kill (built-in) a job */ ! 464: void ! 465: j_kill(job, sig) ! 466: int job; ! 467: int sig; ! 468: { ! 469: register Proc *j; ! 470: ! 471: j = j_search(job); ! 472: if (j == NULL) ! 473: errorf("cannot find job\n"); ! 474: if (j->pgrp == 0) { /* !flag[FMONITOR] */ ! 475: if (kill(j->proc, sig) < 0) /* todo: all member of pipeline */ ! 476: errorf("kill: %s\n", strerror(errno)); ! 477: #if JOBS ! 478: } else { ! 479: if (sig == SIGTERM || sig == SIGHUP) ! 480: (void) killpg(j->pgrp, SIGCONT); ! 481: if (killpg(j->pgrp, sig) < 0) ! 482: errorf("killpg: %s\n", strerror(errno)); ! 483: #endif ! 484: } ! 485: } ! 486: ! 487: #if JOBS ! 488: ! 489: /* fg and bg built-ins */ ! 490: int ! 491: j_resume(job, bg) ! 492: int job; ! 493: int bg; ! 494: { ! 495: register Proc *j; ! 496: ! 497: j = j_search((job == 0) ? j_current : job); ! 498: if (j == NULL) ! 499: errorf("cannot find job\n", job); ! 500: if (j->pgrp == 0) ! 501: errorf("job not job-controlled\n"); ! 502: ! 503: j->state = JRUN; ! 504: j_print(j); ! 505: flushshf(2); ! 506: ! 507: if (!bg) ! 508: tcsetpgrp(ttyfd, j->pgrp); /* attach shell to job */ ! 509: if (killpg(j->pgrp, SIGCONT) < 0) ! 510: errorf("cannot continue job %%%d\n", job); ! 511: if (!bg) ! 512: return j_waitj(j, 0); ! 513: return 0; ! 514: } ! 515: ! 516: #endif ! 517: ! 518: /* list jobs for jobs built-in */ ! 519: void ! 520: j_jobs() ! 521: { ! 522: register Proc *j; ! 523: ! 524: for (j = procs; j != NULL; j = j->next) ! 525: if (j->state != JFREE) ! 526: j_print(j); ! 527: } ! 528: ! 529: /* list jobs for top-level notification */ ! 530: void ! 531: j_notify() ! 532: { ! 533: register Proc *j; ! 534: ! 535: for (j = procs; j != NULL; j = j->next) { ! 536: if (j->state == JEXIT && !flag[FTALKING]) ! 537: j->notify = 0; ! 538: if (j->state != JFREE && j->notify) ! 539: j_print(j); ! 540: if (j->state == JEXIT || j->state == JSIGNAL) ! 541: j->state = JFREE; ! 542: j->notify = 0; ! 543: } ! 544: } ! 545: ! 546: static void ! 547: j_print(j) ! 548: register Proc *j; ! 549: { ! 550: char buf [64], *s = buf; ! 551: ! 552: switch (j->state) { ! 553: case JRUN: ! 554: s = "Running"; ! 555: break; ! 556: ! 557: #if JOBS ! 558: case JSTOP: ! 559: strcpy(buf, "Stopped "); ! 560: s = strchr(sigtraps[WSTOPSIG(j->status)].mess, '('); ! 561: if (s != NULL) ! 562: strcat(buf, s); ! 563: s = buf; ! 564: break; ! 565: #endif ! 566: ! 567: case JEXIT: { ! 568: int rv; ! 569: rv = WEXITSTATUS(j->status); ! 570: sprintf(buf, "Done (%d)", rv); ! 571: if (rv == 0) ! 572: *strchr(buf, '(') = 0; ! 573: j->state = JFREE; ! 574: } break; ! 575: ! 576: case JSIGNAL: { ! 577: int sig = WTERMSIG(j->status); ! 578: #if COHERENT ! 579: char *n = NULL; ! 580: int i; ! 581: for (i = 0; i < SIGNALS; ++i) ! 582: if (sigtraps[i].signal == sig) { ! 583: n = sigtraps[i].mess; ! 584: break; ! 585: } ! 586: #else ! 587: char *n = sigtraps[sig].mess; ! 588: #endif ! 589: if (n != NULL) ! 590: sprintf(buf, "%s", n); ! 591: else ! 592: sprintf(buf, "Signal %d", sig); ! 593: if (WIFCORED(j->status)) ! 594: strcat(buf, " - core dumped"); ! 595: j->state = JFREE; ! 596: } break; ! 597: ! 598: default: ! 599: s = "Hideous job state"; ! 600: j->state = JFREE; ! 601: break; ! 602: } ! 603: shellf("%%%-2d%c %5d %-20s %s%s\n", j->job, ! 604: (j_current==j->job) ? '+' : (j_previous==j->job) ? '-' : ' ', ! 605: j->proc, s, j->com, (j->flags&XPIPEO) ? "|" : ""); ! 606: } ! 607: ! 608: /* convert % sequence to job number */ ! 609: int ! 610: j_lookup(cp) ! 611: char *cp; ! 612: { ! 613: register Proc *j; ! 614: int len, job = 0; ! 615: ! 616: if (*cp == '%') /* leading % is optional */ ! 617: cp++; ! 618: switch (*cp) { ! 619: case '\0': ! 620: case '+': ! 621: job = j_current; ! 622: break; ! 623: ! 624: case '-': ! 625: job = j_previous; ! 626: break; ! 627: ! 628: case '0': case '1': case '2': case '3': case '4': ! 629: case '5': case '6': case '7': case '8': case '9': ! 630: job = atoi(cp); ! 631: break; ! 632: ! 633: case '?': /* %?string */ ! 634: for (j = procs; j != NULL; j = j->next) ! 635: if (j->state != JFREE && strstr(j->com, cp+1) != NULL) ! 636: job = j->job; ! 637: break; ! 638: ! 639: default: /* %string */ ! 640: len = strlen(cp); ! 641: for (j = procs; j != NULL; j = j->next) ! 642: if (j->state != JFREE && strncmp(cp, j->com, len) == 0) ! 643: job = j->job; ! 644: break; ! 645: } ! 646: if (job == 0) ! 647: errorf("%s: no such job\n", cp); ! 648: return job; ! 649: } ! 650: ! 651: /* are any stopped jobs ? */ ! 652: #if JOBS ! 653: int ! 654: j_stopped() ! 655: { ! 656: register Proc *j; ! 657: ! 658: for (j = procs; j != NULL; j = j->next) ! 659: if (j->state == JSTOP) ! 660: return 1; ! 661: return 0; ! 662: } ! 663: #endif ! 664: ! 665: /* create new job number */ ! 666: static int ! 667: j_newjob() ! 668: { ! 669: register Proc *j; ! 670: register int max = 0; ! 671: ! 672: j_lastjob ++; ! 673: for (j = procs; j != NULL; j = j->next) ! 674: if (j->state != JFREE && j->job) ! 675: if (j->job > max) ! 676: max = j->job; ! 677: if (j_lastjob > max) ! 678: j_lastjob = max + 1; ! 679: return j_lastjob; ! 680: } ! 681: ! 682: /* search for job by job number */ ! 683: static Proc * ! 684: j_search(job) ! 685: int job; ! 686: { ! 687: register Proc *j; ! 688: ! 689: for (j = procs; j != NULL; j = j->next) ! 690: if (j->state != JFREE && job == j->job && !(j->flags&XPIPEO)) ! 691: return j; ! 692: return NULL; ! 693: } ! 694:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.