![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / make_key_perm|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / make_key_perm |
1.1 root 1: /*
2: * $Source: /mit/kerberos/src/lib/des/RCS/misc.c,v $
3: * $Author: jtkohl $
4: *
5: * Copyright 1988 by the Massachusetts Institute of Technology.
6: *
7: * For copying and distribution information,
8: * please seethe file <mit-copyright.h>.
9: *
10: * This file contains most of the routines needed by the various
11: * make_foo programs, to account for bit- and byte-ordering on
12: * different machine types. It also contains other routines useful in
13: * generating the intermediate source files.
14: */
15:
16: #include <mit-copyright.h>
17: #include <stdio.h>
18: #include "des_internal.h"
19:
20: /*
21: * The DES algorithm is defined in terms of MSBFIRST, so sometimes,
22: * e.g. VAXes, we need to fix it up. ANSI order means the DES
23: * MSBFIRST order.
24: */
25:
26: #if 0 /* These don't seem to get used anywhere.... */
27: void swap_bits(array)
28: char *array;
29: {
30: #ifdef MSBFIRST
31: /* just return */
32: return;
33: #else /* LSBFIRST */
34: register old,new,i,j;
35:
36: /* for an eight byte block-- */
37: /* flips the bit order within each byte from 0 lsb to 0 msb */
38: for (i = 0; i<=7; i++) {
39: old = *array;
40: new = 0;
41: for (j = 0; j<=7; j++) {
42: new |= old & 01; /* copy a bit */
43: if (j < 7) {
44: /* rotate in opposite directions */
45: old = old >> 1;
46: new = new << 1;
47: }
48: }
49: *array++ = new;
50: }
51: #endif /* MSBFIRST */
52: }
53:
54: unsigned long long_swap_bits(x)
55: unsigned long x;
56: {
57: #ifdef MSBFIRST
58: return x;
59: #else
60: char *array = (char *) &x;
61: register old,new,i,j;
62:
63: /* flips the bit order within each byte from 0 lsb to 0 msb */
64: for (i = 0; i <= (sizeof(long)-1); i++) {
65: old = *array;
66: new = 0;
67: for (j = 0; j<=7; j++) {
68: if (old & 01)
69: new = new | 01;
70: if (j < 7) {
71: old = old >> 1;
72: new = new << 1;
73: }
74: }
75: *array++ = new;
76: }
77: return x;
78: #endif /* LSBFIRST */
79: }
80: #endif /* 0 */
81:
82: unsigned long swap_six_bits_to_ansi(old)
83: unsigned long old;
84: {
85: register unsigned long new, j;
86:
87: /* flips the bit order within each byte from 0 lsb to 0 msb */
88: new = 0;
89: for (j = 0; j<=5; j++) {
90: new |= old & 01; /* copy a bit */
91: if (j < 5) {
92: /* rotate in opposite directions */
93: old = old >> 1;
94: new = new << 1;
95: }
96: }
97: return new;
98: }
99:
100: unsigned long swap_four_bits_to_ansi(old)
101: unsigned long old;
102: {
103: register unsigned long new,j;
104:
105: /* flips the bit order within each byte from 0 lsb to 0 msb */
106: new = 0;
107: for (j = 0; j<=3; j++) {
108: new |= (old & 01); /* copy a bit */
109: if (j < 3) {
110: old = old >> 1;
111: new = new << 1;
112: }
113: }
114: return new;
115: }
116:
117: unsigned long swap_bit_pos_1(x)
118: unsigned long x;
119: {
120: /*
121: * This corrects for the bit ordering of the algorithm, e.g.
122: * bit 0 ==> msb, bit 7 lsb.
123: *
124: * given the number of a bit position, >=1, flips the bit order
125: * each byte. e.g. bit 3 --> bit 6, bit 13 --> bit 12
126: */
127: register y,z;
128:
129: /* always do it, only used by des_make_key_perm.c so far */
130: y = (x-1)/8;
131: z = (x-1)%8;
132:
133: x = (8-z) + (y*8);
134:
135: return x;
136: }
137:
138: unsigned long swap_bit_pos_0(x)
139: unsigned long x;
140: {
141: /* zero based version */
142:
143: /*
144: * This corrects for the bit ordering of the algorithm, e.g.
145: * bit 0 ==> msb, bit 7 lsb.
146: */
147:
148: #ifdef MSBFIRST
149: return x;
150: #else /* LSBFIRST */
151: register y,z;
152:
153: /*
154: * given the number of a bit position, >=0, flips the bit order
155: * each byte. e.g. bit 3 --> bit 6, bit 13 --> bit 12
156: */
157: y = x/8;
158: z = x%8;
159:
160: x = (7-z) + (y*8);
161:
162: return x;
163: #endif /* LSBFIRST */
164: }
165:
166: unsigned long swap_bit_pos_0_to_ansi(x)
167: unsigned long x;
168: {
169: /* zero based version */
170:
171: /*
172: * This corrects for the bit ordering of the algorithm, e.g.
173: * bit 0 ==> msb, bit 7 lsb.
174: */
175:
176: register y,z;
177: /*
178: * given the number of a bit position, >=0, flips the bit order each
179: * byte. e.g. bit 3 --> bit 6, bit 13 --> bit 12
180: */
181: y = x/8;
182: z = x%8;
183:
184: x = (7-z) + (y*8);
185:
186: return x;
187: }
188:
189: unsigned long rev_swap_bit_pos_0(x)
190: unsigned long x;
191: {
192: /* zero based version */
193:
194: /*
195: * This corrects for the bit ordering of the algorithm, e.g.
196: * bit 0 ==> msb, bit 7 lsb.
197: *
198: * Role of LSB and MSB flipped from the swap_bit_pos_0()
199: */
200:
201: #ifdef LSBFIRST
202: return x;
203: #else /* MSBFIRST */
204:
205: register y,z;
206:
207: /*
208: * given the number of a bit position, >=0, flips the bit order each
209: * byte. e.g. bit 3 --> bit 6, bit 13 --> bit 12
210: */
211: y = x/8;
212: z = x%8;
213:
214: x = (7-z) + (y*8);
215:
216: return x;
217: #endif /* MSBFIRST */
218: }
219:
220: unsigned long swap_byte_bits(x)
221: unsigned long x;
222: {
223: #ifdef MSBFIRST
224: return x;
225: #else /* LSBFIRST */
226:
227: char *array = (char *) &x;
228: register unsigned long old,new,j;
229:
230: /* flips the bit order within each byte from 0 lsb to 0 msb */
231: old = *array;
232: new = 0;
233: for (j = 0; j<=7; j++) {
234: new |= (old & 01); /* copy a bit */
235: if (j < 7) {
236: old = old >> 1;
237: new = new << 1;
238: }
239: }
240: return new;
241: #endif /* LSBFIRST */
242: }
243:
244: swap_long_bytes_bit_number(x)
245: unsigned long x;
246: {
247: /*
248: * given a bit number (0-31) from a vax, swap the byte part of the
249: * bit number to change the byte ordering to mSBFIRST type
250: */
251: #ifdef LSBFIRST
252: return x;
253: #else /* MSBFIRST */
254: unsigned long y,z;
255:
256: y = x/8; /* initial byte component */
257: z = x%8; /* bit within byte */
258:
259: x = (3-y)*8 +z;
260: return x;
261: #endif /* MSBFIRST */
262: }
263:
264: void test_set(stream, src, testbit, dest, setbit)
265: FILE *stream;
266: const char *src;
267: int testbit;
268: const char *dest;
269: int setbit;
270: {
271: #ifdef DES_SHIFT_SHIFT
272: if (testbit == setbit)
273: fprintf(stream, " %s |= %s & (1<<%2d);\n",
274: dest, src, testbit);
275: else
276: fprintf(stream, " %s |= (%s & (1<<%2d)) %s %2d;\n",
277: dest, src, testbit,
278: (testbit < setbit) ? "<<" : ">>",
279: abs(testbit - setbit));
280: #else
281: fprintf(stream,
282: " if (%s & (1<<%2d)) %s |= 1<<%2d;\n",
283: src, testbit, dest, setbit);
284: #endif
285: }
286:
287: extern void gen PROTOTYPE((FILE * stream));
288: int des_debug;
289: char const *whoami;
290:
291: main(argc, argv)
292: int argc;
293: char *argv[];
294: {
295: char *filename;
296: char *arg;
297: FILE * stream;
298:
299: whoami = argv[0];
300: filename = (char *)NULL;
301:
302: while (argc--, *++argv) {
303: arg = *argv;
304: if (*arg == '-') {
305: if (!strcmp(arg, "-d") && !strcmp(arg, "-debug"))
306: des_debug++;
307: else {
308: fprintf(stderr, "%s: unknown control argument %s\n",
309: whoami, arg);
310: goto usage;
311: }
312: }
313: else if (filename) {
314: fprintf(stderr,
315: "%s: multiple file names provided: %s, %s\n",
316: whoami, filename, arg);
317: goto usage;
318: }
319: else
320: filename = arg;
321: }
322:
323: if (!filename) {
324: fprintf(stderr, "%s: no file name provided\n", whoami);
325: goto usage;
326: }
327:
328: stream = fopen(filename, "w");
329: if (!stream) {
330: perror(filename);
331: usage:
332: fprintf(stderr, "usage: %s [-debug] filename\n", whoami);
333: exit(1);
334: }
335:
336: fputs(
337: "/* This file is automatically generated. Do not edit it. */\n",
338: stream);
339:
340: /* This routine will generate the contents of the file. */
341: gen(stream);
342: if (fclose(stream) == EOF) {
343: perror(filename);
344: exit(1);
345: }
346: exit(0);
347: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.