Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
sizeof_1_ = 8;
2 
aggr _1_
3 
{
4 
	'U' 0 lo;
5 
	'U' 4 hi;
6 
};
7 
 
8 
defn
9 
_1_(addr) {
10 
	complex _1_ addr;
11 
	print("	lo	", addr.lo, "\n");
12 
	print("	hi	", addr.hi, "\n");
13 
};
14 
 
15 
sizeofFPdbleword = 8;
16 
aggr FPdbleword
17 
{
18 
	'F' 0 x;
19 
	{
20 
	'U' 0 lo;
21 
	'U' 4 hi;
22 
	};
23 
};
24 
 
25 
defn
26 
FPdbleword(addr) {
27 
	complex FPdbleword addr;
28 
	print("	x	", addr.x, "\n");
29 
	print("_1_ {\n");
30 
		_1_(addr+0);
31 
	print("}\n");
32 
};
33 
 
34 
UTFmax = 3;
35 
Runesync = 128;
36 
Runeself = 128;
37 
Runeerror = 65533;
38 
sizeofFmt = 48;
39 
aggr Fmt
40 
{
41 
	'b' 0 runes;
42 
	'X' 4 start;
43 
	'X' 8 to;
44 
	'X' 12 stop;
45 
	'X' 16 flush;
46 
	'X' 20 farg;
47 
	'D' 24 nfmt;
48 
	'X' 28 args;
49 
	'D' 32 r;
50 
	'D' 36 width;
51 
	'D' 40 prec;
52 
	'U' 44 flags;
53 
};
54 
 
55 
defn
56 
Fmt(addr) {
57 
	complex Fmt addr;
58 
	print("	runes	", addr.runes, "\n");
59 
	print("	start	", addr.start\X, "\n");
60 
	print("	to	", addr.to\X, "\n");
61 
	print("	stop	", addr.stop\X, "\n");
62 
	print("	flush	", addr.flush\X, "\n");
63 
	print("	farg	", addr.farg\X, "\n");
64 
	print("	nfmt	", addr.nfmt, "\n");
65 
	print("	args	", addr.args\X, "\n");
66 
	print("	r	", addr.r, "\n");
67 
	print("	width	", addr.width, "\n");
68 
	print("	prec	", addr.prec, "\n");
69 
	print("	flags	", addr.flags, "\n");
70 
};
71 
 
72 
FmtWidth = 1;
73 
FmtLeft = 2;
74 
FmtPrec = 4;
75 
FmtSharp = 8;
76 
FmtSpace = 16;
77 
FmtSign = 32;
78 
FmtZero = 64;
79 
FmtUnsigned = 128;
80 
FmtShort = 256;
81 
FmtLong = 512;
82 
FmtVLong = 1024;
83 
FmtComma = 2048;
84 
FmtByte = 4096;
85 
FmtFlag = 8192;
86 
sizeofTm = 40;
87 
aggr Tm
88 
{
89 
	'D' 0 sec;
90 
	'D' 4 min;
91 
	'D' 8 hour;
92 
	'D' 12 mday;
93 
	'D' 16 mon;
94 
	'D' 20 year;
95 
	'D' 24 wday;
96 
	'D' 28 yday;
97 
	'a' 32 zone;
98 
	'D' 36 tzoff;
99 
};
100 
 
101 
defn
102 
Tm(addr) {
103 
	complex Tm addr;
104 
	print("	sec	", addr.sec, "\n");
105 
	print("	min	", addr.min, "\n");
106 
	print("	hour	", addr.hour, "\n");
107 
	print("	mday	", addr.mday, "\n");
108 
	print("	mon	", addr.mon, "\n");
109 
	print("	year	", addr.year, "\n");
110 
	print("	wday	", addr.wday, "\n");
111 
	print("	yday	", addr.yday, "\n");
112 
	print("	zone	", addr.zone, "\n");
113 
	print("	tzoff	", addr.tzoff, "\n");
114 
};
115 
 
116 
PNPROC = 1;
117 
PNGROUP = 2;
118 
Profoff = 0;
119 
Profuser = 1;
120 
Profkernel = 2;
121 
Proftime = 3;
122 
Profsample = 4;
123 
sizeofLock = 4;
124 
aggr Lock
125 
{
126 
	'D' 0 val;
127 
};
128 
 
129 
defn
130 
Lock(addr) {
131 
	complex Lock addr;
132 
	print("	val	", addr.val, "\n");
133 
};
134 
 
135 
sizeofQLp = 12;
136 
aggr QLp
137 
{
138 
	'D' 0 inuse;
139 
	'A' QLp 4 next;
140 
	'C' 8 state;
141 
};
142 
 
143 
defn
144 
QLp(addr) {
145 
	complex QLp addr;
146 
	print("	inuse	", addr.inuse, "\n");
147 
	print("	next	", addr.next\X, "\n");
148 
	print("	state	", addr.state, "\n");
149 
};
150 
 
151 
sizeofQLock = 16;
152 
aggr QLock
153 
{
154 
	Lock 0 lock;
155 
	'D' 4 locked;
156 
	'A' QLp 8 $head;
157 
	'A' QLp 12 $tail;
158 
};
159 
 
160 
defn
161 
QLock(addr) {
162 
	complex QLock addr;
163 
	print("Lock lock {\n");
164 
	Lock(addr.lock);
165 
	print("}\n");
166 
	print("	locked	", addr.locked, "\n");
167 
	print("	$head	", addr.$head\X, "\n");
168 
	print("	$tail	", addr.$tail\X, "\n");
169 
};
170 
 
