implement Palmsrv;

#
# serve up a Palm using SLP and PADP
#
# Copyright © 2003 Vita Nuova Holdings Limited.  All rights reserved.
#
# forsyth@vitanuova.com
#
# TO DO
#	USB and possibly other transports
#	tickle

include "sys.m";
	sys: Sys;

include "draw.m";

include "timers.m";
	timers: Timers;
	Timer, Sec: import timers;

include "palm.m";

include "arg.m";

Palmsrv: module
{
	init:	fn(nil: ref Draw->Context, nil: list of string);
};

debug := 0;

usage()
{
	sys->fprint(sys->fildes(2), "usage: palm/palmsrv [-d /dev/eia0] [-s 57600]\n");
	raise "fail:usage";
}

init(nil: ref Draw->Context, args: list of string)
{
	sys = load Sys Sys->PATH;
	sys->pctl(Sys->NEWPGRP|Sys->FORKFD, nil);

	device, speed: string;

	arg := load Arg Arg->PATH;
	if(arg == nil)
		error(sys->sprint("can't load %s: %r", Arg->PATH));
	arg->init(args);
	while((c := arg->opt()) != 0)
		case c {
		'D' =>
			debug++;
		'd' =>
			device = arg->arg();
		's' =>
			speed = arg->arg();
		* =>
			usage();
		}
	args = arg->argv();
	arg = nil;

	if(device == nil)
		device = "/dev/eia0";
	if(speed == nil)
		speed = "57600";

	dfd := sys->open(device, Sys->ORDWR);
	if(dfd == nil)
		error(sys->sprint("can't open %s: %r", device));
	cfd := sys->open(device+"ctl", Sys->OWRITE);

	timers = load Timers Timers->PATH;
	if(timers == nil)
		error(sys->sprint("can't load %s: %r", Timers->PATH));
	srvio := sys->file2chan("/chan", "palmsrv");
	if(srvio == nil)
		error(sys->sprint("can't create channel /chan/palmsrv: %r"));
	timers->init(Sec/100);
	p := Pchan.init(dfd, cfd);
	spawn server(srvio, p);
}

error(s: string)
{
	sys->fprint(sys->fildes(2), "palmsrv: %s\n", s);
	raise "fail:error";
}

Xact: adt
{
	fid:	int;
	reply:	array of byte;
	error:	string;
};

server(srv: ref Sys->FileIO, p: ref Pchan)
{
	actions: list of ref Xact;
	nuser := 0;
	for(;;)alt{
	(nil, nbytes, fid, rc) := <-srv.read =>
		if(rc == nil){
			actions = delact(actions, fid);
			break;
		}
		act := findact(actions, fid);
		if(act == nil){
			rc <-= (nil, "no transaction in progress");
			break;
		}
		actions = delact(actions, fid);
		if(p.shutdown)
			rc <-= (nil, "link shut down");
		else if(act.error != nil)
			rc <-= (nil, act.error);
		else if(act.reply != nil)
			rc <-= (act.reply, nil);
		else
			rc <-= (nil, "no reply");	# probably shouldn't happen

	(nil, data, fid, wc) := <-srv.write =>
		actions = delact(actions, fid);	# discard result of any previous transaction
		if(wc == nil){
			if(--nuser <= 0){
				nuser = 0;
				p.stop();
			}
			break;
		}
		if(len data == 4 && string data == "exit"){
			p.close();
			wc <-= (len data, nil);
			exit;
		}
		if(p.shutdown){
			wc <-= (0, "link shut down");	# must close then reopen
			break;
		}
		if(!p.started){
			err := p.start();
			if(err != nil){
				wc <-= (0, sys->sprint("can't start protocol: %s", err));
				break;
			}
			nuser++;
		}
		(result, err) := p.padp_xchg(data, 20*1000);
		if(err != nil){
			wc <-= (0, err);
			break;
		}
		actions = ref Xact(fid, result, err) :: actions;
		wc <-= (len data, nil);
	}
}

findact(l: list of ref Xact, fid: int): ref Xact
{
	for(; l != nil; l = tl l)
		if((a := hd l).fid == fid)
			return a;
	return nil;
}

delact(l: list of ref Xact, fid: int): list of ref Xact
{
	ol := l;
	l = nil;
	for(; ol != nil; ol = tl ol)
		if((a := hd ol).fid != fid)
			l = a :: l;
	return l;
}

killpid(pid: int)
{
	if(pid != 0){
		fd := sys->open("/prog/"+string pid+"/ctl", sys->OWRITE);
		if(fd != nil)
			sys->fprint(fd, "kill");
	}
}

