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: }

Defined functions

collapse defined in line 353; used 2 times
crc defined in line 343; used 1 times
get_record defined in line 169; used 1 times
get_vms_uaf_record defined in line 55; used 1 times
hash_vms_password defined in line 297; used 1 times
purdy defined in line 370; used 1 times
validate_vms_user defined in line 210; used 1 times

Defined variables

autodin defined in line 275; used 1 times
c defined in line 286; used 1 times
wakedelta defined in line 47; used 1 times

Defined struct's

descr defined in line 42; never used

Defined macros

DEFNAME defined in line 31; used 1 times
  • in line 79
DEFSIZE defined in line 32; used 1 times
  • in line 80
DEFUSER defined in line 33; used 1 times
RECSIZ defined in line 28; used 3 times
RETRY_RLK defined in line 26; used 1 times
SLEEP_RLK defined in line 27; used 1 times
  • in line 47
UAF$S_PWD defined in line 40; used 2 times
UAF$S_USERNAME defined in line 39; used 4 times
UAF$_INVPWD defined in line 37; used 1 times
UAF$_INVUSR defined in line 36; used 2 times
UAF$_NORMAL defined in line 35; used 1 times
UAFNAME defined in line 29; used 1 times
  • in line 77
UAFSIZE defined in line 30; used 1 times
  • in line 78
Last modified: 1986-01-11
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 531
Valid CSS Valid XHTML 1.0 Strict