171 
sizeofRWLock = 20;
172 
aggr RWLock
173 
{
174 
	Lock 0 lock;
175 
	'D' 4 readers;
176 
	'D' 8 writer;
177 
	'A' QLp 12 $head;
178 
	'A' QLp 16 $tail;
179 
};
180 
 
181 
defn
182 
RWLock(addr) {
183 
	complex RWLock addr;
184 
	print("Lock lock {\n");
185 
	Lock(addr.lock);
186 
	print("}\n");
187 
	print("	readers	", addr.readers, "\n");
188 
	print("	writer	", addr.writer, "\n");
189 
	print("	$head	", addr.$head\X, "\n");
190 
	print("	$tail	", addr.$tail\X, "\n");
191 
};
192 
 
193 
sizeofRendez = 12;
194 
aggr Rendez
195 
{
196 
	'A' QLock 0 l;
197 
	'A' QLp 4 $head;
198 
	'A' QLp 8 $tail;
199 
};
200 
 
201 
defn
202 
Rendez(addr) {
203 
	complex Rendez addr;
204 
	print("	l	", addr.l\X, "\n");
205 
	print("	$head	", addr.$head\X, "\n");
206 
	print("	$tail	", addr.$tail\X, "\n");
207 
};
208 
 
209 
sizeofNetConnInfo = 36;
210 
aggr NetConnInfo
211 
{
212 
	'X' 0 dir;
213 
	'X' 4 root;
214 
	'X' 8 spec;
215 
	'X' 12 lsys;
216 
	'X' 16 lserv;
217 
	'X' 20 rsys;
218 
	'X' 24 rserv;
219 
	'X' 28 laddr;
220 
	'X' 32 raddr;
221 
};
222 
 
223 
defn
224 
NetConnInfo(addr) {
225 
	complex NetConnInfo addr;
226 
	print("	dir	", addr.dir\X, "\n");
227 
	print("	root	", addr.root\X, "\n");
228 
	print("	spec	", addr.spec\X, "\n");
229 
	print("	lsys	", addr.lsys\X, "\n");
230 
	print("	lserv	", addr.lserv\X, "\n");
231 
	print("	rsys	", addr.rsys\X, "\n");
232 
	print("	rserv	", addr.rserv\X, "\n");
233 
	print("	laddr	", addr.laddr\X, "\n");
234 
	print("	raddr	", addr.raddr\X, "\n");
235 
};
236 
 
237 
RFNAMEG = 1;
238 
RFENVG = 2;
239 
RFFDG = 4;
240 
RFNOTEG = 8;
241 
RFPROC = 16;
242 
RFMEM = 32;
243 
RFNOWAIT = 64;
244 
RFCNAMEG = 1024;
245 
RFCENVG = 2048;
246 
RFCFDG = 4096;
247 
RFREND = 8192;
248 
RFNOMNT = 16384;
249 
sizeofQid = 16;
250 
aggr Qid
251 
{
252 
	'W' 0 path;
253 
	'U' 8 vers;
254 
	'b' 12 type;
255 
};
256 
 
257 
defn
258 
Qid(addr) {
259 
	complex Qid addr;
260 
	print("	path	", addr.path, "\n");
261 
	print("	vers	", addr.vers, "\n");
262 
	print("	type	", addr.type, "\n");
263 
};
264 
 
265 
sizeofDir = 60;
266 
aggr Dir
267 
{
268 
	'u' 0 type;
269 
	'U' 4 dev;
270 
	Qid 8 qid;
271 
	'U' 24 mode;
272 
	'U' 28 atime;
273 
	'U' 32 mtime;
274 
	'V' 36 length;
275 
	'X' 44 name;
276 
	'X' 48 uid;
277 
	'X' 52 gid;
278 
	'X' 56 muid;
279 
};
280 
 
281 
defn
282 
Dir(addr) {
283 
	complex Dir addr;
284 
	print("	type	", addr.type, "\n");
285 
	print("	dev	", addr.dev, "\n");
286 
	print("Qid qid {\n");
287 
	Qid(addr.qid);
288 
	print("}\n");
289 
	print("	mode	", addr.mode, "\n");
290 
	print("	atime	", addr.atime, "\n");
291 
	print("	mtime	", addr.mtime, "\n");
292 
	print("	length	", addr.length, "\n");
293 
	print("	name	", addr.name\X, "\n");
294 
	print("	uid	", addr.uid\X, "\n");
295 
	print("	gid	", addr.gid\X, "\n");
296 
	print("	muid	", addr.muid\X, "\n");
297 
};
298 
 
299 
sizeofWaitmsg = 20;
300 
aggr Waitmsg
301 
{
302 
	'D' 0 pid;
303 
	'a' 4 time;
304 
	'X' 16 msg;
305 
};
306 
 
307 
defn
308 
Waitmsg(addr) {
309 
	complex Waitmsg addr;
310 
	print("	pid	", addr.pid, "\n");
311 
	print("	time	", addr.time, "\n");
312 
	print("	msg	", addr.msg\X, "\n");
313 
};
314 
 
315 
sizeofIOchunk = 8;
316 
aggr IOchunk
317 
{
318 
	'X' 0 addr;
319 
	'U' 4 len;
320 
};
321 
 
