From: arnej@imf.unit.no (Arne Henrik Juul)
Subject: X11R5 for DEC OSF/1 V1.0 [LONG]
Followup-To: comp.unix.osf.osf1
Organization: Norwegian Institute of Technology
Date: 9 Nov 92 00:55:19



(NOTE crossposting and follow-up!)


I have finished my diffs (and tested them, too!) for compiling
X11R5 patchlevel 17 on the DECstation 3100 / DEC OSF/1 V1.0 platform.

Preliminaries:

You need GCC, 2.3.1 preferred. This compiles out-of-the-box configured
for "mips-dec-osf1".

You need the MIT distribution of X11R5, with patches 1-17 applied.

The system include file /usr/include/sys/shm.h has a small error,
which cause the demo program x11perf to fail. A patch is included
that you might want to apply. I made a local version in the gcc
include directory (.../lib/gcc-lib/mips-dec-osf1/2.3.1/include/sys)
and made my changes there.

After you apply these patches, you will probably want to edit site.h
to suit your local conventions. We prefer to install all of X under
/local, with binaries in /local/bin (together with gcc, emacs, etc).
Also you might want to change the value of InstallXdmConfig, etc.

Patches are also available via anonymous FTP to flipper.pvv.unit.no,
directory /pub/decosf/X11R5.

These patches are of course offered on a 'works for me' basis,
but feel free to mail me if you have any problems with them.

   --  Arne H. Juul,   arnej@lise.unit.no


PATCH for /usr/include/sys/shm.h:

*** shm.h.orig	Sun Nov  8 18:27:09 1992
--- shm.h	Sun Nov  8 18:28:47 1992
***************
*** 143,157 ****
  		shmmni,		/* number of shared memory identifiers */
  		shmseg;		/* max attached shared memory segments per process */
  };
  #endif /* _KERNEL */
  
  #endif /* _OSF_SOURCE */
  
- extern struct shmid_internal shmem[];
- extern struct shminfo shminfo;
- 
  #endif /* _SYS_SHM_H_ */
- 
- 
- 
- 
--- 143,152 ----
  		shmmni,		/* number of shared memory identifiers */
  		shmseg;		/* max attached shared memory segments per process */
  };
+ extern struct shmid_internal shmem[];
+ extern struct shminfo shminfo;
  #endif /* _KERNEL */
  
  #endif /* _OSF_SOURCE */
  
  #endif /* _SYS_SHM_H_ */


PATCH for X11R5 patchlevel 17:

diff -rcN X11R5/mit/clients/xconsole/xconsole.c mit/clients/xconsole/xconsole.c
*** X11R5/mit/clients/xconsole/xconsole.c	Thu Jul 25 19:24:34 1991
--- mit/clients/xconsole/xconsole.c	Fri Nov  6 21:47:05 1992
***************
*** 105,111 ****
      {"-exitOnFail", "*exitOnFail",	XrmoptionNoArg,	    "TRUE"},
  };
  
! #ifdef ultrix
  #define USE_FILE
  #define FILE_NAME   "/dev/xcons"
  #endif
--- 105,111 ----
      {"-exitOnFail", "*exitOnFail",	XrmoptionNoArg,	    "TRUE"},
  };
  
! #if defined(ultrix) || (defined(__osf__) && defined(MIPSEL))
  #define USE_FILE
  #define FILE_NAME   "/dev/xcons"
  #endif
diff -rcN X11R5/mit/clients/xload/get_load.c mit/clients/xload/get_load.c
*** X11R5/mit/clients/xload/get_load.c	Thu Jul 25 19:21:17 1991
--- mit/clients/xload/get_load.c	Fri Nov  6 23:39:33 1992
***************
*** 56,62 ****
  #    endif /* i386 */
  #endif
  
! #if defined(umips) || (defined(ultrix) && defined(mips))
  #include <sys/fixpoint.h>
  #endif
  
--- 56,62 ----
  #    endif /* i386 */
  #endif
  
! #if defined(umips) || (defined(ultrix) && defined(mips) && !defined(__osf__))
  #include <sys/fixpoint.h>
  #endif
  
***************
*** 561,567 ****
  	(void) lseek(kmem, loadavg_seek, 0);
  #endif
  
