dossubs.c 37 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <bio.h>
  4. #include <auth.h>
  5. #include <fcall.h>
  6. #include "iotrack.h"
  7. #include "dat.h"
  8. #include "fns.h"
  9. static uchar isdos[256];
  10. int
  11. isdosfs(uchar *buf)
  12. {
  13. /*
  14. * When dynamic disc managers move the disc partition,
  15. * they make it start with 0xE9.
  16. */
  17. if(buf[0] == 0xE9)
  18. return 1;
  19. /*
  20. * Check if the jump displacement (magic[1]) is too short for a FAT.
  21. *
  22. * check now omitted due to digital cameras that use a 0 jump.
  23. * the ecma-107 standard says this is okay and that interoperable fat
  24. * implementations shouldn't assume this:
  25. * http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-107.pdf,
  26. * page 11.
  27. */
  28. if(buf[0] == 0xEB && buf[2] == 0x90 /* && buf[1] >= 0x30 */)
  29. return 1;
  30. if(chatty)
  31. fprint(2, "bad sig %.2ux %.2ux %.2uxn", buf[0], buf[1], buf[2]);
  32. return 0;
  33. }
  34. int
  35. dosfs(Xfs *xf)
  36. {
  37. Iosect *p, *p1;
  38. Dosboot *b;
  39. Fatinfo *fi;
  40. Dosboot32 *b32;
  41. Dosbpb *bp;
  42. long fisec, extflags;
  43. int i;
  44. if(!isdos['a']){
  45. for(i = 'a'; i <= 'z'; i++)
  46. isdos[i] = 1;
  47. for(i = 'A'; i <= 'Z'; i++)
  48. isdos[i] = 1;
  49. for(i = '0'; i <= '9'; i++)
  50. isdos[i] = 1;
  51. isdos['$'] = 1;
  52. isdos['%'] = 1;
  53. isdos['''] = 1;
  54. isdos['-'] = 1;
  55. isdos['_'] = 1;
  56. isdos['@'] = 1;
  57. isdos['~'] = 1;
  58. isdos['`'] = 1;
  59. isdos['!'] = 1;
  60. isdos['('] = 1;
  61. isdos[')'] = 1;
  62. isdos['{'] = 1;
  63. isdos['}'] = 1;
  64. isdos['^'] = 1;
  65. isdos['#'] = 1;
  66. isdos['&'] = 1;
  67. }
  68. p = getsect(xf, 0);
  69. if(p == 0)
  70. return -1;
  71. b = (Dosboot*)p->iobuf;
  72. if(b->clustsize == 0 || isdosfs(p->iobuf) == 0){
  73. putsect(p);
  74. return -1;
  75. }
  76. bp = malloc(sizeof(Dosbpb));
  77. memset(bp, 0, sizeof(Dosbpb)); /* clear lock */
  78. xf->ptr = bp;
  79. xf->fmt = 1;
  80. bp->sectsize = GSHORT(b->sectsize);
  81. bp->clustsize = b->clustsize;
  82. bp->nresrv = GSHORT(b->nresrv);
  83. bp->nfats = b->nfats;
  84. bp->rootsize = GSHORT(b->rootsize);
  85. bp->volsize = GSHORT(b->volsize);
  86. if(bp->volsize == 0)
  87. bp->volsize = GLONG(b->bigvolsize);
  88. bp->mediadesc = b->mediadesc;
  89. bp->fatsize = GSHORT(b->fatsize);
  90. bp->fataddr = GSHORT(b->nresrv);
  91. bp->fatinfo = 0;
  92. if(bp->fatsize == 0){ /* is FAT32 */
  93. if(chatty)
  94. bootsecdump32(2, xf, (Dosboot32*)b);
  95. xf->isfat32 = 1;
  96. b32 = (Dosboot32*)b;
  97. bp->fatsize = GLONG(b32->fatsize32);
  98. if(bp->fatsize == 0){
  99. putsect(p);
  100. if(chatty)
  101. fprint(2, "fatsize 0\n");
  102. return -1;
  103. }
  104. bp->dataaddr = bp->fataddr + bp->nfats*bp->fatsize;
  105. bp->rootaddr = 0;
  106. bp->rootstart = GLONG(b32->rootstart);
  107. /*
  108. * disable fat mirroring?
  109. */
  110. extflags = GSHORT(b32->extflags);
  111. if(extflags & 0x0080){
  112. for(i = 0; i < 4; i++){
  113. if(extflags & (1 << i)){
  114. bp->fataddr += i * bp->fatsize;
  115. bp->nfats = 1;
  116. break;
  117. }
  118. }
  119. }
  120. /*
  121. * fat free list info
  122. */
  123. bp->freeptr = FATRESRV;
  124. fisec = GSHORT(b32->infospec);
  125. if(fisec != 0 && fisec < GSHORT(b32->nresrv)){
  126. p1 = getsect(xf, fisec);
  127. if(p1 != nil){
  128. fi = (Fatinfo*)p1->iobuf;
  129. if(GLONG(fi->sig1) == FATINFOSIG1 && GLONG(fi->sig) == FATINFOSIG){
  130. bp->fatinfo = fisec;
  131. bp->freeptr = GLONG(fi->nextfree);
  132. bp->freeclusters = GLONG(fi->freeclust);
  133. chat("fat info: %ld free clusters, next free %ld\n", bp->freeclusters, bp->freeptr);
  134. }
  135. putsect(p1);
  136. }
  137. }
  138. }else{
  139. if(chatty)
  140. bootdump(2, b);
  141. bp->rootaddr = bp->fataddr + bp->nfats*bp->fatsize;
  142. bp->rootstart = 0;
  143. i = bp->rootsize*DOSDIRSIZE + bp->sectsize-1;
  144. i /= bp->sectsize;
  145. bp->dataaddr = bp->rootaddr + i;
  146. bp->freeptr = FATRESRV;
  147. }
  148. bp->fatclusters = FATRESRV+(bp->volsize - bp->dataaddr)/bp->clustsize;
  149. if(xf->isfat32)
  150. bp->fatbits = 32;
  151. else if(bp->fatclusters < 4087)
  152. bp->fatbits = 12;
  153. else
  154. bp->fatbits = 16;
  155. chat("fatbits=%d (%d clusters)...", bp->fatbits, bp->fatclusters);
  156. for(i=0; i<b->nfats; i++)
  157. chat("fat %d: %ld...", i, bp->fataddr+i*bp->fatsize);
  158. chat("root: %ld...", bp->rootaddr);
  159. chat("data: %ld...", bp->dataaddr);
  160. putsect(p);
  161. return 0;
  162. }
  163. /*
  164. * initialize f to the root directory
  165. * this file has no Dosdir entry,
  166. * so we special case it all over.
  167. */
  168. void
  169. rootfile(Xfile *f)
  170. {
  171. Dosptr *dp;
  172. dp = f->ptr;
  173. memset(dp, 0, sizeof(Dosptr));
  174. dp->prevaddr = -1;
  175. }
  176. int
  177. isroot(ulong addr)
  178. {
  179. return addr == 0;
  180. }
  181. int
  182. getfile(Xfile *f)
  183. {
  184. Dosptr *dp;
  185. Iosect *p;
  186. dp = f->ptr;
  187. if(dp->p)
  188. panic("getfile");
  189. p = getsect(f->xf, dp->addr);
  190. if(p == nil)
  191. return -1;
  192. /*
  193. * we could also make up a Dosdir for the root
  194. */
  195. dp->d = nil;
  196. if(!isroot(dp->addr)){
  197. if(f->qid.path != QIDPATH(dp)){
  198. chat("qid mismatch f=%#llux d=%#lux...", f->qid.path, QIDPATH(dp));
  199. putsect(p);
  200. errno = Enonexist;
  201. return -1;
  202. }
  203. dp->d = (Dosdir *)&p->iobuf[dp->offset];
  204. }
  205. dp->p = p;
  206. return 0;
  207. }
  208. void
  209. putfile(Xfile *f)
  210. {
  211. Dosptr *dp;
  212. dp = f->ptr;
  213. if(!dp->p)
  214. panic("putfile");
  215. putsect(dp->p);
  216. dp->p = nil;
  217. dp->d = nil;
  218. }
  219. long
  220. getstart(Xfs *xf, Dosdir *d)
  221. {
  222. long start;
  223. start = GSHORT(d->start);
  224. if(xf->isfat32)
  225. start |= GSHORT(d->hstart)<<16;
  226. return start;
  227. }
  228. void
  229. putstart(Xfs *xf, Dosdir *d, long start)
  230. {
  231. PSHORT(d->start, start);
  232. if(xf->isfat32)
  233. PSHORT(d->hstart, start>>16);
  234. }
  235. /*
  236. * return the disk cluster for the iclust cluster in f
  237. */
  238. long
  239. fileclust(Xfile *f, long iclust, int cflag)
  240. {
  241. Dosbpb *bp;
  242. Dosptr *dp;
  243. Dosdir *d;
  244. long start, clust, nskip, next;
  245. bp = f->xf->ptr;
  246. dp = f->ptr;
  247. d = dp->d;
  248. next = 0;
  249. /*
  250. * asking for the cluster of the root directory
  251. * is not a well-formed question, since the root directory
  252. * does not begin on a cluster boundary.
  253. */
  254. if(!f->xf->isfat32 && isroot(dp->addr))
  255. return -1;
  256. if(f->xf->isfat32 && isroot(dp->addr)){
  257. start = bp->rootstart;
  258. }else{
  259. start = getstart(f->xf, d);
  260. if(start == 0){
  261. if(!cflag)
  262. return -1;
  263. mlock(bp);
  264. start = falloc(f->xf);
  265. unmlock(bp);
  266. if(start <= 0)
  267. return -1;
  268. puttime(d, 0);
  269. putstart(f->xf, d, start);
  270. dp->p->flags |= BMOD;
  271. dp->clust = 0;
  272. }
  273. }
  274. if(dp->clust == 0 || iclust < dp->iclust){
  275. clust = start;
  276. nskip = iclust;
  277. }else{
  278. clust = dp->clust;
  279. nskip = iclust - dp->iclust;
  280. }
  281. if(chatty > 1 && nskip > 0)
  282. chat("clust %#lx, skip %ld...", clust, nskip);
  283. if(clust <= 0)
  284. return -1;
  285. if(nskip > 0){
  286. mlock(bp);
  287. while(--nskip >= 0){
  288. next = getfat(f->xf, clust);
  289. if(chatty > 1)
  290. chat("->%#lx", next);
  291. if(next > 0){
  292. clust = next;
  293. continue;
  294. }else if(!cflag)
  295. break;
  296. if(d && (d->attr&DSYSTEM)){
  297. next = cfalloc(f);
  298. if(next < 0)
  299. break;
  300. /* cfalloc will call putfat for us, since clust may change */
  301. } else {
  302. next = falloc(f->xf);
  303. if(next < 0)
  304. break;
  305. putfat(f->xf, clust, next);
  306. }
  307. clust = next;
  308. }
  309. unmlock(bp);
  310. if(next <= 0)
  311. return -1;
  312. dp->clust = clust;
  313. dp->iclust = iclust;
  314. }
  315. if(chatty > 1)
  316. chat(" clust(%#lx)=%#lx...", iclust, clust);
  317. return clust;
  318. }
  319. /*
  320. * return the disk sector for the isect disk sector in f
  321. */
  322. long
  323. fileaddr(Xfile *f, long isect, int cflag)
  324. {
  325. Dosbpb *bp;
  326. Dosptr *dp;
  327. long clust;
  328. bp = f->xf->ptr;
  329. dp = f->ptr;
  330. if(!f->xf->isfat32 && isroot(dp->addr)){
  331. if(isect*bp->sectsize >= bp->rootsize*DOSDIRSIZE)
  332. return -1;
  333. return bp->rootaddr + isect;
  334. }
  335. clust = fileclust(f, isect/bp->clustsize, cflag);
  336. if(clust < 0)
  337. return -1;
  338. return clust2sect(bp, clust) + isect%bp->clustsize;
  339. }
  340. /*
  341. * translate names
  342. */
  343. void
  344. fixname(char *buf)
  345. {
  346. int c;
  347. char *p;
  348. p = buf;
  349. while(c = *p){
  350. if(c == ':' && trspaces)
  351. *p = ' ';
  352. p++;
  353. }
  354. }
  355. /*
  356. * classify the file name as one of
  357. * Invalid - contains a bad character
  358. * Short - short valid 8.3 name, no lowercase letters
  359. * ShortLower - short valid 8.3 name except for lowercase letters
  360. * Long - long name
  361. */
  362. int
  363. classifyname(char *buf)
  364. {
  365. char *p, *dot;
  366. int c, isextended, is8dot3, islower, ndot;
  367. p = buf;
  368. isextended = 0;
  369. islower = 0;
  370. dot = nil;
  371. ndot = 0;
  372. while(c = (uchar)*p){
  373. if(c&0x80) /* UTF8 */
  374. isextended = 1;
  375. else if(c == '.'){
  376. dot = p;
  377. ndot++;
  378. }else if(strchr("+,:;=[] ", c))
  379. isextended = 1;
  380. else if(!isdos[c])
  381. return Invalid;
  382. if('a' <= c && c <= 'z')
  383. islower = 1;
  384. p++;
  385. }
  386. is8dot3 = (ndot==0 && p-buf <= 8) || (ndot==1 && dot-buf <= 8 && p-(dot+1) <= 3);
  387. if(!isextended && is8dot3){
  388. if(islower)
  389. return ShortLower;
  390. return Short;
  391. }
  392. return Long;
  393. }
  394. /*
  395. * make an alias for a valid long file name
  396. */
  397. void
  398. mkalias(char *name, char *sname, int id)
  399. {
  400. Rune r;
  401. char *s, *e, sid[10];
  402. int i, esuf, v;
  403. e = strrchr(name, '.');
  404. if(e == nil)
  405. e = strchr(name, '\0');
  406. s = name;
  407. i = 0;
  408. while(s < e && i < 6){
  409. if(isdos[(uchar)*s])
  410. sname[i++] = *s++;
  411. else
  412. s += chartorune(&r, s);
  413. }
  414. v = snprint(sid, 10, "%d", id);
  415. if(i + 1 + v > 8)
  416. i = 8 - 1 - v;
  417. sname[i++] = '~';
  418. strcpy(&sname[i], sid);
  419. i += v;
  420. sname[i++] = '.';
  421. esuf = i + 3;
  422. if(esuf > 12)
  423. panic("bad mkalias");
  424. while(*e && i < esuf){
  425. if(isdos[(uchar)*e])
  426. sname[i++] = *e++;
  427. else
  428. e += chartorune(&r, e);
  429. }
  430. if(sname[i-1] == '.')
  431. i--;
  432. sname[i] = '\0';
  433. }
  434. /*
  435. * check for valid plan 9 names,
  436. * rewrite ' ' to ':'
  437. */
  438. char isfrog[256]={
  439. /*NUL*/ 1, 1, 1, 1, 1, 1, 1, 1,
  440. /*BKS*/ 1, 1, 1, 1, 1, 1, 1, 1,
  441. /*DLE*/ 1, 1, 1, 1, 1, 1, 1, 1,
  442. /*CAN*/ 1, 1, 1, 1, 1, 1, 1, 1,
  443. /* [' '] 1, let's try this -rsc */
  444. ['/'] 1,
  445. [0x7f] 1,
  446. };
  447. int
  448. nameok(char *elem)
  449. {
  450. while(*elem) {
  451. if(*elem == ' ' && trspaces)
  452. *elem = ':';
  453. if(isfrog[*(uchar*)elem])
  454. return 0;
  455. elem++;
  456. }
  457. return 1;
  458. }
  459. /*
  460. * look for a directory entry matching name
  461. * always searches for long names which match a short name
  462. */
  463. int
  464. searchdir(Xfile *f, char *name, Dosptr *dp, int cflag, int longtype)
  465. {
  466. Xfs *xf;
  467. Iosect *p;
  468. Dosbpb *bp;
  469. Dosdir *d;
  470. char buf[261], *bname;
  471. int isect, addr, o, addr1, addr2, prevaddr, prevaddr1, o1, islong, have, need, sum;
  472. xf = f->xf;
  473. bp = xf->ptr;
  474. addr1 = -1;
  475. addr2 = -1;
  476. prevaddr1 = -1;
  477. o1 = 0;
  478. islong = 0;
  479. sum = -1;
  480. need = 1;
  481. if(longtype!=Short && cflag)
  482. need += (utflen(name) + DOSRUNE-1) / DOSRUNE;
  483. memset(dp, 0, sizeof(Dosptr));
  484. dp->prevaddr = -1;
  485. dp->naddr = -1;
  486. dp->paddr = ((Dosptr *)f->ptr)->addr;
  487. dp->poffset = ((Dosptr *)f->ptr)->offset;
  488. have = 0;
  489. addr = -1;
  490. bname = nil;
  491. for(isect=0;; isect++){
  492. prevaddr = addr;
  493. addr = fileaddr(f, isect, cflag);
  494. if(addr < 0)
  495. break;
  496. p = getsect(xf, addr);
  497. if(p == 0)
  498. break;
  499. for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
  500. d = (Dosdir *)&p->iobuf[o];
  501. if(d->name[0] == 0x00){
  502. chat("end dir(0)...");
  503. putsect(p);
  504. if(!cflag)
  505. return -1;
  506. /*
  507. * addr1 & o1 are the start of the dirs
  508. * addr2 is the optional second cluster used if the long name
  509. * entry does not fit within the addr1 cluster
  510. *
  511. * have tells us the number of contiguous free dirs
  512. * starting at addr1.o1; need are necessary to hold the long name.
  513. */
  514. if(addr1 < 0){
  515. addr1 = addr;
  516. prevaddr1 = prevaddr;
  517. o1 = o;
  518. }
  519. if(addr2 < 0 && (bp->sectsize-o)/DOSDIRSIZE + have < need){
  520. addr2 = fileaddr(f, isect+1, cflag);
  521. if(addr2 < 0)
  522. goto breakout;
  523. }else if(addr2 < 0)
  524. addr2 = addr;
  525. if(addr2 == addr1)
  526. addr2 = -1;
  527. dp->addr = addr1;
  528. dp->offset = o1;
  529. dp->prevaddr = prevaddr1;
  530. dp->naddr = addr2;
  531. return 0;
  532. }
  533. if(d->name[0] == DOSEMPTY){
  534. if(chatty)
  535. fprint(2, "empty dir\n");
  536. have++;
  537. if(addr1 == -1){
  538. addr1 = addr;
  539. o1 = o;
  540. prevaddr1 = prevaddr;
  541. }
  542. if(addr2 == -1 && have >= need)
  543. addr2 = addr;
  544. continue;
  545. }
  546. have = 0;
  547. if(addr2 == -1)
  548. addr1 = -1;
  549. dirdump(d);
  550. if((d->attr & 0xf) == 0xf){
  551. bname = getnamesect(buf, bname, p->iobuf + o, &islong, &sum, 1);
  552. continue;
  553. }
  554. if(d->attr & DVLABEL){
  555. islong = 0;
  556. continue;
  557. }
  558. if(islong != 1 || sum != aliassum(d) || cistrcmp(bname, name) != 0){
  559. bname = buf;
  560. getname(buf, d);
  561. }
  562. islong = 0;
  563. if(cistrcmp(bname, name) != 0)
  564. continue;
  565. if(chatty)
  566. fprint(2, "found\n");
  567. if(cflag){
  568. putsect(p);
  569. return -1;
  570. }
  571. dp->addr = addr;
  572. dp->prevaddr = prevaddr;
  573. dp->offset = o;
  574. dp->p = p;
  575. dp->d = d;
  576. return 0;
  577. }
  578. putsect(p);
  579. }
  580. breakout:
  581. chat("end dir(1)...");
  582. return -1;
  583. }
  584. int
  585. emptydir(Xfile *f)
  586. {
  587. Xfs *xf = f->xf;
  588. Dosbpb *bp = xf->ptr;
  589. int isect, addr, o;
  590. Iosect *p;
  591. Dosdir *d;
  592. for(isect=0;; isect++){
  593. addr = fileaddr(f, isect, 0);
  594. if(addr < 0)
  595. break;
  596. p = getsect(xf, addr);
  597. if(p == 0)
  598. return -1;
  599. for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
  600. d = (Dosdir *)&p->iobuf[o];
  601. if(d->name[0] == 0x00){
  602. putsect(p);
  603. return 0;
  604. }
  605. if(d->name[0] == DOSEMPTY)
  606. continue;
  607. if(d->name[0] == '.')
  608. continue;
  609. if(d->attr&DVLABEL)
  610. continue;
  611. putsect(p);
  612. return -1;
  613. }
  614. putsect(p);
  615. }
  616. return 0;
  617. }
  618. long
  619. readdir(Xfile *f, void *vbuf, long offset, long count)
  620. {
  621. Xfs *xf;
  622. Dosbpb *bp;
  623. Dir dir;
  624. int isect, addr, o, islong, sum;
  625. Iosect *p;
  626. Dosdir *d;
  627. long rcnt, n;
  628. char *name, snamebuf[8+1+3+1], namebuf[DOSNAMELEN];
  629. uchar *buf;
  630. buf = vbuf;
  631. rcnt = 0;
  632. xf = f->xf;
  633. bp = xf->ptr;
  634. if(count <= 0)
  635. return 0;
  636. islong = 0;
  637. sum = -1;
  638. name = nil;
  639. for(isect=0;; isect++){
  640. addr = fileaddr(f, isect, 0);
  641. if(addr < 0)
  642. break;
  643. p = getsect(xf, addr);
  644. if(p == 0)
  645. return -1;
  646. for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
  647. d = (Dosdir *)&p->iobuf[o];
  648. if(d->name[0] == 0x00){
  649. putsect(p);
  650. return rcnt;
  651. }
  652. if(d->name[0] == DOSEMPTY)
  653. continue;
  654. dirdump(d);
  655. if(d->name[0] == '.'){
  656. if(d->name[1] == ' ' || d->name[1] == 0)
  657. continue;
  658. if(d->name[1] == '.' &&
  659. (d->name[2] == ' ' || d->name[2] == 0))
  660. continue;
  661. }
  662. if((d->attr & 0xf) == 0xf){
  663. name = getnamesect(namebuf, name, p->iobuf+o, &islong, &sum, 1);
  664. continue;
  665. }
  666. if(d->attr & DVLABEL){
  667. islong = 0;
  668. continue;
  669. }
  670. dir.name = snamebuf;
  671. getdir(xf, &dir, d, addr, o);
  672. if(islong == 1 && nameok(name) && sum == aliassum(d))
  673. dir.name = name;
  674. islong = 0;
  675. n = convD2M(&dir, &buf[rcnt], count - rcnt);
  676. name = nil;
  677. if(n <= BIT16SZ){ /* no room for next entry */
  678. putsect(p);
  679. return rcnt;
  680. }
  681. rcnt += n;
  682. if(offset > 0){
  683. offset -= rcnt;
  684. rcnt = 0;
  685. islong = 0;
  686. continue;
  687. }
  688. if(rcnt == count){
  689. putsect(p);
  690. return rcnt;
  691. }
  692. }
  693. putsect(p);
  694. }
  695. return rcnt;
  696. }
  697. /*
  698. * set up ndp for a directory's parent
  699. * the hardest part is setting up paddr
  700. */
  701. int
  702. walkup(Xfile *f, Dosptr *ndp)
  703. {
  704. Dosbpb *bp;
  705. Dosptr *dp;
  706. Dosdir *xd;
  707. Iosect *p;
  708. long k, o, so, start, pstart, ppstart, st, ppclust;
  709. bp = f->xf->ptr;
  710. dp = f->ptr;
  711. memset(ndp, 0, sizeof(Dosptr));
  712. ndp->prevaddr = -1;
  713. ndp->naddr = -1;
  714. ndp->addr = dp->paddr;
  715. ndp->offset = dp->poffset;
  716. chat("walkup: paddr=%#lx...", dp->paddr);
  717. /*
  718. * root's paddr is always itself
  719. */
  720. if(isroot(dp->paddr))
  721. return 0;
  722. /*
  723. * find the start of our parent's directory
  724. */
  725. p = getsect(f->xf, dp->paddr);
  726. if(p == nil)
  727. goto error;
  728. xd = (Dosdir *)&p->iobuf[dp->poffset];
  729. dirdump(xd);
  730. start = getstart(f->xf, xd);
  731. chat("start=%#lx...", start);
  732. if(start == 0)
  733. goto error;
  734. putsect(p);
  735. /*
  736. * verify that parent's . points to itself
  737. */
  738. p = getsect(f->xf, clust2sect(bp, start));
  739. if(p == nil)
  740. goto error;
  741. xd = (Dosdir *)p->iobuf;
  742. dirdump(xd);
  743. st = getstart(f->xf, xd);
  744. if(xd->name[0]!='.' || xd->name[1]!=' ' || start!=st)
  745. goto error;
  746. /*
  747. * parent's .. is the next entry, and has start of parent's parent
  748. */
  749. xd++;
  750. dirdump(xd);
  751. if(xd->name[0] != '.' || xd->name[1] != '.')
  752. goto error;
  753. pstart = getstart(f->xf, xd);
  754. putsect(p);
  755. /*
  756. * we're done if parent is root
  757. */
  758. if(pstart == 0 || f->xf->isfat32 && pstart == bp->rootstart)
  759. return 0;
  760. /*
  761. * verify that parent's . points to itself
  762. */
  763. p = getsect(f->xf, clust2sect(bp, pstart));
  764. if(p == 0){
  765. chat("getsect %ld failed\n", pstart);
  766. goto error;
  767. }
  768. xd = (Dosdir *)p->iobuf;
  769. dirdump(xd);
  770. st = getstart(f->xf, xd);
  771. if(xd->name[0]!='.' || xd->name[1]!=' ' || pstart!=st)
  772. goto error;
  773. /*
  774. * parent's parent's .. is the next entry, and has start of parent's parent's parent
  775. */
  776. xd++;
  777. dirdump(xd);
  778. if(xd->name[0] != '.' || xd->name[1] != '.')
  779. goto error;
  780. ppstart = getstart(f->xf, xd);
  781. putsect(p);
  782. /*
  783. * open parent's parent's parent, and walk through it until parent's parent is found
  784. * need this to find parent's parent's addr and offset
  785. */
  786. ppclust = ppstart;
  787. if(f->xf->isfat32 && ppclust == 0){
  788. ppclust = bp->rootstart;
  789. chat("ppclust 0, resetting to rootstart\n");
  790. }
  791. k = ppclust ? clust2sect(bp, ppclust) : bp->rootaddr;
  792. p = getsect(f->xf, k);
  793. if(p == nil){
  794. chat("getsect %ld failed\n", k);
  795. goto error;
  796. }
  797. xd = (Dosdir *)p->iobuf;
  798. dirdump(xd);
  799. if(ppstart){
  800. st = getstart(f->xf, xd);
  801. if(xd->name[0]!='.' || xd->name[1]!=' ' || ppstart!=st)
  802. goto error;
  803. }
  804. for(so=1;; so++){
  805. for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
  806. xd = (Dosdir *)&p->iobuf[o];
  807. if(xd->name[0] == 0x00){
  808. chat("end dir\n");
  809. goto error;
  810. }
  811. if(xd->name[0] == DOSEMPTY)
  812. continue;
  813. st = getstart(f->xf, xd);
  814. if(st == pstart)
  815. goto out;
  816. }
  817. if(ppclust){
  818. if(so%bp->clustsize == 0){
  819. mlock(bp);
  820. ppclust = getfat(f->xf, ppclust);
  821. unmlock(bp);
  822. if(ppclust < 0){
  823. chat("getfat %ld failed\n", ppclust);
  824. goto error;
  825. }
  826. }
  827. k = clust2sect(bp, ppclust) +
  828. so%bp->clustsize;
  829. }else{
  830. if(so*bp->sectsize >= bp->rootsize*DOSDIRSIZE)
  831. goto error;
  832. k = bp->rootaddr + so;
  833. }
  834. putsect(p);
  835. p = getsect(f->xf, k);
  836. if(p == 0){
  837. chat("getsect %ld failed\n", k);
  838. goto error;
  839. }
  840. }
  841. out:
  842. putsect(p);
  843. ndp->paddr = k;
  844. ndp->poffset = o;
  845. return 0;
  846. error:
  847. if(p)
  848. putsect(p);
  849. return -1;
  850. }
  851. long
  852. readfile(Xfile *f, void *vbuf, long offset, long count)
  853. {
  854. Xfs *xf = f->xf;
  855. Dosbpb *bp = xf->ptr;
  856. Dosptr *dp = f->ptr;
  857. Dosdir *d = dp->d;
  858. int isect, addr, o, c;
  859. Iosect *p;
  860. uchar *buf;
  861. long length, rcnt;
  862. rcnt = 0;
  863. length = GLONG(d->length);
  864. buf = vbuf;
  865. if(offset >= length)
  866. return 0;
  867. if(offset+count >= length)
  868. count = length - offset;
  869. isect = offset/bp->sectsize;
  870. o = offset%bp->sectsize;
  871. while(count > 0){
  872. addr = fileaddr(f, isect++, 0);
  873. if(addr < 0)
  874. break;
  875. c = bp->sectsize - o;
  876. if(c > count)
  877. c = count;
  878. p = getsect(xf, addr);
  879. if(p == 0)
  880. return -1;
  881. memmove(&buf[rcnt], &p->iobuf[o], c);
  882. putsect(p);
  883. count -= c;
  884. rcnt += c;
  885. o = 0;
  886. }
  887. return rcnt;
  888. }
  889. long
  890. writefile(Xfile *f, void *vbuf, long offset, long count)
  891. {
  892. Xfs *xf = f->xf;
  893. Dosbpb *bp = xf->ptr;
  894. Dosptr *dp = f->ptr;
  895. Dosdir *d = dp->d;
  896. int isect, addr = 0, o, c;
  897. Iosect *p;
  898. uchar *buf;
  899. long length, rcnt = 0, dlen;
  900. buf = vbuf;
  901. isect = offset/bp->sectsize;
  902. o = offset%bp->sectsize;
  903. while(count > 0){
  904. addr = fileaddr(f, isect++, 1);
  905. if(addr < 0)
  906. break;
  907. c = bp->sectsize - o;
  908. if(c > count)
  909. c = count;
  910. if(c == bp->sectsize){
  911. p = getosect(xf, addr);
  912. p->flags = 0;
  913. }else{
  914. p = getsect(xf, addr);
  915. if(p == nil)
  916. return -1;
  917. }
  918. memmove(&p->iobuf[o], &buf[rcnt], c);
  919. p->flags |= BMOD;
  920. putsect(p);
  921. count -= c;
  922. rcnt += c;
  923. o = 0;
  924. }
  925. if(rcnt <= 0 && addr < 0)
  926. return -1;
  927. length = 0;
  928. dlen = GLONG(d->length);
  929. if(rcnt > 0)
  930. length = offset+rcnt;
  931. else if(dp->addr && dp->clust){
  932. c = bp->clustsize*bp->sectsize;
  933. if(dp->iclust > (dlen+c-1)/c)
  934. length = c*dp->iclust;
  935. }
  936. if(length > dlen)
  937. PLONG(d->length, length);
  938. puttime(d, 0);
  939. dp->p->flags |= BMOD;
  940. return rcnt;
  941. }
  942. int
  943. truncfile(Xfile *f, long length)
  944. {
  945. Xfs *xf = f->xf;
  946. Dosbpb *bp = xf->ptr;
  947. Dosptr *dp = f->ptr;
  948. Dosdir *d = dp->d;
  949. long clust, next, n;
  950. mlock(bp);
  951. clust = getstart(f->xf, d);
  952. n = length;
  953. if(n <= 0)
  954. putstart(f->xf, d, 0);
  955. else
  956. n -= bp->sectsize;
  957. while(clust > 0){
  958. next = getfat(xf, clust);
  959. if(n <= 0)
  960. putfat(xf, clust, 0);
  961. else
  962. n -= bp->clustsize*bp->sectsize;
  963. clust = next;
  964. }
  965. unmlock(bp);
  966. PLONG(d->length, length);
  967. dp->iclust = 0;
  968. dp->clust = 0;
  969. dp->p->flags |= BMOD;
  970. return 0;
  971. }
  972. void
  973. putdir(Dosdir *d, Dir *dp)
  974. {
  975. if(dp->mode != ~0){
  976. if(dp->mode & 2)
  977. d->attr &= ~DRONLY;
  978. else
  979. d->attr |= DRONLY;
  980. if(dp->mode & DMEXCL)
  981. d->attr |= DSYSTEM;
  982. else
  983. d->attr &= ~DSYSTEM;
  984. }
  985. if(dp->mtime != ~0)
  986. puttime(d, dp->mtime);
  987. }
  988. /*
  989. * should extend this to deal with
  990. * creation and access dates
  991. */
  992. void
  993. getdir(Xfs *xfs, Dir *dp, Dosdir *d, int addr, int offset)
  994. {
  995. if(d == nil || addr == 0)
  996. panic("getdir on root");
  997. dp->type = 0;
  998. dp->dev = 0;
  999. getname(dp->name, d);
  1000. dp->qid.path = addr*(Sectorsize/DOSDIRSIZE) +
  1001. offset/DOSDIRSIZE;
  1002. dp->qid.vers = 0;
  1003. if(d->attr & DRONLY)
  1004. dp->mode = 0444;
  1005. else
  1006. dp->mode = 0666;
  1007. dp->atime = gtime(d);
  1008. dp->mtime = dp->atime;
  1009. dp->qid.type = QTFILE;
  1010. if(d->attr & DDIR){
  1011. dp->qid.type = QTDIR;
  1012. dp->mode |= DMDIR|0111;
  1013. dp->length = 0;
  1014. }else
  1015. dp->length = GLONG(d->length);
  1016. if(d->attr & DSYSTEM){
  1017. dp->mode |= DMEXCL;
  1018. if(iscontig(xfs, d))
  1019. dp->mode |= DMAPPEND;
  1020. }
  1021. dp->uid = "bill";
  1022. dp->muid = "bill";
  1023. dp->gid = "trog";
  1024. }
  1025. void
  1026. getname(char *p, Dosdir *d)
  1027. {
  1028. int c, i;
  1029. for(i=0; i<8; i++){
  1030. c = d->name[i];
  1031. if(c == '\0' || c == ' ')
  1032. break;
  1033. if(i == 0 && c == 0x05)
  1034. c = 0xe5;
  1035. *p++ = c;
  1036. }
  1037. for(i=0; i<3; i++){
  1038. c = d->ext[i];
  1039. if(c == '\0' || c == ' ')
  1040. break;
  1041. if(i == 0)
  1042. *p++ = '.';
  1043. *p++ = c;
  1044. }
  1045. *p = 0;
  1046. }
  1047. static char*
  1048. getnamerunes(char *dst, uchar *buf, int step)
  1049. {
  1050. int i;
  1051. Rune r;
  1052. char dbuf[DOSRUNE * UTFmax + 1], *d;
  1053. d = dbuf;
  1054. r = 1;
  1055. for(i = 1; r && i < 11; i += 2){
  1056. r = buf[i] | (buf[i+1] << 8);
  1057. d += runetochar(d, &r);
  1058. }
  1059. for(i = 14; r && i < 26; i += 2){
  1060. r = buf[i] | (buf[i+1] << 8);
  1061. d += runetochar(d, &r);
  1062. }
  1063. for(i = 28; r && i < 32; i += 2){
  1064. r = buf[i] | (buf[i+1] << 8);
  1065. d += runetochar(d, &r);
  1066. }
  1067. if(step == 1)
  1068. dst -= d - dbuf;
  1069. memmove(dst, dbuf, d - dbuf);
  1070. if(step == -1){
  1071. dst += d - dbuf;
  1072. *dst = '\0';
  1073. }
  1074. return dst;
  1075. }
  1076. char*
  1077. getnamesect(char *dbuf, char *d, uchar *buf, int *islong, int *sum, int step)
  1078. {
  1079. /*
  1080. * validation checks to make sure we're
  1081. * making up a consistent name
  1082. */
  1083. if(buf[11] != 0xf || buf[12] != 0){
  1084. *islong = 0;
  1085. return nil;
  1086. }
  1087. if(step == 1){
  1088. if((buf[0] & 0xc0) == 0x40){
  1089. *islong = buf[0] & 0x3f;
  1090. *sum = buf[13];
  1091. d = dbuf + DOSNAMELEN;
  1092. *--d = '\0';
  1093. }else if(*islong && *islong == buf[0] + 1 && *sum == buf[13]){
  1094. *islong = buf[0];
  1095. }else{
  1096. *islong = 0;
  1097. return nil;
  1098. }
  1099. }else{
  1100. if(*islong + 1 == (buf[0] & 0xbf) && *sum == buf[13]){
  1101. *islong = buf[0] & 0x3f;
  1102. if(buf[0] & 0x40)
  1103. *sum = -1;
  1104. }else{
  1105. *islong = 0;
  1106. *sum = -1;
  1107. return nil;
  1108. }
  1109. }
  1110. if(*islong > 20){
  1111. *islong = 0;
  1112. *sum = -1;
  1113. return nil;
  1114. }
  1115. return getnamerunes(d, buf, step);
  1116. }
  1117. void
  1118. putname(char *p, Dosdir *d)
  1119. {
  1120. int i;
  1121. memset(d->name, ' ', sizeof d->name+sizeof d->ext);
  1122. for(i=0; i<sizeof d->name; i++){
  1123. if(*p == 0 || *p == '.')
  1124. break;
  1125. d->name[i] = toupper(*p++);
  1126. }
  1127. p = strrchr(p, '.');
  1128. if(p){
  1129. for(i=0; i<sizeof d->ext; i++){
  1130. if(*++p == 0)
  1131. break;
  1132. d->ext[i] = toupper(*p);
  1133. }
  1134. }
  1135. }
  1136. static void
  1137. putnamesect(uchar *slot, Rune *longname, int curslot, int first, int sum)
  1138. {
  1139. Rune r;
  1140. Dosdir ds;
  1141. int i, j;
  1142. memset(&ds, 0xff, sizeof ds);
  1143. ds.attr = 0xf;
  1144. ds.reserved[0] = 0;
  1145. ds.reserved[1] = sum;
  1146. ds.start[0] = 0;
  1147. ds.start[1] = 0;
  1148. if(first)
  1149. ds.name[0] = 0x40 | curslot;
  1150. else
  1151. ds.name[0] = curslot;
  1152. memmove(slot, &ds, sizeof ds);
  1153. j = (curslot-1) * DOSRUNE;
  1154. for(i = 1; i < 11; i += 2){
  1155. r = longname[j++];
  1156. slot[i] = r;
  1157. slot[i+1] = r >> 8;
  1158. if(r == 0)
  1159. return;
  1160. }
  1161. for(i = 14; i < 26; i += 2){
  1162. r = longname[j++];
  1163. slot[i] = r;
  1164. slot[i+1] = r >> 8;
  1165. if(r == 0)
  1166. return;
  1167. }
  1168. for(i = 28; i < 32; i += 2){
  1169. r = longname[j++];
  1170. slot[i] = r;
  1171. slot[i+1] = r >> 8;
  1172. if(r == 0)
  1173. return;
  1174. }
  1175. }
  1176. int
  1177. aliassum(Dosdir *d)
  1178. {
  1179. int i, sum;
  1180. if(d == nil)
  1181. return -1;
  1182. sum = 0;
  1183. for(i = 0; i < 11; i++)
  1184. sum = (((sum&1)<<7) | ((sum&0xfe)>>1)) + d->name[i];
  1185. return sum & 0xff;
  1186. }
  1187. int
  1188. putlongname(Xfs *xf, Dosptr *ndp, char *name, char sname[13])
  1189. {
  1190. Dosbpb *bp;
  1191. Dosdir tmpd;
  1192. Rune longname[DOSNAMELEN+1];
  1193. int i, first, sum, nds, len;
  1194. /* calculate checksum */
  1195. putname(sname, &tmpd);
  1196. sum = aliassum(&tmpd);
  1197. bp = xf->ptr;
  1198. first = 1;
  1199. len = utftorunes(longname, name, DOSNAMELEN);
  1200. if(chatty){
  1201. chat("utftorunes %s =", name);
  1202. for(i=0; i<len; i++)
  1203. chat(" %.4X", longname[i]);
  1204. chat("\n");
  1205. }
  1206. for(nds = (len + DOSRUNE-1) / DOSRUNE; nds > 0; nds--){
  1207. putnamesect(&ndp->p->iobuf[ndp->offset], longname, nds, first, sum);
  1208. first = 0;
  1209. ndp->offset += 32;
  1210. if(ndp->offset == bp->sectsize){
  1211. chat("long name moving over sector boundary\n");
  1212. ndp->p->flags |= BMOD;
  1213. putsect(ndp->p);
  1214. ndp->p = nil;
  1215. /*
  1216. * switch to the next cluster for a long entry
  1217. * naddr should be set up correctly by searchdir
  1218. */
  1219. ndp->prevaddr = ndp->addr;
  1220. ndp->addr = ndp->naddr;
  1221. ndp->naddr = -1;
  1222. if(ndp->addr == -1)
  1223. return -1;
  1224. ndp->p = getsect(xf, ndp->addr);
  1225. if(ndp->p == nil)
  1226. return -1;
  1227. ndp->offset = 0;
  1228. ndp->d = (Dosdir *)&ndp->p->iobuf[ndp->offset];
  1229. }
  1230. }
  1231. return 0;
  1232. }
  1233. long
  1234. getfat(Xfs *xf, int n)
  1235. {
  1236. Dosbpb *bp = xf->ptr;
  1237. Iosect *p;
  1238. ulong k, sect;
  1239. int o, fb;
  1240. if(n < FATRESRV || n >= bp->fatclusters)
  1241. return -1;
  1242. fb = bp->fatbits;
  1243. k = (fb * n) >> 3;
  1244. if(k >= bp->fatsize*bp->sectsize)
  1245. panic("getfat");
  1246. sect = k/bp->sectsize + bp->fataddr;
  1247. o = k%bp->sectsize;
  1248. p = getsect(xf, sect);
  1249. if(p == nil)
  1250. return -1;
  1251. k = p->iobuf[o++];
  1252. if(o >= bp->sectsize){
  1253. putsect(p);
  1254. p = getsect(xf, sect+1);
  1255. if(p == nil)
  1256. return -1;
  1257. o = 0;
  1258. }
  1259. k |= p->iobuf[o++]<<8;
  1260. if(fb == 32){
  1261. /* fat32 is really fat28 */
  1262. k |= p->iobuf[o++] << 16;
  1263. k |= (p->iobuf[o] & 0x0f) << 24;
  1264. fb = 28;
  1265. }
  1266. putsect(p);
  1267. if(fb == 12){
  1268. if(n&1)
  1269. k >>= 4;
  1270. else
  1271. k &= 0xfff;
  1272. }
  1273. if(chatty > 1)
  1274. chat("fat(%#x)=%#lx...", n, k);
  1275. /*
  1276. * This is a very strange check for out of range.
  1277. * As a concrete example, for a 16-bit FAT,
  1278. * FFF8 through FFFF all signify ``end of cluster chain.''
  1279. * This generalizes to other-sized FATs.
  1280. */
  1281. if(k >= (1 << fb) - 8)
  1282. return -1;
  1283. return k;
  1284. }
  1285. void
  1286. putfat(Xfs *xf, int n, ulong val)
  1287. {
  1288. Fatinfo *fi;
  1289. Dosbpb *bp;
  1290. Iosect *p;
  1291. ulong k, sect, esect;
  1292. int o;
  1293. bp = xf->ptr;
  1294. if(n < FATRESRV || n >= bp->fatclusters)
  1295. panic("putfat n=%d", n);
  1296. k = (bp->fatbits * n) >> 3;
  1297. if(k >= bp->fatsize*bp->sectsize)
  1298. panic("putfat");
  1299. sect = k/bp->sectsize + bp->fataddr;
  1300. esect = sect + bp->nfats * bp->fatsize;
  1301. for(; sect<esect; sect+=bp->fatsize){
  1302. o = k%bp->sectsize;
  1303. p = getsect(xf, sect);
  1304. if(p == nil)
  1305. continue;
  1306. switch(bp->fatbits){
  1307. case 12:
  1308. if(n&1){
  1309. p->iobuf[o] &= 0x0f;
  1310. p->iobuf[o++] |= val<<4;
  1311. if(o >= bp->sectsize){
  1312. p->flags |= BMOD;
  1313. putsect(p);
  1314. p = getsect(xf, sect+1);
  1315. if(p == nil)
  1316. continue;
  1317. o = 0;
  1318. }
  1319. p->iobuf[o] = val>>4;
  1320. }else{
  1321. p->iobuf[o++] = val;
  1322. if(o >= bp->sectsize){
  1323. p->flags |= BMOD;
  1324. putsect(p);
  1325. p = getsect(xf, sect+1);
  1326. if(p == nil)
  1327. continue;
  1328. o = 0;
  1329. }
  1330. p->iobuf[o] &= 0xf0;
  1331. p->iobuf[o] |= (val>>8) & 0x0f;
  1332. }
  1333. break;
  1334. case 16:
  1335. p->iobuf[o++] = val;
  1336. p->iobuf[o] = val>>8;
  1337. break;
  1338. case 32: /* fat32 is really fat28 */
  1339. p->iobuf[o++] = val;
  1340. p->iobuf[o++] = val>>8;
  1341. p->iobuf[o++] = val>>16;
  1342. p->iobuf[o] = (p->iobuf[o] & 0xf0) | ((val>>24) & 0x0f);
  1343. break;
  1344. default:
  1345. panic("putfat fatbits");
  1346. }
  1347. p->flags |= BMOD;
  1348. putsect(p);
  1349. }
  1350. if(val == 0)
  1351. bp->freeclusters++;
  1352. else
  1353. bp->freeclusters--;
  1354. if(bp->fatinfo){
  1355. p = getsect(xf, bp->fatinfo);
  1356. if(p != nil){
  1357. fi = (Fatinfo*)p->iobuf;
  1358. PLONG(fi->nextfree, bp->freeptr);
  1359. PLONG(fi->freeclust, bp->freeclusters);
  1360. p->flags |= BMOD;
  1361. putsect(p);
  1362. }
  1363. }
  1364. }
  1365. /*
  1366. * Contiguous falloc; if we can, use lastclust+1.
  1367. * Otherwise, move the file to get some space.
  1368. * If there just isn't enough contiguous space
  1369. * anywhere on disk, fail.
  1370. */
  1371. int
  1372. cfalloc(Xfile *f)
  1373. {
  1374. int l;
  1375. if((l=makecontig(f, 8)) >= 0)
  1376. return l;
  1377. return makecontig(f, 1);
  1378. }
  1379. /*
  1380. * Check whether a file is contiguous.
  1381. */
  1382. int
  1383. iscontig(Xfs *xf, Dosdir *d)
  1384. {
  1385. long clust, next;
  1386. clust = getstart(xf, d);
  1387. if(clust <= 0)
  1388. return 1;
  1389. for(;;) {
  1390. next = getfat(xf, clust);
  1391. if(next < 0)
  1392. return 1;
  1393. if(next != clust+1)
  1394. return 0;
  1395. clust = next;
  1396. }
  1397. }
  1398. /*
  1399. * Make a file contiguous, with nextra clusters of
  1400. * free space after it for later expansion.
  1401. * Return the number of the first new cluster.
  1402. */
  1403. int
  1404. makecontig(Xfile *f, int nextra)
  1405. {
  1406. Dosbpb *bp;
  1407. Dosdir *d;
  1408. Dosptr *dp;
  1409. Xfs *xf;
  1410. Iosect *wp, *rp;
  1411. long clust, next, last, start, rclust, wclust, eclust, ostart;
  1412. int isok, i, n, nclust, nrun, rs, ws;
  1413. xf = f->xf;
  1414. bp = xf->ptr;
  1415. dp = f->ptr;
  1416. d = dp->d;
  1417. isok = 1;
  1418. nclust = 0;
  1419. clust = fileclust(f, 0, 0);
  1420. chat("clust %#lux", clust);
  1421. if(clust != -1) {
  1422. for(;;) {
  1423. nclust++;
  1424. chat(".");
  1425. next = getfat(xf, clust);
  1426. if(next <= 0)
  1427. break;
  1428. if(next != clust+1)
  1429. isok = 0;
  1430. clust = next;
  1431. }
  1432. }
  1433. chat("nclust %d\n", nclust);
  1434. if(isok && clust != -1) {
  1435. eclust = clust+1; /* eclust = first cluster past file */
  1436. assert(eclust == fileclust(f, 0, 0)+nclust);
  1437. for(i=0; i<nextra; i++)
  1438. if(getfat(xf, eclust+i) != 0)
  1439. break;
  1440. if(i == nextra) { /* they were all free */
  1441. chat("eclust=%#lx, getfat eclust-1 = %#lux\n", eclust, getfat(xf, eclust-1));
  1442. assert(getfat(xf, eclust-1) == 0xffffffff);
  1443. putfat(xf, eclust-1, eclust);
  1444. putfat(xf, eclust, 0xffffffff);
  1445. bp->freeptr = clust+1; /* to help keep the blocks free */
  1446. return eclust;
  1447. }
  1448. }
  1449. /* need to search for nclust+nextra contiguous free blocks */
  1450. last = -1;
  1451. n = bp->freeptr;
  1452. nrun = 0;
  1453. for(;;){
  1454. if(getfat(xf, n) == 0) {
  1455. if(last+1 == n)
  1456. nrun++;
  1457. else
  1458. nrun = 1;
  1459. if(nrun >= nclust+nextra)
  1460. break;
  1461. last = n;
  1462. }
  1463. if(++n >= bp->fatclusters)
  1464. n = FATRESRV;
  1465. if(n == bp->freeptr) {
  1466. errno = Econtig;
  1467. return -1;
  1468. }
  1469. }
  1470. bp->freeptr = n+1;
  1471. /* copy old data over */
  1472. start = n+1 - nrun;
  1473. /* sanity check */
  1474. for(i=0; i<nclust+nextra; i++)
  1475. assert(getfat(xf, start+i) == 0);
  1476. chat("relocate chain %lux -> 0x%lux len %d\n", fileclust(f, 0, 0), start, nclust);
  1477. wclust = start;
  1478. for(rclust = fileclust(f, 0, 0); rclust > 0; rclust = next){
  1479. rs = clust2sect(bp, rclust);
  1480. ws = clust2sect(bp, wclust);
  1481. for(i=0; i<bp->clustsize; i++, rs++, ws++){
  1482. rp = getsect(xf, rs);
  1483. if(rp == nil)
  1484. return -1;
  1485. wp = getosect(xf, ws);
  1486. assert(wp != nil);
  1487. memmove(wp->iobuf, rp->iobuf, bp->sectsize);
  1488. wp->flags = BMOD;
  1489. putsect(rp);
  1490. putsect(wp);
  1491. }
  1492. chat("move cluster %#lx -> %#lx...", rclust, wclust);
  1493. next = getfat(xf, rclust);
  1494. putfat(xf, wclust, wclust+1);
  1495. wclust++;
  1496. }
  1497. /* now wclust points at the first new cluster; chain it in */
  1498. chat("wclust 0x%lux start 0x%lux (fat->0x%lux) nclust %d\n", wclust, start, getfat(xf, start), nclust);
  1499. assert(wclust == start+nclust);
  1500. putfat(xf, wclust, 0xffffffff); /* end of file */
  1501. /* update directory entry to point at new start */
  1502. ostart = fileclust(f, 0, 0);
  1503. putstart(xf, d, start);
  1504. /* check our work */
  1505. i = 0;
  1506. clust = fileclust(f, 0, 0);
  1507. if(clust != -1) {
  1508. for(;;) {
  1509. i++;
  1510. next = getfat(xf, clust);
  1511. if(next <= 0)
  1512. break;
  1513. assert(next == clust+1);
  1514. clust = next;
  1515. }
  1516. }
  1517. chat("chain check: len %d\n", i);
  1518. assert(i == nclust+1);
  1519. /* succeeded; remove old chain. */
  1520. for(rclust = ostart; rclust > 0; rclust = next){
  1521. next = getfat(xf, rclust);
  1522. putfat(xf, rclust, 0); /* free cluster */
  1523. }
  1524. return start+nclust;
  1525. }
  1526. int
  1527. falloc(Xfs *xf)
  1528. {
  1529. Dosbpb *bp = xf->ptr;
  1530. Iosect *p;
  1531. int n, i, k;
  1532. n = bp->freeptr;
  1533. for(;;){
  1534. if(getfat(xf, n) == 0)
  1535. break;
  1536. if(++n >= bp->fatclusters)
  1537. n = FATRESRV;
  1538. if(n == bp->freeptr)
  1539. return -1;
  1540. }
  1541. bp->freeptr = n+1;
  1542. if(bp->freeptr >= bp->fatclusters)
  1543. bp->freeptr = FATRESRV;
  1544. putfat(xf, n, 0xffffffff);
  1545. k = clust2sect(bp, n);
  1546. for(i=0; i<bp->clustsize; i++){
  1547. p = getosect(xf, k+i);
  1548. memset(p->iobuf, 0, bp->sectsize);
  1549. p->flags = BMOD;
  1550. putsect(p);
  1551. }
  1552. return n;
  1553. }
  1554. void
  1555. ffree(Xfs *xf, long start)
  1556. {
  1557. putfat(xf, start, 0);
  1558. }
  1559. long
  1560. clust2sect(Dosbpb *bp, long clust)
  1561. {
  1562. return bp->dataaddr + (clust - FATRESRV) * bp->clustsize;
  1563. }
  1564. long
  1565. sect2clust(Dosbpb *bp, long sect)
  1566. {
  1567. long c;
  1568. c = (sect - bp->dataaddr) / bp->clustsize + FATRESRV;
  1569. assert(sect == clust2sect(bp, c));
  1570. return c;
  1571. }
  1572. void
  1573. puttime(Dosdir *d, long s)
  1574. {
  1575. Tm *t;
  1576. ushort x;
  1577. if(s == 0)
  1578. s = time(0);
  1579. t = localtime(s);
  1580. x = (t->hour<<11) | (t->min<<5) | (t->sec>>1);
  1581. PSHORT(d->time, x);
  1582. x = ((t->year-80)<<9) | ((t->mon+1)<<5) | t->mday;
  1583. PSHORT(d->date, x);
  1584. }
  1585. long
  1586. gtime(Dosdir *dp)
  1587. {
  1588. Tm tm;
  1589. int i;
  1590. i = GSHORT(dp->time);
  1591. tm.hour = i >> 11;
  1592. tm.min = (i >> 5) & 63;
  1593. tm.sec = (i & 31) << 1;
  1594. i = GSHORT(dp->date);
  1595. tm.year = 80 + (i >> 9);
  1596. tm.mon = ((i >> 5) & 15) - 1;
  1597. tm.mday = i & 31;
  1598. tm.zone[0] = '\0';
  1599. tm.tzoff = 0;
  1600. tm.yday = 0;
  1601. return tm2sec(&tm);
  1602. }
  1603. /*
  1604. * structure dumps for debugging
  1605. */
  1606. void
  1607. bootdump(int fd, Dosboot *b)
  1608. {
  1609. Biobuf bp;
  1610. Binit(&bp, fd, OWRITE);
  1611. Bprint(&bp, "magic: 0x%2.2x 0x%2.2x 0x%2.2x\n",
  1612. b->magic[0], b->magic[1], b->magic[2]);
  1613. Bprint(&bp, "version: \"%8.8s\"\n", (char*)b->version);
  1614. Bprint(&bp, "sectsize: %d\n", GSHORT(b->sectsize));
  1615. Bprint(&bp, "clustsize: %d\n", b->clustsize);
  1616. Bprint(&bp, "nresrv: %d\n", GSHORT(b->nresrv));
  1617. Bprint(&bp, "nfats: %d\n", b->nfats);
  1618. Bprint(&bp, "rootsize: %d\n", GSHORT(b->rootsize));
  1619. Bprint(&bp, "volsize: %d\n", GSHORT(b->volsize));
  1620. Bprint(&bp, "mediadesc: 0x%2.2x\n", b->mediadesc);
  1621. Bprint(&bp, "fatsize: %d\n", GSHORT(b->fatsize));
  1622. Bprint(&bp, "trksize: %d\n", GSHORT(b->trksize));
  1623. Bprint(&bp, "nheads: %d\n", GSHORT(b->nheads));
  1624. Bprint(&bp, "nhidden: %ld\n", GLONG(b->nhidden));
  1625. Bprint(&bp, "bigvolsize: %ld\n", GLONG(b->bigvolsize));
  1626. Bprint(&bp, "driveno: %d\n", b->driveno);
  1627. Bprint(&bp, "reserved0: 0x%2.2x\n", b->reserved0);
  1628. Bprint(&bp, "bootsig: 0x%2.2x\n", b->bootsig);
  1629. Bprint(&bp, "volid: 0x%8.8lux\n", GLONG(b->volid));
  1630. Bprint(&bp, "label: \"%11.11s\"\n", (char*)b->label);
  1631. Bterm(&bp);
  1632. }
  1633. void
  1634. bootdump32(int fd, Dosboot32 *b)
  1635. {
  1636. Biobuf bp;
  1637. Binit(&bp, fd, OWRITE);
  1638. Bprint(&bp, "magic: 0x%2.2x 0x%2.2x 0x%2.2x\n",
  1639. b->magic[0], b->magic[1], b->magic[2]);
  1640. Bprint(&bp, "version: \"%8.8s\"\n", (char*)b->version);
  1641. Bprint(&bp, "sectsize: %d\n", GSHORT(b->sectsize));
  1642. Bprint(&bp, "clustsize: %d\n", b->clustsize);
  1643. Bprint(&bp, "nresrv: %d\n", GSHORT(b->nresrv));
  1644. Bprint(&bp, "nfats: %d\n", b->nfats);
  1645. Bprint(&bp, "rootsize: %d\n", GSHORT(b->rootsize));
  1646. Bprint(&bp, "volsize: %d\n", GSHORT(b->volsize));
  1647. Bprint(&bp, "mediadesc: 0x%2.2x\n", b->mediadesc);
  1648. Bprint(&bp, "fatsize: %d\n", GSHORT(b->fatsize));
  1649. Bprint(&bp, "trksize: %d\n", GSHORT(b->trksize));
  1650. Bprint(&bp, "nheads: %d\n", GSHORT(b->nheads));
  1651. Bprint(&bp, "nhidden: %ld\n", GLONG(b->nhidden));
  1652. Bprint(&bp, "bigvolsize: %ld\n", GLONG(b->bigvolsize));
  1653. Bprint(&bp, "fatsize32: %ld\n", GLONG(b->fatsize32));
  1654. Bprint(&bp, "extflags: %d\n", GSHORT(b->extflags));
  1655. Bprint(&bp, "version: %d\n", GSHORT(b->version1));
  1656. Bprint(&bp, "rootstart: %ld\n", GLONG(b->rootstart));
  1657. Bprint(&bp, "infospec: %d\n", GSHORT(b->infospec));
  1658. Bprint(&bp, "backupboot: %d\n", GSHORT(b->backupboot));
  1659. Bprint(&bp, "reserved: %d %d %d %d %d %d %d %d %d %d %d %d\n",
  1660. b->reserved[0], b->reserved[1], b->reserved[2], b->reserved[3],
  1661. b->reserved[4], b->reserved[5], b->reserved[6], b->reserved[7],
  1662. b->reserved[8], b->reserved[9], b->reserved[10], b->reserved[11]);
  1663. Bterm(&bp);
  1664. }
  1665. void
  1666. bootsecdump32(int fd, Xfs *xf, Dosboot32 *b32)
  1667. {
  1668. Fatinfo *fi;
  1669. Iosect *p1;
  1670. int fisec, bsec, res;
  1671. fprint(fd, "\nfat32\n");
  1672. bootdump32(fd, b32);
  1673. res = GSHORT(b32->nresrv);
  1674. bsec = GSHORT(b32->backupboot);
  1675. if(bsec < res && bsec != 0){
  1676. p1 = getsect(xf, bsec);
  1677. if(p1 == nil)
  1678. fprint(fd, "\ncouldn't get backup boot sector: %r\n");
  1679. else{
  1680. fprint(fd, "\nbackup boot\n");
  1681. bootdump32(fd, (Dosboot32*)p1->iobuf);
  1682. putsect(p1);
  1683. }
  1684. }else if(bsec != 0xffff)
  1685. fprint(fd, "bad backup boot sector: %d reserved %d\n", bsec, res);
  1686. fisec = GSHORT(b32->infospec);
  1687. if(fisec < res && fisec != 0){
  1688. p1 = getsect(xf, fisec);
  1689. if(p1 == nil)
  1690. fprint(fd, "\ncouldn't get fat info sector: %r\n");
  1691. else{
  1692. fprint(fd, "\nfat info %d\n", fisec);
  1693. fi = (Fatinfo*)p1->iobuf;
  1694. fprint(fd, "sig1: 0x%lux sb 0x%lux\n", GLONG(fi->sig1), FATINFOSIG1);
  1695. fprint(fd, "sig: 0x%lux sb 0x%lux\n", GLONG(fi->sig), FATINFOSIG);
  1696. fprint(fd, "freeclust: %lud\n", GLONG(fi->freeclust));
  1697. fprint(fd, "nextfree: %lud\n", GLONG(fi->nextfree));
  1698. fprint(fd, "reserved: %lud %lud %lud\n", GLONG(fi->resrv), GLONG(fi->resrv+4), GLONG(fi->resrv+8));
  1699. putsect(p1);
  1700. }
  1701. }else if(fisec != 0xffff)
  1702. fprint(2, "bad fat info sector: %d reserved %d\n", bsec, res);
  1703. }
  1704. void
  1705. dirdump(void *vdbuf)
  1706. {
  1707. static char attrchar[] = "rhsvda67";
  1708. Dosdir *d;
  1709. char *name, namebuf[DOSNAMELEN];
  1710. char buf[128], *s, *ebuf;
  1711. uchar *dbuf;
  1712. int i;
  1713. if(!chatty)
  1714. return;
  1715. d = vdbuf;
  1716. ebuf = buf + sizeof(buf);
  1717. if(d->attr == 0xf){
  1718. dbuf = vdbuf;
  1719. name = namebuf + DOSNAMELEN;
  1720. *--name = '\0';
  1721. name = getnamerunes(name, dbuf, 1);
  1722. seprint(buf, ebuf, "\"%s\" %2.2x %2.2ux %2.2ux %d", name, dbuf[0], dbuf[12], dbuf[13], GSHORT(d->start));
  1723. }else{
  1724. s = seprint(buf, ebuf, "\"%.8s.%.3s\" ", (char*)d->name, (char*)d->ext);
  1725. for(i=7; i>=0; i--)
  1726. *s++ = d->attr&(1<<i) ? attrchar[i] : '-';
  1727. i = GSHORT(d->time);
  1728. s = seprint(s, ebuf, " %2.2d:%2.2d:%2.2d", i>>11, (i>>5)&63, (i&31)<<1);
  1729. i = GSHORT(d->date);
  1730. s = seprint(s, ebuf, " %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
  1731. i = GSHORT(d->ctime);
  1732. s = seprint(s, ebuf, " %2.2d:%2.2d:%2.2d", i>>11, (i>>5)&63, (i&31)<<1);
  1733. i = GSHORT(d->cdate);
  1734. s = seprint(s, ebuf, " %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
  1735. i = GSHORT(d->adate);
  1736. s = seprint(s, ebuf, " %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
  1737. seprint(s, ebuf, " %d %d", GSHORT(d->start), GSHORT(d->length));
  1738. }
  1739. chat("%s\n", buf);
  1740. }
  1741. int
  1742. cistrcmp(char *s1, char *s2)
  1743. {
  1744. int c1, c2;
  1745. while(*s1){
  1746. c1 = *s1++;
  1747. c2 = *s2++;
  1748. if(c1 >= 'A' && c1 <= 'Z')
  1749. c1 -= 'A' - 'a';
  1750. if(c2 >= 'A' && c2 <= 'Z')
  1751. c2 -= 'A' - 'a';
  1752. if(c1 != c2)
  1753. return c1 - c2;
  1754. }
  1755. return -*s2;
  1756. }
  1757. int
  1758. utftorunes(Rune *rr, char *s, int n)
  1759. {
  1760. Rune *r, *re;
  1761. int c;
  1762. r = rr;
  1763. re = r + n - 1;
  1764. while(c = (uchar)*s){
  1765. if(c < Runeself){
  1766. *r = c;
  1767. s++;
  1768. }else
  1769. s += chartorune(r, s);
  1770. r++;
  1771. if(r >= re)
  1772. break;
  1773. }
  1774. *r = 0;
  1775. return r - rr;
  1776. }