322 
defn
323 
IOchunk(addr) {
324 
	complex IOchunk addr;
325 
	print("	addr	", addr.addr\X, "\n");
326 
	print("	len	", addr.len, "\n");
327 
};
328 
 
329 
MaxFragSize = 9216;
330 
sizeofVtLog = 40;
331 
aggr VtLog
332 
{
333 
	'A' VtLog 0 next;
334 
	'X' 4 name;
335 
	'X' 8 chunk;
336 
	'U' 12 nchunk;
337 
	'X' 16 w;
338 
	QLock 20 lk;
339 
	'D' 36 ref;
340 
};
341 
 
342 
defn
343 
VtLog(addr) {
344 
	complex VtLog addr;
345 
	print("	next	", addr.next\X, "\n");
346 
	print("	name	", addr.name\X, "\n");
347 
	print("	chunk	", addr.chunk\X, "\n");
348 
	print("	nchunk	", addr.nchunk, "\n");
349 
	print("	w	", addr.w\X, "\n");
350 
	print("QLock lk {\n");
351 
	QLock(addr.lk);
352 
	print("}\n");
353 
	print("	ref	", addr.ref, "\n");
354 
};
355 
 
356 
sizeofVtLogChunk = 12;
357 
aggr VtLogChunk
358 
{
359 
	'X' 0 p;
360 
	'X' 4 ep;
361 
	'X' 8 wp;
362 
};
363 
 
364 
defn
365 
VtLogChunk(addr) {
366 
	complex VtLogChunk addr;
367 
	print("	p	", addr.p\X, "\n");
368 
	print("	ep	", addr.ep\X, "\n");
369 
	print("	wp	", addr.wp\X, "\n");
370 
};
371 
 
372 
VtScoreSize = 20;
373 
VtMaxStringSize = 1024;
374 
VtMaxLumpSize = 57344;
375 
VtPointerDepth = 7;
376 
VtDataType = 0;
377 
VtDirType = 8;
378 
VtRootType = 16;
379 
VtMaxType = 17;
380 
VtCorruptType = 255;
381 
VtTypeDepthMask = 7;
382 
VtTypeBaseMask = -8;
383 
VtEntryActive = 1;
384 
_VtEntryDir = 2;
385 
_VtEntryDepthShift = 2;
386 
_VtEntryDepthMask = 28;
387 
VtEntryLocal = 32;
388 
VtEntrySize = 40;
389 
sizeofVtEntry = 40;
390 
aggr VtEntry
391 
{
392 
	'U' 0 gen;
393 
	'u' 4 psize;
394 
	'u' 6 dsize;
395 
	'b' 8 type;
396 
	'b' 9 flags;
397 
	'W' 12 size;
398 
	'a' 20 score;
399 
};
400 
 
401 
defn
402 
VtEntry(addr) {
403 
	complex VtEntry addr;
404 
	print("	gen	", addr.gen, "\n");
405 
	print("	psize	", addr.psize, "\n");
406 
	print("	dsize	", addr.dsize, "\n");
407 
	print("	type	", addr.type, "\n");
408 
	print("	flags	", addr.flags, "\n");
409 
	print("	size	", addr.size, "\n");
410 
	print("	score	", addr.score, "\n");
411 
};
412 
 
413 
sizeofVtRoot = 300;
414 
aggr VtRoot
415 
{
416 
	'a' 0 name;
417 
	'a' 128 type;
418 
	'a' 256 score;
419 
	'u' 276 blocksize;
420 
	'a' 278 prev;
421 
};
422 
 
423 
defn
424 
VtRoot(addr) {
425 
	complex VtRoot addr;
426 
	print("	name	", addr.name, "\n");
427 
	print("	type	", addr.type, "\n");
428 
	print("	score	", addr.score, "\n");
429 
	print("	blocksize	", addr.blocksize, "\n");
430 
	print("	prev	", addr.prev, "\n");
431 
};
432 
 
433 
VtRootSize = 300;
434 
VtRootVersion = 2;
435 
VtCryptoStrengthNone = 0;
436 
VtCryptoStrengthAuth = 1;
437 
VtCryptoStrengthWeak = 2;
438 
VtCryptoStrengthStrong = 3;
439 
VtCryptoNone = 0;
440 
VtCryptoSSL3 = 1;
441 
VtCryptoTLS1 = 2;
442 
VtCryptoMax = 3;
443 
VtCodecNone = 0;
444 
VtCodecDeflate = 1;
445 
VtCodecThwack = 2;
446 
VtCodecMax = 3;
447 
VtRerror = 1;
448 
VtTping = 2;
449 
VtRping = 3;
450 
VtThello = 4;
451 
VtRhello = 5;
452 
VtTgoodbye = 6;
453 
VtRgoodbye = 7;
454 
VtTauth0 = 8;
455 
VtRauth0 = 9;
456 
VtTauth1 = 10;
457 
VtRauth1 = 11;
458 
VtTread = 12;
459 
VtRread = 13;
460 
VtTwrite = 14;
461 
VtRwrite = 15;
462 
VtTsync = 16;
463 
VtRsync = 17;
464 
VtTmax = 18;
465 
sizeofVtFcall = 80;
466 
aggr VtFcall
467 
{
468 
	'b' 0 msgtype;
469 
	'b' 1 tag;
470 
	'X' 4 error;
471 
	'X' 8 version;
472 
	'X' 12 uid;
473 
	'b' 16 strength;
474 
	'X' 20 crypto;
475 
	'U' 24 ncrypto;
476 
	'X' 28 codec;
477 
	'U' 32 ncodec;
478 
	'X' 36 sid;
479 
	'b' 40 rcrypto;
480 
	'b' 41 rcodec;
481 
	'X' 44 auth;
482 
	'U' 48 nauth;
483 
	'a' 52 score;
484 
	'b' 72 blocktype;
485 
	'u' 74 count;
486 
	'X' 76 data;
487 
};
488 
 
