![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to validate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp / vms|
Return to validate.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp / vms |
1.1 ! root 1: /* ! 2: * ! 3: * Routines to deal with the VMS User Authorization File: ! 4: * ! 5: * get_vms_uaf_record(name,uaf); ! 6: * validate_vms_user(name,password,uaf); ! 7: * hash_vms_password(output_buf,input_buf,input_len,username,type,salt); ! 8: * ! 9: * ! 10: */ ! 11: ! 12: ! 13: /* ! 14: * Includes ! 15: */ ! 16: #include <vms/fab.h> /* File access block */ ! 17: #include <vms/rab.h> /* Record access block */ ! 18: #include <vms/rmsdef.h> /* RMS return codes */ ! 19: #include <vms/ssdef.h> /* System service return codes */ ! 20: #include <vms/uafdef.h> /* Authorization file records */ ! 21: #include <vms/logdef.h> /* Logical name table seach masks */ ! 22: ! 23: /* ! 24: * defines ! 25: */ ! 26: #define RETRY_RLK 2 /* number of retries if record locked */ ! 27: #define SLEEP_RLK 75 /* MS to sleep before retrying a GET */ ! 28: #define RECSIZ 80 /* Maximum length for password string */ ! 29: #define UAFNAME "SYSUAF" /* Name of authorization file */ ! 30: #define UAFSIZE 6 /* Size of above */ ! 31: #define DEFNAME "SYS$SYSTEM:.DAT" /* Default path to authorization file */ ! 32: #define DEFSIZE 15 /* Size of above */ ! 33: #define DEFUSER "DEFAULT " /* "Default user" name */ ! 34: ! 35: #define UAF$_NORMAL 1 /* Normal completion */ ! 36: #define UAF$_INVUSR -2 /* Invalid User Name */ ! 37: #define UAF$_INVPWD -4 /* Invalid Password */ ! 38: ! 39: #define UAF$S_USERNAME 12 /* User Name Size */ ! 40: #define UAF$S_PWD 8 /* Password Size */ ! 41: ! 42: struct descr {int size; char *ptr;}; /* VMS descriptor */ ! 43: ! 44: /* ! 45: * OWN STORAGE: ! 46: */ ! 47: static int wakedelta[] = {-10*1000*SLEEP_RLK,-1}; ! 48: ! 49: ! 50: /* ! 51: * ! 52: * status = get_vms_uaf_record(name,uaf); ! 53: * ! 54: */ ! 55: int get_vms_uaf_record(name,uaf) ! 56: char *name; ! 57: register struct uaf *uaf; ! 58: { ! 59: struct FAB fab; ! 60: struct RAB rab; ! 61: unsigned int old_privs[2],new_privs[2]; ! 62: int status; ! 63: int default_user = 1; ! 64: register int i; ! 65: register char *cp,*cp1,*cp2; ! 66: ! 67: /* ! 68: * Zero the fab and rab ! 69: */ ! 70: bzero(&fab,sizeof(fab)); ! 71: bzero(&rab,sizeof(rab)); ! 72: /* ! 73: * Setup the fab ! 74: */ ! 75: fab.fab$b_bid = FAB$C_BID; ! 76: fab.fab$b_bln = sizeof(fab); ! 77: fab.fab$l_fna = UAFNAME; ! 78: fab.fab$b_fns = UAFSIZE; ! 79: fab.fab$l_dna = DEFNAME; ! 80: fab.fab$b_dns = DEFSIZE; ! 81: fab.fab$b_dsbmsk = (1<<LOG$C_GROUP) | (1<<LOG$C_PROCESS); ! 82: fab.fab$b_fac |= FAB$M_GET; ! 83: fab.fab$b_shr = (FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL); ! 84: fab.fab$b_org = FAB$C_IDX; ! 85: fab.fab$b_rfm = FAB$C_VAR; ! 86: /* ! 87: * setup the rab ! 88: */ ! 89: rab.rab$b_bid = RAB$C_BID; ! 90: rab.rab$b_bln = sizeof(rab); ! 91: rab.rab$b_rac = RAB$C_KEY; ! 92: rab.rab$l_rop |= RAB$M_NLK; ! 93: rab.rab$b_mbc = 10; ! 94: rab.rab$w_usz = sizeof(struct uaf); ! 95: rab.rab$l_ubf = (char *)uaf; ! 96: rab.rab$l_kbfpbf.rab$l_kbf = (unsigned long int *)uaf; ! 97: rab.rab$b_kszpsz.rab$b_ksz = UAF$S_USERNAME; ! 98: rab.rab$l_fab = &fab; ! 99: /* ! 100: * Enable all privileges that we are authorized to have just to ! 101: * enhance the possibility of accessing the SYSUAF file. ! 102: */ ! 103: new_privs[0] = -1; new_privs[1] = -1; ! 104: sys$setprv(1,new_privs,0,old_privs); ! 105: /* ! 106: * Open the File and connect the RAB ! 107: */ ! 108: status = sys$open(&fab); ! 109: if (!(status & 1)) { ! 110: if ((status == RMS$_SNE) || ! 111: (status == RMS$_SPE) || ! 112: (status == RMS$_DME)) { ! 113: fab.fab$b_shr = 0; ! 114: status = sys$open(&fab); ! 115: if (!(status & 1)) goto exit; ! 116: } else goto exit; ! 117: } ! 118: status = sys$connect(&rab); ! 119: if (!(status & 1)) goto exit; ! 120: /* ! 121: * Move the USERNAME to the uaf$t_username field (as a buffer) ! 122: * uppercaseify it along the way and check it against the ! 123: * username "DEFAULT" (which is not a real username). Pad ! 124: * the uaf$t_username field with blanks. ! 125: */ ! 126: i = UAF$S_USERNAME; ! 127: cp = name; ! 128: cp1 = uaf->uaf$t_username; ! 129: cp2 = DEFUSER; ! 130: while(--i >= 0) { ! 131: if (*cp == 0) break; ! 132: if (*cp != *cp2++) default_user = 0; ! 133: *cp1++ = ((*cp >= 'a') && (*cp <= 'z')) ? ! 134: *cp++ + ('A' - 'a') : *cp++; ! 135: } ! 136: i++; ! 137: while(--i >= 0) { ! 138: *cp1++ = ' '; ! 139: if (*cp2++ != ' ') default_user = 0; ! 140: } ! 141: /* ! 142: * The "DEFAULT" user is illegal! ! 143: */ ! 144: if (default_user) { ! 145: status = UAF$_INVUSR; ! 146: goto exit; ! 147: } ! 148: /* ! 149: * Look up the User's UAF record ! 150: */ ! 151: status = get_record(&rab); ! 152: if (status == RMS$_RNF) status = UAF$_INVUSR; ! 153: ! 154: exit: ! 155: /* ! 156: * Done: close the file, release privileges and return status ! 157: */ ! 158: sys$disconnect(&rab); ! 159: sys$close(&fab); ! 160: sys$setprv(0,new_privs,0,0); ! 161: sys$setprv(1,old_privs,0,0); ! 162: return(status); ! 163: } ! 164: ! 165: ! 166: /* ! 167: * Read the record and deal with file locking ! 168: */ ! 169: static get_record(rab) ! 170: struct RAB *rab; ! 171: { ! 172: int retries = RETRY_RLK; ! 173: int status; ! 174: ! 175: /* ! 176: * Re-try the appropriate number of times ! 177: */ ! 178: while(1) { ! 179: /* ! 180: * Get the record ! 181: */ ! 182: status = sys$get(rab); ! 183: /* ! 184: * If the return code is not "Record Locked" it is either ! 185: * a success or error that we can't handle, return it. ! 186: */ ! 187: if (status != RMS$_RLK) break; ! 188: /* ! 189: * Record Locked: If retries exceeded, return error ! 190: */ ! 191: if (--retries < 0) break; ! 192: /* ! 193: * Retry: Sleep first ! 194: */ ! 195: status = sys$schdwk(0,0,wakedelta,0); ! 196: if (status & 1) sys$hiber(); ! 197: } ! 198: /* ! 199: * Done: Return status ! 200: */ ! 201: return(status); ! 202: } ! 203: ! 204: ! 205: /* ! 206: * ! 207: * Validate a UserName/Password pair and return the user's UAF record ! 208: * ! 209: */ ! 210: int validate_vms_user(name,password,uaf) ! 211: char *name; ! 212: char *password; ! 213: register struct uaf *uaf; ! 214: { ! 215: char password_buf[RECSIZ]; ! 216: char username_buf[UAF$S_USERNAME]; ! 217: char encrypt_buf[UAF$S_PWD]; ! 218: register int i; ! 219: register char *cp,*cp1; ! 220: ! 221: /* ! 222: * Get the User's UAF record ! 223: */ ! 224: i = get_vms_uaf_record(name,uaf); ! 225: if (!(i & 1)) return(i); ! 226: /* ! 227: * Limit the username to "UAF$S_USERNAME" size while copying and ! 228: * uppercasifying it. Pad with spaces to "UAF$S_USERNAME" size. ! 229: */ ! 230: i = UAF$S_USERNAME; ! 231: cp = name; ! 232: cp1 = username_buf; ! 233: while(--i >= 0) { ! 234: if (*cp == 0) break; ! 235: *cp1++ = ((*cp >= 'a') && (*cp <= 'z')) ? ! 236: *cp++ + ('A' - 'a') : *cp++; ! 237: } ! 238: i++; ! 239: while(--i >= 0) *cp1++ = ' '; ! 240: /* ! 241: * Limit the password to "RECSIZ" size while copying and ! 242: * uppercasifying it. ! 243: */ ! 244: i = RECSIZ; ! 245: cp = password; ! 246: cp1 = password_buf; ! 247: while(--i >= 0) { ! 248: if (*cp == 0) break; ! 249: *cp1++ = ((*cp >= 'a') && (*cp <= 'z')) ? ! 250: *cp++ + ('A' - 'a') : *cp++; ! 251: } ! 252: i = (RECSIZ - 1) - i; /* Compute size of password string */ ! 253: /* ! 254: * Encrypt the password ! 255: */ ! 256: hash_vms_password(encrypt_buf,password_buf,i,username_buf, ! 257: uaf->uaf$b_encrypt,uaf->uaf$w_salt); ! 258: if (bcmp(encrypt_buf,uaf->uaf$l_pwd,UAF$S_PWD) == 0) ! 259: return(UAF$_NORMAL); ! 260: else return(UAF$_INVPWD); ! 261: } ! 262: ! 263: ! 264: /* ! 265: * ! 266: * PASSWORD SMASHING CODE: ! 267: * The real bit hacking is done in "asm" statements, since ! 268: * "C" is poorly suited towards quad-word arithmetic! ! 269: * ! 270: */ ! 271: ! 272: /* ! 273: * AUTODIN II CRC Coefficients: ! 274: */ ! 275: static unsigned long autodin[] = { ! 276: 000000000000,003555610144,007333420310,004666230254, ! 277: 016667040620,015332650764,011554460530,012001270474, ! 278: 035556101440,036003711504,032665521750,031330331614, ! 279: 023331141260,020664751324,024002561170,027557371034 ! 280: }; ! 281: ! 282: ! 283: /* ! 284: * PURDY Polynomial Coefficients ! 285: */ ! 286: static long c[] = { ! 287: -83, -1, /* C1 */ ! 288: -179, -1, /* C2 */ ! 289: -257, -1, /* C3 */ ! 290: -323, -1, /* C4 */ ! 291: -363, -1 /* C5 */ ! 292: }; ! 293: ! 294: /* ! 295: * Hashing routine ! 296: */ ! 297: hash_vms_password(output_buf,input_buf,input_length,username,type,salt) ! 298: char *output_buf,*input_buf,*username; ! 299: unsigned short salt; ! 300: { ! 301: register int i; ! 302: register char *cp; ! 303: ! 304: /* ! 305: * Dispatch on encryption type ! 306: */ ! 307: if (type == 0) { ! 308: /* ! 309: * AUTODIN II CRC: ! 310: */ ! 311: crc(autodin,-1,input_length,input_buf,output_buf); ! 312: return; ! 313: } else { ! 314: /* ! 315: * PURDY: ! 316: */ ! 317: ! 318: i = 8; ! 319: cp = output_buf; ! 320: while(--i >= 0) *cp++ = 0; /* Init output buffer */ ! 321: /* ! 322: * Collapse the password into a quadword ! 323: */ ! 324: collapse(input_length,input_buf,output_buf); ! 325: /* ! 326: * Add salt to middle of quadword ! 327: */ ! 328: *((unsigned short *)(output_buf+3)) += salt; ! 329: /* ! 330: * Collapse the username into the quadword ! 331: */ ! 332: collapse(/*UAF$S_USERNAME*/12,username,output_buf); ! 333: /* ! 334: * Compute the PURDY polynomial: ! 335: */ ! 336: purdy(output_buf,c); ! 337: } ! 338: } ! 339: ! 340: /* ! 341: * CRC routine: ! 342: */ ! 343: static crc(table,initial_crc,input_len,input_buf,output_buf) ! 344: { ! 345: asm(" crc *4(ap),8(ap),12(ap),*16(ap)"); ! 346: asm(" clrl r1"); ! 347: asm(" movq r0,*20(ap)"); ! 348: } ! 349: ! 350: /* ! 351: * Routine to collapse a string into a quadword: ! 352: */ ! 353: static collapse(input_len,input_buf,output_buf) ! 354: register unsigned char *input_buf; ! 355: register int input_len; ! 356: register unsigned char *output_buf; ! 357: { ! 358: while(input_len > 0) { ! 359: output_buf[input_len & ~(-8)] += *input_buf++; ! 360: input_len--; ! 361: } ! 362: } ! 363: ! 364: ! 365: /* ! 366: * ! 367: * GROMMY STUFF TO COMPUTE THE PURDY POLYNOMIAL ! 368: * ! 369: */ ! 370: static purdy(U,C) ! 371: { ! 372: /* ! 373: * This routine computes f(U) = p(U) mod P. Where P is a prime of the form ! 374: * P = 2^64 - a. The function p is the following polynomial: ! 375: * X^n0 + X^n1*C1 + X^3*C2 + X^2*C3 + X*C4 + C5 ! 376: * The input U is an unsigned quadword. ! 377: */ ! 378: asm(" .set A,59"); /* 2^64 -59 is the biggest quad prime */ ! 379: ! 380: asm(" movq *4(ap),-(sp)"); /* Push U */ ! 381: asm(" bsbw PQMOD_R0"); /* Ensure U less than P */ ! 382: asm(" movaq (sp),r4"); /* Maintain a pointer to X*/ ! 383: asm(" pushl 8(ap)"); ! 384: asm(" movl (sp)+,r5"); /* Point to the table of coefficients */ ! 385: asm(" movq (r4),-(sp)"); ! 386: asm(" pushl $((1<<24)-63)");/* n1 */ ! 387: asm(" bsbb PQEXP_R3"); /* X^n1 */ ! 388: asm(" movq (r4),-(sp)"); ! 389: asm(" pushl $((1<<24)-3)"); ! 390: asm(" subl2 $((1<<24)-63),(sp)");/* n0-n1 */ ! 391: asm(" bsbb PQEXP_R3"); ! 392: asm(" movq (r5)+,-(sp)"); /* C1 */ ! 393: asm(" bsbw PQADD_R0"); /* X^(n0 - n1) + C1 */ ! 394: asm(" bsbw PQMUL_R2"); /* X^n0 + X^n1*C1 */ ! 395: asm(" movq (r5)+,-(sp)"); /* C2 */ ! 396: asm(" movq (r4),-(sp)"); ! 397: asm(" bsbw PQMUL_R2"); /* X*C2 */ ! 398: asm(" movq (r5)+,-(sp)"); /* C3 */ ! 399: asm(" bsbw PQADD_R0"); /* X*C2 + C3 */ ! 400: asm(" movq (r4),-(sp)"); ! 401: asm(" bsbb PQMUL_R2"); /* X^2*C2 + X*C3 */ ! 402: asm(" movq (r5)+,-(sp)"); /* C4 */ ! 403: asm(" bsbw PQADD_R0"); /* X^2*C2 + X*C3 + C4 */ ! 404: asm(" movq (r4),-(sp)"); ! 405: asm(" bsbb PQMUL_R2"); /* X^3*C2 + X^2*C3 + C4*X */ ! 406: asm(" movq (r5)+,-(sp)"); /* C5 */ ! 407: asm(" bsbw PQADD_R0"); /* X^3*C2 + X^2*C3 + C4*X + C5 */ ! 408: asm(" bsbw PQADD_R0"); /* Add in the high order terms */ ! 409: asm(" movq (sp)+,*4(ap)"); /* Replace U with f(X) */ ! 410: asm(" movl $1,r0"); ! 411: asm(" ret"); ! 412: ! 413: ! 414: /* Replaces the inputs with U^n mod P where P is of the form */ ! 415: /* P = 2^64 - a. */ ! 416: /* U is a quadword, n is an unsigned longword. */ ! 417: ! 418: asm("PQEXP_R3:"); ! 419: asm(" popr $8"); /* Record return address */ ! 420: asm(" movq $1,-(sp)"); /* Initialize */ ! 421: asm(" movq 8+4(sp),-(sp)");/* Copy U to top of stack for speed */ ! 422: asm(" tstl 8+8(sp)"); /* Only handle n greater than */ ! 423: asm(" beqlu 3f"); ! 424: asm("1: blbc 8+8(sp),2f"); ! 425: asm(" movq (sp),-(sp)"); /* Copy the current power of U */ ! 426: asm(" movq 8+8(sp),-(sp)");/* Multiply with current value */ ! 427: asm(" bsbb PQMUL_R2"); ! 428: asm(" movq (sp)+,8(sp)"); /* Replace current value */ ! 429: asm(" cmpzv $1,$31,8+8(sp),$0"); ! 430: asm(" beqlu 3f"); ! 431: asm("2: movq (sp),-(sp)"); /* Proceed to next power of U */ ! 432: asm(" bsbb PQMUL_R2"); ! 433: asm(" extzv $1,$31,8+8(sp),8+8(sp)"); ! 434: asm(" brb 1b"); ! 435: asm("3: movq 8(sp),8+8+4(sp)");/* Copy the return value */ ! 436: asm(" movaq 8+8+4(sp),sp"); /* Discard the exponent */ ! 437: asm(" jmp (r3)"); /* return */ ! 438: ! 439: /* Replaces the quadword U on the stack with U mod P where P is of the */ ! 440: /* form P = 2^64 - a. */ ! 441: asm(" .set U,0"); /* Low longword of U */ ! 442: asm(" .set V,U+4"); /* High longword of U */ ! 443: asm(" .set Y,U+8"); /* Low longword of Y */ ! 444: asm(" .set Z,Y+4"); /* High longword of Y */ ! 445: asm("PQMOD_R0:"); ! 446: asm(" popr $1"); /* Record return address */ ! 447: asm(" cmpl V(sp),$-1"); /* Replace U with U mod P */ ! 448: asm(" blssu 1f"); ! 449: asm(" cmpl U(sp),$-A"); ! 450: asm(" blssu 1f"); ! 451: asm(" addl2 $A,U(sp)"); ! 452: asm(" adwc $0,V(sp)"); ! 453: asm("1: jmp (r0)"); /* return */ ! 454: ! 455: ! 456: /* Computes the product U*Y mod P where P is of the form ! 457: * P = 2^64 - a. U, Y are quadwords less than P. The product ! 458: * replaces U and Y on the stack. ! 459: * ! 460: * The product may be formed as the sum of four longword ! 461: * multiplications which are scaled by powers of 2^32 by evaluating: ! 462: * 2^64*v*z + 2^32*(v*y + u*z) + u*y ! 463: * The result is computed such that division by the modulus P ! 464: * is avoided. ! 465: */ ! 466: asm("PQMUL_R2:"); ! 467: asm(" popr $2"); /* Record return address */ ! 468: asm(" movl sp,r2"); /* Record initial stack value */ ! 469: asm(" pushl Z(r2)"); ! 470: asm(" pushl V(r2)"); ! 471: asm(" bsbb EMULQ"); ! 472: asm(" bsbb PQMOD_R0"); ! 473: asm(" bsbb PQLSH_R0"); /* Obtain 2^32*v*z */ ! 474: asm(" pushl Y(r2)"); ! 475: asm(" pushl V(r2)"); ! 476: asm(" bsbb EMULQ"); ! 477: asm(" bsbb PQMOD_R0"); ! 478: asm(" pushl Z(r2)"); ! 479: asm(" pushl U(r2)"); ! 480: asm(" bsbb EMULQ"); ! 481: asm(" bsbb PQMOD_R0"); ! 482: asm(" bsbb PQADD_R0"); /* Obtain (v*y + u*z) */ ! 483: asm(" bsbb PQADD_R0"); /* Add in 2^32*v*z */ ! 484: asm(" bsbb PQLSH_R0"); /* Obtain the first two terms */ ! 485: asm(" pushl Y(r2)"); ! 486: asm(" pushl U(r2)"); ! 487: asm(" bsbb EMULQ"); ! 488: asm(" bsbb PQMOD_R0"); /* Obtain the third term: u*y */ ! 489: asm(" bsbb PQADD_R0"); /* Add it in */ ! 490: asm(" movq (sp)+,Y(r2)"); /* Copy the return value */ ! 491: asm(" movaq Y(r2),sp"); /* Point the stack to the return value */ ! 492: asm(" jmp (r1)"); /* return */ ! 493: ! 494: ! 495: /* This routine knows how to multiply two unsigned longwords, ! 496: * replacing them with the unsigned quadword product on the stack. ! 497: */ ! 498: ! 499: asm("EMULQ:"); ! 500: asm(" emul 4(sp),8(sp),$0,-(sp)"); ! 501: asm(" clrl -(sp)"); ! 502: asm(" tstl 4+8+4(sp)"); /* Check both longwords to see if we */ ! 503: asm(" bgeq 1f"); /* must compensate for the unsigned ! 504: bias. */ ! 505: asm(" addl2 4+8+8(sp),(sp)"); ! 506: asm("1: tstl 4+8+8(sp)"); ! 507: asm(" bgeq 2f"); ! 508: asm(" addl2 4+8+4(sp),(sp)"); ! 509: asm("2: addl2 (sp)+,4(sp)"); /* Add in the compensation. */ ! 510: asm(" movq (sp)+,4(sp)"); /* Replace the longwords with their ! 511: product. */ ! 512: asm(" rsb"); ! 513: ! 514: /* ! 515: * Computes the product 2^32*U mod P where P is of the form ! 516: * P = 2^64 - a. U is a quadword less than P. The product replaces ! 517: * U on the stack. ! 518: * ! 519: * This routine is used by PQMUL in the formation of quadword ! 520: * products in such a way as to avoid division by the modulus P. ! 521: * The product 2^64*v + 2^32*u is congruent a*v + 2^32*u mod P ! 522: * (where u, v are longwords). ! 523: */ ! 524: asm("PQLSH_R0:"); ! 525: asm(" popr $1"); /* Record return address */ ! 526: asm(" pushl V(sp)"); ! 527: asm(" pushl $A"); ! 528: asm(" bsbb EMULQ"); /* Push a*v */ ! 529: asm(" ashq $32,Y(sp),Y(sp)");/* Form Y = 2^32*u */ ! 530: asm(" brb PQADD_R0_1"); /* Return the sum U + Y mod P. */ ! 531: ! 532: /* ! 533: * Computes the sum U + Y mod P where P is of the form P = 2^64 - a. ! 534: * U, Y are quadwords less than P. The sum replaces U and Y on ! 535: * the stack. ! 536: */ ! 537: asm("PQADD_R0:"); ! 538: asm(" popr $1"); /* Record return address */ ! 539: asm("PQADD_R0_1:"); ! 540: asm(" addl2 U(sp),Y(sp)") /* Add the low longwords */ ! 541: asm(" adwc V(sp),Z(sp)"); /* Add the high longwords with the carry */ ! 542: asm(" bcs 2f"); /* If the result is greater than a quadword */ ! 543: asm(" cmpl Z(sp),$-1"); ! 544: asm(" blssu 3f"); ! 545: asm(" cmpl Y(sp),$-A"); /* or simply greater than or equal to P */ ! 546: asm(" blssu 3f"); ! 547: asm("2: addl2 $A,Y(sp)"); /* we must subtract P.*/ ! 548: asm(" adwc $0,Z(sp)"); ! 549: asm("3: movaq Y(sp),sp"); /* Point the stack to the return value */ ! 550: asm(" jmp (r0)"); /* return */ ! 551: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.