#
# protocol implementation
#	Serial Link Protocol (framing)
#	Connection Management Protocol (wakeup, negotiation)
#	Packet Assembly/Disassembly Protocol (reliable delivery fragmented datagram)
#

DATALIM: con 1024;

# SLP packet types
SLP_System, SLP_Unused, SLP_PAD, SLP_Loop: con iota;

# SLP block content, without framing
Sblock: adt {
	src:	int;	# socket ID
	dst:	int;	# socket ID
	proto:	int;	# packet type
	xid:	int;	# transaction ID
	data:	array of byte;

	new:	fn(): ref Sblock;
	print:	fn(sb: self ref Sblock, dir: string);
};

#
# Palm channel
#
Pchan: adt {
	started:	int;
	shutdown:	int;

	protocol:	int;
	lport:	byte;
	rport:	byte;

	fd:	ref Sys->FD;
	cfd:	ref Sys->FD;
	baud:	int;

	rpid:	int;
	lastid:	int;
	rd:	chan of ref Sblock;
	reply:	ref Sblock;	# data replacing lost ack

	init:	fn(dfd: ref Sys->FD, cfd: ref Sys->FD): ref Pchan;
	start:	fn(p: self ref Pchan): string;
	stop:	fn(p: self ref Pchan);
	close:	fn(p: self ref Pchan): int;
	slp_read:	fn(p: self ref Pchan, nil: int): (ref Sblock, string);
	slp_write:	fn(p: self ref Pchan, xid: int, nil: array of byte): string;

	setbaud:	fn(p: self ref Pchan, nil: int);

	padp_read:	fn(p: self ref Pchan, xid: int, timeout: int): (array of byte, string);
	padp_write:	fn(p: self ref Pchan, msg: array of byte, xid: int): string;
	padp_xchg:	fn(p: self ref Pchan, msg: array of byte, timeout: int): (array of byte, string);
	tickle:	fn(p: self ref Pchan);

	connect:	fn(p: self ref Pchan): string;
	accept:	fn(p: self ref Pchan, baud: int): string;

	nextseq:	fn(p: self ref Pchan): int;
};

Pchan.init(dfd: ref Sys->FD, cfd: ref Sys->FD): ref Pchan
{
	p := ref Pchan;
	p.fd = dfd;
	p.cfd = cfd;
	p.baud = InitBaud;
	p.protocol = SLP_PAD;
	p.rport = byte 3;
	p.lport = byte 3;
	p.rd = chan of ref Sblock;
	p.lastid = 0;
	p.rpid = 0;
	p.started = 0;
	p.shutdown = 0;
	return p;
}

Pchan.start(p: self ref Pchan): string
{
	if(p.started)
		return nil;
	p.shutdown = 0;
	p.baud = InitBaud;
	p.reply = nil;
	ctl(p, "f");
	ctl(p, "d1");
	ctl(p, "r1");
	ctl(p, "i8");
	ctl(p, "q8192");
	ctl(p, sys->sprint("b%d", InitBaud));
	pidc := chan of int;
	spawn slp_recv(p, pidc);
	p.started = 1;
	p.rpid = <-pidc;
	err := p.accept(57600);
	if(err != nil)
		p.stop();
	return err;
}

ctl(p: ref Pchan, s: string)
{
	if(p.cfd != nil)
		sys->fprint(p.cfd, "%s", s);
}

Pchan.setbaud(p: self ref Pchan, baud: int)
{
	if(p.baud != baud){
		p.baud = baud;
		ctl(p, sys->sprint("b%d", baud));
		sys->sleep(200);
	}
}

Pchan.stop(p: self ref Pchan)
{
	p.shutdown = 0;
	if(!p.started)
		return;
	killpid(p.rpid);
	p.rpid = 0;
	p.reply = nil;
#	ctl(p, "f");
#	ctl(p, "d0");
#	ctl(p, "r0");
#	ctl(p, sys->sprint("b%d", InitBaud));
	p.started = 0;
}
	
Pchan.close(p: self ref Pchan): int
{
	if(p.started)
		p.stop();
	p.reply = nil;
	p.cfd = nil;
	p.fd = nil;
	timers->shutdown();
	return 0;
}

# CMP protocol for connection management
#	See include/Core/System/CMCommon.h, Palm SDK
# There are two major versions: the original V1, still always used in wakeup messsages;
# and V2, which is completely different (similar structure to Desklink) and used by newer devices, but the headers
# are the same length.  Start off in V1 announcing version 2.x, then switch to that.
# My device supports only V1, so I use that.