489 
defn
490 
VtFcall(addr) {
491 
	complex VtFcall addr;
492 
	print("	msgtype	", addr.msgtype, "\n");
493 
	print("	tag	", addr.tag, "\n");
494 
	print("	error	", addr.error\X, "\n");
495 
	print("	version	", addr.version\X, "\n");
496 
	print("	uid	", addr.uid\X, "\n");
497 
	print("	strength	", addr.strength, "\n");
498 
	print("	crypto	", addr.crypto\X, "\n");
499 
	print("	ncrypto	", addr.ncrypto, "\n");
500 
	print("	codec	", addr.codec\X, "\n");
501 
	print("	ncodec	", addr.ncodec, "\n");
502 
	print("	sid	", addr.sid\X, "\n");
503 
	print("	rcrypto	", addr.rcrypto, "\n");
504 
	print("	rcodec	", addr.rcodec, "\n");
505 
	print("	auth	", addr.auth\X, "\n");
506 
	print("	nauth	", addr.nauth, "\n");
507 
	print("	score	", addr.score, "\n");
508 
	print("	blocktype	", addr.blocktype, "\n");
509 
	print("	count	", addr.count, "\n");
510 
	print("	data	", addr.data\X, "\n");
511 
};
512 
 
513 
VtStateAlloc = 0;
514 
VtStateConnected = 1;
515 
VtStateClosed = 2;
516 
sizeofVtConn = 1404;
517 
aggr VtConn
518 
{
519 
	QLock 0 lk;
520 
	QLock 16 inlk;
521 
	QLock 32 outlk;
522 
	'D' 48 debug;
523 
	'D' 52 infd;
524 
	'D' 56 outfd;
525 
	'D' 60 muxer;
526 
	'X' 64 writeq;
527 
	'X' 68 readq;
528 
	'D' 72 state;
529 
	'a' 76 wait;
530 
	'U' 1100 ntag;
531 
	'U' 1104 nsleep;
532 
	'X' 1108 part;
533 
	Rendez 1112 tagrend;
534 
	Rendez 1124 rpcfork;
535 
	'X' 1136 version;
536 
	'X' 1140 uid;
537 
	'X' 1144 sid;
538 
	'a' 1148 addr;
539 
};
540 
 
541 
defn
542 
VtConn(addr) {
543 
	complex VtConn addr;
544 
	print("QLock lk {\n");
545 
	QLock(addr.lk);
546 
	print("}\n");
547 
	print("QLock inlk {\n");
548 
	QLock(addr.inlk);
549 
	print("}\n");
550 
	print("QLock outlk {\n");
551 
	QLock(addr.outlk);
552 
	print("}\n");
553 
	print("	debug	", addr.debug, "\n");
554 
	print("	infd	", addr.infd, "\n");
555 
	print("	outfd	", addr.outfd, "\n");
556 
	print("	muxer	", addr.muxer, "\n");
557 
	print("	writeq	", addr.writeq\X, "\n");
558 
	print("	readq	", addr.readq\X, "\n");
559 
	print("	state	", addr.state, "\n");
560 
	print("	wait	", addr.wait, "\n");
561 
	print("	ntag	", addr.ntag, "\n");
562 
	print("	nsleep	", addr.nsleep, "\n");
563 
	print("	part	", addr.part\X, "\n");
564 
	print("Rendez tagrend {\n");
565 
	Rendez(addr.tagrend);
566 
	print("}\n");
567 
	print("Rendez rpcfork {\n");
568 
	Rendez(addr.rpcfork);
569 
	print("}\n");
570 
	print("	version	", addr.version\X, "\n");
571 
	print("	uid	", addr.uid\X, "\n");
572 
	print("	sid	", addr.sid\X, "\n");
573 
	print("	addr	", addr.addr, "\n");
574 
};
575 
 
576 
sizeofVtReq = 168;
577 
aggr VtReq
578 
{
579 
	VtFcall 0 tx;
580 
	VtFcall 80 rx;
581 
	'X' 160 srv;
582 
	'X' 164 sc;
583 
};
584 
 
585 
defn
586 
VtReq(addr) {
587 
	complex VtReq addr;
588 
	print("VtFcall tx {\n");
589 
	VtFcall(addr.tx);
590 
	print("}\n");
591 
	print("VtFcall rx {\n");
592 
	VtFcall(addr.rx);
593 
	print("}\n");
594 
	print("	srv	", addr.srv\X, "\n");
595 
	print("	sc	", addr.sc\X, "\n");
596 
};
597 
 
