main.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729
  1. /* cdfs - CD, DVD and BD reader and writer file system */
  2. #include <u.h>
  3. #include <libc.h>
  4. #include <auth.h>
  5. #include <fcall.h>
  6. #include <thread.h>
  7. #include <9p.h>
  8. #include <disk.h>
  9. #include "dat.h"
  10. #include "fns.h"
  11. typedef struct Aux Aux;
  12. struct Aux {
  13. int doff;
  14. Otrack *o;
  15. };
  16. ulong getnwa(Drive *);
  17. static void checktoc(Drive*);
  18. int vflag;
  19. static Drive *drive;
  20. static int nchange;
  21. enum {
  22. Qdir = 0,
  23. Qctl = 1,
  24. Qwa = 2,
  25. Qwd = 3,
  26. Qtrack = 4,
  27. };
  28. char*
  29. geterrstr(void)
  30. {
  31. static char errbuf[ERRMAX];
  32. rerrstr(errbuf, sizeof errbuf);
  33. return errbuf;
  34. }
  35. void*
  36. emalloc(ulong sz)
  37. {
  38. void *v;
  39. v = mallocz(sz, 1);
  40. if(v == nil)
  41. sysfatal("malloc %lud fails", sz);
  42. return v;
  43. }
  44. static void
  45. fsattach(Req *r)
  46. {
  47. char *spec;
  48. spec = r->ifcall.aname;
  49. if(spec && spec[0]) {
  50. respond(r, "invalid attach specifier");
  51. return;
  52. }
  53. checktoc(drive);
  54. r->fid->qid = (Qid){Qdir, drive->nchange, QTDIR};
  55. r->ofcall.qid = r->fid->qid;
  56. r->fid->aux = emalloc(sizeof(Aux));
  57. respond(r, nil);
  58. }
  59. static char*
  60. fsclone(Fid *old, Fid *new)
  61. {
  62. Aux *na;
  63. na = emalloc(sizeof(Aux));
  64. *na = *((Aux*)old->aux);
  65. if(na->o)
  66. na->o->nref++;
  67. new->aux = na;
  68. return nil;
  69. }
  70. static char*
  71. fswalk1(Fid *fid, char *name, Qid *qid)
  72. {
  73. int i;
  74. checktoc(drive);
  75. switch((ulong)fid->qid.path) {
  76. case Qdir:
  77. if(strcmp(name, "..") == 0) {
  78. *qid = (Qid){Qdir, drive->nchange, QTDIR};
  79. return nil;
  80. }
  81. if(strcmp(name, "ctl") == 0) {
  82. *qid = (Qid){Qctl, 0, 0};
  83. return nil;
  84. }
  85. if(strcmp(name, "wa") == 0 && drive->writeok &&
  86. (drive->mmctype == Mmcnone ||
  87. drive->mmctype == Mmccd)) {
  88. *qid = (Qid){Qwa, drive->nchange, QTDIR};
  89. return nil;
  90. }
  91. if(strcmp(name, "wd") == 0 && drive->writeok) {
  92. *qid = (Qid){Qwd, drive->nchange, QTDIR};
  93. return nil;
  94. }
  95. for(i=0; i<drive->ntrack; i++)
  96. if(strcmp(drive->track[i].name, name) == 0)
  97. break;
  98. if(i == drive->ntrack)
  99. return "file not found";
  100. *qid = (Qid){Qtrack+i, 0, 0};
  101. return nil;
  102. case Qwa:
  103. case Qwd:
  104. if(strcmp(name, "..") == 0) {
  105. *qid = (Qid){Qdir, drive->nchange, QTDIR};
  106. return nil;
  107. }
  108. return "file not found";
  109. default: /* bug: lib9p could handle this */
  110. return "walk in non-directory";
  111. }
  112. }
  113. static void
  114. fscreate(Req *r)
  115. {
  116. int omode, type;
  117. Otrack *o;
  118. Fid *fid;
  119. fid = r->fid;
  120. omode = r->ifcall.mode;
  121. if(omode != OWRITE) {
  122. respond(r, "bad mode (use OWRITE)");
  123. return;
  124. }
  125. switch((ulong)fid->qid.path) {
  126. case Qdir:
  127. default:
  128. respond(r, "permission denied");
  129. return;
  130. case Qwa:
  131. if (drive->mmctype != Mmcnone &&
  132. drive->mmctype != Mmccd) {
  133. respond(r, "audio supported only on cd");
  134. return;
  135. }
  136. type = TypeAudio;
  137. break;
  138. case Qwd:
  139. type = TypeData;
  140. break;
  141. }
  142. if((drive->cap & Cwrite) == 0) {
  143. respond(r, "drive does not write");
  144. return;
  145. }
  146. o = drive->create(drive, type);
  147. if(o == nil) {
  148. respond(r, geterrstr());
  149. return;
  150. }
  151. drive->nchange = -1;
  152. checktoc(drive); /* update directory info */
  153. o->nref = 1;
  154. ((Aux*)fid->aux)->o = o;
  155. fid->qid = (Qid){Qtrack+(o->track - drive->track), drive->nchange, 0};
  156. r->ofcall.qid = fid->qid;
  157. respond(r, nil);
  158. }
  159. static void
  160. fsremove(Req *r)
  161. {
  162. switch((ulong)r->fid->qid.path){
  163. case Qwa:
  164. case Qwd:
  165. if(drive->fixate(drive) < 0)
  166. respond(r, geterrstr());
  167. // let us see if it can figure this out: drive->writeok = 0;
  168. else
  169. respond(r, nil);
  170. checktoc(drive);
  171. break;
  172. default:
  173. respond(r, "permission denied");
  174. break;
  175. }
  176. }
  177. /* result is one word, so it can be used as a uid in Dir structs */
  178. static char *
  179. disctype(Drive *drive)
  180. {
  181. char *type, *rw;
  182. switch (drive->mmctype) {
  183. case Mmccd:
  184. type = "cd-";
  185. break;
  186. case Mmcdvdminus:
  187. case Mmcdvdplus:
  188. type = drive->dvdtype;
  189. break;
  190. case Mmcbd:
  191. type = "bd-";
  192. break;
  193. case Mmcnone:
  194. type = "no-disc";
  195. break;
  196. default:
  197. type = "**GOK**"; /* traditional */
  198. break;
  199. }
  200. rw = "";
  201. if (drive->mmctype != Mmcnone && drive->dvdtype == nil)
  202. if (drive->erasable)
  203. rw = drive->mmctype == Mmcbd? "re": "rw";
  204. else if (drive->recordable)
  205. rw = "r";
  206. else
  207. rw = "rom";
  208. return smprint("%s%s", type, rw);
  209. }
  210. int
  211. fillstat(ulong qid, Dir *d)
  212. {
  213. char *ty;
  214. Track *t;
  215. static char buf[32];
  216. nulldir(d);
  217. d->type = L'M';
  218. d->dev = 1;
  219. d->length = 0;
  220. ty = disctype(drive);
  221. strncpy(buf, ty, sizeof buf);
  222. free(ty);
  223. d->uid = d->gid = buf;
  224. d->muid = "";
  225. d->qid = (Qid){qid, drive->nchange, 0};
  226. d->atime = time(0);
  227. d->mtime = drive->changetime;
  228. switch(qid){
  229. case Qdir:
  230. d->name = "/";
  231. d->qid.type = QTDIR;
  232. d->mode = DMDIR|0777;
  233. break;
  234. case Qctl:
  235. d->name = "ctl";
  236. d->mode = 0666;
  237. break;
  238. case Qwa:
  239. if(drive->writeok == 0 ||
  240. drive->mmctype != Mmcnone &&
  241. drive->mmctype != Mmccd)
  242. return 0;
  243. d->name = "wa";
  244. d->qid.type = QTDIR;
  245. d->mode = DMDIR|0777;
  246. break;
  247. case Qwd:
  248. if(drive->writeok == 0)
  249. return 0;
  250. d->name = "wd";
  251. d->qid.type = QTDIR;
  252. d->mode = DMDIR|0777;
  253. break;
  254. default:
  255. if(qid-Qtrack >= drive->ntrack)
  256. return 0;
  257. t = &drive->track[qid-Qtrack];
  258. if(strcmp(t->name, "") == 0)
  259. return 0;
  260. d->name = t->name;
  261. d->mode = t->mode;
  262. d->length = t->size;
  263. break;
  264. }
  265. return 1;
  266. }
  267. static ulong
  268. cddb_sum(int n)
  269. {
  270. int ret;
  271. ret = 0;
  272. while(n > 0) {
  273. ret += n%10;
  274. n /= 10;
  275. }
  276. return ret;
  277. }
  278. static ulong
  279. diskid(Drive *d)
  280. {
  281. int i, n;
  282. ulong tmp;
  283. Msf *ms, *me;
  284. n = 0;
  285. for(i=0; i < d->ntrack; i++)
  286. n += cddb_sum(d->track[i].mbeg.m*60+d->track[i].mbeg.s);
  287. ms = &d->track[0].mbeg;
  288. me = &d->track[d->ntrack].mbeg;
  289. tmp = (me->m*60+me->s) - (ms->m*60+ms->s);
  290. /*
  291. * the spec says n%0xFF rather than n&0xFF. it's unclear which is
  292. * correct. most CDs are in the database under both entries.
  293. */
  294. return ((n % 0xFF) << 24 | (tmp << 8) | d->ntrack);
  295. }
  296. static void
  297. readctl(Req *r)
  298. {
  299. int i, isaudio;
  300. char *p, *e, *ty;
  301. char s[1024];
  302. Msf *m;
  303. isaudio = 0;
  304. for(i=0; i<drive->ntrack; i++)
  305. if(drive->track[i].type == TypeAudio)
  306. isaudio = 1;
  307. p = s;
  308. e = s + sizeof s;
  309. *p = '\0';
  310. if(isaudio){
  311. p = seprint(p, e, "aux/cddb query %8.8lux %d", diskid(drive),
  312. drive->ntrack);
  313. for(i=0; i<drive->ntrack; i++){
  314. m = &drive->track[i].mbeg;
  315. p = seprint(p, e, " %d", (m->m*60 + m->s)*75 + m->f);
  316. }
  317. m = &drive->track[drive->ntrack].mbeg;
  318. p = seprint(p, e, " %d\n", m->m*60 + m->s);
  319. }
  320. if(drive->readspeed == drive->writespeed)
  321. p = seprint(p, e, "speed %d\n", drive->readspeed);
  322. else
  323. p = seprint(p, e, "speed read %d write %d\n",
  324. drive->readspeed, drive->writespeed);
  325. p = seprint(p, e, "maxspeed read %d write %d\n",
  326. drive->maxreadspeed, drive->maxwritespeed);
  327. if (drive->Scsi.changetime != 0 && drive->ntrack != 0) { /* have disc? */
  328. ty = disctype(drive);
  329. p = seprint(p, e, "%s", ty);
  330. free(ty);
  331. if (drive->mmctype != Mmcnone)
  332. p = seprint(p, e, " next writable sector %lud",
  333. getnwa(drive));
  334. seprint(p, e, "\n");
  335. }
  336. readstr(r, s);
  337. }
  338. static void
  339. fsread(Req *r)
  340. {
  341. int j, n, m;
  342. uchar *p, *ep;
  343. Dir d;
  344. Fid *fid;
  345. Otrack *o;
  346. vlong offset;
  347. void *buf;
  348. long count;
  349. Aux *a;
  350. fid = r->fid;
  351. offset = r->ifcall.offset;
  352. buf = r->ofcall.data;
  353. count = r->ifcall.count;
  354. switch((ulong)fid->qid.path) {
  355. case Qdir:
  356. checktoc(drive);
  357. p = buf;
  358. ep = p+count;
  359. m = Qtrack+drive->ntrack;
  360. a = fid->aux;
  361. if(offset == 0)
  362. a->doff = 1; /* skip root */
  363. for(j=a->doff; j<m; j++) {
  364. if(fillstat(j, &d)) {
  365. if((n = convD2M(&d, p, ep-p)) <= BIT16SZ)
  366. break;
  367. p += n;
  368. }
  369. }
  370. a->doff = j;
  371. r->ofcall.count = p - (uchar*)buf;
  372. break;
  373. case Qwa:
  374. case Qwd:
  375. r->ofcall.count = 0;
  376. break;
  377. case Qctl:
  378. readctl(r);
  379. break;
  380. default:
  381. /* a disk track; we can only call read for whole blocks */
  382. o = ((Aux*)fid->aux)->o;
  383. if((count = o->drive->read(o, buf, count, offset)) < 0) {
  384. respond(r, geterrstr());
  385. return;
  386. }
  387. r->ofcall.count = count;
  388. break;
  389. }
  390. respond(r, nil);
  391. }
  392. static char Ebadmsg[] = "bad cdfs control message";
  393. static char*
  394. writectl(void *v, long count)
  395. {
  396. char buf[256];
  397. char *f[10], *p;
  398. int i, nf, n, r, w, what;
  399. if(count >= sizeof(buf))
  400. count = sizeof(buf)-1;
  401. memmove(buf, v, count);
  402. buf[count] = '\0';
  403. nf = tokenize(buf, f, nelem(f));
  404. if(nf == 0)
  405. return Ebadmsg;
  406. if(strcmp(f[0], "speed") == 0){
  407. what = 0;
  408. r = w = -1;
  409. if(nf == 1)
  410. return Ebadmsg;
  411. for(i=1; i<nf; i++){
  412. if(strcmp(f[i], "read") == 0 || strcmp(f[i], "write") == 0){
  413. if(what!=0 && what!='?')
  414. return Ebadmsg;
  415. what = f[i][0];
  416. }else{
  417. if (strcmp(f[i], "best") == 0)
  418. n = (1<<16) - 1;
  419. else {
  420. n = strtol(f[i], &p, 0);
  421. if(*p != '\0' || n <= 0)
  422. return Ebadmsg;
  423. }
  424. switch(what){
  425. case 0:
  426. if(r >= 0 || w >= 0)
  427. return Ebadmsg;
  428. r = w = n;
  429. break;
  430. case 'r':
  431. if(r >= 0)
  432. return Ebadmsg;
  433. r = n;
  434. break;
  435. case 'w':
  436. if(w >= 0)
  437. return Ebadmsg;
  438. w = n;
  439. break;
  440. default:
  441. return Ebadmsg;
  442. }
  443. what = '?';
  444. }
  445. }
  446. if(what != '?')
  447. return Ebadmsg;
  448. return drive->setspeed(drive, r, w);
  449. }
  450. return drive->ctl(drive, nf, f);
  451. }
  452. static void
  453. fswrite(Req *r)
  454. {
  455. Otrack *o;
  456. Fid *fid;
  457. fid = r->fid;
  458. r->ofcall.count = r->ifcall.count;
  459. if(fid->qid.path == Qctl) {
  460. respond(r, writectl(r->ifcall.data, r->ifcall.count));
  461. return;
  462. }
  463. if((o = ((Aux*)fid->aux)->o) == nil || o->omode != OWRITE) {
  464. respond(r, "permission denied");
  465. return;
  466. }
  467. if(o->drive->write(o, r->ifcall.data, r->ifcall.count) < 0)
  468. respond(r, geterrstr());
  469. else
  470. respond(r, nil);
  471. }
  472. static void
  473. fsstat(Req *r)
  474. {
  475. fillstat((ulong)r->fid->qid.path, &r->d);
  476. r->d.name = estrdup9p(r->d.name);
  477. r->d.uid = estrdup9p(r->d.uid);
  478. r->d.gid = estrdup9p(r->d.gid);
  479. r->d.muid = estrdup9p(r->d.muid);
  480. respond(r, nil);
  481. }
  482. static void
  483. fsopen(Req *r)
  484. {
  485. int omode;
  486. Fid *fid;
  487. Otrack *o;
  488. fid = r->fid;
  489. omode = r->ifcall.mode;
  490. checktoc(drive);
  491. r->ofcall.qid = (Qid){fid->qid.path, drive->nchange, fid->qid.vers};
  492. switch((ulong)fid->qid.path){
  493. case Qdir:
  494. case Qwa:
  495. case Qwd:
  496. if(omode != OREAD) {
  497. respond(r, "permission denied");
  498. return;
  499. }
  500. break;
  501. case Qctl:
  502. if(omode & ~(OTRUNC|OREAD|OWRITE|ORDWR)) {
  503. respond(r, "permission denied");
  504. return;
  505. }
  506. break;
  507. default:
  508. if(fid->qid.path >= Qtrack+drive->ntrack) {
  509. respond(r, "file no longer exists");
  510. return;
  511. }
  512. /*
  513. * allow the open with OWRITE or ORDWR if the
  514. * drive and disc are both capable?
  515. */
  516. if(omode != OREAD ||
  517. (o = drive->openrd(drive, fid->qid.path-Qtrack)) == nil) {
  518. respond(r, "permission denied");
  519. return;
  520. }
  521. o->nref = 1;
  522. ((Aux*)fid->aux)->o = o;
  523. break;
  524. }
  525. respond(r, nil);
  526. }
  527. static void
  528. fsdestroyfid(Fid *fid)
  529. {
  530. Aux *aux;
  531. Otrack *o;
  532. aux = fid->aux;
  533. if(aux == nil)
  534. return;
  535. o = aux->o;
  536. if(o && --o->nref == 0) {
  537. bterm(o->buf);
  538. drive->close(o);
  539. checktoc(drive);
  540. }
  541. }
  542. static void
  543. checktoc(Drive *drive)
  544. {
  545. int i;
  546. Track *t;
  547. drive->gettoc(drive);
  548. if(drive->nameok)
  549. return;
  550. for(i=0; i<drive->ntrack; i++) {
  551. t = &drive->track[i];
  552. if(t->size == 0) /* being created */
  553. t->mode = 0;
  554. else
  555. t->mode = 0444;
  556. sprint(t->name, "?%.3d", i);
  557. switch(t->type){
  558. case TypeNone:
  559. t->name[0] = 'u';
  560. // t->mode = 0;
  561. break;
  562. case TypeData:
  563. t->name[0] = 'd';
  564. break;
  565. case TypeAudio:
  566. t->name[0] = 'a';
  567. break;
  568. case TypeBlank:
  569. t->name[0] = '\0';
  570. break;
  571. default:
  572. print("unknown track type %d\n", t->type);
  573. break;
  574. }
  575. }
  576. drive->nameok = 1;
  577. }
  578. long
  579. bufread(Otrack *t, void *v, long n, vlong off)
  580. {
  581. return bread(t->buf, v, n, off);
  582. }
  583. long
  584. bufwrite(Otrack *t, void *v, long n)
  585. {
  586. return bwrite(t->buf, v, n);
  587. }
  588. Srv fs = {
  589. .attach= fsattach,
  590. .destroyfid= fsdestroyfid,
  591. .clone= fsclone,
  592. .walk1= fswalk1,
  593. .open= fsopen,
  594. .read= fsread,
  595. .write= fswrite,
  596. .create= fscreate,
  597. .remove= fsremove,
  598. .stat= fsstat,
  599. };
  600. void
  601. usage(void)
  602. {
  603. fprint(2, "usage: cdfs [-Dv] [-d /dev/sdC0] [-m mtpt]\n");
  604. exits("usage");
  605. }
  606. void
  607. main(int argc, char **argv)
  608. {
  609. Scsi *s;
  610. int fd;
  611. char *dev, *mtpt;
  612. dev = "/dev/sdD0";
  613. mtpt = "/mnt/cd";
  614. ARGBEGIN{
  615. case 'D':
  616. chatty9p++;
  617. break;
  618. case 'd':
  619. dev = EARGF(usage());
  620. break;
  621. case 'm':
  622. mtpt = EARGF(usage());
  623. break;
  624. case 'v':
  625. if((fd = create("/tmp/cdfs.log", OWRITE, 0666)) >= 0) {
  626. dup(fd, 2);
  627. dup(fd, 1);
  628. if(fd != 1 && fd != 2)
  629. close(fd);
  630. vflag++;
  631. scsiverbose = 2; /* verbose but no Readtoc errs */
  632. }
  633. break;
  634. default:
  635. usage();
  636. }ARGEND
  637. if(dev == nil || mtpt == nil || argc > 0)
  638. usage();
  639. if((s = openscsi(dev)) == nil)
  640. sysfatal("openscsi '%s': %r", dev);
  641. if((drive = mmcprobe(s)) == nil)
  642. sysfatal("mmcprobe '%s': %r", dev);
  643. checktoc(drive);
  644. postmountsrv(&fs, nil, mtpt, MREPL|MCREATE);
  645. exits(nil);
  646. }