a

Russ Cox committed 21 years ago

Commit 934846f1 parent 0189e66382 files · +62610 −-4Browse files

Showing the changes to include (19 of 382 files). Show all

Unified · Split

19 files

include/a.out +0 −0
include/auth.h +144 −0
include/authsrv.h +166 −0
include/cursor.h +6 −0
include/draw.h +519 −0
include/dtos.h +10 −0
include/fcall.h +110 −0
include/keyboard.h +42 −0
include/lib.h +246 −0
include/libc.h +3 −0
include/libsec.h +340 −0
include/memdraw.h +200 −0
include/memlayer.h +51 −0
include/mp.h +134 −0
include/u.h +26 −0
include/unix.h +14 −0
include/user.h +65 −0
include/x +0 −0
include/x.c +6 −0

include/a.out+0−0

Binary file not shown.

include/auth.h+144−0

@@ -0,0 +1,144 @@
	1	+#pragma src "/sys/src/libauth"
	2	+#pragma lib "libauth.a"
	3	+
	4	+/*
	5	+ * Interface for typical callers.
	6	+ */
	7	+
	8	+typedef struct AuthInfo AuthInfo;
	9	+typedef struct Chalstate Chalstate;
	10	+typedef struct Chapreply Chapreply;
	11	+typedef struct MSchapreply MSchapreply;
	12	+typedef struct UserPasswd UserPasswd;
	13	+typedef struct AuthRpc AuthRpc;
	14	+
	15	+enum
	16	+{
	17	+ MAXCHLEN= 256, /* max challenge length */
	18	+ MAXNAMELEN= 256, /* maximum name length */
	19	+ MD5LEN= 16,
	20	+
	21	+ ARok = 0, /* rpc return values */
	22	+ ARdone,
	23	+ ARerror,
	24	+ ARneedkey,
	25	+ ARbadkey,
	26	+ ARwritenext,
	27	+ ARtoosmall,
	28	+ ARtoobig,
	29	+ ARrpcfailure,
	30	+ ARphase,
	31	+
	32	+ AuthRpcMax = 4096,
	33	+};
	34	+
	35	+struct AuthRpc
	36	+{
	37	+ int afd;
	38	+ char ibuf[AuthRpcMax];
	39	+ char obuf[AuthRpcMax];
	40	+ char *arg;
	41	+ uint narg;
	42	+};
	43	+
	44	+struct AuthInfo
	45	+{
	46	+ char cuid; / caller id */
	47	+ char suid; / server id */
	48	+ char cap; / capability (only valid on server side) */
	49	+ int nsecret; /* length of secret */
	50	+ uchar secret; / secret */
	51	+};
	52	+
	53	+struct Chalstate
	54	+{
	55	+ char *user;
	56	+ char chal[MAXCHLEN];
	57	+ int nchal;
	58	+ void *resp;
	59	+ int nresp;
	60	+
	61	+/* for implementation only */
	62	+ int afd; /* to factotum */
	63	+ AuthRpc rpc; / to factotum */
	64	+ char userbuf[MAXNAMELEN]; /* temp space if needed */
	65	+ int userinchal; /* user was sent to obtain challenge */
	66	+};
	67	+
	68	+struct Chapreply /* for protocol "chap" */
	69	+{
	70	+ uchar id;
	71	+ char resp[MD5LEN];
	72	+};
	73	+
	74	+struct MSchapreply /* for protocol "mschap" */
	75	+{
	76	+ char LMresp[24]; /* Lan Manager response */
	77	+ char NTresp[24]; /* NT response */
	78	+};
	79	+
	80	+struct UserPasswd
	81	+{
	82	+ char *user;
	83	+ char *passwd;
	84	+};
	85	+
	86	+extern int newns(char, char);
	87	+extern int addns(char, char);
	88	+
	89	+extern int noworld(char*);
	90	+extern int amount(int, char, int, char);
	91	+
	92	+/* these two may get generalized away -rsc */
	93	+extern int login(char, char, char*);
	94	+extern int httpauth(char, char);
	95	+
	96	+typedef struct Attr Attr;
	97	+typedef struct String String;
	98	+enum {
	99	+ AttrNameval, /* name=val -- when matching, must have name=val */
	100	+ AttrQuery, /* name? -- when matching, must be present */
	101	+ AttrDefault, /* name:=val -- when matching, if present must match INTERNAL */
	102	+};
	103	+struct Attr
	104	+{
	105	+ int type;
	106	+ Attr *next;
	107	+ char *name;
	108	+ char *val;
	109	+};
	110	+
	111	+typedef int AuthGetkey(char*);
	112	+
	113	+int _attrfmt(Fmt*);
	114	+Attr _copyattr(Attr);
	115	+Attr _delattr(Attr, char*);
	116	+Attr _findattr(Attr, char*);
	117	+void _freeattr(Attr*);
	118	+Attr _mkattr(int, char, char, Attr);
	119	+Attr _parseattr(char);
	120	+char _strfindattr(Attr, char*);
	121	+#pragma varargck type "A" Attr*
	122	+
	123	+extern AuthInfo* fauth_proxy(int, AuthRpc rpc, AuthGetkey getkey, char *params);
	124	+extern AuthInfo* auth_proxy(int fd, AuthGetkey getkey, char fmt, ...);
	125	+extern int auth_getkey(char*);
	126	+extern int (amount_getkey)(char);
	127	+extern void auth_freeAI(AuthInfo *ai);
	128	+extern int auth_chuid(AuthInfo ai, char ns);
	129	+extern Chalstate auth_challenge(char, ...);
	130	+extern AuthInfo* auth_response(Chalstate*);
	131	+extern int auth_respond(void, uint, char, uint, void, uint, AuthGetkey getkey, char*, ...);
	132	+extern void auth_freechal(Chalstate*);
	133	+extern AuthInfo* auth_userpasswd(char user, char passwd);
	134	+extern UserPasswd* auth_getuserpasswd(AuthGetkey getkey, char, ...);
	135	+extern AuthInfo* auth_getinfo(AuthRpc *rpc);
	136	+extern AuthRpc* auth_allocrpc(int afd);
	137	+extern Attr* auth_attr(AuthRpc *rpc);
	138	+extern void auth_freerpc(AuthRpc *rpc);
	139	+extern uint auth_rpc(AuthRpc rpc, char verb, void *a, int n);
	140	+extern int auth_wep(char, char, ...);
	141	+#pragma varargck argpos auth_proxy 3
	142	+#pragma varargck argpos auth_challenge 1
	143	+#pragma varargck argpos auth_respond 3
	144	+#pragma varargck argpos auth_getuserpasswd 2

include/authsrv.h+166−0

@@ -0,0 +1,166 @@
	1	+#pragma src "/sys/src/libauthsrv"
	2	+#pragma lib "libauthsrv.a"
	3	+
	4	+/*
	5	+ * Interface for talking to authentication server.
	6	+ */
	7	+typedef struct Ticket Ticket;
	8	+typedef struct Ticketreq Ticketreq;
	9	+typedef struct Authenticator Authenticator;
	10	+typedef struct Nvrsafe Nvrsafe;
	11	+typedef struct Passwordreq Passwordreq;
	12	+typedef struct OChapreply OChapreply;
	13	+typedef struct OMSchapreply OMSchapreply;
	14	+
	15	+enum
	16	+{
	17	+ ANAMELEN= 28, /* maximum size of name in previous proto */
	18	+ AERRLEN= 64, /* maximum size of errstr in previous proto */
	19	+ DOMLEN= 48, /* length of an authentication domain name */
	20	+ DESKEYLEN= 7, /* length of a des key for encrypt/decrypt */
	21	+ CHALLEN= 8, /* length of a plan9 sk1 challenge */
	22	+ NETCHLEN= 16, /* max network challenge length (used in AS protocol) */
	23	+ CONFIGLEN= 14,
	24	+ SECRETLEN= 32, /* max length of a secret */
	25	+
	26	+ KEYDBOFF= 8, /* length of random data at the start of key file */
	27	+ OKEYDBLEN= ANAMELEN+DESKEYLEN+4+2, /* length of an entry in old key file */
	28	+ KEYDBLEN= OKEYDBLEN+SECRETLEN, /* length of an entry in key file */
	29	+ OMD5LEN= 16,
	30	+};
	31	+
	32	+/* encryption numberings (anti-replay) */
	33	+enum
	34	+{
	35	+ AuthTreq=1, /* ticket request */
	36	+ AuthChal=2, /* challenge box request */
	37	+ AuthPass=3, /* change password */
	38	+ AuthOK=4, /* fixed length reply follows */
	39	+ AuthErr=5, /* error follows */
	40	+ AuthMod=6, /* modify user */
	41	+ AuthApop=7, /* apop authentication for pop3 */
	42	+ AuthOKvar=9, /* variable length reply follows */
	43	+ AuthChap=10, /* chap authentication for ppp */
	44	+ AuthMSchap=11, /* MS chap authentication for ppp */
	45	+ AuthCram=12, /* CRAM verification for IMAP (RFC2195 & rfc2104) */
	46	+ AuthHttp=13, /* http domain login */
	47	+ AuthVNC=14, /* VNC server login (deprecated) */
	48	+
	49	+
	50	+ AuthTs=64, /* ticket encrypted with server's key */
	51	+ AuthTc, /* ticket encrypted with client's key */
	52	+ AuthAs, /* server generated authenticator */
	53	+ AuthAc, /* client generated authenticator */
	54	+ AuthTp, /* ticket encrypted with client's key for password change */
	55	+ AuthHr, /* http reply */
	56	+};
	57	+
	58	+struct Ticketreq
	59	+{
	60	+ char type;
	61	+ char authid[ANAMELEN]; /* server's encryption id */
	62	+ char authdom[DOMLEN]; /* server's authentication domain */
	63	+ char chal[CHALLEN]; /* challenge from server */
	64	+ char hostid[ANAMELEN]; /* host's encryption id */
	65	+ char uid[ANAMELEN]; /* uid of requesting user on host */
	66	+};
	67	+#define TICKREQLEN (3*ANAMELEN+CHALLEN+DOMLEN+1)
	68	+
	69	+struct Ticket
	70	+{
	71	+ char num; /* replay protection */
	72	+ char chal[CHALLEN]; /* server challenge */
	73	+ char cuid[ANAMELEN]; /* uid on client */
	74	+ char suid[ANAMELEN]; /* uid on server */
	75	+ char key[DESKEYLEN]; /* nonce DES key */
	76	+};
	77	+#define TICKETLEN (CHALLEN+2*ANAMELEN+DESKEYLEN+1)
	78	+
	79	+struct Authenticator
	80	+{
	81	+ char num; /* replay protection */
	82	+ char chal[CHALLEN];
	83	+ ulong id; /* authenticator id, ++'d with each auth */
	84	+};
	85	+#define AUTHENTLEN (CHALLEN+4+1)
	86	+
	87	+struct Passwordreq
	88	+{
	89	+ char num;
	90	+ char old[ANAMELEN];
	91	+ char new[ANAMELEN];
	92	+ char changesecret;
	93	+ char secret[SECRETLEN]; /* new secret */
	94	+};
	95	+#define PASSREQLEN (2*ANAMELEN+1+1+SECRETLEN)
	96	+
	97	+struct OChapreply
	98	+{
	99	+ uchar id;
	100	+ char uid[ANAMELEN];
	101	+ char resp[OMD5LEN];
	102	+};
	103	+
	104	+struct OMSchapreply
	105	+{
	106	+ char uid[ANAMELEN];
	107	+ char LMresp[24]; /* Lan Manager response */
	108	+ char NTresp[24]; /* NT response */
	109	+};
	110	+
	111	+/*
	112	+ * convert to/from wire format
	113	+ */
	114	+extern int convT2M(Ticket, char, char*);
	115	+extern void convM2T(char, Ticket, char*);
	116	+extern void convM2Tnoenc(char, Ticket);
	117	+extern int convA2M(Authenticator, char, char*);
	118	+extern void convM2A(char, Authenticator, char*);
	119	+extern int convTR2M(Ticketreq, char);
	120	+extern void convM2TR(char, Ticketreq);
	121	+extern int convPR2M(Passwordreq, char, char*);
	122	+extern void convM2PR(char, Passwordreq, char*);
	123	+
	124	+/*
	125	+ * convert ascii password to DES key
	126	+ */
	127	+extern int opasstokey(char, char);
	128	+extern int passtokey(char, char);
	129	+
	130	+/*
	131	+ * Nvram interface
	132	+ */
	133	+enum {
	134	+ NVwrite = 1<<0, /* always prompt and rewrite nvram */
	135	+ NVwriteonerr = 1<<1, /* prompt and rewrite nvram when corrupt */
	136	+};
	137	+
	138	+struct Nvrsafe
	139	+{
	140	+ char machkey[DESKEYLEN];
	141	+ uchar machsum;
	142	+ char authkey[DESKEYLEN];
	143	+ uchar authsum;
	144	+ char config[CONFIGLEN];
	145	+ uchar configsum;
	146	+ char authid[ANAMELEN];
	147	+ uchar authidsum;
	148	+ char authdom[DOMLEN];
	149	+ uchar authdomsum;
	150	+};
	151	+
	152	+extern uchar nvcsum(void*, int);
	153	+extern int readnvram(Nvrsafe*, int);
	154	+
	155	+/*
	156	+ * call up auth server
	157	+ */
	158	+extern int authdial(char netroot, char authdom);
	159	+
	160	+/*
	161	+ * exchange messages with auth server
	162	+ */
	163	+extern int _asgetticket(int, char, char);
	164	+extern int _asrdresp(int, char*, int);
	165	+extern int sslnegotiate(int, Ticket, char, char*);
	166	+extern int srvsslnegotiate(int, Ticket, char, char*);