598 
NilBlock = -1;
599 
sizeofVtBlock = 84;
600 
aggr VtBlock
601 
{
602 
	'X' 0 c;
603 
	QLock 4 lk;
604 
	'X' 20 data;
605 
	'a' 24 score;
606 
	'b' 44 type;
607 
	'D' 48 nlock;
608 
	'D' 52 iostate;
609 
	'D' 56 ref;
610 
	'U' 60 heap;
611 
	'A' VtBlock 64 next;
612 
	'A' VtBlock 68 prev;
613 
	'U' 72 used;
614 
	'U' 76 used2;
615 
	'U' 80 addr;
616 
};
617 
 
618 
defn
619 
VtBlock(addr) {
620 
	complex VtBlock addr;
621 
	print("	c	", addr.c\X, "\n");
622 
	print("QLock lk {\n");
623 
	QLock(addr.lk);
624 
	print("}\n");
625 
	print("	data	", addr.data\X, "\n");
626 
	print("	score	", addr.score, "\n");
627 
	print("	type	", addr.type, "\n");
628 
	print("	nlock	", addr.nlock, "\n");
629 
	print("	iostate	", addr.iostate, "\n");
630 
	print("	ref	", addr.ref, "\n");
631 
	print("	heap	", addr.heap, "\n");
632 
	print("	next	", addr.next\X, "\n");
633 
	print("	prev	", addr.prev\X, "\n");
634 
	print("	used	", addr.used, "\n");
635 
	print("	used2	", addr.used2, "\n");
636 
	print("	addr	", addr.addr, "\n");
637 
};
638 
 
639 
sizeofVtFile = 84;
640 
aggr VtFile
641 
{
642 
	QLock 0 lk;
643 
	'D' 16 ref;
644 
	'D' 20 $local;
645 
	'A' VtBlock 24 b;
646 
	'a' 28 score;
647 
	'X' 48 c;
648 
	'D' 52 mode;
649 
	'U' 56 gen;
650 
	'D' 60 dsize;
651 
	'D' 64 psize;
652 
	'D' 68 dir;
653 
	'A' VtFile 72 parent;
654 
	'D' 76 epb;
655 
	'U' 80 offset;
656 
};
657 
 
658 
defn
659 
VtFile(addr) {
660 
	complex VtFile addr;
661 
	print("QLock lk {\n");
662 
	QLock(addr.lk);
663 
	print("}\n");
664 
	print("	ref	", addr.ref, "\n");
665 
	print("	$local	", addr.$local, "\n");
666 
	print("	b	", addr.b\X, "\n");
667 
	print("	score	", addr.score, "\n");
668 
	print("	c	", addr.c\X, "\n");
669 
	print("	mode	", addr.mode, "\n");
670 
	print("	gen	", addr.gen, "\n");
671 
	print("	dsize	", addr.dsize, "\n");
672 
	print("	psize	", addr.psize, "\n");
673 
	print("	dir	", addr.dir, "\n");
674 
	print("	parent	", addr.parent\X, "\n");
675 
	print("	epb	", addr.epb, "\n");
676 
	print("	offset	", addr.offset, "\n");
677 
};
678 
 
679 
VtOREAD = 0;
680 
VtOWRITE = 1;
681 
VtORDWR = 2;
682 
AESbsize = 16;
683 
AESmaxkey = 32;
684 
AESmaxrounds = 14;
685 
sizeofAESstate = 540;
686 
aggr AESstate
687 
{
688 
	'U' 0 setup;
689 
	'D' 4 rounds;
690 
	'D' 8 keybytes;
691 
	'a' 12 key;
692 
	'a' 44 ekey;
693 
	'a' 284 dkey;
694 
	'a' 524 ivec;
695 
};
696 
 
697 
defn
698 
AESstate(addr) {
699 
	complex AESstate addr;
700 
	print("	setup	", addr.setup, "\n");
701 
	print("	rounds	", addr.rounds, "\n");
702 
	print("	keybytes	", addr.keybytes, "\n");
703 
	print("	key	", addr.key, "\n");
704 
	print("	ekey	", addr.ekey, "\n");
705 
	print("	dkey	", addr.dkey, "\n");
706 
	print("	ivec	", addr.ivec, "\n");
707 
};
708 
 
709 
BFbsize = 8;
710 
BFrounds = 16;
711 
sizeofBFstate = 4236;
712 
aggr BFstate
713 
{
714 
	'U' 0 setup;
715 
	'a' 4 key;
716 
	'a' 60 ivec;
717 
	'a' 68 pbox;
718 
	'a' 140 sbox;
719 
};
720 
 
721 
defn
722 
BFstate(addr) {
723 
	complex BFstate addr;
724 
	print("	setup	", addr.setup, "\n");
725 
	print("	key	", addr.key, "\n");
726 
	print("	ivec	", addr.ivec, "\n");
727 
	print("	pbox	", addr.pbox, "\n");
728 
	print("	sbox	", addr.sbox, "\n");
729 
};
730 
 
731 
DESbsize = 8;
732 
sizeofDESstate = 148;
733 
aggr DESstate
734 
{
735 
	'U' 0 setup;
736 
	'a' 4 key;
737 
	'a' 12 expanded;
738 
	'a' 140 ivec;
739 
};
740 
 
741 
defn
742 
DESstate(addr) {
743 
	complex DESstate addr;
744 
	print("	setup	", addr.setup, "\n");
745 
	print("	key	", addr.key, "\n");
746 
	print("	expanded	", addr.expanded, "\n");
747 
	print("	ivec	", addr.ivec, "\n");
748 
};
749 
 
