WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/cmd/webfs/cookies.c

Rev	Author	Line No.	Line
2	-	1	`#include <u.h>`
		2	`#include <libc.h>`
		3	`#include <bio.h>`
		4	`#include <ndb.h>`
		5	`#include <fcall.h>`
		6	`#include <thread.h>`
		7	`#include <9p.h>`
		8	`#include <ctype.h>`
		9	`#include "dat.h"`
		10	`#include "fns.h"`
		11
		12	`int cookiedebug;`
		13
		14	`typedef struct Cookie Cookie;`
		15	`typedef struct Jar Jar;`
		16
		17	`struct Cookie`
		18	`{`
		19	`/* external info */`
		20	`char* name;`
		21	`char* value;`
		22	`char* dom; /* starts with . */`
		23	`char* path;`
		24	`char* version;`
		25	`char* comment; /* optional, may be nil */`
		26
		27	`uint expire; /* time of expiration: ~0 means when webcookies dies */`
		28	`int secure;`
		29	`int explicitdom; /* dom was explicitly set */`
		30	`int explicitpath; /* path was explicitly set */`
		31	`int netscapestyle;`
		32
		33	`/* internal info */`
		34	`int deleted;`
		35	`int mark;`
		36	`int ondisk;`
		37	`};`
		38
		39	`struct Jar`
		40	`{`
		41	`Cookie *c;`
		42	`int nc;`
		43	`int mc;`
		44
		45	`Qid qid;`
		46	`int dirty;`
		47	`char *file;`
		48	`char *lockfile;`
		49	`};`
		50
		51	`struct {`
		52	`char *s;`
		53	`int offset;`
		54	`int ishttp;`
		55	`} stab[] = {`
		56	`"domain", offsetof(Cookie, dom), 1,`
		57	`"path", offsetof(Cookie, path), 1,`
		58	`"name", offsetof(Cookie, name), 0,`
		59	`"value", offsetof(Cookie, value), 0,`
		60	`"comment", offsetof(Cookie, comment), 1,`
		61	`"version", offsetof(Cookie, version), 1,`
		62	`};`
		63
		64	`struct {`
		65	`char *s;`
		66	`int offset;`
		67	`} itab[] = {`
		68	`"expire", offsetof(Cookie, expire),`
		69	`"secure", offsetof(Cookie, secure),`
		70	`"explicitdomain", offsetof(Cookie, explicitdom),`
		71	`"explicitpath", offsetof(Cookie, explicitpath),`
		72	`"netscapestyle", offsetof(Cookie, netscapestyle),`
		73	`};`
		74
		75	`#pragma varargck type "J" Jar*`
		76	`#pragma varargck type "K" Cookie*`
		77
		78	`/* HTTP format */`
		79	`static int`
		80	`jarfmt(Fmt *fp)`
		81	`{`
		82	`int i;`
		83	`Jar *jar;`
		84
		85	`jar = va_arg(fp->args, Jar*);`
		86
		87	`if(jar == nil \|\| jar->nc == 0)`
		88	`return 0;`
		89
		90	`fmtstrcpy(fp, "Cookie: ");`
		91	`if(jar->c[0].version)`
		92	`fmtprint(fp, "$Version=%s; ", jar->c[0].version);`
		93	`for(i=0; i<jar->nc; i++)`
		94	`fmtprint(fp, "%s%s=%s", i ? "; ": "", jar->c[i].name, jar->c[i].value);`
		95	`fmtstrcpy(fp, "\r\n");`
		96	`return 0;`
		97	`}`
		98
		99	`/* individual cookie */`
		100	`static int`
		101	`cookiefmt(Fmt *fp)`
		102	`{`
		103	`int j, k, first;`
		104	`char *t;`
		105	`Cookie *c;`
		106
		107	`c = va_arg(fp->args, Cookie*);`
		108
		109	`first = 1;`
		110	`for(j=0; j<nelem(stab); j++){`
		111	`t = (char*)((uintptr)c+stab[j].offset);`
		112	`if(t == nil)`
		113	`continue;`
		114	`if(first)`
		115	`first = 0;`
		116	`else`
		117	`fmtstrcpy(fp, " ");`
		118	`fmtprint(fp, "%s=%q", stab[j].s, t);`
		119	`}`
		120	`for(j=0; j<nelem(itab); j++){`
		121	`k = (int)((uintptr)c+itab[j].offset);`
		122	`if(k == 0)`
		123	`continue;`
		124	`if(first)`
		125	`first = 0;`
		126	`else`
		127	`fmtstrcpy(fp, " ");`
		128	`fmtprint(fp, "%s=%ud", itab[j].s, k);`
		129	`}`
		130	`return 0;`
		131	`}`
		132
		133	`/*`
		134	`* sort cookies:`
		135	`* - alpha by name`
		136	`* - alpha by domain`
		137	`* - longer paths first, then alpha by path (RFC2109 4.3.4)`
		138	`*/`
		139	`static int`
		140	`cookiecmp(Cookie a, Cookie b)`
		141	`{`
		142	`int i;`
		143
		144	`if((i = strcmp(a->name, b->name)) != 0)`
		145	`return i;`
		146	`if((i = cistrcmp(a->dom, b->dom)) != 0)`
		147	`return i;`
		148	`if((i = strlen(b->path) - strlen(a->path)) != 0)`
		149	`return i;`
		150	`if((i = strcmp(a->path, b->path)) != 0)`
		151	`return i;`
		152	`return 0;`
		153	`}`
		154
		155	`static int`
		156	`exactcookiecmp(Cookie a, Cookie b)`
		157	`{`
		158	`int i;`
		159
		160	`if((i = cookiecmp(a, b)) != 0)`
		161	`return i;`
		162	`if((i = strcmp(a->value, b->value)) != 0)`
		163	`return i;`
		164	`if(a->version \|\| b->version){`
		165	`if(!a->version)`
		166	`return -1;`
		167	`if(!b->version)`
		168	`return 1;`
		169	`if((i = strcmp(a->version, b->version)) != 0)`
		170	`return i;`
		171	`}`
		172	`if(a->comment \|\| b->comment){`
		173	`if(!a->comment)`
		174	`return -1;`
		175	`if(!b->comment)`
		176	`return 1;`
		177	`if((i = strcmp(a->comment, b->comment)) != 0)`
		178	`return i;`
		179	`}`
		180	`if((i = b->expire - a->expire) != 0)`
		181	`return i;`
		182	`if((i = b->secure - a->secure) != 0)`
		183	`return i;`
		184	`if((i = b->explicitdom - a->explicitdom) != 0)`
		185	`return i;`
		186	`if((i = b->explicitpath - a->explicitpath) != 0)`
		187	`return i;`
		188	`if((i = b->netscapestyle - a->netscapestyle) != 0)`
		189	`return i;`
		190
		191	`return 0;`
		192	`}`
		193
		194	`static void`
		195	`freecookie(Cookie *c)`
		196	`{`
		197	`int i;`
		198
		199	`for(i=0; i<nelem(stab); i++)`
		200	`free((char*)((uintptr)c+stab[i].offset));`
		201	`}`
		202
		203	`static void`
		204	`copycookie(Cookie *c)`
		205	`{`
		206	`int i;`
		207	`char **ps;`
		208
		209	`for(i=0; i<nelem(stab); i++){`
		210	`ps = (char**)((uintptr)c+stab[i].offset);`
		211	`if(*ps)`
		212	`ps = estrdup9p(ps);`
		213	`}`
		214	`}`
		215
		216	`static void`
		217	`delcookie(Jar j, Cookie c)`
		218	`{`
		219	`int i;`
		220
		221	`j->dirty = 1;`
		222	`i = c - j->c;`
		223	`if(i < 0 \|\| i >= j->nc)`
		224	`abort();`
		225	`c->deleted = 1;`
		226	`}`
		227
		228	`static void`
		229	`addcookie(Jar j, Cookie c)`
		230	`{`
		231	`int i;`
		232
		233	`if(!c->name \|\| !c->value \|\| !c->path \|\| !c->dom){`
		234	`fprint(2, "not adding incomplete cookie\n");`
		235	`return;`
		236	`}`
		237
		238	`if(cookiedebug)`
		239	`fprint(2, "add %K\n", c);`
		240
		241	`for(i=0; i<j->nc; i++)`
		242	`if(cookiecmp(&j->c[i], c) == 0){`
		243	`if(cookiedebug)`
		244	`fprint(2, "cookie %K matches %K\n", &j->c[i], c);`
		245	`if(exactcookiecmp(&j->c[i], c) == 0){`
		246	`if(cookiedebug)`
		247	`fprint(2, "\texactly\n");`
		248	`j->c[i].mark = 0;`
		249	`return;`
		250	`}`
		251	`delcookie(j, &j->c[i]);`
		252	`}`
		253
		254	`j->dirty = 1;`
		255	`if(j->nc == j->mc){`
		256	`j->mc += 16;`
		257	`j->c = erealloc9p(j->c, j->mc*sizeof(Cookie));`
		258	`}`
		259	`j->c[j->nc] = *c;`
		260	`copycookie(&j->c[j->nc]);`
		261	`j->nc++;`
		262	`}`
		263
		264	`static void`
		265	`purgejar(Jar *j)`
		266	`{`
		267	`int i;`
		268
		269	`for(i=j->nc-1; i>=0; i--){`
		270	`if(!j->c[i].deleted)`
		271	`continue;`
		272	`freecookie(&j->c[i]);`
		273	`--j->nc;`
		274	`j->c[i] = j->c[j->nc];`
		275	`}`
		276	`}`
		277
		278	`static void`
		279	`addtojar(Jar jar, char line, int ondisk)`
		280	`{`
		281	`Cookie c;`
		282	`int i, j, nf, *pint;`
		283	`char f[20], attr, val, *pstr;`
		284
		285	`memset(&c, 0, sizeof c);`
		286	`c.expire = ~0;`
		287	`c.ondisk = ondisk;`
		288	`nf = tokenize(line, f, nelem(f));`
		289	`for(i=0; i<nf; i++){`
		290	`attr = f[i];`
		291	`if((val = strchr(attr, '=')) != nil)`
		292	`*val++ = '\0';`
		293	`else`
		294	`val = "";`
		295	`/* string attributes */`
		296	`for(j=0; j<nelem(stab); j++){`
		297	`if(strcmp(stab[j].s, attr) == 0){`
		298	`pstr = (char**)((uintptr)&c+stab[j].offset);`
		299	`*pstr = val;`
		300	`}`
		301	`}`
		302	`/* integer attributes */`
		303	`for(j=0; j<nelem(itab); j++){`
		304	`if(strcmp(itab[j].s, attr) == 0){`
		305	`pint = (int*)((uintptr)&c+itab[j].offset);`
		306	`if(val[0]=='\0')`
		307	`*pint = 1;`
		308	`else`
		309	`*pint = strtoul(val, 0, 0);`
		310	`}`
		311	`}`
		312	`}`
		313	`if(c.name==nil \|\| c.value==nil \|\| c.dom==nil \|\| c.path==nil){`
		314	`if(cookiedebug)`
		315	`fprint(2, "ignoring fractional cookie %K\n", &c);`
		316	`return;`
		317	`}`
		318	`addcookie(jar, &c);`
		319	`}`
		320
		321	`static Jar*`
		322	`newjar(void)`
		323	`{`
		324	`Jar *jar;`
		325
		326	`jar = emalloc9p(sizeof(Jar));`
		327	`return jar;`
		328	`}`
		329
		330	`static int`
		331	`expirejar(Jar *jar, int exiting)`
		332	`{`
		333	`int i, n;`
		334	`uint now;`
		335
		336	`now = time(0);`
		337	`n = 0;`
		338	`for(i=0; i<jar->nc; i++){`
		339	`if(jar->c[i].expire < now \|\| (exiting && jar->c[i].expire==~0)){`
		340	`delcookie(jar, &jar->c[i]);`
		341	`n++;`
		342	`}`
		343	`}`
		344	`return n;`
		345	`}`
		346
		347	`static void`
		348	`dumpjar(Jar jar, char desc)`
		349	`{`
		350	`int i;`
		351	`Biobuf *b;`
		352	`char *s;`
		353
		354	`print("%s\n", desc);`
		355	`print("\tin memory:\n");`
		356
		357	`for(i=0; i<jar->nc; i++)`
		358	`print("\t%K%s%s%s\n", &jar->c[i],`
		359	`jar->c[i].ondisk ? " ondisk" : "",`
		360	`jar->c[i].deleted ? " deleted" : "",`
		361	`jar->c[i].mark ? " mark" : "");`
		362	`print("\n\ton disk:\n");`
		363	`if((b = Bopen(jar->file, OREAD)) == nil){`
		364	`print("\tno file\n");`
		365	`}else{`
		366	`while((s = Brdstr(b, '\n', 1)) != nil){`
		367	`print("\t%s\n", s);`
		368	`free(s);`
		369	`}`
		370	`Bterm(b);`
		371	`}`
		372	`print("\n");`
		373	`}`
		374
		375	`static int`
		376	`syncjar(Jar *jar)`
		377	`{`
		378	`int i, fd;`
		379	`char *line;`
		380	`Dir *d;`
		381	`Biobuf *b;`
		382	`Qid q;`
		383
		384	`if(jar->file==nil)`
		385	`return 0;`
		386
		387	`memset(&q, 0, sizeof q);`
		388	`if((d = dirstat(jar->file)) != nil){`
		389	`q = d->qid;`
		390	`if(d->qid.path != jar->qid.path \|\| d->qid.vers != jar->qid.vers)`
		391	`jar->dirty = 1;`
		392	`free(d);`
		393	`}`
		394
		395	`if(jar->dirty == 0)`
		396	`return 0;`
		397
		398	`fd = -1;`
		399	`for(i=0; i<50; i++){`
		400	`if((fd = create(jar->lockfile, OWRITE, DMEXCL\|0666)) < 0){`
		401	`sleep(100);`
		402	`continue;`
		403	`}`
		404	`break;`
		405	`}`
		406	`if(fd < 0){`
		407	`if(cookiedebug)`
		408	`fprint(2, "open %s: %r", jar->lockfile);`
		409	`werrstr("cannot acquire jar lock: %r");`
		410	`return -1;`
		411	`}`
		412
		413	`for(i=0; i<jar->nc; i++) /* mark is cleared by addcookie */`
		414	`jar->c[i].mark = jar->c[i].ondisk;`
		415
		416	`if((b = Bopen(jar->file, OREAD)) == nil){`
		417	`if(cookiedebug)`
		418	`fprint(2, "Bopen %s: %r", jar->file);`
		419	`werrstr("cannot read cookie file %s: %r", jar->file);`
		420	`close(fd);`
		421	`return -1;`
		422	`}`
		423	`for(; (line = Brdstr(b, '\n', 1)) != nil; free(line)){`
		424	`if(*line == '#')`
		425	`continue;`
		426	`addtojar(jar, line, 1);`
		427	`}`
		428	`Bterm(b);`
		429
		430	`for(i=0; i<jar->nc; i++)`
		431	`if(jar->c[i].mark && jar->c[i].expire != ~0)`
		432	`delcookie(jar, &jar->c[i]);`
		433
		434	`purgejar(jar);`
		435
		436	`b = Bopen(jar->file, OWRITE);`
		437	`if(b == nil){`
		438	`if(cookiedebug)`
		439	`fprint(2, "Bopen write %s: %r", jar->file);`
		440	`close(fd);`
		441	`return -1;`
		442	`}`
		443	`Bprint(b, "# webcookies cookie jar\n");`
		444	`Bprint(b, "# comments and non-standard fields will be lost\n");`
		445	`for(i=0; i<jar->nc; i++){`
		446	`if(jar->c[i].expire == ~0)`
		447	`continue;`
		448	`Bprint(b, "%K\n", &jar->c[i]);`
		449	`jar->c[i].ondisk = 1;`
		450	`}`
		451	`Bterm(b);`
		452
		453	`jar->dirty = 0;`
		454	`close(fd);`
		455	`if((d = dirstat(jar->file)) != nil){`
		456	`jar->qid = d->qid;`
		457	`free(d);`
		458	`}`
		459	`return 0;`
		460	`}`
		461
		462	`static Jar*`
		463	`readjar(char *file)`
		464	`{`
		465	`char lock, p;`
		466	`Jar *jar;`
		467
		468	`jar = newjar();`
		469	`lock = emalloc9p(strlen(file)+10);`
		470	`strcpy(lock, file);`
		471	`if((p = strrchr(lock, '/')) != nil)`
		472	`p++;`
		473	`else`
		474	`p = lock;`
		475	`memmove(p+2, p, strlen(p)+1);`
		476	`p[0] = 'L';`
		477	`p[1] = '.';`
		478	`jar->lockfile = lock;`
		479	`jar->file = file;`
		480	`jar->dirty = 1;`
		481
		482	`if(syncjar(jar) < 0){`
		483	`free(jar->file);`
		484	`free(jar->lockfile);`
		485	`free(jar);`
		486	`return nil;`
		487	`}`
		488	`return jar;`
		489	`}`
		490
		491	`static void`
		492	`closejar(Jar *jar)`
		493	`{`
		494	`int i;`
		495
		496	`if(jar == nil)`
		497	`return;`
		498	`expirejar(jar, 0);`
		499	`if(syncjar(jar) < 0)`
		500	`fprint(2, "warning: cannot rewrite cookie jar: %r\n");`
		501
		502	`for(i=0; i<jar->nc; i++)`
		503	`freecookie(&jar->c[i]);`
		504
		505	`free(jar->file);`
		506	`free(jar);`
		507	`}`
		508
		509	`/*`
		510	`* Domain name matching is per RFC2109, section 2:`
		511	`*`
		512	`* Hosts names can be specified either as an IP address or a FQHN`
		513	`* string. Sometimes we compare one host name with another. Host A's`
		514	`* name domain-matches host B's if`
		515	`*`
		516	`* * both host names are IP addresses and their host name strings match`
		517	`* exactly; or`
		518	`*`
		519	`* * both host names are FQDN strings and their host name strings match`
		520	`* exactly; or`
		521	`*`
		522	`* * A is a FQDN string and has the form NB, where N is a non-empty name`
		523	`* string, B has the form .B', and B' is a FQDN string. (So, x.y.com`
		524	`* domain-matches .y.com but not y.com.)`
		525	`*`
		526	`* Note that domain-match is not a commutative operation: a.b.c.com`
		527	`* domain-matches .c.com, but not the reverse.`
		528	`*`
		529	`* (This does not verify that IP addresses and FQDN's are well-formed.)`
		530	`*/`
		531	`static int`
		532	`isdomainmatch(char name, char pattern)`
		533	`{`
		534	`int lname, lpattern;`
		535
		536	`if(cistrcmp(name, pattern)==0)`
		537	`return 1;`
		538
		539	`if(strcmp(ipattr(name), "dom")==0 && pattern[0]=='.'){`
		540	`lname = strlen(name);`
		541	`lpattern = strlen(pattern);`
		542	`/* e.g., name: www.google.com && pattern: .google.com */`
		543	`if(lname >= lpattern && cistrcmp(name+lname-lpattern, pattern)==0)`
		544	`return 1;`
		545	`/* e.g., name: google.com && pattern: .google.com */`
		546	`if(lpattern > lname &&`
		547	`cistrcmp(pattern+lpattern-lname, name) == 0)`
		548	`return 1;`
		549	`}`
		550	`return 0;`
		551	`}`
		552
		553	`/*`
		554	`* RFC2109 4.3.4:`
		555	`* - domain must match`
		556	`* - path in cookie must be a prefix of request path`
		557	`* - cookie must not have expired`
		558	`*/`
		559	`static int`
		560	`iscookiematch(Cookie c, char dom, char *path, uint now)`
		561	`{`
		562	`return isdomainmatch(dom, c->dom)`
		563	`&& strncmp(c->path, path, strlen(c->path))==0`
		564	`&& (c->expire == 0 \|\| c->expire >= now);`
		565	`}`
		566
		567	`/*`
		568	`* Produce a subjar of matching cookies.`
		569	`* Secure cookies are only included if secure is set.`
		570	`*/`
		571	`static Jar*`
		572	`cookiesearch(Jar jar, char dom, char *path, int issecure)`
		573	`{`
		574	`int i;`
		575	`Jar *j;`
		576	`uint now;`
		577
		578	`if(cookiedebug)`
		579	`fprint(2, "cookiesearch %s %s %d\n", dom, path, issecure);`
		580	`now = time(0);`
		581	`j = newjar();`
		582	`for(i=0; i<jar->nc; i++){`
		583	`if(cookiedebug)`
		584	`fprint(2, "\ttry %s %s %d %s\n", jar->c[i].dom,`
		585	`jar->c[i].path, jar->c[i].secure,`
		586	`jar->c[i].name);`
		587	`if((issecure \|\| !jar->c[i].secure) &&`
		588	`iscookiematch(&jar->c[i], dom, path, now)){`
		589	`if(cookiedebug)`
		590	`fprint(2, "\tmatched\n");`
		591	`addcookie(j, &jar->c[i]);`
		592	`}`
		593	`}`
		594	`if(j->nc == 0){`
		595	`closejar(j);`
		596	`werrstr("no cookies found");`
		597	`return nil;`
		598	`}`
		599	`qsort(j->c, j->nc, sizeof(j->c[0]), (int()(void, void*))cookiecmp);`
		600	`return j;`
		601	`}`
		602
		603	`/*`
		604	`* RFC2109 4.3.2 security checks`
		605	`*/`
		606	`static char*`
		607	`isbadcookie(Cookie c, char dom, char *path)`
		608	`{`
		609	`int lcdom, ldom;`
		610
		611	`if(strncmp(c->path, path, strlen(c->path)) != 0)`
		612	`return "cookie path is not a prefix of the request path";`
		613
		614	`/*`
		615	`* fgb says omitting this test is necessary to get some sites to work,`
		616	`* but it seems dubious.`
		617	`*/`
		618	`if(c->explicitdom && c->dom[0] != '.')`
		619	`return "cookie domain doesn't start with dot";`
		620
		621	`lcdom = strlen(c->dom);`
		622	`if(memchr(c->dom+1, '.', lcdom-1-1) == nil)`
		623	`return "cookie domain doesn't have embedded dots";`
		624
		625	`if(!isdomainmatch(dom, c->dom))`
		626	`return "request host does not match cookie domain";`
		627
		628	`ldom = strlen(dom);`
		629	`if(strcmp(ipattr(dom), "dom")==0 && lcdom > ldom &&`
		630	`memchr(dom, '.', lcdom - ldom) != nil)`
		631	`return "request host contains dots before cookie domain";`
		632
		633	`return 0;`
		634	`}`
		635
		636	`/*`
		637	`* Sunday, 25-Jan-2002 12:24:36 GMT`
		638	`* Sunday, 25 Jan 2002 12:24:36 GMT`
		639	`* Sun, 25 Jan 02 12:24:36 GMT`
		640	`*/`
		641	`static int`
		642	`isleap(int year)`
		643	`{`
		644	`return year%4==0 && (year%100!=0 \|\| year%400==0);`
		645	`}`
		646
		647	`static uint`
		648	`strtotime(char *s)`
		649	`{`
		650	`char *os;`
		651	`int i;`
		652	`Tm tm;`
		653
		654	`static int mday[2][12] = {`
		655	`31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,`
		656	`31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,`
		657	`};`
		658	`static char *wday[] = {`
		659	`"Sunday", "Monday", "Tuesday", "Wednesday",`
		660	`"Thursday", "Friday", "Saturday",`
		661	`};`
		662	`static char *mon[] = {`
		663	`"Jan", "Feb", "Mar", "Apr", "May", "Jun",`
		664	`"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",`
		665	`};`
		666
		667	`os = s;`
		668	`/* Sunday, */`
		669	`for(i=0; i<nelem(wday); i++){`
		670	`if(cistrncmp(s, wday[i], strlen(wday[i])) == 0){`
		671	`s += strlen(wday[i]);`
		672	`break;`
		673	`}`
		674	`if(cistrncmp(s, wday[i], 3) == 0){`
		675	`s += 3;`
		676	`break;`
		677	`}`
		678	`}`
		679	`if(i==nelem(wday)){`
		680	`if(cookiedebug)`
		681	`fprint(2, "bad wday (%s)\n", os);`
		682	`return -1;`
		683	`}`
		684	`if(s++ != ',' \|\| s++ != ' '){`
		685	`if(cookiedebug)`
		686	`fprint(2, "bad wday separator (%s)\n", os);`
		687	`return -1;`
		688	`}`
		689
		690	`/* 25- */`
		691	`if(!isdigit(s[0]) \|\| !isdigit(s[1]) \|\| (s[2]!='-' && s[2]!=' ')){`
		692	`if(cookiedebug)`
		693	`fprint(2, "bad day of month (%s)\n", os);`
		694	`return -1;`
		695	`}`
		696	`tm.mday = strtol(s, 0, 10);`
		697	`s += 3;`
		698
		699	`/* Jan- */`
		700	`for(i=0; i<nelem(mon); i++)`
		701	`if(cistrncmp(s, mon[i], 3) == 0){`
		702	`tm.mon = i;`
		703	`s += 3;`
		704	`break;`
		705	`}`
		706	`if(i==nelem(mon)){`
		707	`if(cookiedebug)`
		708	`fprint(2, "bad month (%s)\n", os);`
		709	`return -1;`
		710	`}`
		711	`if(s[0] != '-' && s[0] != ' '){`
		712	`if(cookiedebug)`
		713	`fprint(2, "bad month separator (%s)\n", os);`
		714	`return -1;`
		715	`}`
		716	`s++;`
		717
		718	`/* 2002 */`
		719	`if(!isdigit(s[0]) \|\| !isdigit(s[1])){`
		720	`if(cookiedebug)`
		721	`fprint(2, "bad year (%s)\n", os);`
		722	`return -1;`
		723	`}`
		724	`tm.year = strtol(s, 0, 10);`
		725	`s += 2;`
		726	`if(isdigit(s[0]) && isdigit(s[1]))`
		727	`s += 2;`
		728	`else{`
		729	`if(tm.year <= 68)`
		730	`tm.year += 2000;`
		731	`else`
		732	`tm.year += 1900;`
		733	`}`
		734	`if(tm.mday==0 \|\| tm.mday > mday[isleap(tm.year)][tm.mon]){`
		735	`if(cookiedebug)`
		736	`fprint(2, "invalid day of month (%s)\n", os);`
		737	`return -1;`
		738	`}`
		739	`tm.year -= 1900;`
		740	`if(*s++ != ' '){`
		741	`if(cookiedebug)`
		742	`fprint(2, "bad year separator (%s)\n", os);`
		743	`return -1;`
		744	`}`
		745
		746	`if(!isdigit(s[0]) \|\| !isdigit(s[1]) \|\| s[2]!=':'`
		747	`\|\| !isdigit(s[3]) \|\| !isdigit(s[4]) \|\| s[5]!=':'`
		748	`\|\| !isdigit(s[6]) \|\| !isdigit(s[7]) \|\| s[8]!=' '){`
		749	`if(cookiedebug)`
		750	`fprint(2, "bad time (%s)\n", os);`
		751	`return -1;`
		752	`}`
		753
		754	`tm.hour = atoi(s);`
		755	`tm.min = atoi(s+3);`
		756	`tm.sec = atoi(s+6);`
		757	`if(tm.hour >= 24 \|\| tm.min >= 60 \|\| tm.sec >= 60){`
		758	`if(cookiedebug)`
		759	`fprint(2, "invalid time (%s)\n", os);`
		760	`return -1;`
		761	`}`
		762	`s += 9;`
		763
		764	`if(cistrcmp(s, "GMT") != 0){`
		765	`if(cookiedebug)`
		766	`fprint(2, "time zone not GMT (%s)\n", os);`
		767	`return -1;`
		768	`}`
		769	`strcpy(tm.zone, "GMT");`
		770	`tm.yday = 0;`
		771	`return tm2sec(&tm);`
		772	`}`
		773
		774	`/*`
		775	`* skip linear whitespace. we're a bit more lenient than RFC2616 2.2.`
		776	`*/`
		777	`static char*`
		778	`skipspace(char *s)`
		779	`{`
		780	`while(s=='\r' \|\| s=='\n' \|\| s==' ' \|\| s=='\t')`
		781	`s++;`
		782	`return s;`
		783	`}`
		784
		785	`/*`
		786	`* Try to identify old netscape headers.`
		787	`* The old headers:`
		788	`* - didn't allow spaces around the '='`
		789	`* - used an 'Expires' attribute`
		790	`* - had no 'Version' attribute`
		791	`* - had no quotes`
		792	`* - allowed whitespace in values`
		793	`* - apparently separated attr/value pairs with ';' exclusively`
		794	`*/`
		795	`static int`
		796	`isnetscape(char *hdr)`
		797	`{`
		798	`char *s;`
		799
		800	`for(s=hdr; (s=strchr(s, '=')) != nil; s++){`
		801	`if(isspace(s[1]) \|\| (s > hdr && isspace(s[-1])))`
		802	`return 0;`
		803	`if(s[1]=='"')`
		804	`return 0;`
		805	`}`
		806	`if(cistrstr(hdr, "version="))`
		807	`return 0;`
		808	`return 1;`
		809	`}`
		810
		811	`/*`
		812	`* Parse HTTP response headers, adding cookies to jar.`
		813	`* Overwrites the headers. May overwrite path.`
		814	`*/`
		815	`static char* parsecookie(Cookie, char, char*, int, char, char*);`
		816	`static int`
		817	`parsehttp(Jar jar, char hdr, char dom, char path)`
		818	`{`
		819	`static char setcookie[] = "Set-Cookie:";`
		820	`char e, p, *nextp;`
		821	`Cookie c;`
		822	`int isns, n;`
		823
		824	`isns = isnetscape(hdr);`
		825	`n = 0;`
		826	`for(p=hdr; p; p=nextp){`
		827	`p = skipspace(p);`
		828	`if(*p == '\0')`
		829	`break;`
		830	`nextp = strchr(p, '\n');`
		831	`if(nextp != nil)`
		832	`*nextp++ = '\0';`
		833	`if(cistrncmp(p, setcookie, strlen(setcookie)) != 0)`
		834	`continue;`
		835	`if(cookiedebug)`
		836	`fprint(2, "%s\n", p);`
		837	`p = skipspace(p+strlen(setcookie));`
		838	`for(; *p; p=skipspace(p)){`
		839	`if((e = parsecookie(&c, p, &p, isns, dom, path)) != nil){`
		840	`if(cookiedebug)`
		841	`fprint(2, "parse cookie: %s\n", e);`
		842	`break;`
		843	`}`
		844	`if((e = isbadcookie(&c, dom, path)) != nil){`
		845	`if(cookiedebug)`
		846	`fprint(2, "reject cookie; %s\n", e);`
		847	`continue;`
		848	`}`
		849	`addcookie(jar, &c);`
		850	`n++;`
		851	`}`
		852	`}`
		853	`return n;`
		854	`}`
		855
		856	`static char*`
		857	`skipquoted(char *s)`
		858	`{`
		859	`/*`
		860	`* Sec 2.2 of RFC2616 defines a "quoted-string" as:`
		861	`*`
		862	`* quoted-string = ( <"> *(qdtext \| quoted-pair ) <"> )`
		863	`* qdtext = <any TEXT except <">>`
		864	`* quoted-pair = "\" CHAR`
		865	`*`
		866	`* TEXT is any octet except CTLs, but including LWS;`
		867	`* LWS is [CR LF] 1*(SP \| HT);`
		868	`* CHARs are ASCII octets 0-127; (NOTE: we reject 0's)`
		869	`* CTLs are octets 0-31 and 127;`
		870	`*/`
		871	`if(*s != '"')`
		872	`return s;`
		873
		874	`for(s++; 32 <= s && s < 127 && *s != '"'; s++)`
		875	`if(s == '\\' && (s+1) != '\0')`
		876	`s++;`
		877	`return s;`
		878	`}`
		879
		880	`static char*`
		881	`skiptoken(char *s)`
		882	`{`
		883	`/*`
		884	`* Sec 2.2 of RFC2616 defines a "token" as`
		885	`* 1*<any CHAR except CTLs or separators>;`
		886	`* CHARs are ASCII octets 0-127;`
		887	`* CTLs are octets 0-31 and 127;`
		888	`* separators are "()<>@,;:\/[]?={}", double-quote, SP (32), and HT (9)`
		889	`*/`
		890	`while(32 <= s && s < 127 && strchr("()<>@,;:[]?={}\" \t\\", *s)==nil)`
		891	`s++;`
		892
		893	`return s;`
		894	`}`
		895
		896	`static char*`
		897	`skipvalue(char *s, int isns)`
		898	`{`
		899	`char *t;`
		900
		901	`/*`
		902	`* An RFC2109 value is an HTTP token or an HTTP quoted string.`
		903	`* Netscape servers ignore the spec and rely on semicolons, apparently.`
		904	`*/`
		905	`if(isns){`
		906	`if((t = strchr(s, ';')) == nil)`
		907	`t = s+strlen(s);`
		908	`return t;`
		909	`}`
		910	`if(*s == '"')`
		911	`return skipquoted(s);`
		912	`return skiptoken(s);`
		913	`}`
		914
		915	`/*`
		916	`* RMID=80b186bb64c03c65fab767f8; expires=Monday, 10-Feb-2003 04:44:39 GMT;`
		917	`* path=/; domain=.nytimes.com`
		918	`*/`
		919	`static char*`
		920	`parsecookie(Cookie c, char p, char *e, int isns, char dom, char *path)`
		921	`{`
		922	`int i, done;`
		923	`char t, u, attr, val;`
		924
		925	`c->expire = ~0;`
		926	`memset(c, 0, sizeof *c);`
		927
		928	`/* NAME=VALUE */`
		929	`t = skiptoken(p);`
		930	`c->name = p;`
		931	`p = skipspace(t);`
		932	`if(*p != '='){`
		933	`Badname:`
		934	`return "malformed cookie: no NAME=VALUE";`
		935	`}`
		936	`*t = '\0';`
		937	`p = skipspace(p+1);`
		938	`t = skipvalue(p, isns);`
		939	`if(*t)`
		940	`*t++ = '\0';`
		941	`c->value = p;`
		942	`p = skipspace(t);`
		943	`if(c->name[0]=='\0' \|\| c->value[0]=='\0')`
		944	`goto Badname;`
		945
		946	`done = 0;`
		947	`for(; *p && !done; p=skipspace(p)){`
		948	`attr = p;`
		949	`t = skiptoken(p);`
		950	`u = skipspace(t);`
		951	`switch(*u){`
		952	`case '\0':`
		953	`*t = '\0';`
		954	`val = p = u;`
		955	`break;`
		956	`case ';':`
		957	`*t = '\0';`
		958	`val = "";`
		959	`p = u+1;`
		960	`break;`
		961	`case '=':`
		962	`*t = '\0';`
		963	`val = skipspace(u+1);`
		964	`p = skipvalue(val, isns);`
		965	`if(*p==',')`
		966	`done = 1;`
		967	`if(*p)`
		968	`*p++ = '\0';`
		969	`break;`
		970	`case ',':`
		971	`if(!isns){`
		972	`val = "";`
		973	`p = u;`
		974	`*p++ = '\0';`
		975	`done = 1;`
		976	`break;`
		977	`}`
		978	`default:`
		979	`if(cookiedebug)`
		980	`fprint(2, "syntax: %s\n", p);`
		981	`return "syntax error";`
		982	`}`
		983	`for(i=0; i<nelem(stab); i++)`
		984	`if(stab[i].ishttp && cistrcmp(stab[i].s, attr)==0)`
		985	`(char*)((uintptr)c+stab[i].offset) = val;`
		986	`if(cistrcmp(attr, "expires") == 0){`
		987	`if(!isns)`
		988	`return "non-netscape cookie has Expires tag";`
		989	`if(!val[0])`
		990	`return "bad expires tag";`
		991	`c->expire = strtotime(val);`
		992	`if(c->expire == ~0)`
		993	`return "cannot parse netscape expires tag";`
		994	`}`
		995	`if(cistrcmp(attr, "max-age") == 0)`
		996	`c->expire = time(0)+atoi(val);`
		997	`if(cistrcmp(attr, "secure") == 0)`
		998	`c->secure = 1;`
		999	`}`
		1000
		1001	`if(c->dom)`
		1002	`c->explicitdom = 1;`
		1003	`else`
		1004	`c->dom = dom;`
		1005	`if(c->path)`
		1006	`c->explicitpath = 1;`
		1007	`else{`
		1008	`c->path = path;`
		1009	`if((t = strchr(c->path, '?')) != 0)`
		1010	`*t = '\0';`
		1011	`if((t = strrchr(c->path, '/')) != 0)`
		1012	`*t = '\0';`
		1013	`}`
		1014	`c->netscapestyle = isns;`
		1015	`*e = p;`
		1016
		1017	`return nil;`
		1018	`}`
		1019
		1020	`Jar *jar;`
		1021
		1022	`typedef struct Aux Aux;`
		1023	`struct Aux`
		1024	`{`
		1025	`char *dom;`
		1026	`char *path;`
		1027	`char *inhttp;`
		1028	`char *outhttp;`
		1029	`char *ctext;`
		1030	`int rdoff;`
		1031	`};`
		1032	`enum`
		1033	`{`
		1034	`AuxBuf = 4096,`
		1035	`MaxCtext = 1610241024,`
		1036	`};`
		1037
		1038	`void`
		1039	`cookieopen(Req *r)`
		1040	`{`
		1041	`char s, es;`
		1042	`int i, sz;`
		1043	`Aux *a;`
		1044
		1045	`syncjar(jar);`
		1046	`a = emalloc9p(sizeof(Aux));`
		1047	`r->fid->aux = a;`
		1048	`if(r->ifcall.mode&OTRUNC){`
		1049	`a->ctext = emalloc9p(1);`
		1050	`a->ctext[0] = '\0';`
		1051	`}else{`
		1052	`sz = 256jar->nc+1024; / BUG should do better */`
		1053	`a->ctext = emalloc9p(sz);`
		1054	`a->ctext[0] = '\0';`
		1055	`s = a->ctext;`
		1056	`es = s+sz;`
		1057	`for(i=0; i<jar->nc; i++)`
		1058	`s = seprint(s, es, "%K\n", &jar->c[i]);`
		1059	`}`
		1060	`respond(r, nil);`
		1061	`}`
		1062
		1063	`void`
		1064	`cookieread(Req *r)`
		1065	`{`
		1066	`Aux *a;`
		1067
		1068	`a = r->fid->aux;`
		1069	`readstr(r, a->ctext);`
		1070	`respond(r, nil);`
		1071	`}`
		1072
		1073	`void`
		1074	`cookiewrite(Req *r)`
		1075	`{`
		1076	`Aux *a;`
		1077	`int sz;`
		1078
		1079	`a = r->fid->aux;`
		1080	`sz = r->ifcall.count+r->ifcall.offset;`
		1081	`if(sz > strlen(a->ctext)){`
		1082	`if(sz >= MaxCtext){`
		1083	`respond(r, "cookie file too large");`
		1084	`return;`
		1085	`}`
		1086	`a->ctext = erealloc9p(a->ctext, sz+1);`
		1087	`a->ctext[sz] = '\0';`
		1088	`}`
		1089	`memmove(a->ctext+r->ifcall.offset, r->ifcall.data, r->ifcall.count);`
		1090	`r->ofcall.count = r->ifcall.count;`
		1091	`respond(r, nil);`
		1092	`}`
		1093
		1094	`void`
		1095	`cookieclunk(Fid *fid)`
		1096	`{`
		1097	`char p, nextp;`
		1098	`Aux *a;`
		1099	`int i;`
		1100
		1101	`a = fid->aux;`
		1102	`if(a == nil)`
		1103	`return;`
		1104	`for(i=0; i<jar->nc; i++)`
		1105	`jar->c[i].mark = 1;`
		1106	`for(p=a->ctext; *p; p=nextp){`
		1107	`if((nextp = strchr(p, '\n')) != nil)`
		1108	`*nextp++ = '\0';`
		1109	`else`
		1110	`nextp = "";`
		1111	`addtojar(jar, p, 0);`
		1112	`}`
		1113	`for(i=0; i<jar->nc; i++)`
		1114	`if(jar->c[i].mark)`
		1115	`delcookie(jar, &jar->c[i]);`
		1116	`syncjar(jar);`
		1117	`free(a->dom);`
		1118	`free(a->path);`
		1119	`free(a->inhttp);`
		1120	`free(a->outhttp);`
		1121	`free(a->ctext);`
		1122	`free(a);`
		1123	`}`
		1124
		1125	`void`
		1126	`closecookies(void)`
		1127	`{`
		1128	`closejar(jar);`
		1129	`}`
		1130
		1131	`void`
		1132	`initcookies(char *file)`
		1133	`{`
		1134	`char *home;`
		1135
		1136	`fmtinstall('J', jarfmt);`
		1137	`fmtinstall('K', cookiefmt);`
		1138
		1139	`if(file == nil){`
		1140	`home = getenv("home");`
		1141	`if(home == nil)`
		1142	`sysfatal("no cookie file specified and no $home");`
		1143	`file = emalloc9p(strlen(home)+30);`
		1144	`strcpy(file, home);`
		1145	`strcat(file, "/lib/webcookies");`
		1146	`}`
		1147	`jar = readjar(file);`
		1148	`if(jar == nil)`
		1149	`sysfatal("readjar: %r");`
		1150	`}`
		1151
		1152	`void`
		1153	`httpsetcookie(char hdr, char dom, char *path)`
		1154	`{`
		1155	`if(path == nil)`
		1156	`path = "/";`
		1157
		1158	`parsehttp(jar, hdr, dom, path);`
		1159	`syncjar(jar);`
		1160	`}`
		1161
		1162	`char*`
		1163	`httpcookies(char dom, char path, int issecure)`
		1164	`{`
		1165	`char buf[1024];`
		1166	`Jar *j;`
		1167
		1168	`syncjar(jar);`
		1169	`j = cookiesearch(jar, dom, path, issecure);`
		1170	`snprint(buf, sizeof buf, "%J", j);`
		1171	`closejar(j);`
		1172	`return estrdup(buf);`
		1173	`}`

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/cmd/webfs/cookies.c – Rev 2