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