750 
DES3E = 0;
751 
DES3D = 1;
752 
DES3EEE = 0;
753 
DES3EDE = 2;
754 
DES3DED = 5;
755 
DES3DDD = 7;
756 
sizeofDES3state = 420;
757 
aggr DES3state
758 
{
759 
	'U' 0 setup;
760 
	'a' 4 key;
761 
	'a' 28 expanded;
762 
	'a' 412 ivec;
763 
};
764 
 
765 
defn
766 
DES3state(addr) {
767 
	complex DES3state addr;
768 
	print("	setup	", addr.setup, "\n");
769 
	print("	key	", addr.key, "\n");
770 
	print("	expanded	", addr.expanded, "\n");
771 
	print("	ivec	", addr.ivec, "\n");
772 
};
773 
 
774 
SHA1dlen = 20;
775 
MD4dlen = 16;
776 
MD5dlen = 16;
777 
sizeofDigestState = 164;
778 
aggr DigestState
779 
{
780 
	'W' 0 len;
781 
	'a' 8 state;
782 
	'a' 28 buf;
783 
	'D' 156 blen;
784 
	'C' 160 malloced;
785 
	'C' 161 seeded;
786 
};
787 
 
788 
defn
789 
DigestState(addr) {
790 
	complex DigestState addr;
791 
	print("	len	", addr.len, "\n");
792 
	print("	state	", addr.state, "\n");
793 
	print("	buf	", addr.buf, "\n");
794 
	print("	blen	", addr.blen, "\n");
795 
	print("	malloced	", addr.malloced, "\n");
796 
	print("	seeded	", addr.seeded, "\n");
797 
};
798 
 
799 
sizeofRC4state = 260;
800 
aggr RC4state
801 
{
802 
	'a' 0 state;
803 
	'b' 256 x;
804 
	'b' 257 y;
805 
};
806 
 
807 
defn
808 
RC4state(addr) {
809 
	complex RC4state addr;
810 
	print("	state	", addr.state, "\n");
811 
	print("	x	", addr.x, "\n");
812 
	print("	y	", addr.y, "\n");
813 
};
814 
 
815 
sizeofRSApub = 8;
816 
aggr RSApub
817 
{
818 
	'X' 0 n;
819 
	'X' 4 ek;
820 
};
821 
 
822 
defn
823 
RSApub(addr) {
824 
	complex RSApub addr;
825 
	print("	n	", addr.n\X, "\n");
826 
	print("	ek	", addr.ek\X, "\n");
827 
};
828 
 
829 
sizeofRSApriv = 32;
830 
aggr RSApriv
831 
{
832 
	RSApub 0 pub;
833 
	'X' 8 dk;
834 
	'X' 12 p;
835 
	'X' 16 q;
836 
	'X' 20 kp;
837 
	'X' 24 kq;
838 
	'X' 28 c2;
839 
};
840 
 
841 
defn
842 
RSApriv(addr) {
843 
	complex RSApriv addr;
844 
	print("RSApub pub {\n");
845 
	RSApub(addr.pub);
846 
	print("}\n");
847 
	print("	dk	", addr.dk\X, "\n");
848 
	print("	p	", addr.p\X, "\n");
849 
	print("	q	", addr.q\X, "\n");
850 
	print("	kp	", addr.kp\X, "\n");
851 
	print("	kq	", addr.kq\X, "\n");
852 
	print("	c2	", addr.c2\X, "\n");
853 
};
854 
 
855 
sizeofPEMChain = 12;
856 
aggr PEMChain
857 
{
858 
	'A' PEMChain 0 next;
859 
	'X' 4 pem;
860 
	'D' 8 pemlen;
861 
};
862 
 
863 
defn
864 
PEMChain(addr) {
865 
	complex PEMChain addr;
866 
	print("	next	", addr.next\X, "\n");
867 
	print("	pem	", addr.pem\X, "\n");
868 
	print("	pemlen	", addr.pemlen, "\n");
869 
};
870 
 
871 
sizeofEGpub = 12;
872 
aggr EGpub
873 
{
874 
	'X' 0 p;
875 
	'X' 4 alpha;
876 
	'X' 8 key;
877 
};
878 
 
879 
defn
880 
EGpub(addr) {
881 
	complex EGpub addr;
882 
	print("	p	", addr.p\X, "\n");
883 
	print("	alpha	", addr.alpha\X, "\n");
884 
	print("	key	", addr.key\X, "\n");
885 
};
886 
 
887 
sizeofEGpriv = 16;
888 
aggr EGpriv
889 
{
890 
	EGpub 0 pub;
891 
	'X' 12 secret;
892 
};
893 
 
894 
defn
895 
EGpriv(addr) {
896 
	complex EGpriv addr;
897 
	print("EGpub pub {\n");
898 
	EGpub(addr.pub);
899 
	print("}\n");
900 
	print("	secret	", addr.secret\X, "\n");
901 
};
902 
 
903 
sizeofEGsig = 8;
904 
aggr EGsig
905 
{
906 
	'X' 0 r;
907 
	'X' 4 s;
908 
};
909 
 
910 
defn
911 
EGsig(addr) {
912 
	complex EGsig addr;
913 
	print("	r	", addr.r\X, "\n");
914 
	print("	s	", addr.s\X, "\n");
915 
};
916 
 
917 
sizeofDSApub = 16;
918 
aggr DSApub
919 
{
920 
	'X' 0 p;
921 
	'X' 4 q;
922 
	'X' 8 alpha;
923 
	'X' 12 key;
924 
};
925 
 