! #if defined(sun) || defined (UTEK) || defined(sequent) || defined(alliant) || defined(SVR4) || defined(sgi) || defined(hcx)
  	{
  		long temp;
  		(void) read(kmem, (char *)&temp, sizeof(long));
--- 561,570 ----
  	(void) lseek(kmem, loadavg_seek, 0);
  #endif
  
! #if defined(sun) || defined (UTEK) || defined(sequent) || defined(alliant) || defined(SVR4) || defined(sgi) || defined(hcx) || defined(__osf__)
! #ifndef FSCALE
! #define FSCALE 256.0
! #endif
  	{
  		long temp;
  		(void) read(kmem, (char *)&temp, sizeof(long));
diff -rcN X11R5/mit/clients/xterm/main.c mit/clients/xterm/main.c
*** X11R5/mit/clients/xterm/main.c	Mon May  4 14:43:01 1992
--- mit/clients/xterm/main.c	Fri Nov  6 23:38:18 1992
***************
*** 66,71 ****
--- 66,75 ----
  #define ATT
  #define USE_TERMIOS
  #endif
+ 
+ #ifdef __osf__
+ #define USE_SYSV_UTMP
+ #endif
    
  #ifdef SYSV386
  #define USE_SYSV_UTMP
***************
*** 192,203 ****
--- 196,214 ----
  #endif
  
  #ifndef UTMP_FILENAME
+ #ifdef UTMP_FILE
+ #define UTMP_FILENAME UTMP_FILE
+ #else
  #define UTMP_FILENAME "/etc/utmp"
  #endif
+ #endif
  #ifndef LASTLOG_FILENAME
  #define LASTLOG_FILENAME "/usr/adm/lastlog"  /* only on BSD systems */
  #endif
  #ifndef WTMP_FILENAME
+ #ifdef WTMP_FILE
+ #define WTMP_FILENAME WTMP_FILE
+ #else
  #if defined(SYSV)
  #define WTMP_FILENAME "/etc/wtmp"
  #else
***************
*** 204,209 ****
--- 215,221 ----
  #define WTMP_FILENAME "/usr/adm/wtmp"
  #endif
  #endif
+ #endif
  
  #include <signal.h>
  
***************
*** 357,363 ****
  extern struct utmp *getutent();
  extern struct utmp *getutid();
  extern struct utmp *getutline();
! extern void pututline();
  extern void setutent();
  extern void endutent();
  extern void utmpname();
--- 369,375 ----
  extern struct utmp *getutent();
  extern struct utmp *getutid();
  extern struct utmp *getutline();
! /* extern void pututline(); */ /* Include file incorrect in DEC OSF/1 V1.0 */
  extern void setutent();
  extern void endutent();
  extern void utmpname();
***************
*** 1758,1767 ****
  #endif
  #ifdef USE_SYSV_TERMIO
  		char numbuf[12];
  #if defined(UTMP) && defined(USE_SYSV_UTMP)
  		char *ptyname;
  #endif
- #endif	/* USE_SYSV_TERMIO */
  
  #ifdef USE_USG_PTYS
  #if defined(SYSV) && defined(SYSV386)
--- 1770,1779 ----
  #endif
  #ifdef USE_SYSV_TERMIO
  		char numbuf[12];
+ #endif	/* USE_SYSV_TERMIO */
  #if defined(UTMP) && defined(USE_SYSV_UTMP)
  		char *ptyname;
  #endif
  
  #ifdef USE_USG_PTYS
  #if defined(SYSV) && defined(SYSV386)
diff -rcN X11R5/mit/config/Imake.tmpl mit/config/Imake.tmpl
*** X11R5/mit/config/Imake.tmpl	Mon Nov 25 21:44:55 1991
--- mit/config/Imake.tmpl	Fri Nov  6 00:06:42 1992
***************
*** 63,68 ****
--- 63,74 ----
  #define VaxArchitecture
  #endif
  
+ #ifdef __osf__
+ #define MacroIncludeFile <osf1.cf>
+ #define MacroFile osf1.cf
+ #define OSFArchitecture
+ #endif
+ 
  #ifdef sun
  #define MacroIncludeFile <sun.cf>
  #define MacroFile sun.cf
diff -rcN X11R5/mit/config/imakemdep.h mit/config/imakemdep.h
*** X11R5/mit/config/imakemdep.h	Sun Aug 25 20:39:59 1991
--- mit/config/imakemdep.h	Fri Nov  6 00:13:51 1992
***************
*** 156,161 ****
--- 156,164 ----
  #ifdef unix
  	"-Uunix",	/* remove unix symbol so that filename unix.c okay */
  #endif
+ #ifdef __osf__
+ 	"-D__osf__",
+ #endif
  #ifdef M4330
  	"-DM4330",	/* Tektronix */
  #endif
***************
*** 268,273 ****
--- 271,279 ----
  #endif
  #ifdef sun
  	{"sun", "1"},
+ #endif
+ #ifdef __osf__
+ 	{"__osf__", "1"},
  #endif
  #ifdef hpux
  	{"hpux", "1"},
diff -rcN X11R5/mit/config/noop.rules mit/config/noop.rules
*** X11R5/mit/config/noop.rules	Sat Feb 23 18:22:13 1991
--- mit/config/noop.rules	Fri Nov  6 00:48:03 1992
***************
*** 0 ****
--- 1 ----
+ 
diff -rcN X11R5/mit/config/osf1.cf mit/config/osf1.cf
*** X11R5/mit/config/osf1.cf
--- mit/config/osf1.cf	Fri Nov  6 22:18:25 1992
***************
*** 0 ****
--- 1,29 ----
+ /*
+  * SET VERSION NUMBERS BEFORE MAKING MAKEFILES
+  */
+ 
+ #define OSName            OSF1
+ #define OSMajorVersion    1
+ #define OSMinorVersion    0
+ #define SystemV NO
+ #define HasVoidSignalReturn YES
+ #define HasPutenv YES
+ #define HasBsearch YES
+ #define Malloc0ReturnsNull YES
+ 
+ #undef ExtensionDefines
+ #define ExtensionDefines -DSHAPE -DMITSHM -DMULTIBUFFER -DMITMISC
+ #define HasShm YES
+ 
+ #define	BootstrapCFlags -D_BSD -D__osf__ -Dmips -DMIPSEL
+ 
+ #define XdecServer YES
+ #define StandardDefines
+ #define DefaultCCOptions -D_BSD -Dmips -DMIPSEL
+ #define ServerDefines StandardDefines ExtensionDefines -DXDMCP
+ 
+ #define CcCmd gcc -ansi
+ #define ImakeCcCmd gcc -ansi
+ 
+ /**/# platform:  DEC OSF/1 V1.0
+ /**/# operating system:  OSName
diff -rcN X11R5/mit/config/site.def mit/config/site.def
*** X11R5/mit/config/site.def	Thu Aug  1 08:29:28 1991
--- mit/config/site.def	Fri Nov  6 22:16:31 1992
***************
*** 25,41 ****
  
  #ifdef BeforeVendorCF
  
- /* #define HasGcc YES */
- 
  #endif /* BeforeVendorCF */
  
  #ifdef AfterVendorCF
  
- /*
  #ifdef ProjectRoot
  #undef ProjectRoot
  #endif
! #define ProjectRoot /usr/X11R5
! */
  
  #endif /* AfterVendorCF */
--- 25,42 ----
  
  #ifdef BeforeVendorCF
  
  #endif /* BeforeVendorCF */
  
  #ifdef AfterVendorCF
  
  #ifdef ProjectRoot
  #undef ProjectRoot
  #endif
! #define ProjectRoot /local
! #define HasXdmAuth YES
! #define BuildPex YES
! #define MotifBC YES
! #define InstallFSConfig YES
! #define	InstallXdmConfig NO
  
  #endif /* AfterVendorCF */
diff -rcN X11R5/mit/extensions/server/shm.c mit/extensions/server/shm.c
*** X11R5/mit/extensions/server/shm.c	Fri Jul 12 14:55:42 1991
--- mit/extensions/server/shm.c	Fri Nov  6 19:34:24 1992
***************
*** 49,58 ****
--- 49,61 ----
      unsigned long size;
  } ShmDescRec, *ShmDescPtr;
  
+ #ifndef __osf__
+ /* OSF/1 has a proper prototype for this function. */
  #if NeedFunctionPrototypes && !defined(ultrix)
  void *shmat(int, void*, int);
  #else
  char *shmat();
+ #endif
  #endif
  static void miShmPutImage(), fbShmPutImage();
  static PixmapPtr fbShmCreatePixmap();
diff -rcN X11R5/mit/lib/Xdmcp/Wraphelp.c mit/lib/Xdmcp/Wraphelp.c
*** X11R5/mit/lib/Xdmcp/Wraphelp.c
--- mit/lib/Xdmcp/Wraphelp.c	Fri Nov  6 07:10:10 1992
***************
*** 0 ****
--- 1,773 ----
+ /*
+  * Wraphelp.c - DES for Xdm authentication.
+  */
+ /* Dennis Ferguson, University of Toronto */
+ #include <X11/Xos.h>
+ #include <X11/X.h>
+ #include <X11/Xmd.h>
+ #include <X11/Xdmcp.h>
+ 
+ /*
+  * This is a concatentation of several files from an existing library.
+  * Please ignore funny sounding comments.
+  */
+ #include "Wrap.h"
+ 
+ /*
+  * Include the following declaration in any code which uses the
+  * DES_SP_ENCRYPT_ROUND() and DES_SP_DECRYPT_ROUND() macros below.
+  * This may be declared const if you wish, as long as you change the
+  * declaration in des_table.c as well.
+  *
+  * extern unsigned long _Auth_SP_Table[8][64];
+  */
+ 
+ /*
+  * Use standard shortform to reference the table to save typing
+  */
+ #define	SP	_Auth_SP_Table
+ 
+ /*
+  * Code to do a DES round using the tables.  Note that the E expansion
+  * is easy to compute algorithmically, especially if done out-of-order.
+  * Take a look at its form and compare it to everything involving temp
+  * below.
+  *
+  * Be careful when comparing the results of the inner DES loop to other
+  * implementations.  To save a rotation inside the loop, "left" and "right"
+  * are kept rotated 11 bits to the right (i.e. by ((x) >> 11) | (x) << 21).
+  * The SP table is similarly rotated to maintain this.  We make it the
+  * responsibility of the IP code to do the initial rotation, and the FP
+  * code to undo it, as integrating this can save an instruction or so.
+  * In any event, if you want to do a step-by-step comparison of the results
+  * with another DES implementation you will need to rotate the intermediate
+  * results 11 bits to the left to make them match the standard.
+  *
+  * Note too that the SP table has been reordered to match the order of
+  * the keys (if the original order of SP was 12345678, the reordered
+  * table is 71354682).  This is unnecessary, but was done since some
+  * compilers seem to like you going through the matrix from beginning
+  * to end.
+  *
+  * There is a difference in the best way to do this depending on whether
+  * one is encrypting or decrypting.  If encrypting we move forward through
+  * the keys and hence should move forward through the table.  If decrypting
+  * we go back.  Part of the need for this comes from trying to emulate
+  * existing software which generates a single key schedule and uses it
+  * both for encrypting and decrypting.  Generating separate encryption
+  * and decryption key schedules would allow one to use the same code
+  * for both.
+  *
+  * left, right and temp should be unsigned long values.  left and right
+  * should be the high and low order parts of the cipher block at the
+  * current stage of processing (this makes sense if you read the spec).
+  * kp should be an unsigned long pointer which points at the current
+  * set of subkeys in the key schedule.  It is advanced to the next set
+  * (i.e. by 8 bytes) when this is done.
+  *
+  * This occurs in the innermost loop of the DES function.  The four
+  * variables should really be in registers.
+  *
+  * When using this, the inner loop of the DES function might look like:
+  *
+  *	for (i = 0; i < 8; i++) {
+  *		DES_SP_{EN,DE}CRYPT_ROUND(left, right, temp, kp);
+  *		DES_SP_{EN,DE}CRYPT_ROUND(right, left, temp, kp);
+  *	}
+  *
+  * Note the trick above.  You are supposed to do 16 rounds, swapping
+  * left and right at the end of each round.  By doing two rounds at
+  * a time and swapping left and right in the code we can avoid the
+  * swaps altogether.
+  */
+ #define	DES_SP_ENCRYPT_ROUND(left, right, temp, kp) \
+ 	(temp) = (right) ^ *(kp)++; \
+ 	(left) ^= SP[0][((temp) >> 24) & 0x3f] \
+ 		| SP[1][((temp) >> 16) & 0x3f] \
+ 		| SP[2][((temp) >>  8) & 0x3f] \
+ 		| SP[3][((temp)      ) & 0x3f]; \
+ 	(temp) = (((right) >> 12) | ((right) << 20)) ^ *(kp)++; \
+ 	(left) ^= SP[4][((temp) >> 24) & 0x3f] \
+ 		| SP[5][((temp) >> 16) & 0x3f] \
+ 		| SP[6][((temp) >>  8) & 0x3f] \
+ 		| SP[7][((temp)      ) & 0x3f]
+ 
+ #define	DES_SP_DECRYPT_ROUND(left, right, temp, kp) \
+ 	(temp) = (((right) >> 12) | ((right) << 20)) ^ *(--(kp)); \
+ 	(left) ^= SP[7][((temp)      ) & 0x3f] \
+ 		| SP[6][((temp) >>  8) & 0x3f] \
+ 		| SP[5][((temp) >> 16) & 0x3f] \
+ 		| SP[4][((temp) >> 24) & 0x3f]; \
+ 	(temp) = (right) ^ *(--(kp)); \
+ 	(left) ^= SP[3][((temp)      ) & 0x3f] \
+ 		| SP[2][((temp) >>  8) & 0x3f] \
+ 		| SP[1][((temp) >> 16) & 0x3f] \
+ 		| SP[0][((temp) >> 24) & 0x3f]
+ 
+ 
+ /*
+  * The following implements the initial permutation, followed by
+  * an 11 bit right rotation of both halves to keep the inner loop
+  * happy.  This sequence was shown to me by Richard Outerbridge.
+  */
+ #define	DES_INITIAL_PERM(left, right, temp) \
+ 	(temp) = (((left) >> 4) ^ right) & 0x0f0f0f0f; \
+ 	(right) ^= (temp); \
+ 	(left) ^= (temp) << 4; \
+ 	(temp) = (((left) >> 16) ^ (right)) & 0x0000ffff; \
+ 	(right) ^= (temp); \
+ 	(left) ^= (temp) << 16; \
+ 	(temp) = (((right) >> 2) ^ (left)) & 0x33333333; \
+ 	(left) ^= (temp); \
+ 	(right) ^= ((temp) << 2); \
+ 	(temp) = (((right) >> 8) ^ (left)) & 0x00ff00ff; \
+ 	(left) ^= (temp); \
+ 	(right) ^= (temp) << 8; \
+ 	(temp) = (((left) >> 1) ^ (right)) & 0x55555555; \
+ 	(right) ^= (temp); \
+ 	(left) ^= ((temp) << 1); \
+ 	(left) = (((left) >> 11) | ((left) << 21)); \
+ 	(right) = (((right) >> 11) | ((right) << 21))
+ 
+ 
+ /*
+  * Here is the final permutation, which is simply the inverse of
+  * the initial permuation.  Note that there is a tiny trick here.
+  * We are supposed to swap left and right before doing the final
+  * permutation.  We instead do the swap in the first five lines
+  * below (compare to the last five lines above), for free.
+  */
+ #define DES_FINAL_PERM(left, right, temp) \
+ 	(temp) = (((left) << 11) | ((left) >> 21)); \
+ 	(left) = (((right) << 11) | ((right) >> 21)); \
+ 	(right) = (((left) >> 1) ^ (temp)) & 0x55555555; \
+ 	(left) ^= (right) << 1; \
+ 	(right) ^= (temp); \
+ 	(temp) = (((right) >> 8) ^ (left)) & 0x00ff00ff; \
+ 	(left) ^= (temp); \
+ 	(right) ^= (temp) << 8; \
+ 	(temp) = (((right) >> 2) ^ (left)) & 0x33333333; \
+ 	(left) ^= (temp); \
+ 	(right) ^= ((temp) << 2); \
+ 	(temp) = (((left) >> 16) ^ (right)) & 0x0000ffff; \
+ 	(right) ^= (temp); \
+ 	(left) ^= (temp) << 16; \
+ 	(temp) = (((left) >> 4) ^ right) & 0x0f0f0f0f; \
+ 	(right) ^= (temp); \
+ 	(left) ^= ((temp) << 4)
+ 
+ /*
+  * Finally, as a sample of how all this might be held together, the
+  * following two macros do in-place encryptions and decryptions.  left
+  * and right are two unsigned long variables which at the beginning
+  * are expected to hold the clear (encrypted) block in host byte order
+  * (left the high order four bytes, right the low order).  At the end
+  * they will contain the encrypted (clear) block.  temp is an unsigned long
+  * used as a temporary.  kp is an unsigned long pointer pointing at
+  * the start of the key schedule.  All these should be in registers.
+  *
+  * You can probably sometimes do better than these by rewriting for
+  * particular situations.  These aren't bad, though.
+  */
+ #define	DES_DO_ENCRYPT(left, right, temp, kp) \
+ 	do { \
+ 		register int i; \
+ 		DES_INITIAL_PERM((left), (right), (temp)); \
+ 		for (i = 0; i < 8; i++) { \
+ 			DES_SP_ENCRYPT_ROUND((left), (right), (temp), (kp)); \
+ 			DES_SP_ENCRYPT_ROUND((right), (left), (temp), (kp)); \
+ 		} \
+ 		DES_FINAL_PERM((left), (right), (temp)); \
+ 		(kp) -= (2 * 16); \
+ 	} while (0)
+ 
+ #define	DES_DO_DECRYPT(left, right, temp, kp) \
+ 	do { \
+ 		register int i; \
+ 		DES_INITIAL_PERM((left), (right), (temp)); \
+ 		(kp) += (2 * 16); \
+ 		for (i = 0; i < 8; i++) { \
+ 			DES_SP_DECRYPT_ROUND((left), (right), (temp), (kp)); \
+ 			DES_SP_DECRYPT_ROUND((right), (left), (temp), (kp)); \
+ 		} \
+ 		DES_FINAL_PERM((left), (right), (temp)); \
+ 	} while (0)
+ 
+ /*
+  * These are handy dandy utility thingies for straightening out bytes.
+  * Included here because they're used a couple of places.
+  */
+ #define	GET_HALF_BLOCK(lr, ip) \
+ 	(lr) = ((unsigned long)(*(ip)++)) << 24; \
+ 	(lr) |= ((unsigned long)(*(ip)++)) << 16; \
+ 	(lr) |= ((unsigned long)(*(ip)++)) << 8; \
+ 	(lr) |= (unsigned long)(*(ip)++)
+ 
+ #define	PUT_HALF_BLOCK(lr, op) \
+ 	*(op)++ = ((lr) >> 24) & 0xff; \
+ 	*(op)++ = ((lr) >> 16) & 0xff; \
+ 	*(op)++ = ((lr) >> 8) & 0xff; \
+ 	*(op)++ = (lr) & 0xff
+ 
+ 
+ /*
+  * These tables may be declared const if you want.  Many compilers
+  * don't support this, though.
+  */
+ 
+ /*
+  * The DES algorithm which uses these is intended to be fairly speedy
+  * at the expense of some memory.  All the standard hacks are used.
+  * The S boxes and the P permutation are precomputed into one table.
+  * The E box never actually appears explicitly since it is easy to apply
+  * this algorithmically as needed.  This should run pretty fast on machines
+  * with 32 bit words and bit field/multiple bit shift instructions which
+  * are fast.
+  *
+  * [There used to be tables used to do the initial and final permutations
+  *  here.  These were deleted in favour of algorithmic code (table-free). ]
+  */
+ 
+ /*
+  * The SP table is actually the S boxes and the P permutation
+  * table combined.  This table is actually reordered from the
+  * spec, to match the order of key application we follow.  Each
+  * entry has also been rotated right by 11 bits, to remove a
+  * rotation from the inner loop.
+  */
+ static unsigned long _Auth_SP_Table[8][64] = {
+ 	0x00000200, 0x00204200, 0x80204000, 0x00000000,	/* 7 */
+ 	0x80000000, 0x80204000, 0x80200200, 0x80004200,
+ 	0x80204200, 0x00000200, 0x00000000, 0x00204000,
+ 	0x00200000, 0x00004000, 0x00204200, 0x80200000,
+ 	0x80004000, 0x80200200, 0x00200200, 0x80004000,
+ 	0x00204000, 0x00004200, 0x80004200, 0x00200200,
+ 	0x00004200, 0x80000000, 0x80200000, 0x80204200,
+ 	0x80000200, 0x00200000, 0x00004000, 0x80000200,
+ 	0x00004000, 0x80000200, 0x00000200, 0x80204000,
+ 	0x80204000, 0x00204200, 0x00204200, 0x00200000,
+ 	0x00200200, 0x00004000, 0x80004000, 0x00000200,
+ 	0x80004200, 0x80200000, 0x80200200, 0x80004200,
+ 	0x80200000, 0x00204000, 0x80204200, 0x00004200,
+ 	0x80000200, 0x00000000, 0x00200000, 0x80204200,
+ 	0x00000000, 0x80200200, 0x00004200, 0x80000000,
+ 	0x00204000, 0x80004000, 0x80000000, 0x00200200,
+ 
+ 	0x40001010, 0x00000000, 0x00000010, 0x40401010,	/* 1 */
+ 	0x00401010, 0x40400010, 0x00400000, 0x00000010,
+ 	0x40000000, 0x40001010, 0x40401010, 0x40000000,
+ 	0x40401000, 0x00401010, 0x00001000, 0x00400000,
+ 	0x40400000, 0x40001000, 0x40001000, 0x40000010,
+ 	0x40000010, 0x00001010, 0x00001010, 0x40401000,
+ 	0x00400010, 0x00401000, 0x00401000, 0x00400010,
+ 	0x00000000, 0x40400000, 0x40400010, 0x00001000,
+ 	0x00000010, 0x40401010, 0x00400000, 0x00001010,
+ 	0x40001010, 0x00001000, 0x00001000, 0x40000000,
+ 	0x00401010, 0x00000010, 0x40000010, 0x00401000,
+ 	0x40000000, 0x00400000, 0x40401000, 0x40400010,
+ 	0x40401010, 0x00400010, 0x00001010, 0x40401000,
+ 	0x00401000, 0x40400000, 0x40400010, 0x40001010,
+ 	0x40400000, 0x40001000, 0x40001000, 0x00000000,
+ 	0x00400010, 0x40000010, 0x00000000, 0x00401010,
+ 
+ 	0x20800000, 0x20008020, 0x00000000, 0x00808020,	/* 3 */
+ 	0x20008000, 0x00000000, 0x20800020, 0x20008000,
+ 	0x00800020, 0x00808000, 0x00808000, 0x00000020,
+ 	0x20808020, 0x00800020, 0x00008020, 0x20800000,
+ 	0x00008000, 0x00800000, 0x20008020, 0x20000000,
+ 	0x20000020, 0x00008020, 0x00808020, 0x20800020,
+ 	0x20808000, 0x20000020, 0x00000020, 0x20808000,
+ 	0x00800000, 0x20808020, 0x20000000, 0x00008000,
+ 	0x20008020, 0x00008000, 0x00800020, 0x20800000,
+ 	0x00000020, 0x20008020, 0x20008000, 0x00000000,
+ 	0x20000000, 0x00800020, 0x20808020, 0x20008000,
+ 	0x00808000, 0x20000000, 0x00000000, 0x00808020,
+ 	0x20808000, 0x00000020, 0x00008000, 0x20808020,
+ 	0x00800000, 0x20800020, 0x20000020, 0x00808000,
+ 	0x00008020, 0x20808000, 0x20800000, 0x00008020,
+ 	0x20800020, 0x00800000, 0x00808020, 0x20000020,
+ 
+ 	0x10000000, 0x10002080, 0x00002080, 0x10042000,	/* 5 */
+ 	0x00000080, 0x10000000, 0x00040000, 0x00002080,
+ 	0x10040080, 0x00000080, 0x10002000, 0x10040080,
+ 	0x10042000, 0x00042080, 0x10000080, 0x00040000,
+ 	0x00002000, 0x00040080, 0x00040080, 0x00000000,
+ 	0x10040000, 0x10042080, 0x10042080, 0x10002000,
+ 	0x00042080, 0x10040000, 0x00000000, 0x00042000,
+ 	0x10002080, 0x00002000, 0x00042000, 0x10000080,
+ 	0x00000080, 0x10042000, 0x10000000, 0x00002000,
+ 	0x00040000, 0x00002080, 0x10042000, 0x10040080,
+ 	0x10002000, 0x00040000, 0x00042080, 0x10002080,
+ 	0x10040080, 0x10000000, 0x00002000, 0x00042080,
+ 	0x10042080, 0x10000080, 0x00042000, 0x10042080,
+ 	0x00002080, 0x00000000, 0x00040080, 0x00042000,
+ 	0x10000080, 0x10002000, 0x10040000, 0x00000080,
+ 	0x00000000, 0x00040080, 0x10002080, 0x10040000,
+ 
+ 	0x00100802, 0x08100002, 0x08100002, 0x08000000,	/* 4 */
+ 	0x08000802, 0x08100800, 0x00100800, 0x00100002,
+ 	0x00000000, 0x00000802, 0x00000802, 0x08100802,
+ 	0x08100000, 0x00000000, 0x08000800, 0x00100800,
+ 	0x00100000, 0x00000002, 0x00000800, 0x00100802,
+ 	0x08000000, 0x00000800, 0x00100002, 0x08000002,
+ 	0x08100800, 0x00100000, 0x08000002, 0x08000800,
+ 	0x00000002, 0x08000802, 0x08100802, 0x08100000,
+ 	0x08000800, 0x00100800, 0x00000802, 0x08100802,
+ 	0x08100000, 0x00000000, 0x00000000, 0x00000802,
+ 	0x08000002, 0x08000800, 0x08100800, 0x00100000,
+ 	0x00100802, 0x08100002, 0x08100002, 0x08000000,
+ 	0x08100802, 0x08100000, 0x00100000, 0x00000002,
+ 	0x00100800, 0x00100002, 0x08000802, 0x08100800,
+ 	0x00100002, 0x08000002, 0x00000800, 0x00100802,
+ 	0x08000000, 0x00000800, 0x00000002, 0x08000802,
+ 
+ 	0x01020000, 0x00020400, 0x00000004, 0x01020404,	/* 6 */
+ 	0x00020400, 0x01000000, 0x01020404, 0x00000400,
+ 	0x00020004, 0x01000404, 0x00000400, 0x01020000,
+ 	0x01000400, 0x00020004, 0x00020000, 0x01000004,
+ 	0x00000000, 0x01000400, 0x01020004, 0x00000004,
+ 	0x00000404, 0x01020004, 0x01000000, 0x01020400,
+ 	0x01020400, 0x00000000, 0x01000404, 0x00020404,
+ 	0x01000004, 0x00000404, 0x00020404, 0x00020000,
+ 	0x00020004, 0x01000000, 0x01020400, 0x00000404,
+ 	0x01020404, 0x00000400, 0x01000004, 0x01020000,
+ 	0x00000400, 0x00020004, 0x00020000, 0x01000004,
+ 	0x01020000, 0x01020404, 0x00000404, 0x00020400,
+ 	0x01000404, 0x00020404, 0x00000000, 0x01020400,
+ 	0x01000000, 0x00000004, 0x00020400, 0x01000404,
+ 	0x00000004, 0x01000400, 0x01020004, 0x00000000,
+ 	0x00020404, 0x00020000, 0x01000400, 0x01020004,
+ 
+ 	0x04010001, 0x00000001, 0x00000040, 0x04010041,	/* 8 */
+ 	0x00010000, 0x04010001, 0x04000000, 0x00010000,
+ 	0x04000040, 0x00010040, 0x04010041, 0x00000041,
+ 	0x00010041, 0x04000041, 0x00000001, 0x04000000,
+ 	0x00010040, 0x04010000, 0x00010001, 0x04000001,
+ 	0x00000041, 0x04000040, 0x04010040, 0x00010041,
+ 	0x04000001, 0x00000000, 0x00000000, 0x04010040,
+ 	0x04010000, 0x00010001, 0x04000041, 0x00000040,
+ 	0x04000041, 0x00000040, 0x00010041, 0x00000001,
+ 	0x04000000, 0x04010040, 0x00000001, 0x04000041,
+ 	0x00010001, 0x04000000, 0x04010000, 0x00010040,
+ 	0x04010040, 0x00010000, 0x00000040, 0x04010001,
+ 	0x00000000, 0x04010041, 0x04000040, 0x04010000,
+ 	0x00010040, 0x00010001, 0x04010001, 0x00000000,
+ 	0x04010041, 0x00000041, 0x00000041, 0x04000001,
+ 	0x04000001, 0x04000040, 0x00010000, 0x00010041,
+ 
+ 	0x02080108, 0x00080008, 0x00000008, 0x02000108,	/* 2 */
+ 	0x00000100, 0x02000000, 0x02080100, 0x02080008,
+ 	0x02080000, 0x02080108, 0x00080108, 0x00080000,
+ 	0x00080008, 0x00000100, 0x02000000, 0x02080100,
+ 	0x00000108, 0x02000100, 0x02080008, 0x00000000,
+ 	0x00080000, 0x00000008, 0x02000108, 0x00080100,
+ 	0x02000100, 0x02080000, 0x00000000, 0x00000108,
+ 	0x02000008, 0x00080108, 0x00080100, 0x02000008,
+ 	0x00000000, 0x02000108, 0x02080100, 0x00000100,
+ 	0x02080008, 0x00080100, 0x00080108, 0x00000008,
+ 	0x00080100, 0x00080008, 0x02000000, 0x02080108,
+ 	0x02000108, 0x02000000, 0x00000008, 0x00080000,
+ 	0x02000008, 0x00080108, 0x00000100, 0x02080000,
+ 	0x02000100, 0x02080008, 0x02080000, 0x02000100,
+ 	0x00000108, 0x00000000, 0x00080008, 0x02000008,
+ 	0x00080000, 0x02080100, 0x02080108, 0x00000108
+ };
+ 
+ 
+ /*
+  * XdmcpAuthDoIt - {en,de}crypt a block in ECB mode
+  */
+ void
+ _XdmcpAuthDoIt(in, out, schedule, encrypt)
+ 	auth_cblock *in;
+ 	auth_cblock *out;
+ 	auth_wrapper_schedule schedule;
+ 	int encrypt;
+ {
+ 	register unsigned long left, right;
+ 	register unsigned long temp;
+ 	register int i;
+ 
+ 	{
+ 		/*
+ 		 * Need a temporary for copying the data in
+ 		 */
+ 		register unsigned char *datap;
+ 
+ 		/*
+ 		 * Copy the input block into the registers
+ 		 */
+ 		datap = (unsigned char *)in;
+ 		GET_HALF_BLOCK(left, datap);
+ 		GET_HALF_BLOCK(right, datap);
+ 	}
+ 
+ 	/*
+ 	 * Do the initial permutation.
+ 	 */
+ 	DES_INITIAL_PERM(left, right, temp);
+ 
+ 	/*
+ 	 * Now the rounds.  Use different code depending on whether it
+ 	 * is an encryption or a decryption (gross, should keep both
+ 	 * sets of keys in the key schedule instead).
+ 	 */
+ 	if (encrypt) {
+ 		register unsigned long *kp;
+ 
+ 		kp = (unsigned long *)schedule;
+ 		for (i = 0; i < 8; i++) {
+ 			DES_SP_ENCRYPT_ROUND(left, right, temp, kp);
+ 			DES_SP_ENCRYPT_ROUND(right, left, temp, kp);
+ 		}
+ 	} else {
+ 		register unsigned long *kp;
+ 
+ 		/*
+ 		 * Point kp past end of schedule
+ 		 */
+ 		kp = ((unsigned long *)schedule) + (2 * 16);;
+ 		for (i = 0; i < 8; i++) {
+ 			DES_SP_DECRYPT_ROUND(left, right, temp, kp);
+ 			DES_SP_DECRYPT_ROUND(right, left, temp, kp);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Do the final permutation
+ 	 */
+ 	DES_FINAL_PERM(left, right, temp);
+ 
+ 	/*
+ 	 * Finally, copy the result out a byte at a time
+ 	 */
+ 	{
+ 		register unsigned char *datap;
+ 
+ 		datap = (unsigned char *)out;
+ 		PUT_HALF_BLOCK(left, datap);
+ 		PUT_HALF_BLOCK(right, datap);
+ 	}
+ }
+ 
+ 
+ /*
+  * Permuted choice 1 tables.  These are used to extract bits
+  * from the left and right parts of the key to form Ci and Di.
+  * The code that uses these tables knows which bits from which
+  * part of each key are used to form Ci and Di.
+  */
+ static unsigned long PC1_CL[8] = {
+     0x00000000, 0x00000010, 0x00001000, 0x00001010,
+     0x00100000, 0x00100010, 0x00101000, 0x00101010
+ };
+ 
+ static unsigned long PC1_DL[16] = {
+     0x00000000, 0x00100000, 0x00001000, 0x00101000,
+     0x00000010, 0x00100010, 0x00001010, 0x00101010,
+     0x00000001, 0x00100001, 0x00001001, 0x00101001,
+     0x00000011, 0x00100011, 0x00001011, 0x00101011
+ };
+ 
+ static unsigned long PC1_CR[16] = {
+     0x00000000, 0x00000001, 0x00000100, 0x00000101,
+     0x00010000, 0x00010001, 0x00010100, 0x00010101,
+     0x01000000, 0x01000001, 0x01000100, 0x01000101,
+     0x01010000, 0x01010001, 0x01010100, 0x01010101
+ };
+ 
+ static unsigned long PC1_DR[8] = {
+     0x00000000, 0x01000000, 0x00010000, 0x01010000,
+     0x00000100, 0x01000100, 0x00010100, 0x01010100
+ };
+ 
+ 
+ /*
+  * At the start of some iterations of the key schedule we do
+  * a circular left shift by one place, while for others we do a shift by
+  * two places.  This has bits set for the iterations where we do 2 bit
+  * shifts, starting at the low order bit.
+  */
+ #define	TWO_BIT_SHIFTS	0x7efc
+ 
+ /*
+  * Permuted choice 2 tables.  The first actually produces the low order
+  * 24 bits of the subkey Ki from the 28 bit value of Ci.  The second produces
+  * the high order 24 bits from Di.  The tables are indexed by six bit
+  * segments of Ci and Di respectively.  The code is handcrafted to compute
+  * the appropriate 6 bit chunks.
+  *
+  * Note that for ease of computation, the 24 bit values are produced with
+  * six bits going into each byte.  Note also that the table has been byte
+  * rearranged to produce keys which match the order we will apply them
+  * in in the des code.
+  */
+ static unsigned long PC2_C[4][64] = {
+     0x00000000, 0x00000004, 0x00010000, 0x00010004,
+     0x00000400, 0x00000404, 0x00010400, 0x00010404,
+     0x00000020, 0x00000024, 0x00010020, 0x00010024,
+     0x00000420, 0x00000424, 0x00010420, 0x00010424,
+     0x01000000, 0x01000004, 0x01010000, 0x01010004,
+     0x01000400, 0x01000404, 0x01010400, 0x01010404,
+     0x01000020, 0x01000024, 0x01010020, 0x01010024,
+     0x01000420, 0x01000424, 0x01010420, 0x01010424,
+     0x00020000, 0x00020004, 0x00030000, 0x00030004,
+     0x00020400, 0x00020404, 0x00030400, 0x00030404,
+     0x00020020, 0x00020024, 0x00030020, 0x00030024,
+     0x00020420, 0x00020424, 0x00030420, 0x00030424,
+     0x01020000, 0x01020004, 0x01030000, 0x01030004,
+     0x01020400, 0x01020404, 0x01030400, 0x01030404,
+     0x01020020, 0x01020024, 0x01030020, 0x01030024,
+     0x01020420, 0x01020424, 0x01030420, 0x01030424,
+ 
+     0x00000000, 0x02000000, 0x00000800, 0x02000800,
+     0x00080000, 0x02080000, 0x00080800, 0x02080800,
+     0x00000001, 0x02000001, 0x00000801, 0x02000801,
+     0x00080001, 0x02080001, 0x00080801, 0x02080801,
+     0x00000100, 0x02000100, 0x00000900, 0x02000900,
+     0x00080100, 0x02080100, 0x00080900, 0x02080900,
+     0x00000101, 0x02000101, 0x00000901, 0x02000901,
+     0x00080101, 0x02080101, 0x00080901, 0x02080901,
+     0x10000000, 0x12000000, 0x10000800, 0x12000800,
+     0x10080000, 0x12080000, 0x10080800, 0x12080800,
+     0x10000001, 0x12000001, 0x10000801, 0x12000801,
+     0x10080001, 0x12080001, 0x10080801, 0x12080801,
+     0x10000100, 0x12000100, 0x10000900, 0x12000900,
+     0x10080100, 0x12080100, 0x10080900, 0x12080900,
+     0x10000101, 0x12000101, 0x10000901, 0x12000901,
+     0x10080101, 0x12080101, 0x10080901, 0x12080901,
+ 
+     0x00000000, 0x00040000, 0x00002000, 0x00042000,
+     0x00100000, 0x00140000, 0x00102000, 0x00142000,
+     0x20000000, 0x20040000, 0x20002000, 0x20042000,
+     0x20100000, 0x20140000, 0x20102000, 0x20142000,
+     0x00000008, 0x00040008, 0x00002008, 0x00042008,
+     0x00100008, 0x00140008, 0x00102008, 0x00142008,
+     0x20000008, 0x20040008, 0x20002008, 0x20042008,
+     0x20100008, 0x20140008, 0x20102008, 0x20142008,
+     0x00200000, 0x00240000, 0x00202000, 0x00242000,
+     0x00300000, 0x00340000, 0x00302000, 0x00342000,
+     0x20200000, 0x20240000, 0x20202000, 0x20242000,
+     0x20300000, 0x20340000, 0x20302000, 0x20342000,
+     0x00200008, 0x00240008, 0x00202008, 0x00242008,
+     0x00300008, 0x00340008, 0x00302008, 0x00342008,
+     0x20200008, 0x20240008, 0x20202008, 0x20242008,
+     0x20300008, 0x20340008, 0x20302008, 0x20342008,
+ 
+     0x00000000, 0x00000010, 0x08000000, 0x08000010,
+     0x00000200, 0x00000210, 0x08000200, 0x08000210,
+     0x00000002, 0x00000012, 0x08000002, 0x08000012,
+     0x00000202, 0x00000212, 0x08000202, 0x08000212,
+     0x04000000, 0x04000010, 0x0c000000, 0x0c000010,
+     0x04000200, 0x04000210, 0x0c000200, 0x0c000210,
+     0x04000002, 0x04000012, 0x0c000002, 0x0c000012,
+     0x04000202, 0x04000212, 0x0c000202, 0x0c000212,
+     0x00001000, 0x00001010, 0x08001000, 0x08001010,
+     0x00001200, 0x00001210, 0x08001200, 0x08001210,
+     0x00001002, 0x00001012, 0x08001002, 0x08001012,
+     0x00001202, 0x00001212, 0x08001202, 0x08001212,
+     0x04001000, 0x04001010, 0x0c001000, 0x0c001010,
+     0x04001200, 0x04001210, 0x0c001200, 0x0c001210,
+     0x04001002, 0x04001012, 0x0c001002, 0x0c001012,
+     0x04001202, 0x04001212, 0x0c001202, 0x0c001212
+ };
+ 
+ static unsigned long PC2_D[4][64] = {
+     0x00000000, 0x02000000, 0x00020000, 0x02020000,
+     0x00000100, 0x02000100, 0x00020100, 0x02020100,
+     0x00000008, 0x02000008, 0x00020008, 0x02020008,
+     0x00000108, 0x02000108, 0x00020108, 0x02020108,
+     0x00200000, 0x02200000, 0x00220000, 0x02220000,
+     0x00200100, 0x02200100, 0x00220100, 0x02220100,
+     0x00200008, 0x02200008, 0x00220008, 0x02220008,
+     0x00200108, 0x02200108, 0x00220108, 0x02220108,
+     0x00000200, 0x02000200, 0x00020200, 0x02020200,
+     0x00000300, 0x02000300, 0x00020300, 0x02020300,
+     0x00000208, 0x02000208, 0x00020208, 0x02020208,
+     0x00000308, 0x02000308, 0x00020308, 0x02020308,
+     0x00200200, 0x02200200, 0x00220200, 0x02220200,
+     0x00200300, 0x02200300, 0x00220300, 0x02220300,
+     0x00200208, 0x02200208, 0x00220208, 0x02220208,
+     0x00200308, 0x02200308, 0x00220308, 0x02220308,
+ 
+     0x00000000, 0x00001000, 0x00000020, 0x00001020,
+     0x00100000, 0x00101000, 0x00100020, 0x00101020,
+     0x08000000, 0x08001000, 0x08000020, 0x08001020,
+     0x08100000, 0x08101000, 0x08100020, 0x08101020,
+     0x00000004, 0x00001004, 0x00000024, 0x00001024,
+     0x00100004, 0x00101004, 0x00100024, 0x00101024,
+     0x08000004, 0x08001004, 0x08000024, 0x08001024,
+     0x08100004, 0x08101004, 0x08100024, 0x08101024,
+     0x00000400, 0x00001400, 0x00000420, 0x00001420,
+     0x00100400, 0x00101400, 0x00100420, 0x00101420,
+     0x08000400, 0x08001400, 0x08000420, 0x08001420,
+     0x08100400, 0x08101400, 0x08100420, 0x08101420,
+     0x00000404, 0x00001404, 0x00000424, 0x00001424,
+     0x00100404, 0x00101404, 0x00100424, 0x00101424,
+     0x08000404, 0x08001404, 0x08000424, 0x08001424,
+     0x08100404, 0x08101404, 0x08100424, 0x08101424,
+ 
+     0x00000000, 0x10000000, 0x00010000, 0x10010000,
+     0x00000002, 0x10000002, 0x00010002, 0x10010002,
+     0x00002000, 0x10002000, 0x00012000, 0x10012000,
+     0x00002002, 0x10002002, 0x00012002, 0x10012002,
+     0x00040000, 0x10040000, 0x00050000, 0x10050000,
+     0x00040002, 0x10040002, 0x00050002, 0x10050002,
+     0x00042000, 0x10042000, 0x00052000, 0x10052000,
+     0x00042002, 0x10042002, 0x00052002, 0x10052002,
+     0x20000000, 0x30000000, 0x20010000, 0x30010000,
+     0x20000002, 0x30000002, 0x20010002, 0x30010002,
+     0x20002000, 0x30002000, 0x20012000, 0x30012000,
+     0x20002002, 0x30002002, 0x20012002, 0x30012002,
+     0x20040000, 0x30040000, 0x20050000, 0x30050000,
+     0x20040002, 0x30040002, 0x20050002, 0x30050002,
+     0x20042000, 0x30042000, 0x20052000, 0x30052000,
+     0x20042002, 0x30042002, 0x20052002, 0x30052002,
+ 
+     0x00000000, 0x04000000, 0x00000001, 0x04000001,
+     0x01000000, 0x05000000, 0x01000001, 0x05000001,
+     0x00000010, 0x04000010, 0x00000011, 0x04000011,
+     0x01000010, 0x05000010, 0x01000011, 0x05000011,
+     0x00080000, 0x04080000, 0x00080001, 0x04080001,
+     0x01080000, 0x05080000, 0x01080001, 0x05080001,
+     0x00080010, 0x04080010, 0x00080011, 0x04080011,
+     0x01080010, 0x05080010, 0x01080011, 0x05080011,
+     0x00000800, 0x04000800, 0x00000801, 0x04000801,
+     0x01000800, 0x05000800, 0x01000801, 0x05000801,
+     0x00000810, 0x04000810, 0x00000811, 0x04000811,
+     0x01000810, 0x05000810, 0x01000811, 0x05000811,
+     0x00080800, 0x04080800, 0x00080801, 0x04080801,
+     0x01080800, 0x05080800, 0x01080801, 0x05080801,
+     0x00080810, 0x04080810, 0x00080811, 0x04080811,
+     0x01080810, 0x05080810, 0x01080811, 0x05080811
+ };
+ 
+ 
+ 
+ /*
+  * Permute the key to give us our key schedule.
+  */
+ void
+ _XdmcpAuthSetup(key, schedule)
+     auth_cblock *key;
+     auth_wrapper_schedule schedule;
+ {
+     register unsigned long c, d;
+ 
+     {
+ 	/*
+ 	 * Need a pointer for the keys and a temporary long
+ 	 */
+ 	register unsigned char *k;
+ 	register unsigned long tmp;
+ 
+ 	/*
+ 	 * Fetch the key into something we can work with
+ 	 */
+ 	k = (unsigned char *)key;
+ 
+ 	/*
+ 	 * The first permutted choice gives us the 28 bits for C0 and
+ 	 * 28 for D0.  C0 gets 12 bits from the left key and 16 from
+ 	 * the right, while D0 gets 16 from the left and 12 from the
+ 	 * right.  The code knows which bits go where.
+ 	 */
+ 	tmp = ((unsigned long)(*(k)++)) << 24;
+ 	tmp |= ((unsigned long)(*(k)++)) << 16;
+ 	tmp |= ((unsigned long)(*(k)++)) << 8;
+ 	tmp |= (unsigned long)(*(k)++);		/* left part of key */
+ 	c =  PC1_CL[(tmp >> 29) & 0x7]
+ 	  | (PC1_CL[(tmp >> 21) & 0x7] << 1)
+ 	  | (PC1_CL[(tmp >> 13) & 0x7] << 2)
+ 	  | (PC1_CL[(tmp >>  5) & 0x7] << 3);
+ 	d =  PC1_DL[(tmp >> 25) & 0xf]
+ 	  | (PC1_DL[(tmp >> 17) & 0xf] << 1)
+ 	  | (PC1_DL[(tmp >>  9) & 0xf] << 2)
+ 	  | (PC1_DL[(tmp >>  1) & 0xf] << 3);
+ 
+ 	tmp = ((unsigned long)(*(k)++)) << 24;
+ 	tmp |= ((unsigned long)(*(k)++)) << 16;
+ 	tmp |= ((unsigned long)(*(k)++)) << 8;
+ 	tmp |= (unsigned long)(*(k)++);		/* right part of key */
+ 	c |= PC1_CR[(tmp >> 28) & 0xf]
+ 	  | (PC1_CR[(tmp >> 20) & 0xf] << 1)
+ 	  | (PC1_CR[(tmp >> 12) & 0xf] << 2)
+ 	  | (PC1_CR[(tmp >>  4) & 0xf] << 3);
+ 	d |= PC1_DR[(tmp >> 25) & 0x7]
+ 	  | (PC1_DR[(tmp >> 17) & 0x7] << 1)
+ 	  | (PC1_DR[(tmp >>  9) & 0x7] << 2)
+ 	  | (PC1_DR[(tmp >>  1) & 0x7] << 3);
+     }
+ 
+     {
+ 	/*
+ 	 * Need several temporaries in here
+ 	 */
+ 	register unsigned long ltmp, rtmp;
+ 	register unsigned long *k;
+ 	register int two_bit_shifts;
+ 	register int i;
+ 	/*
+ 	 * Now iterate to compute the key schedule.  Note that we
+ 	 * record the entire set of subkeys in 6 bit chunks since
+ 	 * they are used that way.  At 6 bits/char, we need
+ 	 * 48/6 char's/subkey * 16 subkeys/encryption == 128 bytes.
+ 	 * The schedule must be this big.
+ 	 */
+ 	k = (unsigned long *)schedule;
+ 	two_bit_shifts = TWO_BIT_SHIFTS;
+ 	for (i = 16; i > 0; i--) {
+ 	    /*
+ 	     * Do the rotation.  One bit and two bit rotations
+ 	     * are done separately.  Note C and D are 28 bits.
+ 	     */
+ 	    if (two_bit_shifts & 0x1) {
+ 		c = ((c << 2) & 0xffffffc) | (c >> 26);
+ 		d = ((d << 2) & 0xffffffc) | (d >> 26);
+ 	    } else {
+ 		c = ((c << 1) & 0xffffffe) | (c >> 27);
+ 		d = ((d << 1) & 0xffffffe) | (d >> 27);
+ 	    }
+ 	    two_bit_shifts >>= 1;
+ 
+ 	    /*
+ 	     * Apply permutted choice 2 to C to get the first
+ 	     * 24 bits worth of keys.  Note that bits 9, 18, 22
+ 	     * and 25 (using DES numbering) in C are unused.  The
+ 	     * shift-mask stuff is done to delete these bits from
+ 	     * the indices, since this cuts the table size in half.
+ 	     *
+ 	     * The table is torqued, by the way.  If the standard
+ 	     * byte order for this (high to low order) is 1234,
+ 	     * the table actually gives us 4132.
+ 	     */
+ 	    ltmp = PC2_C[0][((c >> 22) & 0x3f)]
+ 	         | PC2_C[1][((c >> 15) & 0xf) | ((c >> 16) & 0x30)]
+ 	         | PC2_C[2][((c >>  4) & 0x3) | ((c >>  9) & 0x3c)]
+ 	         | PC2_C[3][((c      ) & 0x7) | ((c >>  4) & 0x38)];
+ 	    /*
+ 	     * Apply permutted choice 2 to D to get the other half.
+ 	     * Here, bits 7, 10, 15 and 26 go unused.  The sqeezing
+ 	     * actually turns out to be cheaper here.
+ 	     *
+ 	     * This table is similarly torqued.  If the standard
+ 	     * byte order is 5678, the table has the bytes permuted
+ 	     * to give us 7685.
+ 	     */
+ 	    rtmp = PC2_D[0][((d >> 22) & 0x3f)]
+ 	         | PC2_D[1][((d >> 14) & 0xf) | ((d >> 15) & 0x30)]
+ 	         | PC2_D[2][((d >>  7) & 0x3f)]
+ 	         | PC2_D[3][((d      ) & 0x3) | ((d >>  1) & 0x3c)];
+ 
+ 	    /*
+ 	     * Make up two words of the key schedule, with a
+ 	     * byte order which is convenient for the DES
+ 	     * inner loop.  The high order (first) word will
+ 	     * hold bytes 7135 (high to low order) while the
+ 	     * second holds bytes 4682.
+ 	     */
+ 	    *k++ = (ltmp & 0x00ffff00) | (rtmp & 0xff0000ff);
+ 	    *k++ = (ltmp & 0xff0000ff) | (rtmp & 0x00ffff00);
+ 	}
+     }
+ }
diff -rcN X11R5/mit/server/ddx/dec/cfbpmax/cfbpmax_io.c mit/server/ddx/dec/cfbpmax/cfbpmax_io.c
*** X11R5/mit/server/ddx/dec/cfbpmax/cfbpmax_io.c	Tue Jun 11 01:19:01 1991
--- mit/server/ddx/dec/cfbpmax/cfbpmax_io.c	Fri Nov  6 23:40:17 1992
***************
*** 31,38 ****
--- 31,40 ----
  #include <sys/tty.h>
  #include <errno.h>
  #include <sys/devio.h>
+ #ifndef __osf__
  #include <io/tc/pmioctl.h>
  #include <io/tc/dc7085reg.h>
+ #endif
  
  #include "misc.h"
  #include "X.h"
diff -rcN X11R5/mit/extensions/server/PEX/ddpex/mi/level1/Imakefile mit/extensions/server/PEX/ddpex/mi/level1/Imakefile
*** X11R5/mit/extensions/server/PEX/ddpex/mi/level1/Imakefile	Wed Jul 24 21:57:43 1991
--- mit/extensions/server/PEX/ddpex/mi/level1/Imakefile	Sat Nov  7 19:05:30 1992
***************
*** 57,69 ****
  	miPck1Prim.c
  
  OBJS = miDDCtoGC.o \
! 	miListUtil.o \ 
  	miLvl1Tab.o \
  	miRndFArea.o \
  	miRndPLine.o \
  	miRndMarkr.o \
  	miRndText.o \
! 	miRndTStrip.o \ 
  	miPck1Prim.o
  
  NormalLibraryObjectRule()
--- 57,69 ----
  	miPck1Prim.c
  
  OBJS = miDDCtoGC.o \
! 	miListUtil.o \
  	miLvl1Tab.o \
  	miRndFArea.o \
  	miRndPLine.o \
  	miRndMarkr.o \
  	miRndText.o \
! 	miRndTStrip.o \
  	miPck1Prim.o
  
  NormalLibraryObjectRule()
Newsgroups: comp.sys.dec