main.c 12 KB

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