1 #include "a.h"
2 
3 enum
4 {
5 	Qroot = 0,        //  /smug/
6 	Qctl,             //  /smug/ctl
7 	Qrpclog,          //  /smug/rpclog
8 	Quploads,		// /smug/uploads
9 	Qnick,            //  /smug/nick/
10 	Qnickctl,         //  /smug/nick/ctl
11 	Qalbums,          //  /smug/nick/albums/
12 	Qalbumsctl,       //  /smug/nick/albums/ctl
13 	Qcategory,        //  /smug/nick/Category/
14 	Qcategoryctl,     //  /smug/nick/Category/ctl
15 	Qalbum,           //  /smug/nick/Category/Album/
16 	Qalbumctl,        //  /smug/nick/Category/Album/ctl
17 	Qalbumsettings,   //  /smug/nick/Category/Album/settings
18 	Quploadfile,      //  /smug/nick/Category/Album/upload/file.jpg
19 	Qimage,           //  /smug/nick/Category/Album/Image/
20 	Qimagectl,        //  /smug/nick/Category/Album/Image/ctl
21 	Qimageexif,       //  /smug/nick/Category/Album/Image/exif
22 	Qimagesettings,   //  /smug/nick/Category/Album/Image/settings
23 	Qimageurl,        //  /smug/nick/Category/Album/Image/url
24 	Qimagefile,       //  /smug/nick/Category/Album/Image/file.jpg
25 };
26 
27 void
28 mylock(Lock *lk)
29 {
30 	lock(lk);
31 	fprint(2, "locked from %p\n", getcallerpc(&lk));
32 }
33 
34 void
35 myunlock(Lock *lk)
36 {
37 	unlock(lk);
38 	fprint(2, "unlocked from %p\n", getcallerpc(&lk));
39 }
40 
41 //#define lock mylock
42 //#define unlock myunlock
43 
44 typedef struct Upload Upload;
45 
46 typedef struct SmugFid SmugFid;
47 struct SmugFid
48 {
49 	int type;
50 	int nickid;
51 	vlong category;  // -1 for "albums"
52 	vlong album;
53 	char *albumkey;
54 	vlong image;
55 	char *imagekey;
56 	Upload *upload;
57 	int upwriter;
58 };
59 
60 #define QTYPE(p) ((p)&0xFF)
61 #define QARG(p) ((p)>>8)
62 #define QPATH(p, q) ((p)|((q)<<8))
63 
64 char **nick;
65 int nnick;
66 
67 struct Upload
68 {
69 	Lock lk;
70 	int fd;
71 	char *name;
72 	char *file;
73 	vlong album;
74 	vlong length;
75 	char *albumkey;
76 	int size;
77 	int ready;
78 	int nwriters;
79 	int uploaded;
80 	int ref;
81 	int uploading;
82 };
83 
84 Upload **up;
85 int nup;
86 QLock uploadlock;
87 Rendez uploadrendez;
88 
89 void uploader(void*);
90 
91 Upload*
92 newupload(SmugFid *sf, char *name)
93 {
94 	Upload *u;
95 	int fd, i;
96 	char tmp[] = "/var/tmp/smugfs.XXXXXX";
97 	
98 	if((fd = opentemp(tmp, ORDWR)) < 0)
99 		return nil;
100 	qlock(&uploadlock);
101 	for(i=0; i<nup; i++){
102 		u = up[i];
103 		lock(&u->lk);
104 		if(u->ref == 0){
105 			u->ref = 1;
106 			goto Reuse;
107 		}
108 		unlock(&u->lk);
109 	}
110 	if(nup == 0){
111 		uploadrendez.l = &uploadlock;
112 		proccreate(uploader, nil, STACKSIZE);
113 	}
114 	u = emalloc(sizeof *u);
115 	lock(&u->lk);
116 	u->ref = 1;
117 	up = erealloc(up, (nup+1)*sizeof up[0]);
118 	up[nup++] = u;
119 Reuse:
120 	qunlock(&uploadlock);
121 	u->fd = fd;
122 	u->name = estrdup(name);
123 	u->file = estrdup(tmp);
124 	u->album = sf->album;
125 	u->albumkey = estrdup(sf->albumkey);
126 	u->nwriters = 1;
127 	unlock(&u->lk);
128 	return u;
129 }
130 
131 void
132 closeupload(Upload *u)
133 {
134 	lock(&u->lk);
135 	if(--u->ref > 0){
136 		unlock(&u->lk);
137 		return;
138 	}
139 	if(u->ref < 0)
140 		abort();
141 	if(u->fd >= 0){
142 		close(u->fd);
143 		u->fd = -1;
144 	}
145 	if(u->name){
146 		free(u->name);
147 		u->name = nil;
148 	}
149 	if(u->file){
150 		remove(u->file);
151 		free(u->file);
152 		u->file = nil;
153 	}
154 	u->album = 0;
155 	if(u->albumkey){
156 		free(u->albumkey);
157 		u->albumkey = nil;
158 	}
159 	u->size = 0;
160 	u->ready = 0;
161 	u->nwriters = 0;
162 	u->uploaded = 0;
163 	u->uploading = 0;
164 	u->length = 0;
165 	unlock(&u->lk);
166 }
167 
168 Upload*
169 getuploadindex(SmugFid *sf, int *index)
170 {
171 	int i;
172 	Upload *u;
173 
174 	qlock(&uploadlock);
175 	for(i=0; i<nup; i++){
176 		u = up[i];
177 		lock(&u->lk);
178 		if(u->ref > 0 && !u->uploaded && u->album == sf->album && (*index)-- == 0){
179 			qunlock(&uploadlock);
180 			u->ref++;
181 			unlock(&u->lk);
182 			return u;
183 		}
184 		unlock(&u->lk);
185 	}
186 	qunlock(&uploadlock);
187 	return nil;
188 }
189 
190 Upload*
191 getuploadname(SmugFid *sf, char *name)
192 {
193 	int i;
194 	Upload *u;
195 	
196 	qlock(&uploadlock);
197 	for(i=0; i<nup; i++){
198 		u = up[i];
199 		lock(&u->lk);
200 		if(u->ref > 0 && !u->uploaded && u->album == sf->album && strcmp(name, u->name) == 0){
201 			qunlock(&uploadlock);
202 			u->ref++;
203 			unlock(&u->lk);
204 			return u;
205 		}
206 		unlock(&u->lk);
207 	}
208 	qunlock(&uploadlock);
209 	return nil;
210 }
211 
212 void doupload(Upload*);
213 
214 void
215 uploader(void *v)
216 {
217 	int i, did;
218 	Upload *u;
219 
220 	qlock(&uploadlock);
221 	for(;;){
222 		did = 0;
223 		for(i=0; i<nup; i++){
224 			u = up[i];
225 			lock(&u->lk);
226 			if(u->ref > 0 && u->ready && !u->uploading && !u->uploaded){
227 				u->uploading = 1;
228 				unlock(&u->lk);
229 				qunlock(&uploadlock);
230 				doupload(u);
231 				closeupload(u);
232 				did = 1;
233 				qlock(&uploadlock);
234 			}else
235 				unlock(&u->lk);
236 		}
237 		if(!did)
238 			rsleep(&uploadrendez);
239 	}
240 }
241 
242 void
243 kickupload(Upload *u)
244 {
245 	Dir *d;
246 
247 	lock(&u->lk);
248 	if((d = dirfstat(u->fd)) != nil)
249 		u->length = d->length;
250 	close(u->fd);
251 	u->fd = -1;
252 	u->ref++;
253 	u->ready = 1;
254 	unlock(&u->lk);
255 	qlock(&uploadlock);
256 	rwakeup(&uploadrendez);
257 	qunlock(&uploadlock);
258 }
259 
260 void
261 doupload(Upload *u)
262 {
263 	Dir *d;
264 	vlong datalen;
265 	Fmt fmt;
266 	char *req;
267 	char buf[8192];
268 	int n, total;
269 	uchar digest[MD5dlen];
270 	DigestState ds;
271 	Json *jv;
272 
273 	if((u->fd = open(u->file, OREAD)) < 0){
274 		fprint(2, "cannot reopen temporary file %s: %r\n", u->file);
275 		return;
276 	}
277 	if((d = dirfstat(u->fd)) == nil){
278 		fprint(2, "fstat: %r\n");
279 		return;
280 	}
281 	datalen = d->length;
282 	free(d);
283 	
284 	memset(&ds, 0, sizeof ds);
285 	seek(u->fd, 0, 0);
286 	total = 0;
287 	while((n = read(u->fd, buf, sizeof buf)) > 0){
288 		md5((uchar*)buf, n, nil, &ds);
289 		total += n;
290 	}
291 	if(total != datalen){
292 		fprint(2, "bad total: %lld %lld\n", total, datalen);
293 		return;
294 	}
295 	md5(nil, 0, digest, &ds);
296 
297 	fmtstrinit(&fmt);
298 	fmtprint(&fmt, "PUT /%s HTTP/1.0\r\n", u->name);
299 	fmtprint(&fmt, "Content-Length: %lld\r\n", datalen);
300 	fmtprint(&fmt, "Content-MD5: %.16lH\r\n", digest);
301 	fmtprint(&fmt, "X-Smug-SessionID: %s\r\n", sessid);
302 	fmtprint(&fmt, "X-Smug-Version: %s\r\n", API_VERSION);
303 	fmtprint(&fmt, "X-Smug-ResponseType: JSON\r\n");
304 	// Can send X-Smug-ImageID instead to replace existing files.
305 	fmtprint(&fmt, "X-Smug-AlbumID: %lld\r\n", u->album);
306 	fmtprint(&fmt, "X-Smug-FileName: %s\r\n", u->name);
307 	fmtprint(&fmt, "\r\n");
308 	req = fmtstrflush(&fmt);
309 	
310 	seek(u->fd, 0, 0);
311 	jv = jsonupload(&http, UPLOAD_HOST, req, u->fd, datalen);
312 	free(req);
313 	if(jv == nil){
314 		fprint(2, "upload: %r\n");
315 		return;
316 	}
317 
318 	close(u->fd);
319 	remove(u->file);
320 	free(u->file);
321 	u->file = nil;
322 	u->fd = -1;
323 	u->uploaded = 1;
324 	rpclog("uploaded: %J", jv);
325 	jclose(jv);
326 }
327 
328 int
329 nickindex(char *name)
330 {
331 	int i;
332 	Json *v;
333 	
334 	for(i=0; i<nnick; i++)
335 		if(strcmp(nick[i], name) == 0)
336 			return i;
337 	v = smug("smugmug.users.getTree", "NickName", name, nil);
338 	if(v == nil)
339 		return -1;
340 	nick = erealloc(nick, (nnick+1)*sizeof nick[0]);
341 	nick[nnick] = estrdup(name);
342 	return nnick++;
343 }
344 
345 char*
346 nickname(int i)
347 {
348 	if(i < 0 || i >= nnick)
349 		return nil;
350 	return nick[i];
351 }
352 
353 void
354 responderrstr(Req *r)
355 {
356 	char err[ERRMAX];
357 	
358 	rerrstr(err, sizeof err);
359 	respond(r, err);
360 }
361 
362 static char*
363 xclone(Fid *oldfid, Fid *newfid)
364 {
365 	SmugFid *sf;
366 	
367 	if(oldfid->aux == nil)
368 		return nil;
369 
370 	sf = emalloc(sizeof *sf);
371 	*sf = *(SmugFid*)oldfid->aux;
372 	sf->upload = nil;
373 	sf->upwriter = 0;
374 	if(sf->albumkey)
375 		sf->albumkey = estrdup(sf->albumkey);
376 	if(sf->imagekey)
377 		sf->imagekey = estrdup(sf->imagekey);
378 	newfid->aux = sf;
379 	return nil;
380 }
381 
382 static void
383 xdestroyfid(Fid *fid)
384 {
385 	SmugFid *sf;
386 
387 	sf = fid->aux;
388 	free(sf->albumkey);
389 	free(sf->imagekey);
390 	if(sf->upload){
391 		if(sf->upwriter && --sf->upload->nwriters == 0){
392 			fprint(2, "should upload %s\n", sf->upload->name);
393 			kickupload(sf->upload);
394 		}
395 		closeupload(sf->upload);
396 		sf->upload = nil;
397 	}
398 	free(sf);
399 }
400 
401 static Json*
402 getcategories(SmugFid *sf)
403 {
404 	Json *v, *w;
405 	
406 	v = smug("smugmug.categories.get", "NickName", nickname(sf->nickid), nil);
407 	w = jincref(jwalk(v, "Categories"));
408 	jclose(v);
409 	return w;
410 }
411 
412 static Json*
413 getcategorytree(SmugFid *sf)
414 {
415 	Json *v, *w;
416 	
417 	v = smug("smugmug.users.getTree", "NickName", nickname(sf->nickid), nil);
418 	w = jincref(jwalk(v, "Categories"));
419 	jclose(v);
420 	return w;
421 }
422 
423 static Json*
424 getcategory(SmugFid *sf, vlong id)
425 {
426 	int i;
427 	Json *v, *w;
428 	
429 	v = getcategorytree(sf);
430 	if(v == nil)
431 		return nil;
432 	for(i=0; i<v->len; i++){
433 		if(jint(jwalk(v->value[i], "id")) == id){
434 			w = jincref(v->value[i]);
435 			jclose(v);
436 			return w;
437 		}
438 	}
439 	jclose(v);
440 	return nil;
441 }
442 
443 static vlong
444 getcategoryid(SmugFid *sf, char *name)
445 {
446 	int i;
447 	vlong id;
448 	Json *v;
449 	
450 	v = getcategories(sf);
451 	if(v == nil)
452 		return -1;
453 	for(i=0; i<v->len; i++){
454 		if(jstrcmp(jwalk(v->value[i], "Name"), name) == 0){
455 			id = jint(jwalk(v->value[i], "id"));
456 			if(id < 0){
457 				jclose(v);
458 				return -1;
459 			}
460 			jclose(v);
461 			return id;
462 		}
463 	}
464 	jclose(v);
465 	return -1;
466 }
467 
468 static vlong
469 getcategoryindex(SmugFid *sf, int i)
470 {
471 	Json *v;
472 	vlong id;
473 	
474 	v = getcategories(sf);
475 	if(v == nil)
476 		return -1;
477 	if(i < 0 || i >= v->len){
478 		jclose(v);
479 		return -1;
480 	}
481 	id = jint(jwalk(v->value[i], "id"));
482 	jclose(v);
483 	return id;
484 }
485 
486 static Json*
487 getalbum(SmugFid *sf, vlong albumid, char *albumkey)
488 {
489 	char id[50];
490 	Json *v, *w;
491 
492 	snprint(id, sizeof id, "%lld", albumid);
493 	v = smug("smugmug.albums.getInfo",
494 		"AlbumID", id, "AlbumKey", albumkey,
495 		"NickName", nickname(sf->nickid), nil);
496 	w = jincref(jwalk(v, "Album"));
497 	jclose(v);
498 	return w;
499 }
500 
501 static Json*
502 getalbums(SmugFid *sf)
503 {
504 	Json *v, *w;
505 
506 	if(sf->category >= 0)
507 		v = getcategory(sf, sf->category);
508 	else
509 		v = smug("smugmug.albums.get",
510 			"NickName", nickname(sf->nickid), nil);
511 	w = jincref(jwalk(v, "Albums"));
512 	jclose(v);
513 	return w;	
514 }
515 
516 static vlong
517 getalbumid(SmugFid *sf, char *name, char **keyp)
518 {
519 	int i;
520 	vlong id;
521 	Json *v;
522 	char *key;
523 	
524 	v = getalbums(sf);
525 	if(v == nil)
526 		return -1;
527 	for(i=0; i<v->len; i++){
528 		if(jstrcmp(jwalk(v->value[i], "Title"), name) == 0){
529 			id = jint(jwalk(v->value[i], "id"));
530 			key = jstring(jwalk(v->value[i], "Key"));
531 			if(id < 0 || key == nil){
532 				jclose(v);
533 				return -1;
534 			}
535 			if(keyp)
536 				*keyp = estrdup(key);
537 			jclose(v);
538 			return id;
539 		}
540 	}
541 	jclose(v);
542 	return -1;
543 }
544 
545 static vlong
546 getalbumindex(SmugFid *sf, int i, char **keyp)
547 {
548 	vlong id;
549 	Json *v;
550 	char *key;
551 	
552 	v = getalbums(sf);
553 	if(v == nil)
554 		return -1;
555 	if(i < 0 || i >= v->len){
556 		jclose(v);
557 		return -1;
558 	}
559 	id = jint(jwalk(v->value[i], "id"));
560 	key = jstring(jwalk(v->value[i], "Key"));
561 	if(id < 0 || key == nil){
562 		jclose(v);
563 		return -1;
564 	}
565 	if(keyp)
566 		*keyp = estrdup(key);
567 	jclose(v);
568 	return id;
569 }
570 
571 static Json*
572 getimages(SmugFid *sf, vlong albumid, char *albumkey)
573 {
574 	char id[50];
575 	Json *v, *w;
576 
577 	snprint(id, sizeof id, "%lld", albumid);
578 	v = smug("smugmug.images.get",
579 		"AlbumID", id, "AlbumKey", albumkey,
580 		"NickName", nickname(sf->nickid), nil);
581 	w = jincref(jwalk(v, "Images"));
582 	jclose(v);
583 	return w;
584 }
585 
586 static vlong
587 getimageid(SmugFid *sf, char *name, char **keyp)
588 {
589 	int i;
590 	vlong id;
591 	Json *v;
592 	char *p;
593 	char *key;
594 	
595 	id = strtol(name, &p, 10);
596 	if(*p != 0 || *name == 0)
597 		return -1;
598 
599 	v = getimages(sf, sf->album, sf->albumkey);
600 	if(v == nil)
601 		return -1;
602 	for(i=0; i<v->len; i++){
603 		if(jint(jwalk(v->value[i], "id")) == id){
604 			key = jstring(jwalk(v->value[i], "Key"));
605 			if(key == nil){
606 				jclose(v);
607 				return -1;
608 			}
609 			if(keyp)
610 				*keyp = estrdup(key);
611 			jclose(v);
612 			return id;
613 		}
614 	}
615 	jclose(v);
616 	return -1;
617 }
618 
619 static Json*
620 getimageinfo(SmugFid *sf, vlong imageid, char *imagekey)
621 {
622 	char id[50];
623 	Json *v, *w;
624 
625 	snprint(id, sizeof id, "%lld", imageid);
626 	v = smug("smugmug.images.getInfo",
627 		"ImageID", id, "ImageKey", imagekey,
628 		"NickName", nickname(sf->nickid), nil);
629 	w = jincref(jwalk(v, "Image"));
630 	jclose(v);
631 	return w;
632 }
633 
634 static Json*
635 getimageexif(SmugFid *sf, vlong imageid, char *imagekey)
636 {
637 	char id[50];
638 	Json *v, *w;
639 
640 	snprint(id, sizeof id, "%lld", imageid);
641 	v = smug("smugmug.images.getEXIF",
642 		"ImageID", id, "ImageKey", imagekey,
643 		"NickName", nickname(sf->nickid), nil);
644 	w = jincref(jwalk(v, "Image"));
645 	jclose(v);
646 	return w;
647 }
648 
649 static vlong
650 getimageindex(SmugFid *sf, int i, char **keyp)
651 {
652 	vlong id;
653 	Json *v;
654 	char *key;
655 	
656 	v = getimages(sf, sf->album, sf->albumkey);
657 	if(v == nil)
658 		return -1;
659 	if(i < 0 || i >= v->len){
660 		jclose(v);
661 		return -1;
662 	}
663 	id = jint(jwalk(v->value[i], "id"));
664 	key = jstring(jwalk(v->value[i], "Key"));
665 	if(id < 0 || key == nil){
666 		jclose(v);
667 		return -1;
668 	}
669 	if(keyp)
670 		*keyp = estrdup(key);
671 	jclose(v);
672 	return id;
673 }
674 
675 static char*
676 categoryname(SmugFid *sf)
677 {
678 	Json *v;
679 	char *s;
680 	
681 	v = getcategory(sf, sf->category);
682 	s = jstring(jwalk(v, "Name"));
683 	if(s)
684 		s = estrdup(s);
685 	jclose(v);
686 	return s;
687 }
688 
689 static char*
690 albumname(SmugFid *sf)
691 {
692 	Json *v;
693 	char *s;
694 	
695 	v = getalbum(sf, sf->album, sf->albumkey);
696 	s = jstring(jwalk(v, "Title"));
697 	if(s)
698 		s = estrdup(s);
699 	jclose(v);
700 	return s;
701 }
702 
703 static char*
704 imagename(SmugFid *sf)
705 {
706 	char *s;
707 	Json *v;
708 	
709 	v = getimageinfo(sf, sf->image, sf->imagekey);
710 	s = jstring(jwalk(v, "FileName"));
711 	if(s && s[0])
712 		s = estrdup(s);
713 	else
714 		s = smprint("%lld.jpg", sf->image);	// TODO: use Format
715 	jclose(v);
716 	return s;
717 }
718 
719 static vlong
720 imagelength(SmugFid *sf)
721 {
722 	vlong length;
723 	Json *v;
724 	
725 	v = getimageinfo(sf, sf->image, sf->imagekey);
726 	length = jint(jwalk(v, "Size"));
727 	jclose(v);
728 	return length;
729 }
730 
731 static struct {
732 	char *key;
733 	char *name;
734 } urls[] = {
735 	"AlbumURL", "album",
736 	"TinyURL", "tiny",
737 	"ThumbURL", "thumb",
738 	"SmallURL", "small",
739 	"MediumURL", "medium",
740 	"LargeURL", "large",
741 	"XLargeURL", "xlarge",
742 	"X2LargeURL", "xxlarge",
743 	"X3LargeURL", "xxxlarge",
744 	"OriginalURL", "original",
745 };
746 
747 static char*
748 imageurl(SmugFid *sf)
749 {
750 	Json *v;
751 	char *s;
752 	int i;
753 
754 	v = getimageinfo(sf, sf->image, sf->imagekey);
755 	for(i=nelem(urls)-1; i>=0; i--){
756 		if((s = jstring(jwalk(v, urls[i].key))) != nil){
757 			s = estrdup(s);
758 			jclose(v);
759 			return s;
760 		}
761 	}
762 	jclose(v);
763 	return nil;
764 }
765 
766 static char* imagestrings[] = 
767 {
768 	"Caption",
769 	"LastUpdated",
770 	"FileName",
771 	"MD5Sum",
772 	"Watermark",
773 	"Format",
774 	"Keywords",
775 	"Date",
776 	"AlbumURL",
777 	"TinyURL",
778 	"ThumbURL",
779 	"SmallURL",
780 	"MediumURL",
781 	"LargeURL",
782 	"XLargeURL",
783 	"X2LargeURL",
784 	"X3LargeURL",
785 	"OriginalURL",
786 	"Album",
787 };
788 
789 static char* albumbools[] = 
790 {
791 	"Public",
792 	"Printable",
793 	"Filenames",
794 	"Comments",
795 	"External",
796 	"Originals",
797 	"EXIF",
798 	"Share",
799 	"SortDirection",
800 	"FamilyEdit",
801 	"FriendEdit",
802 	"HideOwner",
803 	"CanRank",
804 	"Clean",
805 	"Geography",
806 	"SmugSearchable",
807 	"WorldSearchable",
808 	"SquareThumbs",
809 	"X2Larges",
810 	"X3Larges",
811 };
812 
813 static char* albumstrings[] = 
814 {
815 	"Description"
816 	"Keywords",
817 	"Password",
818 	"PasswordHint",
819 	"SortMethod",
820 	"LastUpdated",
821 };
822 
823 static char*
824 readctl(SmugFid *sf)
825 {
826 	int i;
827 	Upload *u;
828 	char *s;
829 	Json *v, *vv;
830 	Fmt fmt;
831 
832 	v = nil;
833 	switch(sf->type){
834 	case Qctl:
835 		return smprint("%#J\n", userinfo);
836 
837 	case Quploads:
838 		fmtstrinit(&fmt);
839 		qlock(&uploadlock);
840 		for(i=0; i<nup; i++){
841 			u = up[i];
842 			lock(&u->lk);
843 			if(u->ready && !u->uploaded && u->ref > 0)
844 				fmtprint(&fmt, "%s %s%s\n", u->name, u->file, u->uploading ? " [uploading]" : "");
845 			unlock(&u->lk);
846 		}
847 		qunlock(&uploadlock);
848 		return fmtstrflush(&fmt);
849 
850 	case Qnickctl:
851 		v = getcategories(sf);
852 		break;
853 
854 	case Qcategoryctl:
855 		v = getcategory(sf, sf->category);
856 		break;
857 
858 	case Qalbumctl:
859 		v = getimages(sf, sf->album, sf->albumkey);
860 		break;
861 
862 	case Qalbumsctl:
863 		v = getalbums(sf);
864 		break;
865 
866 	case Qimagectl:
867 		v = getimageinfo(sf, sf->image, sf->imagekey);
868 		break;
869 	
870 	case Qimageurl:
871 		v = getimageinfo(sf, sf->image, sf->imagekey);
872 		fmtstrinit(&fmt);
873 		for(i=0; i<nelem(urls); i++)
874 			if((s = jstring(jwalk(v, urls[i].key))) != nil)
875 				fmtprint(&fmt, "%s %s\n", urls[i].name, s);
876 		jclose(v);
877 		return fmtstrflush(&fmt);
878 	
879 	case Qimageexif:
880 		v = getimageexif(sf, sf->image, sf->imagekey);
881 		break;
882 	
883 	case Qalbumsettings:
884 		v = getalbum(sf, sf->album, sf->albumkey);
885 		fmtstrinit(&fmt);
886 		fmtprint(&fmt, "id\t%lld\n", jint(jwalk(v, "id")));
887 		// TODO: Category/id
888 		// TODO: SubCategory/id
889 		// TODO: Community/id
890 		// TODO: Template/id
891 		fmtprint(&fmt, "Highlight\t%lld\n", jint(jwalk(v, "Highlight/id")));
892 		fmtprint(&fmt, "Position\t%lld\n", jint(jwalk(v, "Position")));
893 		fmtprint(&fmt, "ImageCount\t%lld\n", jint(jwalk(v, "ImageCount")));
894 		for(i=0; i<nelem(albumbools); i++){
895 			vv = jwalk(v, albumbools[i]);
896 			if(vv)
897 				fmtprint(&fmt, "%s\t%J\n", albumbools[i], vv);
898 		}
899 		for(i=0; i<nelem(albumstrings); i++){
900 			s = jstring(jwalk(v, albumstrings[i]));
901 			if(s)
902 				fmtprint(&fmt, "%s\t%s\n", albumstrings[i], s);
903 		}
904 		s = fmtstrflush(&fmt);
905 		jclose(v);
906 		return s;
907 
908 	case Qimagesettings:
909 		v = getimageinfo(sf, sf->image, sf->imagekey);
910 		fmtstrinit(&fmt);
911 		fmtprint(&fmt, "id\t%lld\n", jint(jwalk(v, "id")));
912 		fmtprint(&fmt, "Position\t%lld\n", jint(jwalk(v, "Position")));
913 		fmtprint(&fmt, "Serial\t%lld\n", jint(jwalk(v, "Serial")));
914 		fmtprint(&fmt, "Size\t%lld\t%lldx%lld\n",
915 			jint(jwalk(v, "Size")),
916 			jint(jwalk(v, "Width")),
917 			jint(jwalk(v, "Height")));
918 		vv = jwalk(v, "Hidden");
919 		fmtprint(&fmt, "Hidden\t%J\n", vv);
920 		// TODO: Album/id
921 		for(i=0; i<nelem(imagestrings); i++){
922 			s = jstring(jwalk(v, imagestrings[i]));
923 			if(s)
924 				fmtprint(&fmt, "%s\t%s\n", imagestrings[i], s);
925 		}
926 		s = fmtstrflush(&fmt);
927 		jclose(v);
928 		return s;
929 	}
930 
931 	if(v == nil)
932 		return estrdup("");
933 	s = smprint("%#J\n", v);
934 	jclose(v);
935 	return s;
936 }
937 
938 
939 static void
940 dostat(SmugFid *sf, Qid *qid, Dir *dir)
941 {
942 	Qid q;
943 	char *name;
944 	int freename;
945 	ulong mode;
946 	char *uid;
947 	char *s;
948 	vlong length;
949 	
950 	memset(&q, 0, sizeof q);
951 	name = nil;
952 	freename = 0;
953 	uid = "smugfs";
954 	q.type = 0;
955 	q.vers = 0;
956 	q.path = QPATH(sf->type, sf->nickid);
957 	length = 0;
958 	mode = 0444;
959 
960 	switch(sf->type){
961 	case Qroot:
962 		name = "/";
963 		q.type = QTDIR;
964 		break;
965 	case Qctl:
966 		name = "ctl";
967 		mode |= 0222;
968 		break;
969 	case Quploads:
970 		name = "uploads";
971 		s = readctl(sf);
972 		if(s){
973 			length = strlen(s);
974 			free(s);
975 		}
976 		break;
977 	case Qrpclog:
978 		name = "rpclog";
979 		break;
980 	case Qnick:
981 		name = nickname(sf->nickid);
982 		q.type = QTDIR;
983 		break;
984 	case Qnickctl:
985 		name = "ctl";
986 		mode |= 0222;
987 		break;
988 	case Qalbums:
989 		name = "albums";
990 		q.type = QTDIR;
991 		break;
992 	case Qalbumsctl:
993 		name = "ctl";
994 		mode |= 0222;
995 		break;
996 	case Qcategory:
997 		name = categoryname(sf);
998 		freename = 1;
999 		q.path |= QPATH(0, sf->category << 8);
1000 		q.type = QTDIR;
1001 		break;
1002 	case Qcategoryctl:
1003 		name = "ctl";
1004 		mode |= 0222;
1005 		q.path |= QPATH(0, sf->category << 8);
1006 		break;
1007 	case Qalbum:
1008 		name = albumname(sf);
1009 		freename = 1;
1010 		q.path |= QPATH(0, sf->album << 8);
1011 		q.type = QTDIR;
1012 		break;
1013 	case Qalbumctl:
1014 		name = "ctl";
1015 		mode |= 0222;
1016 		q.path |= QPATH(0, sf->album << 8);
1017 		break;
1018 	case Qalbumsettings:
1019 		name = "settings";
1020 		mode |= 0222;
1021 		q.path |= QPATH(0, sf->album << 8);
1022 		break;
1023 	case Quploadfile:
1024 		q.path |= QPATH(0, (uintptr)sf->upload << 8);
1025 		if(sf->upload){
1026 			Dir *dd;
1027 			name = sf->upload->name;
1028 			if(sf->upload->fd >= 0){
1029 				dd = dirfstat(sf->upload->fd);
1030 				if(dd){
1031 					length = dd->length;
1032 					free(dd);
1033 				}
1034 			}else
1035 				length = sf->upload->length;
1036 			if(!sf->upload->ready)
1037 				mode |= 0222;
1038 		}
1039 		break;
1040 	case Qimage:
1041 		name = smprint("%lld", sf->image);
1042 		freename = 1;
1043 		q.path |= QPATH(0, sf->image << 8);
1044 		q.type = QTDIR;
1045 		break;
1046 	case Qimagectl:
1047 		name = "ctl";
1048 		mode |= 0222;
1049 		q.path |= QPATH(0, sf->image << 8);
1050 		break;
1051 	case Qimagesettings:
1052 		name = "settings";
1053 		mode |= 0222;
1054 		q.path |= QPATH(0, sf->image << 8);
1055 		break;
1056 	case Qimageexif:
1057 		name = "exif";
1058 		q.path |= QPATH(0, sf->image << 8);
1059 		break;
1060 	case Qimageurl:
1061 		name = "url";
1062 		q.path |= QPATH(0, sf->image << 8);
1063 		break;
1064 	case Qimagefile:
1065 		name = imagename(sf);
1066 		freename = 1;
1067 		q.path |= QPATH(0, sf->image << 8);
1068 		length = imagelength(sf);
1069 		break;
1070 	default:
1071 		name = "?egreg";
1072 		q.path = 0;
1073 		break;
1074 	}
1075 
1076 	if(name == nil){
1077 		name = "???";
1078 		freename = 0;
1079 	}
1080 
1081 	if(qid)
1082 		*qid = q;
1083 	if(dir){
1084 		memset(dir, 0, sizeof *dir);
1085 		dir->name = estrdup9p(name);
1086 		dir->muid = estrdup9p("muid");
1087 		mode |= q.type<<24;
1088 		if(mode & DMDIR)
1089 			mode |= 0755;
1090 		dir->mode = mode;
1091 		dir->uid = estrdup9p(uid);
1092 		dir->gid = estrdup9p("smugfs");
1093 		dir->qid = q;
1094 		dir->length = length;
1095 	}
1096 	if(freename)
1097 		free(name);
1098 }
1099 
1100 static char*
1101 xwalk1(Fid *fid, char *name, Qid *qid)
1102 {
1103 	int dotdot, i;
1104 	vlong id;
1105 	char *key;
1106 	SmugFid *sf;
1107 	char *x;
1108 	Upload *u;
1109 	
1110 	dotdot = strcmp(name, "..") == 0;
1111 	sf = fid->aux;
1112 	switch(sf->type){
1113 	default:
1114 	NotFound:
1115 		return "file not found";
1116 
1117 	case Qroot:
1118 		if(dotdot)
1119 			break;
1120 		if(strcmp(name, "ctl") == 0){
1121 			sf->type = Qctl;
1122 			break;
1123 		}
1124 		if(strcmp(name, "uploads") == 0){
1125 			sf->type = Quploads;
1126 			break;
1127 		}
1128 		if(strcmp(name, "rpclog") == 0){
1129 			sf->type = Qrpclog;
1130 			break;
1131 		}
1132 		if((i = nickindex(name)) >= 0){
1133 			sf->nickid = i;
1134 			sf->type = Qnick;
1135 			break;
1136 		}
1137 		goto NotFound;
1138 
1139 	case Qnick:
1140 		if(dotdot){
1141 			sf->type = Qroot;
1142 			sf->nickid = 0;
1143 			break;
1144 		}
1145 		if(strcmp(name, "ctl") == 0){
1146 			sf->type = Qnickctl;
1147 			break;
1148 		}
1149 		if(strcmp(name, "albums") == 0){
1150 			sf->category = -1;
1151 			sf->type = Qalbums;
1152 			break;
1153 		}
1154 		if((id = getcategoryid(sf, name)) >= 0){
1155 			sf->category = id;
1156 			sf->type = Qcategory;
1157 			break;
1158 		}
1159 		goto NotFound;
1160 	
1161 	case Qalbums:
1162 	case Qcategory:
1163 		if(dotdot){
1164 			sf->category = 0;
1165 			sf->type = Qnick;
1166 			break;
1167 		}
1168 		if(strcmp(name, "ctl") == 0){
1169 			sf->type++;
1170 			break;
1171 		}
1172 		if((id = getalbumid(sf, name, &key)) >= 0){
1173 			sf->album = id;
1174 			sf->albumkey = key;
1175 			sf->type = Qalbum;
1176 			break;
1177 		}
1178 		goto NotFound;
1179 
1180 	case Qalbum:
1181 		if(dotdot){
1182 			free(sf->albumkey);
1183 			sf->albumkey = nil;
1184 			sf->album = 0;
1185 			if(sf->category == -1)
1186 				sf->type = Qalbums;
1187 			else
1188 				sf->type = Qcategory;
1189 			break;
1190 		}
1191 		if(strcmp(name, "ctl") == 0){
1192 			sf->type = Qalbumctl;
1193 			break;
1194 		}
1195 		if(strcmp(name, "settings") == 0){
1196 			sf->type = Qalbumsettings;
1197 			break;
1198 		}
1199 		if((id = getimageid(sf, name, &key)) >= 0){
1200 			sf->image = id;
1201 			sf->imagekey = key;
1202 			sf->type = Qimage;
1203 			break;
1204 		}
1205 		if((u = getuploadname(sf, name)) != nil){
1206 			sf->upload = u;
1207 			sf->type = Quploadfile;
1208 			break;
1209 		}
1210 		goto NotFound;
1211 	
1212 	case Qimage:
1213 		if(dotdot){
1214 			free(sf->imagekey);
1215 			sf->imagekey = nil;
1216 			sf->image = 0;
1217 			sf->type = Qalbum;
1218 			break;
1219 		}
1220 		if(strcmp(name, "ctl") == 0){
1221 			sf->type = Qimagectl;
1222 			break;
1223 		}
1224 		if(strcmp(name, "url") == 0){
1225 			sf->type = Qimageurl;
1226 			break;
1227 		}
1228 		if(strcmp(name, "settings") == 0){
1229 			sf->type = Qimagesettings;
1230 			break;
1231 		}
1232 		if(strcmp(name, "exif") == 0){
1233 			sf->type = Qimageexif;
1234 			break;
1235 		}
1236 		x = imagename(sf);
1237 		if(x && strcmp(name, x) == 0){
1238 			free(x);
1239 			sf->type = Qimagefile;
1240 			break;
1241 		}
1242 		free(x);
1243 		goto NotFound;
1244 	}
1245 	dostat(sf, qid, nil);
1246 	fid->qid = *qid;
1247 	return nil;
1248 }
1249 
1250 static int
1251 dodirgen(int i, Dir *d, void *v)
1252 {
1253 	SmugFid *sf, xsf;
1254 	char *key;
1255 	vlong id;
1256 	Upload *u;
1257 
1258 	sf = v;
1259 	xsf = *sf;
1260 	if(i-- == 0){
1261 		xsf.type++;	// ctl in every directory
1262 		dostat(&xsf, nil, d);
1263 		return 0;
1264 	}
1265 
1266 	switch(sf->type){
1267 	default:
1268 		return -1;
1269 
1270 	case Qroot:
1271 		if(i-- == 0){
1272 			xsf.type = Qrpclog;
1273 			dostat(&xsf, nil, d);
1274 			return 0;
1275 		}
1276 		if(i < 0 || i >= nnick)
1277 			return -1;
1278 		xsf.type = Qnick;
1279 		xsf.nickid = i;
1280 		dostat(&xsf, nil, d);
1281 		return 0;
1282 	
1283 	case Qnick:
1284 		if(i-- == 0){
1285 			xsf.type = Qalbums;
1286 			dostat(&xsf, nil, d);
1287 			return 0;
1288 		}
1289 		if((id = getcategoryindex(sf, i)) < 0)
1290 			return -1;
1291 		xsf.type = Qcategory;
1292 		xsf.category = id;
1293 		dostat(&xsf, nil, d);
1294 		return 0;
1295 	
1296 	case Qalbums:
1297 	case Qcategory:
1298 		if((id = getalbumindex(sf, i, &key)) < 0)
1299 			return -1;
1300 		xsf.type = Qalbum;
1301 		xsf.album = id;
1302 		xsf.albumkey = key;
1303 		dostat(&xsf, nil, d);
1304 		free(key);
1305 		return 0;
1306 	
1307 	case Qalbum:
1308 		if(i-- == 0){
1309 			xsf.type = Qalbumsettings;
1310 			dostat(&xsf, nil, d);
1311 			return 0;
1312 		}
1313 		if((u = getuploadindex(sf, &i)) != nil){
1314 			xsf.upload = u;
1315 			xsf.type = Quploadfile;
1316 			dostat(&xsf, nil, d);
1317 			closeupload(u);
1318 			return 0;
1319 		}
1320 		if((id = getimageindex(sf, i, &key)) < 0)
1321 			return -1;
1322 		xsf.type = Qimage;
1323 		xsf.image = id;
1324 		xsf.imagekey = key;
1325 		dostat(&xsf, nil, d);
1326 		free(key);
1327 		return 0;
1328 	
1329 	case Qimage:
1330 		if(i-- == 0){
1331 			xsf.type = Qimagefile;
1332 			dostat(&xsf, nil, d);
1333 			return 0;
1334 		}
1335 		if(i-- == 0){
1336 			xsf.type = Qimageexif;
1337 			dostat(&xsf, nil, d);
1338 			return 0;
1339 		}
1340 		if(i-- == 0){
1341 			xsf.type = Qimagesettings;
1342 			dostat(&xsf, nil, d);
1343 			return 0;
1344 		}
1345 		if(i-- == 0){
1346 			xsf.type = Qimageurl;
1347 			dostat(&xsf, nil, d);
1348 			return 0;
1349 		}
1350 		return -1;
1351 	}
1352 }
1353 
1354 static void
1355 xstat(Req *r)
1356 {
1357 	dostat(r->fid->aux, nil, &r->d);
1358 	respond(r, nil);
1359 }
1360 
1361 static void
1362 xwstat(Req *r)
1363 {
1364 	SmugFid *sf;
1365 	Json *v;
1366 	char *s;
1367 	char strid[50];
1368 
1369 	sf = r->fid->aux;
1370 	if(r->d.uid[0] || r->d.gid[0] || r->d.muid[0] || ~r->d.mode != 0
1371 	|| ~r->d.atime != 0 || ~r->d.mtime != 0 || ~r->d.length != 0){
1372 		respond(r, "invalid wstat");
1373 		return;
1374 	}
1375 	if(r->d.name[0]){
1376 		switch(sf->type){
1377 		default:
1378 			respond(r, "invalid wstat");
1379 			return;
1380 		// TODO: rename category
1381 		case Qalbum:
1382 			snprint(strid, sizeof strid, "%lld", sf->album);
1383 			v = ncsmug("smugmug.albums.changeSettings",
1384 				"AlbumID", strid, "Title", r->d.name, nil);
1385 			if(v == nil)
1386 				responderrstr(r);
1387 			else
1388 				respond(r, nil);
1389 			s = smprint("&AlbumID=%lld&", sf->album);
1390 			jcacheflush(s);
1391 			free(s);
1392 			jcacheflush("smugmug.albums.get&");
1393 			return;
1394 		}
1395 	}
1396 	respond(r, "invalid wstat");
1397 }			
1398 
1399 static void
1400 xattach(Req *r)
1401 {
1402 	SmugFid *sf;
1403 	
1404 	sf = emalloc(sizeof *sf);
1405 	r->fid->aux = sf;
1406 	sf->type = Qroot;
1407 	dostat(sf, &r->ofcall.qid, nil);
1408 	r->fid->qid = r->ofcall.qid;
1409 	respond(r, nil);
1410 }
1411 
1412 void
1413 xopen(Req *r)
1414 {
1415 	SmugFid *sf;
1416 
1417 	if((r->ifcall.mode&~OTRUNC) > 2){
1418 		respond(r, "permission denied");
1419 		return;
1420 	}
1421 
1422 	sf = r->fid->aux;
1423 	switch(sf->type){
1424 	case Qctl:
1425 	case Qnickctl:
1426 	case Qalbumsctl:
1427 	case Qcategoryctl:
1428 	case Qalbumctl:
1429 	case Qimagectl:
1430 	case Qalbumsettings:
1431 	case Qimagesettings:
1432 		break;
1433 	
1434 	case Quploadfile:
1435 		if(r->ifcall.mode != OREAD){
1436 			lock(&sf->upload->lk);
1437 			if(sf->upload->ready){
1438 				unlock(&sf->upload->lk);
1439 				respond(r, "permission denied");
1440 				return;
1441 			}
1442 			sf->upwriter = 1;
1443 			sf->upload->nwriters++;
1444 			unlock(&sf->upload->lk);
1445 		}
1446 		break;
1447 	
1448 	default:
1449 		if(r->ifcall.mode != OREAD){
1450 			respond(r, "permission denied");
1451 			return;
1452 		}
1453 		break;
1454 	}
1455 
1456 	r->ofcall.qid = r->fid->qid;
1457 	respond(r, nil);
1458 }
1459 
1460 void
1461 xcreate(Req *r)
1462 {
1463 	SmugFid *sf;
1464 	Json *v;
1465 	vlong id;
1466 	char strid[50], *key;
1467 	Upload *u;
1468 
1469 	sf = r->fid->aux;
1470 	switch(sf->type){
1471 	case Qnick:
1472 		// Create new category.
1473 		if(!(r->ifcall.perm&DMDIR))
1474 			break;
1475 		v = ncsmug("smugmug.categories.create",
1476 			"Name", r->ifcall.name, nil);
1477 		if(v == nil){
1478 			responderrstr(r);
1479 			return;
1480 		}
1481 		id = jint(jwalk(v, "Category/id"));
1482 		if(id < 0){
1483 			fprint(2, "Create category: %J\n", v);
1484 			jclose(v);
1485 			responderrstr(r);
1486 			return;
1487 		}
1488 		sf->type = Qcategory;
1489 		sf->category = id;
1490 		jcacheflush("method=smugmug.users.getTree&");
1491 		jcacheflush("method=smugmug.categories.get&");
1492 		dostat(sf, &r->ofcall.qid, nil);
1493 		respond(r, nil);
1494 		return;
1495 		
1496 	case Qcategory:
1497 		// Create new album.
1498 		if(!(r->ifcall.perm&DMDIR))
1499 			break;
1500 		snprint(strid, sizeof strid, "%lld", sf->category);
1501 		// Start with most restrictive settings.
1502 		v = ncsmug("smugmug.albums.create",
1503 			"Title", r->ifcall.name, 
1504 			"CategoryID", strid,
1505 			"Public", "0",
1506 			"WorldSearchable", "0",
1507 			"SmugSearchable", "0",
1508 			nil);
1509 		if(v == nil){
1510 			responderrstr(r);
1511 			return;
1512 		}
1513 		id = jint(jwalk(v, "Album/id"));
1514 		key = jstring(jwalk(v, "Album/Key"));
1515 		if(id < 0 || key == nil){
1516 			fprint(2, "Create album: %J\n", v);
1517 			jclose(v);
1518 			responderrstr(r);
1519 			return;
1520 		}
1521 		sf->type = Qalbum;
1522 		sf->album = id;
1523 		sf->albumkey = estrdup(key);
1524 		jclose(v);
1525 		jcacheflush("method=smugmug.users.getTree&");
1526 		dostat(sf, &r->ofcall.qid, nil);
1527 		respond(r, nil);
1528 		return;
1529 		
1530 	case Qalbum:
1531 		// Upload image to album.
1532 		if(r->ifcall.perm&DMDIR)
1533 			break;
1534 		u = newupload(sf, r->ifcall.name);
1535 		if(u == nil){
1536 			responderrstr(r);
1537 			return;
1538 		}
1539 		sf->upload = u;
1540 		sf->upwriter = 1;
1541 		sf->type = Quploadfile;
1542 		dostat(sf, &r->ofcall.qid, nil);
1543 		respond(r, nil);
1544 		return;
1545 	}
1546 	respond(r, "permission denied");	
1547 }
1548 
1549 static int
1550 writetofd(Req *r, int fd)
1551 {
1552 	int total, n;
1553 	
1554 	total = 0;
1555 	while(total < r->ifcall.count){
1556 		n = pwrite(fd, (char*)r->ifcall.data+total, r->ifcall.count-total, r->ifcall.offset+total);
1557 		if(n <= 0)
1558 			return -1;
1559 		total += n;
1560 	}
1561 	r->ofcall.count = r->ifcall.count;
1562 	return 0;
1563 }
1564 
1565 static void
1566 readfromfd(Req *r, int fd)
1567 {
1568 	int n;
1569 	n = pread(fd, r->ofcall.data, r->ifcall.count, r->ifcall.offset);
1570 	if(n < 0)
1571 		n = 0;
1572 	r->ofcall.count = n;
1573 }
1574 
1575 void
1576 xread(Req *r)
1577 {
1578 	SmugFid *sf;
1579 	char *data;
1580 	int fd;
1581 	HTTPHeader hdr;
1582 	char *url;
1583 	
1584 	sf = r->fid->aux;
1585 	r->ofcall.count = 0;
1586 	switch(sf->type){
1587 	default:
1588 		respond(r, "not implemented");
1589 		return;
1590 	case Qroot:
1591 	case Qnick:
1592 	case Qalbums:
1593 	case Qcategory:
1594 	case Qalbum:
1595 	case Qimage:
1596 		dirread9p(r, dodirgen, sf);
1597 		break;
1598 	case Qrpclog:
1599 		rpclogread(r);
1600 		return;
1601 	case Qctl:
1602 	case Qnickctl:
1603 	case Qalbumsctl:
1604 	case Qcategoryctl:
1605 	case Qalbumctl:
1606 	case Qimagectl:
1607 	case Qimageurl:
1608 	case Qimageexif:
1609 	case Quploads:
1610 	case Qimagesettings:
1611 	case Qalbumsettings:
1612 		data = readctl(sf);
1613 		readstr(r, data);
1614 		free(data);
1615 		break;
1616 	case Qimagefile:
1617 		url = imageurl(sf);
1618 		if(url == nil || (fd = download(url, &hdr)) < 0){
1619 			free(url);
1620 			responderrstr(r);
1621 			return;
1622 		}
1623 		readfromfd(r, fd);
1624 		free(url);
1625 		close(fd);
1626 		break;
1627 	case Quploadfile:
1628 		if(sf->upload)
1629 			readfromfd(r, sf->upload->fd);
1630 		break;
1631 	}
1632 	respond(r, nil);
1633 }
1634 
1635 void
1636 xwrite(Req *r)
1637 {
1638 	int sync;
1639 	char *s, *t, *p;
1640 	Json *v;
1641 	char strid[50];
1642 	SmugFid *sf;
1643 	
1644 	sf = r->fid->aux;
1645 	r->ofcall.count = r->ifcall.count;
1646 	sync = (r->ifcall.count==4 && memcmp(r->ifcall.data, "sync", 4) == 0);
1647 	switch(sf->type){
1648 	case Qctl:
1649 		if(sync){
1650 			jcacheflush(nil);
1651 			respond(r, nil);
1652 			return;
1653 		}
1654 		break;
1655 	case Qnickctl:
1656 		if(sync){
1657 			s = smprint("&NickName=%s&", nickname(sf->nickid));
1658 			jcacheflush(s);
1659 			free(s);
1660 			respond(r, nil);
1661 			return;
1662 		}
1663 		break;		
1664 	case Qalbumsctl:
1665 	case Qcategoryctl:
1666 		jcacheflush("smugmug.categories.get");
1667 		break;
1668 	case Qalbumctl:
1669 		if(sync){
1670 			s = smprint("&AlbumID=%lld&", sf->album);
1671 			jcacheflush(s);
1672 			free(s);
1673 			respond(r, nil);
1674 			return;
1675 		}
1676 		break;
1677 	case Qimagectl:
1678 		if(sync){
1679 			s = smprint("&ImageID=%lld&", sf->image);
1680 			jcacheflush(s);
1681 			free(s);
1682 			respond(r, nil);
1683 			return;
1684 		}
1685 		break;
1686 	case Quploadfile:
1687 		if(sf->upload){
1688 			if(writetofd(r, sf->upload->fd) < 0){
1689 				responderrstr(r);
1690 				return;
1691 			}
1692 			respond(r, nil);
1693 			return;
1694 		}
1695 		break;
1696 	case Qimagesettings:
1697 	case Qalbumsettings:
1698 		s = (char*)r->ifcall.data;	// lib9p nul-terminated it
1699 		t = strpbrk(s, " \r\t\n");
1700 		if(t == nil)
1701 			t = "";
1702 		else{
1703 			*t++ = 0;
1704 			while(*t == ' ' || *t == '\r' || *t == '\t' || *t == '\n')
1705 				t++;
1706 		}
1707 		p = strchr(t, '\n');
1708 		if(p && p[1] == 0)
1709 			*p = 0;
1710 		else if(p){
1711 			respond(r, "newline in argument");
1712 			return;
1713 		}
1714 		if(sf->type == Qalbumsettings)
1715 			goto Albumsettings;
1716 		snprint(strid, sizeof strid, "%lld", sf->image);
1717 		v = ncsmug("smugmug.images.changeSettings",
1718 			"ImageID", strid,
1719 			s, t, nil);
1720 		if(v == nil)
1721 			responderrstr(r);
1722 		else
1723 			respond(r, nil);
1724 		s = smprint("&ImageID=%lld&", sf->image);
1725 		jcacheflush(s);
1726 		free(s);
1727 		return;
1728 	Albumsettings:
1729 		snprint(strid, sizeof strid, "%lld", sf->album);
1730 		v = ncsmug("smugmug.albums.changeSettings",
1731 			"AlbumID", strid, s, t, nil);
1732 		if(v == nil)
1733 			responderrstr(r);
1734 		else
1735 			respond(r, nil);
1736 		s = smprint("&AlbumID=%lld&", sf->album);
1737 		jcacheflush(s);
1738 		free(s);
1739 		return;
1740 	}
1741 	respond(r, "invalid control message");
1742 	return;
1743 }	
1744 
1745 void
1746 xremove(Req *r)
1747 {
1748 	char id[100];
1749 	SmugFid *sf;
1750 	Json *v;
1751 
1752 	sf = r->fid->aux;
1753 	switch(sf->type){
1754 	default:
1755 		respond(r, "permission denied");
1756 		return;
1757 	case Qcategoryctl:
1758 	case Qalbumctl:
1759 	case Qalbumsettings:
1760 	case Qimagectl:
1761 	case Qimagesettings:
1762 	case Qimageexif:
1763 	case Qimageurl:
1764 	case Qimagefile:
1765 		/* ignore remove request, but no error, so rm -r works */
1766 		/* you can pretend they get removed and immediately grow back! */
1767 		respond(r, nil);
1768 		return;
1769 	case Qcategory:
1770 		v = getalbums(sf);
1771 		if(v && v->len > 0){
1772 			respond(r, "directory not empty");
1773 			return;
1774 		}
1775 		snprint(id, sizeof id, "%lld", sf->category);
1776 		v = ncsmug("smugmug.categories.delete",
1777 			"CategoryID", id, nil);
1778 		if(v == nil)
1779 			responderrstr(r);
1780 		else{
1781 			jclose(v);
1782 			jcacheflush("smugmug.users.getTree");
1783 			jcacheflush("smugmug.categories.get");
1784 			respond(r, nil);
1785 		}
1786 		return;
1787 	case Qalbum:
1788 		v = getimages(sf, sf->album, sf->albumkey);
1789 		if(v && v->len > 0){
1790 			respond(r, "directory not empty");
1791 			return;
1792 		}
1793 		snprint(id, sizeof id, "%lld", sf->album);
1794 		v = ncsmug("smugmug.albums.delete",
1795 			"AlbumID", id, nil);
1796 		if(v == nil)
1797 			responderrstr(r);
1798 		else{
1799 			jclose(v);
1800 			jcacheflush("smugmug.users.getTree");
1801 			jcacheflush("smugmug.categories.get");
1802 			jcacheflush("smugmug.albums.get");
1803 			respond(r, nil);
1804 		}
1805 		return;
1806 		
1807 	case Qimage:
1808 		snprint(id, sizeof id, "%lld", sf->image);
1809 		v = ncsmug("smugmug.images.delete",
1810 			"ImageID", id, nil);
1811 		if(v == nil)
1812 			responderrstr(r);
1813 		else{
1814 			jclose(v);
1815 			snprint(id, sizeof id, "ImageID=%lld&", sf->image);
1816 			jcacheflush(id);
1817 			jcacheflush("smugmug.images.get&");
1818 			respond(r, nil);
1819 		}
1820 		return;
1821 	}
1822 }
1823 
1824 void
1825 xflush(Req *r)
1826 {
1827 	rpclogflush(r->oldreq);
1828 	respond(r, nil);
1829 }
1830 
1831 Srv xsrv;
1832 
1833 void
1834 xinit(void)
1835 {	
1836 	xsrv.attach = xattach;
1837 	xsrv.open = xopen;
1838 	xsrv.create = xcreate;
1839 	xsrv.read = xread;
1840 	xsrv.stat = xstat;
1841 	xsrv.walk1 = xwalk1;
1842 	xsrv.clone = xclone;
1843 	xsrv.destroyfid = xdestroyfid;
1844 	xsrv.remove = xremove;
1845 	xsrv.write = xwrite;
1846 	xsrv.flush = xflush;
1847 	xsrv.wstat = xwstat;
1848 }