include/cursor.h+6−0

@@ -0,0 +1,6 @@
	1	+struct Cursor
	2	+{
	3	+ Point offset;
	4	+ uchar clr[2*16];
	5	+ uchar set[2*16];
	6	+};

include/draw.h+519−0

@@ -0,0 +1,519 @@
	1	+#pragma src "/sys/src/libdraw"
	2	+#pragma lib "libdraw.a"
	3	+
	4	+typedef struct Cachefont Cachefont;
	5	+typedef struct Cacheinfo Cacheinfo;
	6	+typedef struct Cachesubf Cachesubf;
	7	+typedef struct Display Display;
	8	+typedef struct Font Font;
	9	+typedef struct Fontchar Fontchar;
	10	+typedef struct Image Image;
	11	+typedef struct Mouse Mouse;
	12	+typedef struct Point Point;
	13	+typedef struct Rectangle Rectangle;
	14	+typedef struct RGB RGB;
	15	+typedef struct Screen Screen;
	16	+typedef struct Subfont Subfont;
	17	+
	18	+#pragma varargck type "R" Rectangle
	19	+#pragma varargck type "P" Point
	20	+extern int Rfmt(Fmt*);
	21	+extern int Pfmt(Fmt*);
	22	+
	23	+enum
	24	+{
	25	+ DOpaque = 0xFFFFFFFF,
	26	+ DTransparent = 0x00000000, /* only useful for allocimage, memfillcolor */
	27	+ DBlack = 0x000000FF,
	28	+ DWhite = 0xFFFFFFFF,
	29	+ DRed = 0xFF0000FF,
	30	+ DGreen = 0x00FF00FF,
	31	+ DBlue = 0x0000FFFF,
	32	+ DCyan = 0x00FFFFFF,
	33	+ DMagenta = 0xFF00FFFF,
	34	+ DYellow = 0xFFFF00FF,
	35	+ DPaleyellow = 0xFFFFAAFF,
	36	+ DDarkyellow = 0xEEEE9EFF,
	37	+ DDarkgreen = 0x448844FF,
	38	+ DPalegreen = 0xAAFFAAFF,
	39	+ DMedgreen = 0x88CC88FF,
	40	+ DDarkblue = 0x000055FF,
	41	+ DPalebluegreen= 0xAAFFFFFF,
	42	+ DPaleblue = 0x0000BBFF,
	43	+ DBluegreen = 0x008888FF,
	44	+ DGreygreen = 0x55AAAAFF,
	45	+ DPalegreygreen = 0x9EEEEEFF,
	46	+ DYellowgreen = 0x99994CFF,
	47	+ DMedblue = 0x000099FF,
	48	+ DGreyblue = 0x005DBBFF,
	49	+ DPalegreyblue = 0x4993DDFF,
	50	+ DPurpleblue = 0x8888CCFF,
	51	+
	52	+ DNotacolor = 0xFFFFFF00,
	53	+ DNofill = DNotacolor,
	54	+
	55	+};
	56	+
	57	+enum
	58	+{
	59	+ Displaybufsize = 8000,
	60	+ ICOSSCALE = 1024,
	61	+ Borderwidth = 4,
	62	+};
	63	+
	64	+enum
	65	+{
	66	+ /* refresh methods */
	67	+ Refbackup = 0,
	68	+ Refnone = 1,
	69	+ Refmesg = 2
	70	+};
	71	+#define NOREFRESH ((void*)-1)
	72	+
	73	+enum
	74	+{
	75	+ /* line ends */
	76	+ Endsquare = 0,
	77	+ Enddisc = 1,
	78	+ Endarrow = 2,
	79	+ Endmask = 0x1F
	80	+};
	81	+
	82	+#define ARROW(a, b, c) (Endarrow\|((a)<<5)\|((b)<<14)\|((c)<<23))
	83	+
	84	+typedef enum
	85	+{
	86	+ /* Porter-Duff compositing operators */
	87	+ Clear = 0,
	88	+
	89	+ SinD = 8,
	90	+ DinS = 4,
	91	+ SoutD = 2,
	92	+ DoutS = 1,
	93	+
	94	+ S = SinD\|SoutD,
	95	+ SoverD = SinD\|SoutD\|DoutS,
	96	+ SatopD = SinD\|DoutS,
	97	+ SxorD = SoutD\|DoutS,
	98	+
	99	+ D = DinS\|DoutS,
	100	+ DoverS = DinS\|DoutS\|SoutD,
	101	+ DatopS = DinS\|SoutD,
	102	+ DxorS = DoutS\|SoutD, /* == SxorD */
	103	+
	104	+ Ncomp = 12,
	105	+} Drawop;
	106	+
	107	+/*
	108	+ * image channel descriptors
	109	+ */
	110	+enum {
	111	+ CRed = 0,
	112	+ CGreen,
	113	+ CBlue,
	114	+ CGrey,
	115	+ CAlpha,
	116	+ CMap,
	117	+ CIgnore,
	118	+ NChan,
	119	+};
	120	+
	121	+#define __DC(type, nbits) ((((type)&15)<<4)\|((nbits)&15))
	122	+#define CHAN1(a,b) __DC(a,b)
	123	+#define CHAN2(a,b,c,d) (CHAN1((a),(b))<<8\|__DC((c),(d)))
	124	+#define CHAN3(a,b,c,d,e,f) (CHAN2((a),(b),(c),(d))<<8\|__DC((e),(f)))
	125	+#define CHAN4(a,b,c,d,e,f,g,h) (CHAN3((a),(b),(c),(d),(e),(f))<<8\|__DC((g),(h)))
	126	+
	127	+#define NBITS(c) ((c)&15)
	128	+#define TYPE(c) (((c)>>4)&15)
	129	+
	130	+enum {
	131	+ GREY1 = CHAN1(CGrey, 1),
	132	+ GREY2 = CHAN1(CGrey, 2),
	133	+ GREY4 = CHAN1(CGrey, 4),
	134	+ GREY8 = CHAN1(CGrey, 8),
	135	+ CMAP8 = CHAN1(CMap, 8),
	136	+ RGB15 = CHAN4(CIgnore, 1, CRed, 5, CGreen, 5, CBlue, 5),
	137	+ RGB16 = CHAN3(CRed, 5, CGreen, 6, CBlue, 5),
	138	+ RGB24 = CHAN3(CRed, 8, CGreen, 8, CBlue, 8),
	139	+ BGR24 = CHAN3(CBlue, 8, CGreen, 8, CRed, 8),
	140	+ RGBA32 = CHAN4(CRed, 8, CGreen, 8, CBlue, 8, CAlpha, 8),
	141	+ ARGB32 = CHAN4(CAlpha, 8, CRed, 8, CGreen, 8, CBlue, 8), /* stupid VGAs */
	142	+ XRGB32 = CHAN4(CIgnore, 8, CRed, 8, CGreen, 8, CBlue, 8),
	143	+ XBGR32 = CHAN4(CIgnore, 8, CBlue, 8, CGreen, 8, CRed, 8),
	144	+};
	145	+
	146	+extern char* chantostr(char*, ulong);
	147	+extern ulong strtochan(char*);
	148	+extern int chantodepth(ulong);
	149	+
	150	+struct Point
	151	+{
	152	+ int x;
	153	+ int y;
	154	+};
	155	+
	156	+struct Rectangle
	157	+{
	158	+ Point min;
	159	+ Point max;
	160	+};
	161	+
	162	+typedef void (Reffn)(Image, Rectangle, void*);
	163	+
	164	+struct Screen
	165	+{
	166	+ Display display; / display holding data */
	167	+ int id; /* id of system-held Screen */
	168	+ Image image; / unused; for reference only */
	169	+ Image fill; / color to paint behind windows */
	170	+};
	171	+
	172	+struct Display
	173	+{
	174	+ QLock qlock;
	175	+ int locking; /program is using lockdisplay /
	176	+ int dirno;
	177	+ int fd;
	178	+ int reffd;
	179	+ int ctlfd;
	180	+ int imageid;
	181	+ int local;
	182	+ void (error)(Display, char*);
	183	+ char *devdir;
	184	+ char *windir;
	185	+ char oldlabel[64];
	186	+ ulong dataqid;
	187	+ Image *white;
	188	+ Image *black;
	189	+ Image *opaque;
	190	+ Image *transparent;
	191	+ Image *image;
	192	+ uchar *buf;
	193	+ int bufsize;
	194	+ uchar *bufp;
	195	+ Font *defaultfont;
	196	+ Subfont *defaultsubfont;
	197	+ Image *windows;
	198	+ Image *screenimage;
	199	+ int _isnewdisplay;
	200	+};
	201	+
	202	+struct Image
	203	+{
	204	+ Display display; / display holding data */
	205	+ int id; /* id of system-held Image */
	206	+ Rectangle r; /* rectangle in data area, local coords */
	207	+ Rectangle clipr; /* clipping region */
	208	+ int depth; /* number of bits per pixel */
	209	+ ulong chan;
	210	+ int repl; /* flag: data replicates to tile clipr */
	211	+ Screen screen; / 0 if not a window */
	212	+ Image next; / next in list of windows */
	213	+};
	214	+
	215	+struct RGB
	216	+{
	217	+ ulong red;
	218	+ ulong green;
	219	+ ulong blue;
	220	+};
	221	+
	222	+/*
	223	+ * Subfonts
	224	+ *
	225	+ * given char c, Subfont f, Fontchar i, and Point p, one says
	226	+ * i = f->info+c;
	227	+ * draw(b, Rect(p.x+i->left, p.y+i->top,
	228	+ * p.x+i->left+((i+1)->x-i->x), p.y+i->bottom),
	229	+ * color, f->bits, Pt(i->x, i->top));
	230	+ * p.x += i->width;
	231	+ * to draw characters in the specified color (itself an Image) in Image b.
	232	+ */
	233	+
	234	+struct Fontchar
	235	+{
	236	+ int x; /* left edge of bits */
	237	+ uchar top; /* first non-zero scan-line */
	238	+ uchar bottom; /* last non-zero scan-line + 1 */
	239	+ char left; /* offset of baseline */
	240	+ uchar width; /* width of baseline */
	241	+};
	242	+
	243	+struct Subfont
	244	+{
	245	+ char *name;
	246	+ short n; /* number of chars in font */
	247	+ uchar height; /* height of image */
	248	+ char ascent; /* top of image to baseline */
	249	+ Fontchar info; / n+1 character descriptors */
	250	+ Image bits; / of font */
	251	+ int ref;
	252	+};
	253	+
	254	+enum
	255	+{
	256	+ /* starting values */
	257	+ LOG2NFCACHE = 6,
	258	+ NFCACHE = (1<<LOG2NFCACHE), /* #chars cached */
	259	+ NFLOOK = 5, /* #chars to scan in cache */
	260	+ NFSUBF = 2, /* #subfonts to cache */
	261	+ /* max value */
	262	+ MAXFCACHE = 1024+NFLOOK, /* upper limit */
	263	+ MAXSUBF = 50, /* generous upper limit */
	264	+ /* deltas */
	265	+ DSUBF = 4,
	266	+ /* expiry ages */
	267	+ SUBFAGE = 10000,
	268	+ CACHEAGE = 10000
	269	+};
	270	+
	271	+struct Cachefont
	272	+{
	273	+ Rune min; /* lowest rune value to be taken from subfont */
	274	+ Rune max; /* highest rune value+1 to be taken from subfont */
	275	+ int offset; /* position in subfont of character at min */
	276	+ char name; / stored in font */
	277	+ char subfontname; / to access subfont */
	278	+};
	279	+
	280	+struct Cacheinfo
	281	+{
	282	+ ushort x; /* left edge of bits */
	283	+ uchar width; /* width of baseline */
	284	+ schar left; /* offset of baseline */
	285	+ Rune value; /* value of character at this slot in cache */
	286	+ ushort age;
	287	+};
	288	+
	289	+struct Cachesubf
	290	+{
	291	+ ulong age; /* for replacement */
	292	+ Cachefont cf; / font info that owns us */
	293	+ Subfont f; / attached subfont */
	294	+};
	295	+
	296	+struct Font
	297	+{
	298	+ char *name;
	299	+ Display *display;
	300	+ short height; /* max height of image, interline spacing */
	301	+ short ascent; /* top of image to baseline */
	302	+ short width; /* widest so far; used in caching only */
	303	+ short nsub; /* number of subfonts */
	304	+ ulong age; /* increasing counter; used for LRU */
	305	+ int maxdepth; /* maximum depth of all loaded subfonts */
	306	+ int ncache; /* size of cache */
	307	+ int nsubf; /* size of subfont list */
	308	+ Cacheinfo *cache;
	309	+ Cachesubf *subf;
	310	+ Cachefont *sub; / as read from file */
	311	+ Image *cacheimage;
	312	+};
	313	+
	314	+#define Dx(r) ((r).max.x-(r).min.x)
	315	+#define Dy(r) ((r).max.y-(r).min.y)
	316	+
	317	+/*
	318	+ * Image management
	319	+ */
	320	+extern Image* _allocimage(Image, Display, Rectangle, ulong, int, ulong, int, int);
	321	+extern Image* allocimage(Display*, Rectangle, ulong, int, ulong);
	322	+extern uchar* bufimage(Display*, int);
	323	+extern int bytesperline(Rectangle, int);
	324	+extern void closedisplay(Display*);
	325	+extern void drawerror(Display, char);
	326	+extern int flushimage(Display*, int);
	327	+extern int freeimage(Image*);
	328	+extern int _freeimage1(Image*);
	329	+extern int geninitdraw(char, void()(Display, char), char, char, char*, int);
	330	+extern int initdraw(void()(Display, char), char, char*);
	331	+extern int newwindow(char*);
	332	+extern Display* initdisplay(char, char, void()(Display, char*));
	333	+extern int loadimage(Image, Rectangle, uchar, int);
	334	+extern int cloadimage(Image, Rectangle, uchar, int);
	335	+extern int getwindow(Display*, int);
	336	+extern int gengetwindow(Display, char, Image, Screen, int);
	337	+extern Image* readimage(Display*, int, int);
	338	+extern Image* creadimage(Display*, int, int);
	339	+extern int unloadimage(Image, Rectangle, uchar, int);
	340	+extern int wordsperline(Rectangle, int);
	341	+extern int writeimage(int, Image*, int);
	342	+extern Image* namedimage(Display, char);
	343	+extern int nameimage(Image, char, int);
	344	+extern Image* allocimagemix(Display*, ulong, ulong);
	345	+
	346	+/*
	347	+ * Colors
	348	+ */
	349	+extern void readcolmap(Display, RGB);
	350	+extern void writecolmap(Display, RGB);
	351	+extern ulong setalpha(ulong, uchar);
	352	+
	353	+/*
	354	+ * Windows
	355	+ */
	356	+extern Screen* allocscreen(Image, Image, int);
	357	+extern Image* _allocwindow(Image, Screen, Rectangle, int, ulong);
	358	+extern Image* allocwindow(Screen*, Rectangle, int, ulong);
	359	+extern void bottomnwindows(Image**, int);
	360	+extern void bottomwindow(Image*);
	361	+extern int freescreen(Screen*);
	362	+extern Screen* publicscreen(Display*, int, ulong);
	363	+extern void topnwindows(Image**, int);
	364	+extern void topwindow(Image*);
	365	+extern int originwindow(Image*, Point, Point);
	366	+
	367	+/*
	368	+ * Geometry
	369	+ */
	370	+extern Point Pt(int, int);
	371	+extern Rectangle Rect(int, int, int, int);
	372	+extern Rectangle Rpt(Point, Point);
	373	+extern Point addpt(Point, Point);
	374	+extern Point subpt(Point, Point);
	375	+extern Point divpt(Point, int);
	376	+extern Point mulpt(Point, int);
	377	+extern int eqpt(Point, Point);
	378	+extern int eqrect(Rectangle, Rectangle);
	379	+extern Rectangle insetrect(Rectangle, int);
	380	+extern Rectangle rectaddpt(Rectangle, Point);
	381	+extern Rectangle rectsubpt(Rectangle, Point);
	382	+extern Rectangle canonrect(Rectangle);
	383	+extern int rectXrect(Rectangle, Rectangle);
	384	+extern int rectinrect(Rectangle, Rectangle);
	385	+extern void combinerect(Rectangle*, Rectangle);
	386	+extern int rectclip(Rectangle*, Rectangle);
	387	+extern int ptinrect(Point, Rectangle);
	388	+extern void replclipr(Image*, int, Rectangle);
	389	+extern int drawreplxy(int, int, int); /* used to be drawsetxy */
	390	+extern Point drawrepl(Rectangle, Point);
	391	+extern int rgb2cmap(int, int, int);
	392	+extern int cmap2rgb(int);
	393	+extern int cmap2rgba(int);
	394	+extern void icossin(int, int, int);
	395	+extern void icossin2(int, int, int, int);
	396	+
	397	+/*
	398	+ * Graphics
	399	+ */
	400	+extern void draw(Image, Rectangle, Image, Image*, Point);
	401	+extern void drawop(Image, Rectangle, Image, Image*, Point, Drawop);
	402	+extern void gendraw(Image, Rectangle, Image, Point, Image*, Point);
	403	+extern void gendrawop(Image, Rectangle, Image, Point, Image*, Point, Drawop);
	404	+extern void line(Image, Point, Point, int, int, int, Image, Point);
	405	+extern void lineop(Image, Point, Point, int, int, int, Image, Point, Drawop);
	406	+extern void poly(Image, Point, int, int, int, int, Image*, Point);
	407	+extern void polyop(Image, Point, int, int, int, int, Image*, Point, Drawop);
	408	+extern void fillpoly(Image, Point, int, int, Image*, Point);
	409	+extern void fillpolyop(Image, Point, int, int, Image*, Point, Drawop);
	410	+extern Point string(Image, Point, Image, Point, Font, char);
	411	+extern Point stringop(Image, Point, Image, Point, Font, char, Drawop);
	412	+extern Point stringn(Image, Point, Image, Point, Font, char, int);
	413	+extern Point stringnop(Image, Point, Image, Point, Font, char, int, Drawop);
	414	+extern Point runestring(Image, Point, Image, Point, Font, Rune);
	415	+extern Point runestringop(Image, Point, Image, Point, Font, Rune, Drawop);
	416	+extern Point runestringn(Image, Point, Image, Point, Font, Rune, int);
	417	+extern Point runestringnop(Image, Point, Image, Point, Font, Rune, int, Drawop);
	418	+extern Point stringbg(Image, Point, Image, Point, Font, char, Image*, Point);
	419	+extern Point stringbgop(Image, Point, Image, Point, Font, char, Image*, Point, Drawop);
	420	+extern Point stringnbg(Image, Point, Image, Point, Font, char, int, Image*, Point);
	421	+extern Point stringnbgop(Image, Point, Image, Point, Font, char, int, Image*, Point, Drawop);
	422	+extern Point runestringbg(Image, Point, Image, Point, Font, Rune, Image*, Point);
	423	+extern Point runestringbgop(Image, Point, Image, Point, Font, Rune, Image*, Point, Drawop);
	424	+extern Point runestringnbg(Image, Point, Image, Point, Font, Rune, int, Image*, Point);
	425	+extern Point runestringnbgop(Image, Point, Image, Point, Font, Rune, int, Image*, Point, Drawop);
	426	+extern Point _string(Image, Point, Image, Point, Font, char, Rune, int, Rectangle, Image, Point, Drawop);
	427	+extern Point stringsubfont(Image, Point, Image, Subfont, char);
	428	+extern int bezier(Image, Point, Point, Point, Point, int, int, int, Image, Point);
	429	+extern int bezierop(Image, Point, Point, Point, Point, int, int, int, Image, Point, Drawop);
	430	+extern int bezspline(Image, Point, int, int, int, int, Image*, Point);
	431	+extern int bezsplineop(Image, Point, int, int, int, int, Image*, Point, Drawop);
	432	+extern int bezsplinepts(Point, int, Point*);
	433	+extern int fillbezier(Image, Point, Point, Point, Point, int, Image, Point);
	434	+extern int fillbezierop(Image, Point, Point, Point, Point, int, Image, Point, Drawop);
	435	+extern int fillbezspline(Image, Point, int, int, Image*, Point);
	436	+extern int fillbezsplineop(Image, Point, int, int, Image*, Point, Drawop);
	437	+extern void ellipse(Image, Point, int, int, int, Image, Point);
	438	+extern void ellipseop(Image, Point, int, int, int, Image, Point, Drawop);
	439	+extern void fillellipse(Image, Point, int, int, Image, Point);
	440	+extern void fillellipseop(Image, Point, int, int, Image, Point, Drawop);
	441	+extern void arc(Image, Point, int, int, int, Image, Point, int, int);
	442	+extern void arcop(Image, Point, int, int, int, Image, Point, int, int, Drawop);
	443	+extern void fillarc(Image, Point, int, int, Image, Point, int, int);
	444	+extern void fillarcop(Image, Point, int, int, Image, Point, int, int, Drawop);
	445	+extern void border(Image, Rectangle, int, Image, Point);
	446	+extern void borderop(Image, Rectangle, int, Image, Point, Drawop);
	447	+
	448	+/*
	449	+ * Font management
	450	+ */
	451	+extern Font* openfont(Display, char);
	452	+extern Font* buildfont(Display, char, char*);
	453	+extern void freefont(Font*);
	454	+extern Font* mkfont(Subfont*, Rune);
	455	+extern int cachechars(Font, char, Rune, ushort, int, int, char*);
	456	+extern void agefont(Font*);
	457	+extern Subfont* allocsubfont(char, int, int, int, Fontchar, Image*);
	458	+extern Subfont* lookupsubfont(Display, char);
	459	+extern void installsubfont(char, Subfont);
	460	+extern void uninstallsubfont(Subfont*);
	461	+extern void freesubfont(Subfont*);
	462	+extern Subfont* readsubfont(Display, char, int, int);
	463	+extern Subfont* readsubfonti(Display, char, int, Image*, int);
	464	+extern int writesubfont(int, Subfont*);
	465	+extern void _unpackinfo(Fontchar, uchar, int);
	466	+extern Point stringsize(Font, char);
	467	+extern int stringwidth(Font, char);
	468	+extern int stringnwidth(Font, char, int);
	469	+extern Point runestringsize(Font, Rune);
	470	+extern int runestringwidth(Font, Rune);
	471	+extern int runestringnwidth(Font, Rune, int);
	472	+extern Point strsubfontwidth(Subfont, char);
	473	+extern int loadchar(Font, Rune, Cacheinfo, int, int, char**);
	474	+extern char* subfontname(char, char, int);
	475	+extern Subfont* _getsubfont(Display, char);
	476	+extern Subfont* getdefont(Display*);
	477	+extern void lockdisplay(Display*);
	478	+extern void unlockdisplay(Display*);
	479	+extern int drawlsetrefresh(ulong, int, void, void);
	480	+
	481	+/*
	482	+ * Predefined
	483	+ */
	484	+extern uchar defontdata[];
	485	+extern int sizeofdefont;
	486	+extern Point ZP;
	487	+extern Rectangle ZR;
	488	+
	489	+/*
	490	+ * Set up by initdraw()
	491	+ */
	492	+extern Display *display;
	493	+extern Font *font;
	494	+/* extern Image screen; /
	495	+extern Screen *_screen;
	496	+extern int _cursorfd;
	497	+extern int _drawdebug; /* set to 1 to see errors from flushimage */
	498	+extern void _setdrawop(Display*, Drawop);
	499	+
	500	+#define BGSHORT(p) (((p)[0]<<0) \| ((p)[1]<<8))
	501	+#define BGLONG(p) ((BGSHORT(p)<<0) \| (BGSHORT(p+2)<<16))
	502	+#define BPSHORT(p, v) ((p)[0]=(v), (p)[1]=((v)>>8))
	503	+#define BPLONG(p, v) (BPSHORT(p, (v)), BPSHORT(p+2, (v)>>16))
	504	+
	505	+/*
	506	+ * Compressed image file parameters and helper routines
	507	+ */
	508	+#define NMATCH 3 /* shortest match possible */
	509	+#define NRUN (NMATCH+31) /* longest match possible */
	510	+#define NMEM 1024 /* window size */
	511	+#define NDUMP 128 /* maximum length of dump */
	512	+#define NCBLOCK 6000 /* size of compressed blocks */
	513	+extern void _twiddlecompressed(uchar*, int);
	514	+extern int _compblocksize(Rectangle, int);
	515	+
	516	+/* XXX backwards helps; should go */
	517	+extern int log2[];
	518	+extern ulong drawld2chan[];
	519	+extern void drawsetdebug(int);

