implement Sshfmt; include "sys.m";	sys: Sys;	sprint: import sys;include "util0.m";	util: Util0;	prefix, suffix, rev, l2a, max, min, warn, join, eq, g32, g32i, g64, p32, p32i, p64: import util;include "keyring.m";	kr: Keyring;	IPint: import kr;include "sshfmt.m";  init(){	sys = load Sys Sys->PATH;	kr = load Keyring Keyring->PATH;	util = load Util0 Util0->PATH;	util->init();} pack(v: array of ref Val, withlength: int): array of byte{	lensize := 0;	if(withlength)		lensize = 4; 	size := 0;	for(i := 0; i < len v; i++)		size += v[i].size(); 	buf := array[lensize+size] of byte;	if(withlength)		p32i(buf, 0, size); 	o := lensize;	for(i = 0; i < len v; i++)		o += v[i].packbuf(buf[o:]);	if(o != len buf)		raise "packerror";	return buf;} parseall(buf: array of byte, l: list of int): (array of ref Val, string){	(v, o, err) := parse(buf, l);	if(err != nil)		return (nil, err);	if(o != len buf)		return (nil, sprint("leftover bytes, %d of %d used", o, len buf));	return (v, nil);} parse(buf: array of byte, l: list of int): (array of ref Val, int, string){	{		(v, o) := xparse(buf, l);		return (v, o, nil);	} exception x {	"parse:*" =>		return (nil, 0, x[len "parse:":]);	}} parseerror(s: string){	raise "parse:"+s;} xparse(buf: array of byte, l: list of int): (array of ref Val, int){	r: list of ref Val;	o := 0;	i := 0;	for(; l != nil; l = tl l) {		#say(sprint("parse, %d elems left, %d bytes left", len l, len buf-o));		t := hd l;		case t {		Tbyte =>			if(o+1 > len buf)				parseerror("short buffer for byte");			r = ref Val.Byte (buf[o++])::r;		Tbool =>			if(o+1 > len buf)				parseerror("short buffer for byte");			r = ref Val.Bool (int buf[o++])::r;		Tint =>			if(o+4 > len buf)				parseerror("short buffer for int");			e := ref Val.Int;			(e.v, o) = g32(buf, o);			r = e::r;		Tbig =>			if(o+8 > len buf)				parseerror("short buffer for big");			e := ref Val.Big;			(e.v, o) = g64(buf, o);			r = e::r;		Tnames or		Tstr or		Tmpint =>			if(o+4 > len buf)				parseerror("short buffer for int for length");			length: int;			(length, o) = g32i(buf, o);			if(o+length > len buf)				parseerror("short buffer for name-list/string/mpint");			case t {			Tnames =>				# xxx disallow non-printable?				# xxx better verify tokens				r = ref Val.Names (sys->tokenize(string buf[o:o+length], ",").t1)::r;			Tstr =>				r = ref Val.Str (buf[o:o+length])::r;			Tmpint =>				#say(sprint("read mpint of length %d", length));				if(length == 0) {					r = valmpint(IPint.strtoip("0", 10))::r;				} else {					neg := 0;					if(int buf[o] & 16r80) {						raise "negative incoming";						neg = 1;						buf[o] &= byte 16r7f;					}					v := IPint.bebytestoip(buf[o:o+length]);					if(neg) {						buf[o] |= byte 16r80;						v = v.neg();					}					r = valmpint(v)::r;					#say(sprint("new mpint %s", (hd r).text()));				}			}			o += length;		* =>			if(t < 0)				parseerror(sprint("unknown type %d requested", t));			if(o+t > len buf)				parseerror("short buffer for byte-array");			r = ref Val.Str (buf[o:o+t])::r;			o += t;		}		#say(sprint("new val, size %d, text %s", (hd r).size(), (hd r).text()));		i++;	}	return (l2a(rev(r)), o);}  Val.getbyte(v: self ref Val): byte{	pick vv := v {	Byte =>	return byte vv.v;	}	raise "not byte";} Val.getbool(v: self ref Val): int{	pick vv := v {	Bool =>	return vv.v;	}	raise "not bool";} Val.getint(v: self ref Val): int{	pick vv := v {	Int =>	return int vv.v;	}	raise "not int";} Val.getintb(v: self ref Val): big{	pick vv := v {	Int =>	return vv.v;	}	raise "not int";} Val.getbig(v: self ref Val): big{	pick vv := v {	Big =>	return vv.v;	}	raise "not big";} Val.getnames(v: self ref Val): list of string{	pick vv := v {	Names =>	return vv.l;	}	raise "not names";} Val.getipint(v: self ref Val): ref IPint{	pick vv := v {	Mpint =>	return vv.v;	}	raise "not mpint";} Val.getstr(v: self ref Val): string{	pick vv := v {	Str =>	return string vv.buf;	}	raise "not string";} Val.getbytes(v: self ref Val): array of byte{	pick vv := v {	Str =>	return vv.buf;	}	raise "not string (bytes)";}  Val.pack(v: self ref Val): array of byte{	n := v.size();	d := array[n] of byte;	v.packbuf(d);	return d;} Val.text(vv: self ref Val): string{	pick v := vv {	Byte =>	return string v.v;	Bool =>		if(v.v)			return "true";		return "false";	Int =>	return string v.v;	Big =>	return string v.v;	Names =>	return join(v.l, ",");	Str =>	return "string "+string v.buf;	Mpint =>		return "ipint "+v.v.iptostr(16);	Buf =>	return "buf "+string v.buf;	}} Val.size(vv: self ref Val): int{	pick v := vv {	Byte =>	return 1;	Bool =>	return 1;	Int =>	return 4;	Big =>	return 8;	Names =>	return 4+len join(v.l, ",");	Str =>	return 4+len v.buf;	Mpint =>	return len packmpint(v.v);	Buf =>	return len v.buf;	}} packmpint(v: ref IPint): array of byte{	zero := IPint.strtoip("0", 10);	cmp := zero.cmp(v);	if(cmp == 0) {		d := array[4] of byte;		p32i(d, 0, 0);		return d;	}	if(v.cmp(zero) < 0)		raise "negative";	buf := v.iptobebytes();	if(int buf[0] & 16r80) {		nbuf := array[len buf+1] of byte;		nbuf[0] = byte 0;		nbuf[1:] = buf;		buf = nbuf;	}	d := array[4+len buf] of byte;	p32i(d, 0, len buf);	d[4:] = buf;	#say(sprint("Val.Mpint.pack, hex %s", hex(d)));	return d;} Val.packbuf(vv: self ref Val, d: array of byte): int{	pick v := vv {	Byte =>		d[0] = v.v;		return 1;	Bool =>		d[0] = byte v.v;		return 1;	Int =>		return p32(d, 0, v.v);	Big =>		return p64(d, 0, v.v);	Names =>		s := array of byte join(v.l, ",");		p32i(d, 0, len s);		d[4:] = s;		return 4+len s;	Str =>		p32i(d, 0, len v.buf);		d[4:] = v.buf;		return 4+len v.buf;	Mpint =>		buf := packmpint(v.v);		d[:] = buf;		return len buf;	Buf =>		d[:] = v.buf;		return len v.buf;	};}  valbyte(v: byte): ref Val{	return ref Val.Byte (v);}valbool(v: int): ref Val{	return ref Val.Bool (v);}valint(v: int): ref Val{	return ref Val.Int (big v);}valintb(v: big): ref Val{	return ref Val.Int (v);}valbig(v: big): ref Val{	return ref Val.Big (v);}valmpint(v: ref IPint): ref Val{	return ref Val.Mpint (v);}valnames(v: list of string): ref Val{	return ref Val.Names (v);}valstr(v: string): ref Val{	return ref Val.Str (array of byte v);}valbytes(v: array of byte): ref Val{	return ref Val.Str (v);}valbuf(v: array of byte): ref Val{	return ref Val.Buf (v);}