CMPHDRLEN: con 10;	# V1: type[1] flags[1] vermajor[1] verminor[1] mbz[2] baud[4]
					# V2: type[1] cmd[1] error[2] argc[1] mbz[1] mbz[4]

# CMP V1
Cmajor:	con 1;
Cminor:	con 2;

InitBaud: con 9600;

# type
Cwake, Cinit, Cabort, Cextended: con 1+iota;

# Cinit flags
ChangeBaud: con 16r80;
RcvTimeout1: con 16r40;	# tell Palm to set receive timeout to 1 minute (CMP v1.1)
RcvTimeout2:	con 16r20;	# tell Palm to set receive timeout to 2 minutes (v1.1)

# Cinit and Cwake flag
LongPacketEnable:	con 16r10;	# enable long packet support (v1.2)

# Cabort flags
WrongVersion:	con 16r80;	# incompatible com versions

# CMP V2
Carg1:		con Palm->ArgIDbase;
Cresponse:	con 16r80;
Cxchgprefs, Chandshake:	con 16r10+iota;

Pchan.connect(p: self ref Pchan): string
{
	(nil, e1) := cmp_write(p, Cwake, 0, Cmajor, Cminor, 57600);
	if(e1 != nil)
		return e1;
	(op, flag, nil, nil, baud, e2) := cmp_read(p, 0);
	if(e2 != nil)
		return e2;
	case op {
	Cinit=>
		if(flag & ChangeBaud)
			p.setbaud(baud);
		return nil;

	Cabort=>
		return "Palm rejected connect";

	* =>
		return sys->sprint("Palm connect: reply %d", op);
	}
	return nil;
}

Pchan.accept(p: self ref Pchan, maxbaud: int): string
{
	(op, nil, major, minor, baud, err) := cmp_read(p, 0);
	if(err != nil)
		return err;
	if(major != 1){
		sys->fprint(sys->fildes(2), "palmsrv: comm version mismatch: %d.%d\n", major, minor);
		cmp_write(p, Cabort, WrongVersion, Cmajor, 0, 0);
		return sys->sprint("comm version mismatch: %d.%d", major, minor);
	}
	if(baud > maxbaud)
		baud = maxbaud;
	flag := 0;
	if(baud != InitBaud)
		flag = ChangeBaud;
	(nil, err) = cmp_write(p, Cinit, flag, Cmajor, Cminor, baud);
	if(err != nil)
		return err;
	p.setbaud(baud);
	return nil;
}

cmp_write(p: ref Pchan, op: int, flag: int, major: int, minor: int, baud: int): (int, string)
{
	cmpbuf := array[CMPHDRLEN] of byte;
	cmpbuf[0] = byte op;
	cmpbuf[1] = byte flag;
	cmpbuf[2] = byte major;
	cmpbuf[3] = byte minor;
	cmpbuf[4] = byte 0;
	cmpbuf[5] = byte 0;
	put4(cmpbuf[6:], baud);

	if(op == Cwake)
		return (16rFF, p.padp_write(cmpbuf, 16rFF));
	xid := p.nextseq();
	return (xid, p.padp_write(cmpbuf, xid));
}

cmp_read(p: ref Pchan, xid: int): (int, int, int, int, int, string)
{
	(c, err) := p.padp_read(xid, 20*Sec);
	if(err != nil)
		return (0, 0, 0, 0, 0, err);
	if(len c != CMPHDRLEN)
		return (0, 0, 0, 0, 0, "CMP: bad response");
	return (int c[0], int c[1], int c[2], int c[3], get4(c[6:]), nil);
}

#
# Palm PADP protocol
#	``The Packet Assembly/Disassembly Protocol'' in
#	Developing Palm OS Communications, US Robotics, 1996, pp. 53-68.
#
# forsyth@caldo.demon.co.uk, 1997
#

FIRST: con 16r80;
LAST: con 16r40;
MEMERROR: con 16r20;

# packet types
Pdata: con 1;
Pack: con 2;
Ptickle: con 4;
Pabort: con 8;

PADPHDRLEN: con 4;	# type[1] flags[1] size[2]

RetryInterval: con 4*Sec;
MaxRetries: con 14; # they say 14 `seconds', but later state they might need 20 for heap mgmt, so i'll assume 14 attempts (at 4sec ea)

