![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fdesc_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / miscfs / fdesc|
Return to fdesc_vnops.c CVS log | Up to [Net/2] / Net2 / miscfs / fdesc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1990, 1992 Jan-Simon Pendry ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Jan-Simon Pendry. ! 7: * ! 8: * Redistribution and use in source and binary forms, with or without ! 9: * modification, are permitted provided that the following conditions ! 10: * are met: ! 11: * 1. Redistributions of source code must retain the above copyright ! 12: * notice, this list of conditions and the following disclaimer. ! 13: * 2. Redistributions in binary form must reproduce the above copyright ! 14: * notice, this list of conditions and the following disclaimer in the ! 15: * documentation and/or other materials provided with the distribution. ! 16: * 3. All advertising materials mentioning features or use of this software ! 17: * must display the following acknowledgement: ! 18: * This product includes software developed by the University of ! 19: * California, Berkeley and its contributors. ! 20: * 4. Neither the name of the University nor the names of its contributors ! 21: * may be used to endorse or promote products derived from this software ! 22: * without specific prior written permission. ! 23: * ! 24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 34: * SUCH DAMAGE. ! 35: * ! 36: * $Id: fdesc_vnops.c,v 1.3 1993/03/30 05:16:56 cgd Exp $ ! 37: */ ! 38: ! 39: /* ! 40: * /dev/fd Filesystem ! 41: */ ! 42: ! 43: #include "param.h" ! 44: #include "systm.h" ! 45: #include "types.h" ! 46: #include "time.h" ! 47: #include "proc.h" ! 48: #include "resourcevar.h" ! 49: #include "filedesc.h" ! 50: #include "vnode.h" ! 51: #include "file.h" ! 52: #include "stat.h" ! 53: #include "mount.h" ! 54: #include "namei.h" ! 55: #include "buf.h" ! 56: #include "miscfs/fdesc/fdesc.h" ! 57: ! 58: #include "../ufs/dir.h" /* For readdir() XXX */ ! 59: ! 60: /* ! 61: * vp is the current namei directory ! 62: * ndp is the name to locate in that directory... ! 63: */ ! 64: fdesc_lookup(dvp, ndp, p) ! 65: struct vnode *dvp; ! 66: struct nameidata *ndp; ! 67: struct proc *p; ! 68: { ! 69: char *pname = ndp->ni_ptr; ! 70: int nfiles = p->p_fd->fd_nfiles; ! 71: unsigned fd; ! 72: int error; ! 73: struct vnode *fvp; ! 74: ! 75: #ifdef FDESC_DIAGNOSTIC ! 76: printf("fdesc_lookup(%s)\n", pname); ! 77: #endif ! 78: if (ndp->ni_namelen == 1 && *pname == '.') { ! 79: ndp->ni_dvp = dvp; ! 80: ndp->ni_vp = dvp; ! 81: VREF(dvp); ! 82: /*VOP_LOCK(dvp);*/ ! 83: return (0); ! 84: } ! 85: ! 86: fd = 0; ! 87: while (*pname >= '0' && *pname <= '9') { ! 88: fd = 10 * fd + *pname++ - '0'; ! 89: if (fd >= nfiles) ! 90: break; ! 91: } ! 92: ! 93: #ifdef FDESC_DIAGNOSTIC ! 94: printf("fdesc_lookup: fd = %d, *pname = %x\n", fd, *pname); ! 95: #endif ! 96: if (*pname == '/') { ! 97: error = ENOTDIR; ! 98: goto bad; ! 99: } ! 100: ! 101: if (*pname != '\0') { ! 102: error = ENOENT; ! 103: goto bad; ! 104: } ! 105: ! 106: if (fd >= nfiles || p->p_fd->fd_ofiles[fd] == NULL) { ! 107: error = EBADF; ! 108: goto bad; ! 109: } ! 110: ! 111: #ifdef FDESC_DIAGNOSTIC ! 112: printf("fdesc_lookup: allocate new vnode\n"); ! 113: #endif ! 114: error = getnewvnode(VT_UFS, dvp->v_mount, &fdesc_vnodeops, &fvp); ! 115: if (error) ! 116: goto bad; ! 117: VTOFDESC(fvp)->f_fd = fd; ! 118: /*VTOFDESC(fvp)->f_isroot = 0;*/ ! 119: ndp->ni_dvp = dvp; ! 120: ndp->ni_vp = fvp; ! 121: #ifdef FDESC_DIAGNOSTIC ! 122: printf("fdesc_lookup: newvp = %x\n", fvp); ! 123: #endif ! 124: return (0); ! 125: ! 126: bad:; ! 127: ndp->ni_dvp = dvp; ! 128: ndp->ni_vp = NULL; ! 129: #ifdef FDESC_DIAGNOSTIC ! 130: printf("fdesc_lookup: error = %d\n", error); ! 131: #endif ! 132: return (error); ! 133: } ! 134: ! 135: fdesc_open(vp, mode, cred, p) ! 136: struct vnode *vp; ! 137: int mode; ! 138: struct ucred *cred; ! 139: struct proc *p; ! 140: { ! 141: int error; ! 142: struct filedesc *fdp; ! 143: struct file *fp; ! 144: int dfd; ! 145: int fd; ! 146: ! 147: /* ! 148: * Can always open the root (modulo perms) ! 149: */ ! 150: if (vp->v_flag & VROOT) ! 151: return (0); ! 152: ! 153: /* ! 154: * XXX Kludge: set p->p_dupfd to contain the value of the ! 155: * the file descriptor being sought for duplication. The error ! 156: * return ensures that the vnode for this device will be released ! 157: * by vn_open. Open will detect this special error and take the ! 158: * actions in dupfdopen. Other callers of vn_open or VOP_OPEN ! 159: * will simply report the error. ! 160: */ ! 161: p->p_dupfd = VTOFDESC(vp)->f_fd; /* XXX */ ! 162: return (ENODEV); ! 163: } ! 164: ! 165: static int ! 166: fdesc_attr(fd, vap, cred, p) ! 167: int fd; ! 168: struct vattr *vap; ! 169: struct ucred *cred; ! 170: struct proc *p; ! 171: { ! 172: struct filedesc *fdp = p->p_fd; ! 173: struct file *fp; ! 174: int error; ! 175: ! 176: #ifdef FDESC_DIAGNOSTIC ! 177: printf("fdesc_attr: fd = %d, nfiles = %d\n", fd, fdp->fd_nfiles); ! 178: #endif ! 179: if (fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL) { ! 180: #ifdef FDESC_DIAGNOSTIC ! 181: printf("fdesc_attr: fp = %x (EBADF)\n", fp); ! 182: #endif ! 183: return (EBADF); ! 184: } ! 185: ! 186: /* ! 187: * Can stat the underlying vnode, but not sockets because ! 188: * they don't use struct vattrs. Well, we could convert from ! 189: * a struct stat back to a struct vattr, later... ! 190: */ ! 191: switch (fp->f_type) { ! 192: case DTYPE_VNODE: ! 193: error = VOP_GETATTR((struct vnode *) fp->f_data, vap, cred, p); ! 194: break; ! 195: ! 196: case DTYPE_SOCKET: ! 197: error = EOPNOTSUPP; ! 198: break; ! 199: ! 200: default: ! 201: panic("fdesc attr"); ! 202: break; ! 203: } ! 204: ! 205: #ifdef FDESC_DIAGNOSTIC ! 206: printf("fdesc_attr: returns error %d\n", error); ! 207: #endif ! 208: return (error); ! 209: } ! 210: ! 211: fdesc_getattr(vp, vap, cred, p) ! 212: struct vnode *vp; ! 213: struct vattr *vap; ! 214: struct ucred *cred; ! 215: struct proc *p; ! 216: { ! 217: unsigned fd; ! 218: int error; ! 219: ! 220: if (vp->v_flag & VROOT) { ! 221: #ifdef FDESC_DIAGNOSTIC ! 222: printf("fdesc_getattr: stat rootdir\n"); ! 223: #endif ! 224: bzero((caddr_t) vap, sizeof(*vap)); ! 225: vattr_null(vap); ! 226: vap->va_type = VDIR; ! 227: vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH; ! 228: vap->va_nlink = 2; ! 229: vap->va_uid = 0; ! 230: vap->va_gid = 0; ! 231: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; ! 232: vap->va_fileid = 2; ! 233: /* vap->va_qsize = 0; */ ! 234: vap->va_size = DEV_BSIZE; ! 235: vap->va_blocksize = DEV_BSIZE; ! 236: microtime(&vap->va_atime); ! 237: vap->va_mtime = vap->va_atime; ! 238: vap->va_ctime = vap->va_ctime; ! 239: vap->va_gen = 0; ! 240: vap->va_flags = 0; ! 241: vap->va_rdev = 0; ! 242: /* vap->va_qbytes = 0; */ ! 243: vap->va_bytes = 0; ! 244: return (0); ! 245: } ! 246: ! 247: fd = VTOFDESC(vp)->f_fd; ! 248: error = fdesc_attr(fd, vap, cred, p); ! 249: if (error == 0) ! 250: vp->v_type = vap->va_type; ! 251: return (error); ! 252: } ! 253: ! 254: fdesc_setattr(vp, vap, cred, p) ! 255: struct vnode *vp; ! 256: struct vattr *vap; ! 257: struct ucred *cred; ! 258: struct proc *p; ! 259: { ! 260: struct filedesc *fdp = p->p_fd; ! 261: struct file *fp; ! 262: unsigned fd; ! 263: int error; ! 264: ! 265: /* ! 266: * Can't mess with the root vnode ! 267: */ ! 268: if (vp->v_flag & VROOT) ! 269: return (EACCES); ! 270: ! 271: fd = VTOFDESC(vp)->f_fd; ! 272: #ifdef FDESC_DIAGNOSTIC ! 273: printf("fdesc_setattr: fd = %d, nfiles = %d\n", fd, fdp->fd_nfiles); ! 274: #endif ! 275: if (fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL) { ! 276: #ifdef FDESC_DIAGNOSTIC ! 277: printf("fdesc_setattr: fp = %x (EBADF)\n", fp); ! 278: #endif ! 279: return (EBADF); ! 280: } ! 281: ! 282: /* ! 283: * Can setattr the underlying vnode, but not sockets! ! 284: */ ! 285: switch (fp->f_type) { ! 286: case DTYPE_VNODE: ! 287: error = VOP_SETATTR((struct vnode *) fp->f_data, vap, cred, p); ! 288: break; ! 289: ! 290: case DTYPE_SOCKET: ! 291: error = EOPNOTSUPP; ! 292: break; ! 293: ! 294: default: ! 295: panic("fdesc setattr"); ! 296: break; ! 297: } ! 298: ! 299: #ifdef FDESC_DIAGNOSTIC ! 300: printf("fdesc_setattr: returns error %d\n", error); ! 301: #endif ! 302: return (error); ! 303: } ! 304: ! 305: fdesc_readdir(vp, uio, cred, eofflagp) ! 306: struct vnode *vp; ! 307: struct uio *uio; ! 308: struct ucred *cred; ! 309: int *eofflagp; ! 310: { ! 311: struct filedesc *fdp; ! 312: int ind, i; ! 313: int error; ! 314: ! 315: #define UIO_MX 16 ! 316: ! 317: fdp = uio->uio_procp->p_fd; ! 318: ind = uio->uio_offset / UIO_MX; ! 319: error = 0; ! 320: while (uio->uio_resid > 0) { ! 321: struct direct d; ! 322: struct direct *dp = &d; ! 323: ! 324: if (ind < 2) { /* . or .. */ ! 325: bzero((caddr_t) dp, UIO_MX); ! 326: if (ind == 0) { ! 327: strcpy(dp->d_name, "."); ! 328: dp->d_namlen = 1; ! 329: } else if (ind == 1) { ! 330: strcpy(dp->d_name, ".."); ! 331: dp->d_namlen = 2; ! 332: } else ! 333: panic("fdesc: ind is negative!"); ! 334: ! 335: dp->d_reclen = UIO_MX; ! 336: dp->d_ino = 2; ! 337: ! 338: /* ! 339: * And ship to userland ! 340: */ ! 341: error = uiomove((caddr_t) dp, UIO_MX, uio); ! 342: if (error) ! 343: break; ! 344: ! 345: ind++; ! 346: continue; ! 347: } ! 348: i = ind - 2; ! 349: if (i >= fdp->fd_nfiles) { ! 350: *eofflagp = 1; ! 351: break; ! 352: } ! 353: if (fdp->fd_ofiles[i] != NULL) { ! 354: struct direct d; ! 355: struct direct *dp = &d; ! 356: char *cp = dp->d_name; ! 357: #ifdef FDESC_FILEID ! 358: struct vattr va; ! 359: #endif ! 360: int j; ! 361: ! 362: bzero((caddr_t) dp, UIO_MX); ! 363: ! 364: /* ! 365: * Generate an ASCII representation of the name. ! 366: * This can cope with fds in the range 0..99999 ! 367: */ ! 368: cp++; ! 369: if (i > 10) cp++; ! 370: if (i > 100) cp++; ! 371: if (i > 1000) cp++; ! 372: if (i > 10000) cp++; ! 373: if (i > 100000) panic("fdesc_readdir"); ! 374: dp->d_namlen = cp - dp->d_name; ! 375: *cp = '\0'; ! 376: j = i; ! 377: do { ! 378: *--cp = j % 10 + '0'; ! 379: j /= 10; ! 380: } while (j > 0); ! 381: /* ! 382: * Fill in the remaining fields ! 383: */ ! 384: dp->d_reclen = UIO_MX; ! 385: dp->d_ino = i + 3; ! 386: #ifdef FDESC_FILEID ! 387: /* ! 388: * If we want the file ids to match the ! 389: * we must call getattr on the underlying file. ! 390: * fdesc_attr may return an error, in which case ! 391: * we ignore the returned file id. ! 392: */ ! 393: error = fdesc_attr(i, &va, cred, p); ! 394: if (error == 0) ! 395: dp->d_ino = va.va_fileid; ! 396: #endif ! 397: /* ! 398: * And ship to userland ! 399: */ ! 400: error = uiomove((caddr_t) dp, UIO_MX, uio); ! 401: if (error) ! 402: break; ! 403: } ! 404: ind++; ! 405: } ! 406: ! 407: uio->uio_offset = ind * UIO_MX; ! 408: return (error); ! 409: } ! 410: ! 411: fdesc_inactive(vp, p) ! 412: struct vnode *vp; ! 413: struct proc *p; ! 414: { ! 415: /* ! 416: * Clear out the v_type field to avoid ! 417: * nasty things happening in vgone(). ! 418: */ ! 419: vp->v_type = VNON; ! 420: #ifdef FDESC_DIAGNOSTIC ! 421: printf("fdesc_inactive(%x)\n", vp); ! 422: #endif ! 423: return (0); ! 424: } ! 425: ! 426: /* ! 427: * Print out the contents of a /dev/fd vnode. ! 428: */ ! 429: /* ARGSUSED */ ! 430: fdesc_print(vp) ! 431: struct vnode *vp; ! 432: { ! 433: printf("tag VT_NON, fdesc vnode\n"); ! 434: } ! 435: ! 436: /* ! 437: * /dev/fd vnode unsupported operation ! 438: */ ! 439: fdesc_enotsupp() ! 440: { ! 441: return (EOPNOTSUPP); ! 442: } ! 443: ! 444: /* ! 445: * /dev/fd "should never get here" operation ! 446: */ ! 447: fdesc_badop() ! 448: { ! 449: panic("fdesc: bad op"); ! 450: /* NOTREACHED */ ! 451: } ! 452: ! 453: /* ! 454: * /dev/fd vnode null operation ! 455: */ ! 456: fdesc_nullop() ! 457: { ! 458: return (0); ! 459: } ! 460: ! 461: #define fdesc_create ((int (*) __P(( \ ! 462: struct nameidata *ndp, \ ! 463: struct vattr *vap, \ ! 464: struct proc *p))) fdesc_enotsupp) ! 465: #define fdesc_mknod ((int (*) __P(( \ ! 466: struct nameidata *ndp, \ ! 467: struct vattr *vap, \ ! 468: struct ucred *cred, \ ! 469: struct proc *p))) fdesc_enotsupp) ! 470: #define fdesc_close ((int (*) __P(( \ ! 471: struct vnode *vp, \ ! 472: int fflag, \ ! 473: struct ucred *cred, \ ! 474: struct proc *p))) nullop) ! 475: #define fdesc_access ((int (*) __P(( \ ! 476: struct vnode *vp, \ ! 477: int mode, \ ! 478: struct ucred *cred, \ ! 479: struct proc *p))) nullop) ! 480: #define fdesc_read ((int (*) __P(( \ ! 481: struct vnode *vp, \ ! 482: struct uio *uio, \ ! 483: int ioflag, \ ! 484: struct ucred *cred))) fdesc_enotsupp) ! 485: #define fdesc_write ((int (*) __P(( \ ! 486: struct vnode *vp, \ ! 487: struct uio *uio, \ ! 488: int ioflag, \ ! 489: struct ucred *cred))) fdesc_enotsupp) ! 490: #define fdesc_ioctl ((int (*) __P(( \ ! 491: struct vnode *vp, \ ! 492: int command, \ ! 493: caddr_t data, \ ! 494: int fflag, \ ! 495: struct ucred *cred, \ ! 496: struct proc *p))) fdesc_enotsupp) ! 497: #define fdesc_select ((int (*) __P(( \ ! 498: struct vnode *vp, \ ! 499: int which, \ ! 500: int fflags, \ ! 501: struct ucred *cred, \ ! 502: struct proc *p))) fdesc_enotsupp) ! 503: #define fdesc_mmap ((int (*) __P(( \ ! 504: struct vnode *vp, \ ! 505: int fflags, \ ! 506: struct ucred *cred, \ ! 507: struct proc *p))) fdesc_enotsupp) ! 508: #define fdesc_fsync ((int (*) __P(( \ ! 509: struct vnode *vp, \ ! 510: int fflags, \ ! 511: struct ucred *cred, \ ! 512: int waitfor, \ ! 513: struct proc *p))) nullop) ! 514: #define fdesc_seek ((int (*) __P(( \ ! 515: struct vnode *vp, \ ! 516: off_t oldoff, \ ! 517: off_t newoff, \ ! 518: struct ucred *cred))) nullop) ! 519: #define fdesc_remove ((int (*) __P(( \ ! 520: struct nameidata *ndp, \ ! 521: struct proc *p))) fdesc_enotsupp) ! 522: #define fdesc_link ((int (*) __P(( \ ! 523: struct vnode *vp, \ ! 524: struct nameidata *ndp, \ ! 525: struct proc *p))) fdesc_enotsupp) ! 526: #define fdesc_rename ((int (*) __P(( \ ! 527: struct nameidata *fndp, \ ! 528: struct nameidata *tdnp, \ ! 529: struct proc *p))) fdesc_enotsupp) ! 530: #define fdesc_mkdir ((int (*) __P(( \ ! 531: struct nameidata *ndp, \ ! 532: struct vattr *vap, \ ! 533: struct proc *p))) fdesc_enotsupp) ! 534: #define fdesc_rmdir ((int (*) __P(( \ ! 535: struct nameidata *ndp, \ ! 536: struct proc *p))) fdesc_enotsupp) ! 537: #define fdesc_symlink ((int (*) __P(( \ ! 538: struct nameidata *ndp, \ ! 539: struct vattr *vap, \ ! 540: char *target, \ ! 541: struct proc *p))) fdesc_enotsupp) ! 542: #define fdesc_readlink ((int (*) __P(( \ ! 543: struct vnode *vp, \ ! 544: struct uio *uio, \ ! 545: struct ucred *cred))) fdesc_enotsupp) ! 546: #define fdesc_abortop ((int (*) __P(( \ ! 547: struct nameidata *ndp))) nullop) ! 548: #ifdef FDESC_DIAGNOSTIC ! 549: int fdesc_reclaim(vp) ! 550: struct vnode *vp; ! 551: { ! 552: printf("fdesc_reclaim(%x)\n", vp); ! 553: return (0); ! 554: } ! 555: #else ! 556: #define fdesc_reclaim ((int (*) __P(( \ ! 557: struct vnode *vp))) nullop) ! 558: #endif ! 559: #define fdesc_lock ((int (*) __P(( \ ! 560: struct vnode *vp))) nullop) ! 561: #define fdesc_unlock ((int (*) __P(( \ ! 562: struct vnode *vp))) nullop) ! 563: #define fdesc_bmap ((int (*) __P(( \ ! 564: struct vnode *vp, \ ! 565: daddr_t bn, \ ! 566: struct vnode **vpp, \ ! 567: daddr_t *bnp))) fdesc_badop) ! 568: #define fdesc_strategy ((int (*) __P(( \ ! 569: struct buf *bp))) fdesc_badop) ! 570: #define fdesc_islocked ((int (*) __P(( \ ! 571: struct vnode *vp))) nullop) ! 572: #define fdesc_advlock ((int (*) __P(( \ ! 573: struct vnode *vp, \ ! 574: caddr_t id, \ ! 575: int op, \ ! 576: struct flock *fl, \ ! 577: int flags))) fdesc_enotsupp) ! 578: ! 579: struct vnodeops fdesc_vnodeops = { ! 580: fdesc_lookup, /* lookup */ ! 581: fdesc_create, /* create */ ! 582: fdesc_mknod, /* mknod */ ! 583: fdesc_open, /* open */ ! 584: fdesc_close, /* close */ ! 585: fdesc_access, /* access */ ! 586: fdesc_getattr, /* getattr */ ! 587: fdesc_setattr, /* setattr */ ! 588: fdesc_read, /* read */ ! 589: fdesc_write, /* write */ ! 590: fdesc_ioctl, /* ioctl */ ! 591: fdesc_select, /* select */ ! 592: fdesc_mmap, /* mmap */ ! 593: fdesc_fsync, /* fsync */ ! 594: fdesc_seek, /* seek */ ! 595: fdesc_remove, /* remove */ ! 596: fdesc_link, /* link */ ! 597: fdesc_rename, /* rename */ ! 598: fdesc_mkdir, /* mkdir */ ! 599: fdesc_rmdir, /* rmdir */ ! 600: fdesc_symlink, /* symlink */ ! 601: fdesc_readdir, /* readdir */ ! 602: fdesc_readlink, /* readlink */ ! 603: fdesc_abortop, /* abortop */ ! 604: fdesc_inactive, /* inactive */ ! 605: fdesc_reclaim, /* reclaim */ ! 606: fdesc_lock, /* lock */ ! 607: fdesc_unlock, /* unlock */ ! 608: fdesc_bmap, /* bmap */ ! 609: fdesc_strategy, /* strategy */ ! 610: fdesc_print, /* print */ ! 611: fdesc_islocked, /* islocked */ ! 612: fdesc_advlock, /* advlock */ ! 613: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.