926 
defn
927 
DSApub(addr) {
928 
	complex DSApub addr;
929 
	print("	p	", addr.p\X, "\n");
930 
	print("	q	", addr.q\X, "\n");
931 
	print("	alpha	", addr.alpha\X, "\n");
932 
	print("	key	", addr.key\X, "\n");
933 
};
934 
 
935 
sizeofDSApriv = 20;
936 
aggr DSApriv
937 
{
938 
	DSApub 0 pub;
939 
	'X' 16 secret;
940 
};
941 
 
942 
defn
943 
DSApriv(addr) {
944 
	complex DSApriv addr;
945 
	print("DSApub pub {\n");
946 
	DSApub(addr.pub);
947 
	print("}\n");
948 
	print("	secret	", addr.secret\X, "\n");
949 
};
950 
 
951 
sizeofDSAsig = 8;
952 
aggr DSAsig
953 
{
954 
	'X' 0 r;
955 
	'X' 4 s;
956 
};
957 
 
958 
defn
959 
DSAsig(addr) {
960 
	complex DSAsig addr;
961 
	print("	r	", addr.r\X, "\n");
962 
	print("	s	", addr.s\X, "\n");
963 
};
964 
 
965 
sizeofThumbprint = 24;
966 
aggr Thumbprint
967 
{
968 
	'A' Thumbprint 0 next;
969 
	'a' 4 sha1;
970 
};
971 
 
972 
defn
973 
Thumbprint(addr) {
974 
	complex Thumbprint addr;
975 
	print("	next	", addr.next\X, "\n");
976 
	print("	sha1	", addr.sha1, "\n");
977 
};
978 
 
979 
sizeofTLSconn = 80;
980 
aggr TLSconn
981 
{
982 
	'a' 0 dir;
983 
	'X' 40 cert;
984 
	'X' 44 sessionID;
985 
	'D' 48 certlen;
986 
	'D' 52 sessionIDlen;
987 
	'X' 56 trace;
988 
	'A' PEMChain 60 chain;
989 
	'X' 64 sessionType;
990 
	'X' 68 sessionKey;
991 
	'D' 72 sessionKeylen;
992 
	'X' 76 sessionConst;
993 
};
994 
 
995 
defn
996 
TLSconn(addr) {
997 
	complex TLSconn addr;
998 
	print("	dir	", addr.dir, "\n");
999 
	print("	cert	", addr.cert\X, "\n");
1000 
	print("	sessionID	", addr.sessionID\X, "\n");
1001 
	print("	certlen	", addr.certlen, "\n");
1002 
	print("	sessionIDlen	", addr.sessionIDlen, "\n");
1003 
	print("	trace	", addr.trace\X, "\n");
1004 
	print("	chain	", addr.chain\X, "\n");
1005 
	print("	sessionType	", addr.sessionType\X, "\n");
1006 
	print("	sessionKey	", addr.sessionKey\X, "\n");
1007 
	print("	sessionKeylen	", addr.sessionKeylen, "\n");
1008 
	print("	sessionConst	", addr.sessionConst\X, "\n");
1009 
};
1010 
 
1011 
BigMemSize = 9216;
1012 
SmallMemSize = 1152;
1013 
NLocalFrag = 2;
1014 
PFront = 0;
1015 
PMiddle = 1;
1016 
PEnd = 2;
1017 
sizeofMem = 28;
1018 
aggr Mem
1019 
{
1020 
	Lock 0 lk;
1021 
	'D' 4 ref;
1022 
	'X' 8 bp;
1023 
	'X' 12 ep;
1024 
	'X' 16 rp;
1025 
	'X' 20 wp;
1026 
	'A' Mem 24 next;
1027 
};
1028 
 
1029 
defn
1030 
Mem(addr) {
1031 
	complex Mem addr;
1032 
	print("Lock lk {\n");
1033 
	Lock(addr.lk);
1034 
	print("}\n");
1035 
	print("	ref	", addr.ref, "\n");
1036 
	print("	bp	", addr.bp\X, "\n");
1037 
	print("	ep	", addr.ep\X, "\n");
1038 
	print("	rp	", addr.rp\X, "\n");
1039 
	print("	wp	", addr.wp\X, "\n");
1040 
	print("	next	", addr.next\X, "\n");
1041 
};
1042 
 
1043 
FragLocalFree = 0;
1044 
FragLocalAlloc = 1;
1045 
FragGlobal = 2;
1046 
sizeofFrag = 32;
1047 
aggr Frag
1048 
{
1049 
	'D' 0 state;
1050 
	'A' Mem 4 mem;
1051 
	'X' 8 rp;
1052 
	'X' 12 wp;
1053 
	'A' Frag 16 next;
1054 
	'X' 20 free;
1055 
	'X' 24 a;
1056 
	'X' 28 p;
1057 
};
1058 
 
1059 
defn
1060 
Frag(addr) {
1061 
	complex Frag addr;
1062 
	print("	state	", addr.state, "\n");
1063 
	print("	mem	", addr.mem\X, "\n");
1064 
	print("	rp	", addr.rp\X, "\n");
1065 
	print("	wp	", addr.wp\X, "\n");
1066 
	print("	next	", addr.next\X, "\n");
1067 
	print("	free	", addr.free\X, "\n");
1068 
	print("	a	", addr.a\X, "\n");
1069 
	print("	p	", addr.p\X, "\n");
1070 
};
1071 
 