Pchan.padp_xchg(p: self ref Pchan, msg: array of byte, timeout: int): (array of byte, string)
{
	xid := p.nextseq();
	err := p.padp_write(msg, xid);
	if(err != nil)
		return (nil, err);
	return p.padp_read(xid, timeout);
}

#
# PADP header
#	type[1] flags[2] size[2], high byte first for size
#
# max block size is 2^16-1
# must ack within 2 seconds
# wait at most 10 seconds for next chunk
# 10 retries
#

Pchan.padp_write(p: self ref Pchan, buf: array of byte, xid: int): string
{
	count := len buf;
	if(count >= 1<<16)
		return "padp: write too big";
	p.reply = nil;
	flags := FIRST;
	mem := buf[0:];
	offset := 0;
	while(count > 0){
		n := count;
		if(n > DATALIM)
			n = DATALIM;
		else
			flags |= LAST;
		ob := array[PADPHDRLEN+n] of byte;
		ob[0] = byte Pdata;
		ob[1] = byte flags;
		l: int;
		if(flags & FIRST)
			l = count;	# total size in first segment
		else
			l = offset;	# offset in rest
		put2(ob[2:], l);
		ob[PADPHDRLEN:] = mem[0:n];
		if(debug)
			padp_dump(ob, "Tx");
		p.slp_write(xid, ob);
		retries := 0;
		for(;;){
			(ib, nil) := p.slp_read(RetryInterval);
			if(ib == nil){
				sys->print("padp write: ack timeout\n");
				retries++;
				if(retries > MaxRetries){
					# USR says not to give up if (flags&LAST)!=0; giving up seems safer
					sys->print("padp write: give up\n");
					return "PADP: no response";
				}
				p.slp_write(xid, ob);
				continue;
			}
			if(ib.proto != SLP_PAD || len ib.data < PADPHDRLEN || ib.xid != xid && ib.xid != 16rFF){
				sys->print("padp write: ack wrong type(%d) or xid(%d,%d), or len %d\n", ib.proto, ib.xid, xid, len ib.data);
				continue;
			}
			if(ib.xid == 16rFF){	# connection management
				if(int ib.data[0] == Ptickle)
					continue;
				if(int ib.data[0] == Pabort){
					sys->print("padp write: device abort\n");
					p.shutdown = 1;
					return "device cancelled operation";
				}
			}
			if(int ib.data[0] != Pack){
				if(int ib.data[0] == Ptickle)
					continue;
				# right transaction ... if it's acceptable data, USR says to save it & treat as ack
				sys->print("padp write: type %d, not ack\n", int ib.data[0]);
				if(int ib.data[0] == Pdata && flags & LAST && int ib.data[1] & FIRST){
					p.reply = ib;
					break;
				}
				continue;
			}
			if(int ib.data[1] & MEMERROR)
				return "padp: pilot out of memory";
			if((flags&(FIRST|LAST)) != (int ib.data[1]&(FIRST|LAST)) ||
			    get2(ib.data[2:]) != get2(ob[2:])){
				sys->print("padp write: ack, wrong flags (#%x,#%x) or offset (%d,%d)\n", int ib.data[1], flags, get2(ib.data[2:]), get2(ob[2:]));
				continue;
			}
			if(debug)
				sys->print("padp write: ack %d %d\n", xid, get2(ob[2:]));
			break;
		}
		mem = mem[n:];
		count -= n;
		offset += n;
		flags &= ~FIRST;
	}
	return nil;
}