include/dtos.h+10−0

@@ -0,0 +1,10 @@
	1	+#if defined(linux) \|\| defined(IRIX) \|\| defined(SOLARIS) \|\| defined(OSF1) \|\| defined(__FreeBSD__) \|\| defined(__APPLE__)
	2	+# include "unix.h"
	3	+# ifdef __APPLE__
	4	+# define panic dt_panic
	5	+# endif
	6	+#elif defined(WINDOWS)
	7	+# include "winduhz.h"
	8	+#else
	9	+# error "Define an OS"
	10	+#endif

include/fcall.h+110−0

@@ -0,0 +1,110 @@
	1	+#define VERSION9P "9P2000"
	2	+
	3	+#define MAXWELEM 16
	4	+
	5	+typedef
	6	+struct Fcall
	7	+{
	8	+ uchar type;
	9	+ u32int fid;
	10	+ ushort tag;
	11	+ u32int msize; /* Tversion, Rversion */
	12	+ char version; / Tversion, Rversion */
	13	+ ushort oldtag; /* Tflush */
	14	+ char ename; / Rerror */
	15	+ Qid qid; /* Rattach, Ropen, Rcreate */
	16	+ u32int iounit; /* Ropen, Rcreate */
	17	+ Qid aqid; /* Rauth */
	18	+ u32int afid; /* Tauth, Tattach */
	19	+ char uname; / Tauth, Tattach */
	20	+ char aname; / Tauth, Tattach */
	21	+ u32int perm; /* Tcreate */
	22	+ char name; / Tcreate */
	23	+ uchar mode; /* Tcreate, Topen */
	24	+ u32int newfid; /* Twalk */
	25	+ ushort nwname; /* Twalk */
	26	+ char wname[MAXWELEM]; / Twalk */
	27	+ ushort nwqid; /* Rwalk */
	28	+ Qid wqid[MAXWELEM]; /* Rwalk */
	29	+ vlong offset; /* Tread, Twrite */
	30	+ u32int count; /* Tread, Twrite, Rread */
	31	+ char data; / Twrite, Rread */
	32	+ ushort nstat; /* Twstat, Rstat */
	33	+ uchar stat; / Twstat, Rstat */
	34	+} Fcall;
	35	+
	36	+
	37	+#define GBIT8(p) ((p)[0])
	38	+#define GBIT16(p) ((p)[0]\|((p)[1]<<8))
	39	+#define GBIT32(p) ((p)[0]\|((p)[1]<<8)\|((p)[2]<<16)\|((p)[3]<<24))
	40	+#define GBIT64(p) ((vlong)((p)[0]\|((p)[1]<<8)\|((p)[2]<<16)\|((p)[3]<<24)) \|\
	41	+ ((vlong)((p)[4]\|((p)[5]<<8)\|((p)[6]<<16)\|((p)[7]<<24)) << 32))
	42	+
	43	+#define PBIT8(p,v) (p)[0]=(v)
	44	+#define PBIT16(p,v) (p)[0]=(v);(p)[1]=(v)>>8
	45	+#define PBIT32(p,v) (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24
	46	+#define PBIT64(p,v) (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\
	47	+ (p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56
	48	+
	49	+#define BIT8SZ 1
	50	+#define BIT16SZ 2
	51	+#define BIT32SZ 4
	52	+#define BIT64SZ 8
	53	+#define QIDSZ (BIT8SZ+BIT32SZ+BIT64SZ)
	54	+
	55	+/* STATFIXLEN includes leading 16-bit count */
	56	+/* The count, however, excludes itself; total size is BIT16SZ+count */
	57	+#define STATFIXLEN (BIT16SZ+QIDSZ+5BIT16SZ+4BIT32SZ+1BIT64SZ) / amount of fixed length data in a stat buffer */
	58	+
	59	+#define NOTAG (ushort)~0U /* Dummy tag */
	60	+#define NOFID (u32int)~0U /* Dummy fid */
	61	+#define IOHDRSZ 24 /* ample room for Twrite/Rread header (iounit) */
	62	+
	63	+enum
	64	+{
	65	+ Tversion = 100,
	66	+ Rversion,
	67	+ Tauth = 102,
	68	+ Rauth,
	69	+ Tattach = 104,
	70	+ Rattach,
	71	+ Terror = 106, /* illegal */
	72	+ Rerror,
	73	+ Tflush = 108,
	74	+ Rflush,
	75	+ Twalk = 110,
	76	+ Rwalk,
	77	+ Topen = 112,
	78	+ Ropen,
	79	+ Tcreate = 114,
	80	+ Rcreate,
	81	+ Tread = 116,
	82	+ Rread,
	83	+ Twrite = 118,
	84	+ Rwrite,
	85	+ Tclunk = 120,
	86	+ Rclunk,
	87	+ Tremove = 122,
	88	+ Rremove,
	89	+ Tstat = 124,
	90	+ Rstat,
	91	+ Twstat = 126,
	92	+ Rwstat,
	93	+ Tmax,
	94	+};
	95	+
	96	+uint convM2S(uchar, uint, Fcall);
	97	+uint convS2M(Fcall, uchar, uint);
	98	+uint sizeS2M(Fcall*);
	99	+
	100	+int statcheck(uchar *abuf, uint nbuf);
	101	+uint convM2D(uchar, uint, Dir, char*);
	102	+uint convD2M(Dir, uchar, uint);
	103	+uint sizeD2M(Dir*);
	104	+
	105	+int fcallfmt(Fmt*);
	106	+int dirfmt(Fmt*);
	107	+int dirmodefmt(Fmt*);
	108	+
	109	+int read9pmsg(int, void*, uint);
	110	+

include/keyboard.h+42−0

@@ -0,0 +1,42 @@
	1	+#pragma src "/sys/src/libdraw"
	2	+#pragma lib "libdraw.a"
	3	+
	4	+typedef struct Keyboardctl Keyboardctl;
	5	+typedef struct Channel Channel;
	6	+
	7	+struct Keyboardctl
	8	+{
	9	+ Channel c; / chan(Rune)[20] */
	10	+
	11	+ char *file;
	12	+ int consfd; /* to cons file */
	13	+ int ctlfd; /* to ctl file */
	14	+ int pid; /* of slave proc */
	15	+};
	16	+
	17	+
	18	+extern Keyboardctl* initkeyboard(char*);
	19	+extern int ctlkeyboard(Keyboardctl, char);
	20	+extern void closekeyboard(Keyboardctl*);
	21	+
	22	+enum {
	23	+ KF= 0xF000, /* Rune: beginning of private Unicode space */
	24	+ Spec= 0xF800,
	25	+ /* KF\|1, KF\|2, ..., KF\|0xC is F1, F2, ..., F12 */
	26	+ Khome= KF\|0x0D,
	27	+ Kup= KF\|0x0E,
	28	+ Kpgup= KF\|0x0F,
	29	+ Kprint= KF\|0x10,
	30	+ Kleft= KF\|0x11,
	31	+ Kright= KF\|0x12,
	32	+ Kdown= Spec\|0x00,
	33	+ Kview= Spec\|0x00,
	34	+ Kpgdown= KF\|0x13,
	35	+ Kins= KF\|0x14,
	36	+ Kend= KF\|0x18,
	37	+
	38	+ Kalt= KF\|0x15,
	39	+ Kshift= KF\|0x16,
	40	+ Kctl= KF\|0x17,
	41	+};
	42	+

include/lib.h+246−0

@@ -0,0 +1,246 @@
	1	+/* avoid name conflicts */
	2	+#define accept pm_accept
	3	+#define listen pm_listen
	4	+#define sleep ksleep
	5	+#define wakeup kwakeup
	6	+#define strtod libstrtod
	7	+#define pow10 libpow10
	8	+
	9	+/* conflicts on some os's */
	10	+#define encrypt libencrypt
	11	+#define decrypt libdecrypt
	12	+#define oserror liboserror
	13	+#define clone libclone
	14	+#define atexit libatexit
	15	+#define log2 liblog2
	16	+#define log liblog
	17	+#define reboot libreboot
	18	+#define srand dtsrand
	19	+#define rand dtrand
	20	+#define nrand dtnrand
	21	+#define lrand dtlrand
	22	+#define lnrand dtlnrand
	23	+#undef timeradd
	24	+#define timeradd xtimeradd
	25	+
	26	+
	27	+#define nil ((void*)0)
	28	+
	29	+typedef unsigned char p9_uchar;
	30	+typedef unsigned int p9_uint;
	31	+typedef unsigned int p9_ulong;
	32	+typedef int p9_long;
	33	+typedef signed char p9_schar;
	34	+typedef unsigned short p9_ushort;
	35	+typedef unsigned short Rune;
	36	+typedef unsigned int p9_u32int;
	37	+typedef p9_u32int mpdigit;
	38	+
	39	+/* make sure we don't conflict with predefined types */
	40	+#define schar p9_schar
	41	+#define uchar p9_uchar
	42	+#define ushort p9_ushort
	43	+#define uint p9_uint
	44	+#define u32int p9_u32int
	45	+
	46	+/* #define long int rather than p9_long so that "unsigned long" is valid */
	47	+#define long int
	48	+#define ulong p9_ulong
	49	+#define vlong p9_vlong
	50	+#define uvlong p9_uvlong
	51	+
	52	+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
	53	+#define USED(x) if(x);else
	54	+#define SET(x)
	55	+
	56	+enum
	57	+{
	58	+ UTFmax = 3, /* maximum bytes per rune */
	59	+ Runesync = 0x80, /* cannot represent part of a UTF sequence (<) */
	60	+ Runeself = 0x80, /* rune and UTF sequences are the same (<) */
	61	+ Runeerror = 0x80 /* decoding error in UTF */
	62	+};
	63	+
	64	+/*
	65	+ * new rune routines
	66	+ */
	67	+extern int runetochar(char, Rune);
	68	+extern int chartorune(Rune, char);
	69	+extern int runelen(long);
	70	+extern int fullrune(char*, int);
	71	+
	72	+extern int wstrtoutf(char, Rune, int);
	73	+extern int wstrutflen(Rune*);
	74	+
	75	+/*
	76	+ * rune routines from converted str routines
	77	+ */
	78	+extern long utflen(char*);
	79	+extern char* utfrune(char*, long);
	80	+extern char* utfrrune(char*, long);
	81	+
	82	+/*
	83	+ * Syscall data structures
	84	+ */
	85	+#define MORDER 0x0003 /* mask for bits defining order of mounting */
	86	+#define MREPL 0x0000 /* mount replaces object */
	87	+#define MBEFORE 0x0001 /* mount goes before others in union directory */
	88	+#define MAFTER 0x0002 /* mount goes after others in union directory */
	89	+#define MCREATE 0x0004 /* permit creation in mounted directory */
	90	+#define MCACHE 0x0010 /* cache some data */
	91	+#define MMASK 0x0017 /* all bits on */
	92	+
	93	+#define OREAD 0 /* open for read */
	94	+#define OWRITE 1 /* write */
	95	+#define ORDWR 2 /* read and write */
	96	+#define OEXEC 3 /* execute, == read but check execute permission */
	97	+#define OTRUNC 16 /* or'ed in (except for exec), truncate file first */
	98	+#define OCEXEC 32 /* or'ed in, close on exec */
	99	+#define ORCLOSE 64 /* or'ed in, remove on close */
	100	+#define OEXCL 0x1000 /* or'ed in, exclusive create */
	101	+
	102	+#define NCONT 0 /* continue after note */
	103	+#define NDFLT 1 /* terminate after note */
	104	+#define NSAVE 2 /* clear note but hold state */
	105	+#define NRSTR 3 /* restore saved state */
	106	+
	107	+#define ERRMAX 128 /* max length of error string */
	108	+#define KNAMELEN 28 /* max length of name held in kernel */
	109	+
	110	+/* bits in Qid.type */
	111	+#define QTDIR 0x80 /* type bit for directories */
	112	+#define QTAPPEND 0x40 /* type bit for append only files */
	113	+#define QTEXCL 0x20 /* type bit for exclusive use files */
	114	+#define QTMOUNT 0x10 /* type bit for mounted channel */
	115	+#define QTAUTH 0x08 /* type bit for authentication file */
	116	+#define QTFILE 0x00 /* plain file */
	117	+
	118	+/* bits in Dir.mode */
	119	+#define DMDIR 0x80000000 /* mode bit for directories */
	120	+#define DMAPPEND 0x40000000 /* mode bit for append only files */
	121	+#define DMEXCL 0x20000000 /* mode bit for exclusive use files */
	122	+#define DMMOUNT 0x10000000 /* mode bit for mounted channel */
	123	+#define DMAUTH 0x08000000 /* mode bit for authentication files */
	124	+#define DMREAD 0x4 /* mode bit for read permission */
	125	+#define DMWRITE 0x2 /* mode bit for write permission */
	126	+#define DMEXEC 0x1 /* mode bit for execute permission */
	127	+
	128	+typedef struct Lock
	129	+{
	130	+ long key;
	131	+} Lock;
	132	+
	133	+typedef struct QLock
	134	+{
	135	+ Lock lk;
	136	+ struct Proc *hold;
	137	+ struct Proc *first;
	138	+ struct Proc *last;
	139	+} QLock;
	140	+
	141	+typedef
	142	+struct Qid
	143	+{
	144	+ uvlong path;
	145	+ ulong vers;
	146	+ uchar type;
	147	+} Qid;
	148	+
	149	+typedef
	150	+struct Dir {
	151	+ /* system-modified data */
	152	+ ushort type; /* server type */
	153	+ uint dev; /* server subtype */
	154	+ /* file data */
	155	+ Qid qid; /* unique id from server */
	156	+ ulong mode; /* permissions */
	157	+ ulong atime; /* last read time */
	158	+ ulong mtime; /* last write time */
	159	+ vlong length; /* file length */
	160	+ char name; / last element of path */
	161	+ char uid; / owner name */
	162	+ char gid; / group name */
	163	+ char muid; / last modifier name */
	164	+} Dir;
	165	+
	166	+typedef
	167	+struct Waitmsg
	168	+{
	169	+ int pid; /* of loved one */
	170	+ ulong time[3]; /* of loved one & descendants */
	171	+ char *msg;
	172	+} Waitmsg;
	173	+
	174	+/*
	175	+ * print routines
	176	+ */
	177	+typedef struct Fmt Fmt;
	178	+struct Fmt{
	179	+ uchar runes; /* output buffer is runes or chars? */
	180	+ void start; / of buffer */
	181	+ void to; / current place in the buffer */
	182	+ void stop; / end of the buffer; overwritten if flush fails */
	183	+ int (flush)(Fmt ); /* called when to == stop */
	184	+ void farg; / to make flush a closure */
	185	+ int nfmt; /* num chars formatted so far */
	186	+ va_list args; /* args passed to dofmt */
	187	+ int r; /* % format Rune */
	188	+ int width;
	189	+ int prec;
	190	+ ulong flags;
	191	+};
	192	+
	193	+enum{
	194	+ FmtWidth = 1,
	195	+ FmtLeft = FmtWidth << 1,
	196	+ FmtPrec = FmtLeft << 1,
	197	+ FmtSharp = FmtPrec << 1,
	198	+ FmtSpace = FmtSharp << 1,
	199	+ FmtSign = FmtSpace << 1,
	200	+ FmtZero = FmtSign << 1,
	201	+ FmtUnsigned = FmtZero << 1,
	202	+ FmtShort = FmtUnsigned << 1,
	203	+ FmtLong = FmtShort << 1,
	204	+ FmtVLong = FmtLong << 1,
	205	+ FmtComma = FmtVLong << 1,
	206	+ FmtByte = FmtComma << 1,
	207	+
	208	+ FmtFlag = FmtByte << 1
	209	+};
	210	+
	211	+extern int print(char*, ...);
	212	+extern char* seprint(char, char, char*, ...);
	213	+extern char* vseprint(char, char, char*, va_list);
	214	+extern int snprint(char, int, char, ...);
	215	+extern int vsnprint(char, int, char, va_list);
	216	+extern char* smprint(char*, ...);
	217	+extern char* vsmprint(char*, va_list);
	218	+extern int sprint(char, char, ...);
	219	+extern int fprint(int, char*, ...);
	220	+extern int vfprint(int, char*, va_list);
	221	+
	222	+extern int (*doquote)(int);
	223	+extern int runesprint(Rune, char, ...);
	224	+extern int runesnprint(Rune, int, char, ...);
	225	+extern int runevsnprint(Rune, int, char, va_list);
	226	+extern Rune* runeseprint(Rune, Rune, char*, ...);
	227	+extern Rune* runevseprint(Rune, Rune, char*, va_list);
	228	+extern Rune* runesmprint(char*, ...);
	229	+extern Rune* runevsmprint(char*, va_list);
	230	+
	231	+extern int fmtfdinit(Fmt, int, char, int);
	232	+extern int fmtfdflush(Fmt*);
	233	+extern int fmtstrinit(Fmt*);
	234	+extern int fmtinstall(int, int ()(Fmt));
	235	+extern char* fmtstrflush(Fmt*);
	236	+extern int runefmtstrinit(Fmt*);
	237	+extern Rune* runefmtstrflush(Fmt*);
	238	+
	239	+extern void* mallocz(ulong, int);
	240	+
	241	+extern void srand(long);
	242	+extern int rand(void);
	243	+extern int nrand(int);
	244	+extern long lrand(void);
	245	+extern long lnrand(long);
	246	+extern double frand(void);

include/libc.h+3−0

@@ -0,0 +1,3 @@
	1	+#include "lib.h"
	2	+#include "user.h"
	3	+

include/libsec.h+340−0

@@ -0,0 +1,340 @@
	1	+
	2	+#ifndef _MPINT
	3	+typedef struct mpint mpint;
	4	+#endif
	5	+
	6	+/////////////////////////////////////////////////////////
	7	+// AES definitions
	8	+/////////////////////////////////////////////////////////
	9	+
	10	+enum
	11	+{
	12	+ AESbsize= 16,
	13	+ AESmaxkey= 32,
	14	+ AESmaxrounds= 14
	15	+};
	16	+
	17	+typedef struct AESstate AESstate;
	18	+struct AESstate
	19	+{
	20	+ ulong setup;
	21	+ int rounds;
	22	+ int keybytes;
	23	+ uchar key[AESmaxkey]; /* unexpanded key */
	24	+ u32int ekey[4(AESmaxrounds + 1)]; / encryption key */
	25	+ u32int dkey[4(AESmaxrounds + 1)]; / decryption key */
	26	+ uchar ivec[AESbsize]; /* initialization vector */
	27	+};
	28	+
	29	+void setupAESstate(AESstate s, uchar key[], int keybytes, uchar ivec);
	30	+void aesCBCencrypt(uchar p, int len, AESstate s);
	31	+void aesCBCdecrypt(uchar p, int len, AESstate s);
	32	+
	33	+/////////////////////////////////////////////////////////
	34	+// Blowfish Definitions
	35	+/////////////////////////////////////////////////////////
	36	+
	37	+enum
	38	+{
	39	+ BFbsize = 8,
	40	+ BFrounds = 16
	41	+};
	42	+
	43	+// 16-round Blowfish
	44	+typedef struct BFstate BFstate;
	45	+struct BFstate
	46	+{
	47	+ ulong setup;
	48	+
	49	+ uchar key[56];
	50	+ uchar ivec[8];
	51	+
	52	+ u32int pbox[BFrounds+2];
	53	+ u32int sbox[1024];
	54	+};
	55	+
	56	+void setupBFstate(BFstate s, uchar key[], int keybytes, uchar ivec);
	57	+void bfCBCencrypt(uchar, int, BFstate);
	58	+void bfCBCdecrypt(uchar, int, BFstate);
	59	+void bfECBencrypt(uchar, int, BFstate);
	60	+void bfECBdecrypt(uchar, int, BFstate);
	61	+
	62	+/////////////////////////////////////////////////////////
	63	+// DES definitions
	64	+/////////////////////////////////////////////////////////
	65	+
	66	+enum
	67	+{
	68	+ DESbsize= 8
	69	+};
	70	+
	71	+// single des
	72	+typedef struct DESstate DESstate;
	73	+struct DESstate
	74	+{
	75	+ ulong setup;
	76	+ uchar key[8]; /* unexpanded key */
	77	+ ulong expanded[32]; /* expanded key */
	78	+ uchar ivec[8]; /* initialization vector */
	79	+};
	80	+
	81	+void setupDESstate(DESstate s, uchar key[8], uchar ivec);
	82	+void des_key_setup(uchar[8], ulong[32]);
	83	+void block_cipher(ulong, uchar, int);
	84	+void desCBCencrypt(uchar, int, DESstate);
	85	+void desCBCdecrypt(uchar, int, DESstate);
	86	+void desECBencrypt(uchar, int, DESstate);
	87	+void desECBdecrypt(uchar, int, DESstate);
	88	+
	89	+// for backward compatibility with 7 byte DES key format
	90	+void des56to64(uchar k56, uchar k64);
	91	+void des64to56(uchar k64, uchar k56);
	92	+void key_setup(uchar[7], ulong[32]);
	93	+
	94	+// triple des encrypt/decrypt orderings
	95	+enum {
	96	+ DES3E= 0,
	97	+ DES3D= 1,
	98	+ DES3EEE= 0,
	99	+ DES3EDE= 2,
	100	+ DES3DED= 5,
	101	+ DES3DDD= 7
	102	+};
	103	+
	104	+typedef struct DES3state DES3state;
	105	+struct DES3state
	106	+{
	107	+ ulong setup;
	108	+ uchar key[3][8]; /* unexpanded key */
	109	+ ulong expanded[3][32]; /* expanded key */
	110	+ uchar ivec[8]; /* initialization vector */
	111	+};
	112	+
	113	+void setupDES3state(DES3state s, uchar key[3][8], uchar ivec);
	114	+void triple_block_cipher(ulong keys[3][32], uchar*, int);
	115	+void des3CBCencrypt(uchar, int, DES3state);
	116	+void des3CBCdecrypt(uchar, int, DES3state);
	117	+void des3ECBencrypt(uchar, int, DES3state);
	118	+void des3ECBdecrypt(uchar, int, DES3state);
	119	+
	120	+/////////////////////////////////////////////////////////
	121	+// digests
	122	+/////////////////////////////////////////////////////////
	123	+
	124	+enum
	125	+{
	126	+ SHA1dlen= 20, /* SHA digest length */
	127	+ MD4dlen= 16, /* MD4 digest length */
	128	+ MD5dlen= 16 /* MD5 digest length */
	129	+};
	130	+
	131	+typedef struct DigestState DigestState;
	132	+struct DigestState
	133	+{
	134	+ ulong len;
	135	+ u32int state[5];
	136	+ uchar buf[128];
	137	+ int blen;
	138	+ char malloced;
	139	+ char seeded;
	140	+};
	141	+typedef struct DigestState SHAstate; /* obsolete name */
	142	+typedef struct DigestState SHA1state;
	143	+typedef struct DigestState MD5state;
	144	+typedef struct DigestState MD4state;
	145	+
	146	+DigestState* md4(uchar, ulong, uchar, DigestState*);
	147	+DigestState* md5(uchar, ulong, uchar, DigestState*);
	148	+DigestState* sha1(uchar, ulong, uchar, DigestState*);
	149	+DigestState* hmac_md5(uchar, ulong, uchar, ulong, uchar, DigestState);
	150	+DigestState* hmac_sha1(uchar, ulong, uchar, ulong, uchar, DigestState);
	151	+char* sha1pickle(SHA1state*);
	152	+SHA1state* sha1unpickle(char*);
	153	+
	154	+/////////////////////////////////////////////////////////
	155	+// random number generation
	156	+/////////////////////////////////////////////////////////
	157	+void genrandom(uchar *buf, int nbytes);
	158	+void prng(uchar *buf, int nbytes);
	159	+ulong fastrand(void);
	160	+ulong nfastrand(ulong);
	161	+
	162	+/////////////////////////////////////////////////////////
	163	+// primes
	164	+/////////////////////////////////////////////////////////
	165	+void genprime(mpint *p, int n, int accuracy); // generate an n bit probable prime
	166	+void gensafeprime(mpint p, mpint alpha, int n, int accuracy); // prime and generator
	167	+void genstrongprime(mpint *p, int n, int accuracy); // generate an n bit strong prime
	168	+void DSAprimes(mpint q, mpint p, uchar seed[SHA1dlen]);
	169	+int probably_prime(mpint *n, int nrep); // miller-rabin test
	170	+int smallprimetest(mpint *p); // returns -1 if not prime, 0 otherwise
	171	+
	172	+/////////////////////////////////////////////////////////
	173	+// rc4
	174	+/////////////////////////////////////////////////////////
	175	+typedef struct RC4state RC4state;
	176	+struct RC4state
	177	+{
	178	+ uchar state[256];
	179	+ uchar x;
	180	+ uchar y;
	181	+};
	182	+
	183	+void setupRC4state(RC4state, uchar, int);
	184	+void rc4(RC4state, uchar, int);
	185	+void rc4skip(RC4state*, int);
	186	+void rc4back(RC4state*, int);
	187	+
	188	+/////////////////////////////////////////////////////////
	189	+// rsa
	190	+/////////////////////////////////////////////////////////
	191	+typedef struct RSApub RSApub;
	192	+typedef struct RSApriv RSApriv;
	193	+
	194	+// public/encryption key
	195	+struct RSApub
	196	+{
	197	+ mpint *n; // modulus
	198	+ mpint *ek; // exp (encryption key)
	199	+};
	200	+
	201	+// private/decryption key
	202	+struct RSApriv
	203	+{
	204	+ RSApub pub;
	205	+
	206	+ mpint *dk; // exp (decryption key)
	207	+
	208	+ // precomputed values to help with chinese remainder theorem calc
	209	+ mpint *p;
	210	+ mpint *q;
	211	+ mpint *kp; // dk mod p-1
	212	+ mpint *kq; // dk mod q-1
	213	+ mpint *c2; // (inv p) mod q
	214	+};
	215	+
	216	+RSApriv* rsagen(int nlen, int elen, int rounds);
	217	+RSApriv* rsafill(mpint n, mpint e, mpint d, mpint p, mpint *q);
	218	+mpint* rsaencrypt(RSApub k, mpint in, mpint *out);
	219	+mpint* rsadecrypt(RSApriv k, mpint in, mpint *out);
	220	+RSApub* rsapuballoc(void);
	221	+void rsapubfree(RSApub*);
	222	+RSApriv* rsaprivalloc(void);
	223	+void rsaprivfree(RSApriv*);
	224	+RSApub* rsaprivtopub(RSApriv*);
	225	+RSApub* X509toRSApub(uchar, int, char, int);
	226	+RSApriv* asn1toRSApriv(uchar*, int);
	227	+void asn1dump(uchar *der, int len);
	228	+uchar* decodepem(char s, char type, int *len);
	229	+uchar* X509gen(RSApriv priv, char subj, ulong valid[2], int *certlen);
	230	+uchar* X509req(RSApriv priv, char subj, int *certlen);
	231	+char* X509verify(uchar cert, int ncert, RSApub pk);
	232	+void X509dump(uchar *cert, int ncert);
	233	+/////////////////////////////////////////////////////////
	234	+// elgamal
	235	+/////////////////////////////////////////////////////////
	236	+typedef struct EGpub EGpub;
	237	+typedef struct EGpriv EGpriv;
	238	+typedef struct EGsig EGsig;
	239	+
	240	+// public/encryption key
	241	+struct EGpub
	242	+{
	243	+ mpint *p; // modulus
	244	+ mpint *alpha; // generator
	245	+ mpint key; // (encryption key) alpha*secret mod p
	246	+};
	247	+
	248	+// private/decryption key
	249	+struct EGpriv
	250	+{
	251	+ EGpub pub;
	252	+ mpint *secret; // (decryption key)
	253	+};
	254	+
	255	+// signature
	256	+struct EGsig
	257	+{
	258	+ mpint r, s;
	259	+};
	260	+
	261	+EGpriv* eggen(int nlen, int rounds);
	262	+mpint* egencrypt(EGpub k, mpint in, mpint *out);
	263	+mpint* egdecrypt(EGpriv k, mpint in, mpint *out);
	264	+EGsig* egsign(EGpriv k, mpint m);
	265	+int egverify(EGpub k, EGsig sig, mpint *m);
	266	+EGpub* egpuballoc(void);
	267	+void egpubfree(EGpub*);
	268	+EGpriv* egprivalloc(void);
	269	+void egprivfree(EGpriv*);
	270	+EGsig* egsigalloc(void);
	271	+void egsigfree(EGsig*);
	272	+EGpub* egprivtopub(EGpriv*);
	273	+
	274	+/////////////////////////////////////////////////////////
	275	+// dsa
	276	+/////////////////////////////////////////////////////////
	277	+typedef struct DSApub DSApub;
	278	+typedef struct DSApriv DSApriv;
	279	+typedef struct DSAsig DSAsig;
	280	+
	281	+// public/encryption key
	282	+struct DSApub
	283	+{
	284	+ mpint *p; // modulus
	285	+ mpint *q; // group order, q divides p-1
	286	+ mpint *alpha; // group generator
	287	+ mpint key; // (encryption key) alpha*secret mod p
	288	+};
	289	+
	290	+// private/decryption key
	291	+struct DSApriv
	292	+{
	293	+ DSApub pub;
	294	+ mpint *secret; // (decryption key)
	295	+};
	296	+
	297	+// signature
	298	+struct DSAsig
	299	+{
	300	+ mpint r, s;
	301	+};
	302	+
	303	+DSApriv* dsagen(DSApub *opub);
	304	+DSAsig* dsasign(DSApriv k, mpint m);
	305	+int dsaverify(DSApub k, DSAsig sig, mpint *m);
	306	+DSApub* dsapuballoc(void);
	307	+void dsapubfree(DSApub*);
	308	+DSApriv* dsaprivalloc(void);
	309	+void dsaprivfree(DSApriv*);
	310	+DSAsig* dsasigalloc(void);
	311	+void dsasigfree(DSAsig*);
	312	+DSApub* dsaprivtopub(DSApriv*);
	313	+
	314	+/////////////////////////////////////////////////////////
	315	+// TLS
	316	+/////////////////////////////////////////////////////////
	317	+typedef struct Thumbprint{
	318	+ struct Thumbprint *next;
	319	+ uchar sha1[SHA1dlen];
	320	+} Thumbprint;
	321	+
	322	+typedef struct TLSconn{
	323	+ char dir[40]; // connection directory
	324	+ uchar *cert; // certificate (local on input, remote on output)
	325	+ uchar *sessionID;
	326	+ int certlen, sessionIDlen;
	327	+ int (trace)(charfmt, ...);
	328	+} TLSconn;
	329	+
	330	+// tlshand.c
	331	+extern int tlsClient(int fd, TLSconn *c);
	332	+extern int tlsServer(int fd, TLSconn *c);
	333	+
	334	+// thumb.c
	335	+extern Thumbprint* initThumbprints(char ok, char crl);
	336	+extern void freeThumbprints(Thumbprint *ok);
	337	+extern int okThumbprint(uchar sha1, Thumbprint ok);
	338	+
	339	+// readcert.c
	340	+extern uchar readcert(char filename, int *pcertlen);

include/memdraw.h+200−0

@@ -0,0 +1,200 @@
	1	+#pragma src "/sys/src/libmemdraw"
	2	+#pragma lib "libmemdraw.a"
	3	+
	4	+typedef struct Memimage Memimage;
	5	+typedef struct Memdata Memdata;
	6	+typedef struct Memsubfont Memsubfont;
	7	+typedef struct Memlayer Memlayer;
	8	+typedef struct Memcmap Memcmap;
	9	+typedef struct Memdrawparam Memdrawparam;
	10	+
	11	+/*
	12	+ * Memdata is allocated from main pool, but .data from the image pool.
	13	+ * Memdata is allocated separately to permit patching its pointer after
	14	+ * compaction when windows share the image data.
	15	+ * The first word of data is a back pointer to the Memdata, to find
	16	+ * The word to patch.
	17	+ */
	18	+
	19	+struct Memdata
	20	+{
	21	+ ulong base; / allocated data pointer */
	22	+ uchar bdata; / pointer to first byte of actual data; word-aligned */
	23	+ int ref; /* number of Memimages using this data */
	24	+ void* imref;
	25	+ int allocd; /* is this malloc'd? */
	26	+};
	27	+
	28	+enum {
	29	+ Frepl = 1<<0, /* is replicated */
	30	+ Fsimple = 1<<1, /* is 1x1 */
	31	+ Fgrey = 1<<2, /* is grey */
	32	+ Falpha = 1<<3, /* has explicit alpha */
	33	+ Fcmap = 1<<4, /* has cmap channel */
	34	+ Fbytes = 1<<5, /* has only 8-bit channels */
	35	+};
	36	+
	37	+struct Memimage
	38	+{
	39	+ Rectangle r; /* rectangle in data area, local coords */
	40	+ Rectangle clipr; /* clipping region */
	41	+ int depth; /* number of bits of storage per pixel */
	42	+ int nchan; /* number of channels */
	43	+ ulong chan; /* channel descriptions */
	44	+ Memcmap *cmap;
	45	+
	46	+ Memdata data; / pointer to data; shared by windows in this image */
	47	+ int zero; /* data->bdata+zero==&byte containing (0,0) */
	48	+ ulong width; /* width in words of a single scan line */
	49	+ Memlayer layer; / nil if not a layer*/
	50	+ ulong flags;
	51	+
	52	+ int shift[NChan];
	53	+ int mask[NChan];
	54	+ int nbits[NChan];
	55	+
	56	+ void *X;
	57	+};
	58	+
	59	+struct Memcmap
	60	+{
	61	+ uchar cmap2rgb[3*256];
	62	+ uchar rgb2cmap[161616];
	63	+};
	64	+
	65	+/*
	66	+ * Subfonts
	67	+ *
	68	+ * given char c, Subfont f, Fontchar i, and Point p, one says
	69	+ * i = f->info+c;
	70	+ * draw(b, Rect(p.x+i->left, p.y+i->top,
	71	+ * p.x+i->left+((i+1)->x-i->x), p.y+i->bottom),
	72	+ * color, f->bits, Pt(i->x, i->top));
	73	+ * p.x += i->width;
	74	+ * to draw characters in the specified color (itself a Memimage) in Memimage b.
	75	+ */
	76	+
	77	+struct Memsubfont
	78	+{
	79	+ char *name;
	80	+ short n; /* number of chars in font */
	81	+ uchar height; /* height of bitmap */
	82	+ char ascent; /* top of bitmap to baseline */
	83	+ Fontchar info; / n+1 character descriptors */
	84	+ Memimage bits; / of font */
	85	+};
	86	+
	87	+/*
	88	+ * Encapsulated parameters and information for sub-draw routines.
	89	+ */
	90	+enum {
	91	+ Simplesrc=1<<0,
	92	+ Simplemask=1<<1,
	93	+ Replsrc=1<<2,
	94	+ Replmask=1<<3,
	95	+ Fullmask=1<<4,
	96	+};
	97	+struct Memdrawparam
	98	+{
	99	+ Memimage *dst;
	100	+ Rectangle r;
	101	+ Memimage *src;
	102	+ Rectangle sr;
	103	+ Memimage *mask;
	104	+ Rectangle mr;
	105	+ int op;
	106	+
	107	+ ulong state;
	108	+ ulong mval; /* if Simplemask, the mask pixel in mask format */
	109	+ ulong mrgba; /* mval in rgba */
	110	+ ulong sval; /* if Simplesrc, the source pixel in src format */
	111	+ ulong srgba; /* sval in rgba */
	112	+ ulong sdval; /* sval in dst format */
	113	+};
	114	+
	115	+/*
	116	+ * Memimage management
	117	+ */
	118	+
	119	+extern Memimage* allocmemimage(Rectangle, ulong);
	120	+extern Memimage* _allocmemimage(Rectangle, ulong);
	121	+extern Memimage* allocmemimaged(Rectangle, ulong, Memdata, void);
	122	+extern Memimage* readmemimage(int);
	123	+extern Memimage* creadmemimage(int);
	124	+extern int writememimage(int, Memimage*);
	125	+extern void freememimage(Memimage*);
	126	+extern int _loadmemimage(Memimage, Rectangle, uchar, int);
	127	+extern int _cloadmemimage(Memimage, Rectangle, uchar, int);
	128	+extern int _unloadmemimage(Memimage, Rectangle, uchar, int);
	129	+extern int loadmemimage(Memimage, Rectangle, uchar, int);
	130	+extern int cloadmemimage(Memimage, Rectangle, uchar, int);
	131	+extern int unloadmemimage(Memimage, Rectangle, uchar, int);
	132	+extern ulong* wordaddr(Memimage*, Point);
	133	+extern uchar* byteaddr(Memimage*, Point);
	134	+extern int drawclip(Memimage, Rectangle, Memimage, Point, Memimage, Point, Rectangle, Rectangle);
	135	+extern void memfillcolor(Memimage*, ulong);
	136	+extern int memsetchan(Memimage*, ulong);
	137	+
	138	+/*
	139	+ * Graphics
	140	+ */
	141	+extern void memdraw(Memimage, Rectangle, Memimage, Point, Memimage*, Point, int);
	142	+extern void memline(Memimage, Point, Point, int, int, int, Memimage, Point, int);
	143	+extern void mempoly(Memimage, Point, int, int, int, int, Memimage*, Point, int);
	144	+extern void memfillpoly(Memimage, Point, int, int, Memimage*, Point, int);
	145	+extern void _memfillpolysc(Memimage, Point, int, int, Memimage*, Point, int, int, int, int);
	146	+extern Memdrawparam* _memimagedrawsetup(Memimage, Rectangle, Memimage, Point, Memimage*, Point, int);
	147	+extern void _memimagedraw(Memdrawparam*);
	148	+extern void memimagedraw(Memimage, Rectangle, Memimage, Point, Memimage*, Point, int);
	149	+extern int hwdraw(Memdrawparam*);
	150	+extern void memimageline(Memimage, Point, Point, int, int, int, Memimage, Point, int);
	151	+extern void _memimageline(Memimage, Point, Point, int, int, int, Memimage, Point, Rectangle, int);
	152	+extern Point memimagestring(Memimage, Point, Memimage, Point, Memsubfont, char);
	153	+extern void memellipse(Memimage, Point, int, int, int, Memimage, Point, int);
	154	+extern void memarc(Memimage, Point, int, int, int, Memimage, Point, int, int, int);
	155	+extern Rectangle memlinebbox(Point, Point, int, int, int);
	156	+extern int memlineendsize(int);
	157	+extern void _memmkcmap(void);
	158	+extern void memimageinit(void);
	159	+
	160	+/*
	161	+ * Subfont management
	162	+ */
	163	+extern Memsubfont* allocmemsubfont(char, int, int, int, Fontchar, Memimage*);
	164	+extern Memsubfont* openmemsubfont(char*);
	165	+extern void freememsubfont(Memsubfont*);
	166	+extern Point memsubfontwidth(Memsubfont, char);
	167	+extern Memsubfont* getmemdefont(void);
	168	+
	169	+/*
	170	+ * Predefined
	171	+ */
	172	+extern Memimage* memwhite;
	173	+extern Memimage* memblack;
	174	+extern Memimage* memopaque;
	175	+extern Memimage* memtransparent;
	176	+extern Memcmap *memdefcmap;
	177	+
	178	+/*
	179	+ * Kernel interface
	180	+ */
	181	+void memimagemove(void, void);
	182	+
	183	+/*
	184	+ * Kernel cruft
	185	+ */
	186	+extern void rdb(void);
	187	+extern int iprint(char*, ...);
	188	+#pragma varargck argpos iprint 1
	189	+extern int drawdebug;
	190	+
	191	+/*
	192	+ * doprint interface: numbconv bit strings
	193	+ */
	194	+#pragma varargck type "llb" vlong
	195	+#pragma varargck type "llb" uvlong
	196	+#pragma varargck type "lb" long
	197	+#pragma varargck type "lb" ulong
	198	+#pragma varargck type "b" int
	199	+#pragma varargck type "b" uint
	200	+

include/memlayer.h+51−0

@@ -0,0 +1,51 @@
	1	+#pragma src "/sys/src/libmemlayer"
	2	+#pragma lib "libmemlayer.a"
	3	+
	4	+typedef struct Memscreen Memscreen;
	5	+typedef void (Refreshfn)(Memimage, Rectangle, void*);
	6	+
	7	+struct Memscreen
	8	+{
	9	+ Memimage frontmost; / frontmost layer on screen */
	10	+ Memimage rearmost; / rearmost layer on screen */
	11	+ Memimage image; / upon which all layers are drawn */
	12	+ Memimage fill; / if non-zero, picture to use when repainting */
	13	+};
	14	+
	15	+struct Memlayer
	16	+{
	17	+ Rectangle screenr; /* true position of layer on screen */
	18	+ Point delta; /* add delta to go from image coords to screen */
	19	+ Memscreen screen; / screen this layer belongs to */
	20	+ Memimage front; / window in front of this one */
	21	+ Memimage rear; / window behind this one*/
	22	+ int clear; /* layer is fully visible */
	23	+ Memimage save; / save area for obscured parts */
	24	+ Refreshfn refreshfn; /* function to call to refresh obscured parts if save==nil */
	25	+ void refreshptr; / argument to refreshfn */
	26	+};
	27	+
	28	+/*
	29	+ * These functions accept local coordinates
	30	+ */
	31	+int memload(Memimage, Rectangle, uchar, int, int);
	32	+int memunload(Memimage, Rectangle, uchar, int);
	33	+
	34	+/*
	35	+ * All these functions accept screen coordinates, not local ones.
	36	+ */
	37	+void _memlayerop(void (fn)(Memimage, Rectangle, Rectangle, void, int), Memimage, Rectangle, Rectangle, void*);
	38	+Memimage* memlalloc(Memscreen, Rectangle, Refreshfn, void, ulong);
	39	+void memldelete(Memimage*);
	40	+void memlfree(Memimage*);
	41	+void memltofront(Memimage*);
	42	+void memltofrontn(Memimage**, int);
	43	+void _memltofrontfill(Memimage*, int);
	44	+void memltorear(Memimage*);
	45	+void memltorearn(Memimage**, int);
	46	+int memlsetrefresh(Memimage, Refreshfn, void);
	47	+void memlhide(Memimage*, Rectangle);
	48	+void memlexpose(Memimage*, Rectangle);
	49	+void _memlsetclear(Memscreen*);
	50	+int memlorigin(Memimage*, Point, Point);
	51	+void memlnorefresh(Memimage, Rectangle, void);

include/mp.h+134−0

@@ -0,0 +1,134 @@
	1	+#define _MPINT 1
	2	+
	3	+// the code assumes mpdigit to be at least an int
	4	+// mpdigit must be an atomic type. mpdigit is defined
	5	+// in the architecture specific u.h
	6	+
	7	+typedef struct mpint mpint;
	8	+
	9	+struct mpint
	10	+{
	11	+ int sign; // +1 or -1
	12	+ int size; // allocated digits
	13	+ int top; // significant digits
	14	+ mpdigit *p;
	15	+ char flags;
	16	+};
	17	+
	18	+enum
	19	+{
	20	+ MPstatic= 0x01,
	21	+ Dbytes= sizeof(mpdigit), // bytes per digit
	22	+ Dbits= Dbytes*8 // bits per digit
	23	+};
	24	+
	25	+// allocation
	26	+void mpsetminbits(int n); // newly created mpint's get at least n bits
	27	+mpint* mpnew(int n); // create a new mpint with at least n bits
	28	+void mpfree(mpint *b);
	29	+void mpbits(mpint *b, int n); // ensure that b has at least n bits
	30	+void mpnorm(mpint *b); // dump leading zeros
	31	+mpint* mpcopy(mpint *b);
	32	+void mpassign(mpint old, mpint new);
	33	+
	34	+// random bits
	35	+mpint* mprand(int bits, void (gen)(uchar, int), mpint *b);
	36	+
	37	+// conversion
	38	+mpint* strtomp(char, char, int, mpint); // ascii
	39	+int mpfmt(Fmt*);
	40	+char* mptoa(mpint, int, char, int);
	41	+mpint* letomp(uchar, uint, mpint); // byte array, little-endian
	42	+int mptole(mpint, uchar, uint, uchar**);
	43	+mpint* betomp(uchar, uint, mpint); // byte array, little-endian
	44	+int mptobe(mpint, uchar, uint, uchar**);
	45	+uint mptoui(mpint*); // unsigned int
	46	+mpint* uitomp(uint, mpint*);
	47	+int mptoi(mpint*); // int
	48	+mpint* itomp(int, mpint*);
	49	+uvlong mptouv(mpint*); // unsigned vlong
	50	+mpint* uvtomp(uvlong, mpint*);
	51	+vlong mptov(mpint*); // vlong
	52	+mpint* vtomp(vlong, mpint*);
	53	+
	54	+// divide 2 digits by one
	55	+void mpdigdiv(mpdigit dividend, mpdigit divisor, mpdigit quotient);
	56	+
	57	+// in the following, the result mpint may be
	58	+// the same as one of the inputs.
	59	+void mpadd(mpint b1, mpint b2, mpint *sum); // sum = b1+b2
	60	+void mpsub(mpint b1, mpint b2, mpint *diff); // diff = b1-b2
	61	+void mpleft(mpint b, int shift, mpint res); // res = b<<shift
	62	+void mpright(mpint b, int shift, mpint res); // res = b>>shift
	63	+void mpmul(mpint b1, mpint b2, mpint prod); // prod = b1b2
	64	+void mpexp(mpint b, mpint e, mpint m, mpint res); // res = b**e mod m
	65	+void mpmod(mpint b, mpint m, mpint *remainder); // remainder = b mod m
	66	+
	67	+// quotient = dividend/divisor, remainder = dividend % divisor
	68	+void mpdiv(mpint dividend, mpint divisor, mpint quotient, mpint remainder);
	69	+
	70	+// return neg, 0, pos as b1-b2 is neg, 0, pos
	71	+int mpcmp(mpint b1, mpint b2);
	72	+
	73	+// extended gcd return d, x, and y, s.t. d = gcd(a,b) and ax+by = d
	74	+void mpextendedgcd(mpint a, mpint b, mpint d, mpint x, mpint *y);
	75	+
	76	+// res = b**-1 mod m
	77	+void mpinvert(mpint b, mpint m, mpint *res);
	78	+
	79	+// bit counting
	80	+int mpsignif(mpint*); // number of sigificant bits in mantissa
	81	+int mplowbits0(mpint); // k, where n = 2k q for odd q
	82	+
	83	+// well known constants
	84	+extern mpint mpzero, mpone, *mptwo;
	85	+
	86	+// sum[0:alen] = a[0:alen-1] + b[0:blen-1]
	87	+// prereq: alen >= blen, sum has room for alen+1 digits
	88	+void mpvecadd(mpdigit a, int alen, mpdigit b, int blen, mpdigit *sum);
	89	+
	90	+// diff[0:alen-1] = a[0:alen-1] - b[0:blen-1]
	91	+// prereq: alen >= blen, diff has room for alen digits
	92	+void mpvecsub(mpdigit a, int alen, mpdigit b, int blen, mpdigit *diff);
	93	+
	94	+// p[0:n] += m * b[0:n-1]
	95	+// prereq: p has room for n+1 digits
	96	+void mpvecdigmuladd(mpdigit b, int n, mpdigit m, mpdigit p);
	97	+
	98	+// p[0:n] -= m * b[0:n-1]
	99	+// prereq: p has room for n+1 digits
	100	+int mpvecdigmulsub(mpdigit b, int n, mpdigit m, mpdigit p);
	101	+
	102	+// p[0:alenblen-1] = a[0:alen-1] b[0:blen-1]
	103	+// prereq: alen >= blen, p has room for m*n digits
	104	+void mpvecmul(mpdigit a, int alen, mpdigit b, int blen, mpdigit *p);
	105	+
	106	+// sign of a - b or zero if the same
	107	+int mpveccmp(mpdigit a, int alen, mpdigit b, int blen);
	108	+
	109	+// divide the 2 digit dividend by the one digit divisor and stick in quotient
	110	+// we assume that the result is one digit - overflow is all 1's
	111	+void mpdigdiv(mpdigit dividend, mpdigit divisor, mpdigit quotient);
	112	+
	113	+// playing with magnitudes
	114	+int mpmagcmp(mpint b1, mpint b2);
	115	+void mpmagadd(mpint b1, mpint b2, mpint *sum); // sum = b1+b2
	116	+void mpmagsub(mpint b1, mpint b2, mpint *sum); // sum = b1+b2
	117	+
	118	+// chinese remainder theorem
	119	+typedef struct CRTpre CRTpre; // precomputed values for converting
	120	+ // twixt residues and mpint
	121	+typedef struct CRTres CRTres; // residue form of an mpint
	122	+
	123	+struct CRTres
	124	+{
	125	+ int n; // number of residues
	126	+ mpint *r[1]; // residues
	127	+};
	128	+
	129	+CRTpre* crtpre(int, mpint**); // precompute conversion values
	130	+CRTres* crtin(CRTpre, mpint); // convert mpint to residues
	131	+void crtout(CRTpre, CRTres, mpint*); // convert residues to mpint
	132	+void crtprefree(CRTpre*);
	133	+void crtresfree(CRTres*);
	134	+

include/u.h+26−0

@@ -0,0 +1,26 @@
	1	+#include "dtos.h"
	2	+
	3	+/* avoid name conflicts */
	4	+#undef accept
	5	+#undef listen
	6	+
	7	+/* sys calls */
	8	+#undef bind
	9	+#undef chdir
	10	+#undef close
	11	+#undef create
	12	+#undef dup
	13	+#undef export
	14	+#undef fstat
	15	+#undef fwstat
	16	+#undef mount
	17	+#undef open
	18	+#undef start
	19	+#undef read
	20	+#undef remove
	21	+#undef seek
	22	+#undef stat
	23	+#undef write
	24	+#undef wstat
	25	+#undef unmount
	26	+#undef pipe

include/unix.h+14−0

@@ -0,0 +1,14 @@
	1	+#include <stdio.h>
	2	+#include <stdlib.h>
	3	+#include <string.h>
	4	+#include <math.h>
	5	+#include <fcntl.h>
	6	+#include <setjmp.h>
	7	+#include <time.h>
	8	+#include <assert.h>
	9	+#include <unistd.h>
	10	+#include <stdarg.h>
	11	+
	12	+
	13	+typedef long long p9_vlong;
	14	+typedef unsigned long long p9_uvlong;

include/user.h+65−0

@@ -0,0 +1,65 @@
	1	+/* sys calls */
	2	+#define bind sysbind
	3	+#define chdir syschdir
	4	+#define close sysclose
	5	+#define create syscreate
	6	+#define dup sysdup
	7	+#define export sysexport
	8	+#define fstat sysfstat
	9	+#define fwstat sysfwstat
	10	+#define mount sysmount
	11	+#define open sysopen
	12	+#define read sysread
	13	+#define remove sysremove
	14	+#define seek sysseek
	15	+#define stat sysstat
	16	+#define write syswrite
	17	+#define wstat syswstat
	18	+#define unmount sysunmount
	19	+#define pipe syspipe
	20	+#define rendezvous sysrendezvous
	21	+#define getpid sysgetpid
	22	+#define time systime
	23	+#define nsec sysnsec
	24	+#define pread syspread
	25	+#define pwrite syspwrite
	26	+
	27	+extern int bind(char, char, int);
	28	+extern int chdir(char*);
	29	+extern int close(int);
	30	+extern int create(char*, int, ulong);
	31	+extern int dup(int, int);
	32	+extern int export(int);
	33	+extern int fstat(int, uchar*, int);
	34	+extern int fwstat(int, uchar*, int);
	35	+extern int mount(int, int, char, int, char);
	36	+extern int unmount(char, char);
	37	+extern int open(char*, int);
	38	+extern int pipe(int*);
	39	+extern long read(int, void*, long);
	40	+extern long readn(int, void*, long);
	41	+extern int remove(char*);
	42	+extern vlong seek(int, vlong, int);
	43	+extern int stat(char, uchar, int);
	44	+extern long write(int, void*, long);
	45	+extern int wstat(char, uchar, int);
	46	+
	47	+extern Dir dirstat(char);
	48	+extern Dir *dirfstat(int);
	49	+extern int dirwstat(char, Dir);
	50	+extern int dirfwstat(int, Dir*);
	51	+extern long dirread(int, Dir*, long);
	52	+
	53	+/*
	54	+ * network dialing and authentication
	55	+ */
	56	+#define NETPATHLEN 40
	57	+extern int accept(int, char*);
	58	+extern int announce(char, char);
	59	+extern int dial(char, char, char, int);
	60	+extern int hangup(int);
	61	+extern int listen(char, char);
	62	+extern char netmkaddr(char, char, char);
	63	+extern int reject(int, char, char);
	64	+
	65	+extern char* argv0;

include/x+0−0

Empty file added.

include/x.c+6−0

@@ -0,0 +1,6 @@
	1	+#include <stdio.h>
	2	+
	3	+void
	4	+main(void)
	5	+{
	6	+}

a

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code