1072 
sizeofPacket = 88;
1073 
aggr Packet
1074 
{
1075 
	'D' 0 size;
1076 
	'D' 4 asize;
1077 
	'U' 8 pc;
1078 
	'A' Packet 12 next;
1079 
	'A' Frag 16 first;
1080 
	'A' Frag 20 last;
1081 
	'a' 24 $local;
1082 
};
1083 
 
1084 
defn
1085 
Packet(addr) {
1086 
	complex Packet addr;
1087 
	print("	size	", addr.size, "\n");
1088 
	print("	asize	", addr.asize, "\n");
1089 
	print("	pc	", addr.pc, "\n");
1090 
	print("	next	", addr.next\X, "\n");
1091 
	print("	first	", addr.first\X, "\n");
1092 
	print("	last	", addr.last\X, "\n");
1093 
	print("	$local	", addr.$local, "\n");
1094 
};
1095 
 
1096 
sizeof_2_ = 36;
1097 
aggr _2_
1098 
{
1099 
	Lock 0 lk;
1100 
	'A' Packet 4 packet;
1101 
	'D' 8 npacket;
1102 
	'A' Frag 12 frag;
1103 
	'D' 16 nfrag;
1104 
	'A' Mem 20 bigmem;
1105 
	'D' 24 nbigmem;
1106 
	'A' Mem 28 smallmem;
1107 
	'D' 32 nsmallmem;
1108 
};
1109 
 
1110 
defn
1111 
_2_(addr) {
1112 
	complex _2_ addr;
1113 
	print("Lock lk {\n");
1114 
	Lock(addr.lk);
1115 
	print("}\n");
1116 
	print("	packet	", addr.packet\X, "\n");
1117 
	print("	npacket	", addr.npacket, "\n");
1118 
	print("	frag	", addr.frag\X, "\n");
1119 
	print("	nfrag	", addr.nfrag, "\n");
1120 
	print("	bigmem	", addr.bigmem\X, "\n");
1121 
	print("	nbigmem	", addr.nbigmem, "\n");
1122 
	print("	smallmem	", addr.smallmem\X, "\n");
1123 
	print("	nsmallmem	", addr.nsmallmem, "\n");
1124 
};
1125 
 
1126 
complex _2_ freelist;
1127 
complex Packet packetalloc:p;
1128 
complex Packet packetfree:p;
1129 
complex Frag packetfree:f;
1130 
complex Frag packetfree:ff;
1131 
complex Packet packetdup:p;
1132 
complex Frag packetdup:f;
1133 
complex Frag packetdup:ff;
1134 
complex Packet packetdup:pp;
1135 
complex Packet packetsplit:p;
1136 
complex Packet packetsplit:pp;
1137 
complex Frag packetsplit:f;
1138 
complex Frag packetsplit:ff;
1139 
complex Packet packetconsume:p;
1140 
complex Packet packettrim:p;
1141 
complex Frag packettrim:f;
1142 
complex Frag packettrim:ff;
1143 
complex Packet packetheader:p;
1144 
complex Frag packetheader:f;
1145 
complex Mem packetheader:m;
1146 
complex Packet packettrailer:p;
1147 
complex Mem packettrailer:m;
1148 
complex Frag packettrailer:f;
1149 
complex Packet packetprefix:p;
1150 
complex Frag packetprefix:f;
1151 
complex Mem packetprefix:m;
1152 
complex Packet packetappend:p;
1153 
complex Frag packetappend:f;
1154 
complex Mem packetappend:m;
1155 
complex Packet packetconcat:p;
1156 
complex Packet packetconcat:pp;
1157 
complex Frag packetconcat:f;
1158 
complex Packet packetpeek:p;
1159 
complex Frag packetpeek:f;
1160 
complex Packet packetcopy:p;
1161 
complex Packet packetfragments:p;
1162 
complex IOchunk packetfragments:io;
1163 
complex Frag packetfragments:f;
1164 
complex IOchunk packetfragments:eio;
1165 
complex Packet packetstats:p;
1166 
complex Frag packetstats:f;
1167 
complex Mem packetstats:m;
1168 
complex Packet packetsize:p;
1169 
complex Frag packetsize:f;
1170 
complex Packet packetasize:p;
1171 
complex Frag packetasize:f;
1172 
complex Packet packetsha1:p;
1173 
complex DigestState packetsha1:ds;
1174 
complex Frag packetsha1:f;
1175 
complex Packet packetcmp:pkt0;
1176 
complex Packet packetcmp:pkt1;
1177 
complex Frag packetcmp:f0;
1178 
complex Frag packetcmp:f1;
1179 
complex Packet fragalloc:p;
1180 
complex Frag fragalloc:next;
1181 
complex Frag fragalloc:f;
1182 
complex Frag fragalloc:ef;
1183 
complex Mem fragalloc:m;
1184 
complex Packet packetforeign:p;
1185 
complex Frag packetforeign:f;
1186 
complex Packet fragdup:p;
1187 
complex Frag fragdup:f;
1188 
complex Frag fragdup:ff;
1189 
complex Mem fragdup:m;
1190 
complex Frag fragfree:f;
1191 
complex Mem memalloc:m;
1192 
complex Mem memfree:m;
1193 
complex Mem memhead:m;
1194 
complex Mem memtail:m;