Pchan.padp_read(p: self ref Pchan,  xid, timeout: int): (array of byte, string)
{
	buf, mem: array of byte;

	offset := 0;
	ready := 0;
	retries := 0;
	ack := array[PADPHDRLEN] of byte;
	for(;;){
		b := p.reply;
		if(b == nil){
			err: string;
			(b, err) = p.slp_read(timeout);
			if(b == nil){
				sys->print("padp read: timeout %d\n", retries);
				if(++retries <= 5)
					continue;
				sys->print("padp read: gave up\n");
				return (nil, err);
			}
			retries = 0;
		} else
			p.reply = nil;
		if(debug)
			padp_dump(b.data, "Rx");
 		if(len b.data < PADPHDRLEN){
			sys->print("padp read: length\n");
			continue;
		}
		if(b.proto != SLP_PAD){
			sys->print("padp read: bad proto (%d)\n", b.proto);
			continue;
		}
		if(int b.data[0] == Pabort && b.xid == 16rFF){
			p.shutdown = 1;
			return (nil, "device cancelled transaction");
		}
		if(int b.data[0] != Pdata || xid != 0 && b.xid != xid){
			sys->print("padp read mismatch: type (%d) or xid(%d::%d)\n", int b.data[0], b.xid, xid);
			continue;
		}
		f := int b.data[1];
		o := get2(b.data[2:]);
		if(f & FIRST){
			buf = array[o] of byte;
			ready = 1;
			offset = 0;
			o = 0;
			mem = buf;
			timeout = 4*Sec;
		}
		if(!ready || o != offset){
			sys->print("padp read: offset %d, expected %d\n", o, offset);
			continue;
		}
		n := len b.data - PADPHDRLEN;
		if(n > len mem){
			sys->print("padp read: record too long (%d/%d)\n", n, len mem);
			# it's probably fatal, but retrying does no harm
			continue;
		}
		mem[0:] = b.data[PADPHDRLEN:PADPHDRLEN+n];
		mem = mem[n:];
		offset += n;
		ack[0:] = b.data[0:PADPHDRLEN];
		ack[0] = byte Pack;
		p.slp_write(xid, ack);
		if(f & LAST)
			break;
	}
	if(offset != len buf)
		return (buf[0:offset], nil);
	return (buf, nil);
}

Pchan.nextseq(p: self ref Pchan): int
{
	n := p.lastid + 1;
	if(n >= 16rFF)
		n = 1;
	p.lastid = n;
	return n;
}

Pchan.tickle(p: self ref Pchan)
{
	xid := p.nextseq();
	data := array[PADPHDRLEN] of byte;
	data[0] = byte Ptickle;
	data[1] = byte (FIRST|LAST);
	put2(data[2:], 0);
	if(debug)
		sys->print("PADP: tickle\n");
	p.slp_write(xid, data);
}

padp_dump(data: array of byte, dir: string)
{
	stype: string;

	case int data[0] {
	Pdata =>	stype = "Data";
	Pack =>	stype = "Ack";
	Ptickle =>	stype = "Tickle";
	Pabort =>	stype = "Abort";
	* =>	stype = sys->sprint("#%x", int data[0]);
	}

	sys->print("PADP %s %s flags=#%x len=%d\n", stype, dir, int data[1], get2(data[2:]));

	if(debug > 1 && (data[0] != byte Pack || len data > 4)){
		data = data[4:];
		for(i := 0; i < len data;){
			sys->print(" %.2x", int data[i]);
			if(++i%16 == 0)
				sys->print("\n");
		}
		sys->print("\n");
	}
}

#
# Palm's Serial Link Protocol
#	See include/Core/System/SerialLinkMgr.h in Palm SDK
# 	and the description in the USR document mentioned above.
#

SLPHDRLEN: con 10;		# BE[1] EF[1] ED[1] dest[1] src[1] type[1] size[2] xid[1] check[1] body[size] crc[2]
SLP_MTU: con SLPHDRLEN+PADPHDRLEN+DATALIM;

Sblock.new(): ref Sblock
{
	return ref Sblock(0, 0, 0, 16rFF, nil);
}

#
# format and write an SLP frame
#
Pchan.slp_write(p: self ref Pchan, xid: int, b: array of byte): string
{
	d := array[SLPHDRLEN] of byte;
	cb := array[2] of byte;

	nb := len b;
	d[0] = byte 16rBE;
	d[1] = byte 16rEF;
	d[2] = byte 16rED;
	d[3] = byte p.rport;
	d[4] = byte p.lport;
	d[5] = byte p.protocol;
	d[6] = byte (nb >> 8);
	d[7] = byte (nb & 16rFF);
	d[8] = byte xid;
	d[9] = byte 0;
	n := 0;
	for(i:=0; i<len d; i++)
		n += int d[i];
	d[9] = byte (n & 16rFF);
	if(debug)
		printbytes(d, "SLP Tx hdr");
	crc := crc16(d, 0);
	put2(cb, crc16(b, crc));

	if(sys->write(p.fd, d, SLPHDRLEN) != SLPHDRLEN ||
	   sys->write(p.fd, b, nb) != len b ||
	   sys->write(p.fd, cb, 2) != 2)
		return sys->sprint("%r");
	return nil;
}

Pchan.slp_read(p: self ref Pchan, timeout: int): (ref Sblock, string)
{
	clock := Timer.start(timeout);
	alt {
	<-clock.timeout =>
		if(debug)
			sys->print("SLP: timeout\n");
		return (nil, "SLP: timeout");
	b := <-p.rd =>
		clock.stop();
		return (b, nil);
	}
}

slp_recv(p: ref Pchan, pidc: chan of int)
{
	n: int;

	pidc <-= sys->pctl(0, nil);
	buf := array[2*SLP_MTU] of byte;
	sb := Sblock.new();
	rd := wr := 0;
Work:
	for(;;){

		if(wr != rd){
			# data already in buffer might start a new frame
			if(rd != 0){
				buf[0:] = buf[rd:wr];
				wr -= rd;
				rd = 0;
			}
		}else
			rd = wr = 0;

		# header
		while(wr < SLPHDRLEN){
			n = sys->read(p.fd, buf[wr:], SLPHDRLEN-wr);
			if(n <= 0)
				break Work;
			wr += n;
		}
#		{for(i:=0; i<wr;i++)sys->print("%.2x", int buf[i]);sys->print("\n");}
		if(buf[0] != byte 16rBE || buf[1] != byte 16rEF || buf[2] != byte 16rED){
			rd++;
			continue;
		}
		if(debug)
			printbytes(buf[0:wr], "SLP Rx hdr");
		n = 0;
		for(i:=0; i<SLPHDRLEN-1; i++)
			n += int buf[i];
		if((n & 16rFF) != int buf[9]){
			rd += 3;
			continue;
		}
		hdr := buf[0:SLPHDRLEN];
		sb.dst = int hdr[3];
		sb.src = int hdr[4];
		sb.proto = int hdr[5];
		size := (int hdr[6]<<8) | int hdr[7];
		sb.xid = int hdr[8];
		sb.data = array[size] of byte;
		crc := crc16(hdr, 0);
		rd += SLPHDRLEN;
		if(rd == wr)
			rd = wr = 0;

		# data and CRC
		while(wr-rd < size+2){
			n = sys->read(p.fd, buf[wr:], size+2-(wr-rd));
			if(n <= 0)
				break Work;
			wr += n;
		}
		crc = crc16(buf[rd:rd+size], crc);
		if(crc != get2(buf[rd+size:])){
			if(debug)
				sys->print("CRC error: local=#%.4ux pilot=#%.4ux\n", crc, get2(buf[rd+size:]));
			for(; rd < wr && buf[rd] != byte 16rBE; rd++)
				;	# hunt for next header
			continue;
		}
		if(sb.proto != SLP_Loop){
			sb.data[0:] = buf[rd:rd+size];
			if(debug)
				sb.print("Rx");
			rd += size+2;
			p.rd <-= sb;
			sb = Sblock.new();
		} else {
			# should we reflect these?
			if(debug)
				sb.print("Loop");
			rd += size+2;
		}
	}
	p.rd <-= nil;
}

Sblock.print(b: self ref Sblock, dir: string)
{
	sys->print("SLP %s %d->%d len=%d proto=%d xid=#%.2x\n",
			dir, int b.src, int b.dst, len b.data, int b.proto, int b.xid);
}

printbytes(d: array of byte, what: string)
{
	buf := sys->sprint("%s[", what);
	for(i:=0; i<len d; i++)
		buf += sys->sprint(" #%.2x", int d[i]);
	buf += "]";
	sys->print("%s\n", buf);
}

get4(p: array of byte): int
{
	return (int p[0]<<24) | (int p[1]<<16) | (int p[2]<<8) | int p[3];
}

get3(p: array of byte): int
{
	return (int p[1]<<16) | (int p[2]<<8) | int p[3];
}

get2(p: array of byte): int
{
	return (int p[0]<<8) | int p[1];
}

put4(p: array of byte, v: int)
{
	p[0] = byte (v>>24);
	p[1] = byte (v>>16);
	p[2] = byte (v>>8);
	p[3] = byte (v & 16rFF);
}

put3(p: array of byte, v: int)
{
	p[0] = byte (v>>16);
	p[1] = byte (v>>8);
	p[2] = byte (v & 16rFF);
}

put2(p: array of byte, v: int)
{
	p[0] = byte (v>>8);
	p[1] = byte (v & 16rFF);
}

# this will be done by table look up;
# polynomial is xⁱ⁶+xⁱ⁲+x⁵+1

crc16(buf: array of byte, crc: int): int
{
	for(j := 0; j < len buf; j++){
		crc = crc ^ (int buf[j]) << 8;
		for(i := 0; i < 8; i++)
			if(crc & 16r8000)
				crc = (crc << 1) ^ 16r1021;
			else
				crc = crc << 1;
	}
	return crc & 16rffff;
}