开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
FATFS.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：53k
源码类别：

操作系统开发

开发平台：

DOS

FATFS.C：源码内容
  1. /****************************************************************/
  2. /*                                                              */
  3. /*                          fatfs.c                             */
  4. /*                           DOS-C                              */
  5. /*                                                              */
  6. /*                 FAT File System I/O Functions                */
  7. /*                                                              */
  8. /*                      Copyright (c) 1995                      */
  9. /*                      Pasquale J. Villani                     */
  10. /*                      All Rights Reserved                     */
  11. /*                                                              */
  12. /* This file is part of DOS-C.                                  */
  13. /*                                                              */
  14. /* DOS-C is free software; you can redistribute it and/or       */
  15. /* modify it under the terms of the GNU General Public License  */
  16. /* as published by the Free Software Foundation; either version */
  17. /* 2, or (at your option) any later version.                    */
  18. /*                                                              */
  19. /* DOS-C is distributed in the hope that it will be useful, but */
  20. /* WITHOUT ANY WARRANTY; without even the implied warranty of   */
  21. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
  22. /* the GNU General Public License for more details.             */
  23. /*                                                              */
  24. /* You should have received a copy of the GNU General Public    */
  25. /* License along with DOS-C; see the file COPYING.  If not,     */
  26. /* write to the Free Software Foundation, 675 Mass Ave,         */
  27. /* Cambridge, MA 02139, USA.                                    */
  28. /****************************************************************/
  30. #include "../../hdr/portab.h"
  31. #include "globals.h"
  34. #ifdef VERSION_STRINGS
  35. BYTE *RcsId = "$Header:   C:/dos-c/src/fs/fatfs.c_v   1.12   03 Feb 1998 11:28:04   patv  $";
  36. #endif
  38. /* $Log:   C:/dos-c/src/fs/fatfs.c_v  $
  39.  * 
  40.  *    Rev 1.12   03 Feb 1998 11:28:04   patv
  41.  * Fixed lseek bug.
  42.  * 
  43.  *    Rev 1.11   22 Jan 1998  5:38:08   patv
  44.  * Corrected remaining file name and extension copies that did not
  45.  * account for far file nodes due to allocated FILES= spec.
  46.  * 
  47.  *    Rev 1.10   22 Jan 1998  4:09:00   patv
  48.  * Fixed pointer problems affecting SDA
  49.  * 
  50.  *    Rev 1.9   04 Jan 1998 23:14:40   patv
  51.  * Changed Log for strip utility
  52.  * 
  53.  *    Rev 1.8   04 Jan 1998 17:24:14   patv
  54.  * Corrected subdirectory bug
  55.  * 
  56.  *    Rev 1.7   03 Jan 1998  8:36:04   patv
  57.  * Converted data area to SDA format
  58.  * 
  59.  *    Rev 1.6   22 Jan 1997 13:00:30   patv
  60.  * pre-0.92 bug fixes
  61.  * 
  62.  *    Rev 1.5   16 Jan 1997 12:46:24   patv
  63.  * pre-Release 0.92 feature additions
  64.  * 
  65.  *    Rev 1.4   29 May 1996 21:15:16   patv
  66.  * bug fixes for v0.91a
  67.  * 
  68.  *    Rev 1.3   19 Feb 1996  3:20:10   patv
  69.  * Added NLS, int2f and config.sys processing
  70.  * 
  71.  *    Rev 1.2   01 Sep 1995 17:48:40   patv
  72.  * First GPL release.
  73.  * 
  74.  *    Rev 1.1   30 Jul 1995 20:50:24   patv
  75.  * Eliminated version strings in ipl
  76.  * 
  77.  *    Rev 1.0   02 Jul 1995  8:04:46   patv
  78.  * Initial revision.
  79.  */
  80. /* $EndLog$ */
  83. /*                                                                      */
  84. /*      function prototypes                                             */
  85. /*                                                                      */
  86. struct f_node FAR *xlt_fd(COUNT);
  87. COUNT xlt_fnp(struct f_node FAR *);
  88. struct f_node FAR *split_path(BYTE FAR *, BYTE *, BYTE *, BYTE *);
  89. BOOL find_fname(struct f_node FAR *, BYTE *, BYTE *);
  90. date dos_getdate(VOID);
  91. time dos_gettime(VOID);
  92. BOOL find_free(struct f_node FAR *);
  93. UWORD find_fat_free(struct f_node FAR *);
  94. VOID wipe_out(struct f_node FAR *);
  95. BOOL last_link(struct f_node FAR *);
  96. BOOL extend(struct f_node FAR *);
  97. COUNT extend_dir(struct f_node FAR *);
  98. BOOL first_fat(struct f_node FAR *);
  99. COUNT map_cluster(struct f_node FAR *, COUNT);
  102. /************************************************************************/
  103. /*                                                                      */
  104. /*      Internal file handlers - open, create, read, write, close, etc. */
  105. /*                                                                      */
  106. /************************************************************************/
  108. /* Open a file given the path. Flags is 0 for read, 1 for write and 2   */
  109. /* for update.                                                          */
  110. /* Returns an integer file desriptor or a negative error code           */
  112. COUNT 
  113. dos_open (BYTE FAR *path, COUNT flag)
  114. {
  115. REG struct f_node FAR *fnp;
  116. COUNT i;
  117. BYTE FAR *fnamep;
  119. /* First test the flag to see if the user has passed a valid    */
  120. /* file mode...                                                 */
  121. if(flag < 0 || flag > 2)
  122. return DE_INVLDACC;
  124. /* first split the passed dir into comopnents (i.e. - path to   */
  125. /* new directory and name of new directory.                     */
  126. if((fnp = split_path(path, szDirName, szFileName, szFileExt)) == NULL)
  127. {
  128. dir_close(fnp);
  129. return DE_PATHNOTFND;
  130. }
  132. /* Look for the file. If we can't find it, just return a not    */
  133. /* found error.                                                 */
  134. if(!find_fname(fnp, szFileName, szFileExt))
  135. {
  136. dir_close(fnp);
  137. return DE_FILENOTFND;
  138. }
  140. /* Set the fnode to the desired mode                            */
  141. fnp -> f_mode = flag;
  143. /* Initialize the rest of the fnode.                            */
  144. fnp -> f_offset = 0l;
  145. fnp -> f_highwater = fnp -> f_dir.dir_size;
  147. fnp -> f_back = LONG_LAST_CLUSTER;
  148. fnp -> f_cluster = fnp -> f_dir.dir_start;
  150. fnp -> f_flags.f_dmod = FALSE;
  151. fnp -> f_flags.f_dnew = FALSE;
  152. fnp -> f_flags.f_ddir = FALSE;
  154. return xlt_fnp(fnp);
  155. }
  158. #ifndef IPL
  159. BOOL fcmp(s1, s2, n)
  160. BYTE FAR *s1, FAR *s2;
  161. COUNT n;
  162. {
  163. while(n--)
  164. if(*s1++ != *s2++)
  165. return FALSE;
  166. return TRUE;
  167. }
  170. BOOL fcmp_wild(s1, s2, n)
  171. BYTE FAR *s1, FAR *s2;
  172. COUNT n;
  173. {
  174. while(n--)
  175. {
  176. if(*s1 == '?')
  177. {
  178. ++s1, ++s2;
  179. continue;
  180. }
  181. if(*s1++ != *s2++)
  182. return FALSE;
  183. }
  184. return TRUE;
  185. }
  186. #endif
  189. COUNT 
  190. dos_close (COUNT fd)
  191. {
  192. struct f_node FAR *fnp;
  194. /* Translate the fd into a useful pointer                       */
  195. fnp = xlt_fd(fd);
  197. /* If the fd was invalid because it was out of range or the     */
  198. /* requested file was not open, tell the caller and exit        */
  199. /* note: an invalid fd is indicated by a 0 return               */
  200. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  201. return DE_INVLDHNDL;
  202. if(fnp -> f_mode != RDONLY)
  203. {
  204. fnp -> f_dir.dir_size = fnp -> f_highwater;
  205. fnp -> f_flags.f_dmod = TRUE;
  206. }
  207. fnp -> f_flags.f_ddir = TRUE;
  209. dir_close(fnp);
  210. return SUCCESS;
  211. }
  214. /*                                                                      */
  215. /* split a path into it's component directory and file name             */
  216. /*                                                                      */
  217. static struct f_node FAR *
  218. split_path (BYTE FAR *path, BYTE *dname, BYTE *fname, BYTE *fext)
  219. {
  220. REG struct f_node FAR *fnp;
  221. COUNT nDrive;
  222. struct dpb *dpbp;
  225. /* Start off by parsing out the components. */
  226. ParseDosName(adjust_far(path), &nDrive, &dname[2], fname, fext);
  227. if(nDrive < 0)
  228. nDrive = default_drive;
  229. dname[0] = 'A' + nDrive;
  230. dname[1] = ':';
  232. /* Add trailing spaces to the file name and extension */
  233. SpacePad(fname, FNAME_SIZE);
  234. SpacePad(fext, FEXT_SIZE);
  236. /* If the path is null, we to default to the current            */
  237. /* directory...                                                 */
  238. if(!dname[2])
  239. {
  240. dpbp = &blk_devices[nDrive];
  241. fsncopy((BYTE FAR *)dpbp -> dpb_path,
  242.         (BYTE FAR *)&dname[2],
  243.         PARSE_MAX);
  244. }
  246. /* Translate the path into a useful pointer                     */
  247. fnp = dir_open((BYTE FAR *)dname);
  249. /* If the fd was invalid because it was out of range or the     */
  250. /* requested file was not open, tell the caller and exit...     */
  251. /* note: an invalid fd is indicated by a 0 return               */
  252. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  253. {
  254. dir_close(fnp);
  255. return (struct f_node FAR *)0;
  256. }
  258. /* Convert the name into an absolute name for comparison...     */
  259. upMem((BYTE FAR *)dname, strlen(dname));
  260. upMem((BYTE FAR *)fname, FNAME_SIZE);
  261. upMem((BYTE FAR *)fext, FEXT_SIZE);
  263. return fnp;
  264. }
  268. static BOOL 
  269. find_fname (struct f_node FAR *fnp, BYTE *fname, BYTE *fext)
  270. {
  271. BOOL found = FALSE;
  273. while(dir_read(fnp) == DIRENT_SIZE)
  274. {
  275. if(fnp -> f_dir.dir_name[0] != '')
  276. {
  277. if(fnp -> f_dir.dir_name[0] == DELETED)
  278. continue;
  279. if(fcmp((BYTE FAR *)fname, (BYTE FAR *)fnp -> f_dir.dir_name, FNAME_SIZE)
  280. && fcmp((BYTE FAR *)fext, (BYTE FAR *)fnp -> f_dir.dir_ext, FEXT_SIZE))
  281. {
  282. found = TRUE;
  283. break;
  284. }
  285. }
  286. }
  287. return found;
  288. }
  291. #ifndef IPL
  292. COUNT 
  293. dos_creat (BYTE FAR *path, COUNT attrib)
  294. {
  295. REG struct f_node FAR *fnp;
  297. /* first split the passed dir into comopnents (i.e. -   */
  298. /* path to new directory and name of new directory      */
  299. if((fnp = split_path(path, szDirName, szFileName, szFileExt)) == NULL)
  300. {
  301. dir_close(fnp);
  302. return DE_PATHNOTFND;
  303. }
  305. /* Check that we don't have a duplicate name, so if we  */
  306. /* find one, truncate it.                               */
  307. if(find_fname(fnp, szFileName, szFileExt))
  308. {
  309. /* The only permissable attribute is archive,   */
  310. /* check for any other bit set. If it is, give  */
  311. /* an access error.                             */
  312. if((fnp -> f_dir.dir_attrib & (D_RDONLY | D_DIR | D_VOLID))
  313.    || (fnp -> f_dir.dir_attrib & ~D_ARCHIVE & ~attrib))
  314. {
  315. dir_close(fnp);
  316. return DE_ACCESS;
  317. }
  319. /* Release the existing files FAT and set the   */
  320. /* length to zero, effectively truncating the   */
  321. /* file to zero.                                */
  322. wipe_out(fnp);
  324. }
  325. else
  326. {
  327. BOOL is_free;
  328. REG COUNT idx;
  329. struct buffer FAR *bp;
  330. BYTE FAR *p;
  332. /* Reset the directory by a close followed by   */
  333. /* an open                                      */
  334. fnp -> f_flags.f_dmod = FALSE;
  335. dir_close(fnp);
  336. fnp = dir_open((BYTE FAR *)szDirName);
  338. /* Get a free f_node pointer so that we can use */
  339. /* it in building the new file.                 */
  340. /* Note that if we're in the root and we don't  */
  341. /* find an empty slot, we need to abort.        */
  342. if(!(is_free = find_free(fnp)) && (fnp -> f_flags.f_droot))
  343. {
  344. fnp -> f_flags.f_dmod = FALSE;
  345. dir_close(fnp);
  346. return DE_TOOMANY;
  347. }
  349. /* Otherwise just expand the directory          */
  350. else if(!is_free && !(fnp -> f_flags.f_droot))
  351. {
  352. COUNT ret;
  354. if((ret = extend_dir(fnp)) != SUCCESS)
  355. return ret;
  356. }
  358. /* put the fnode's name into the directory.             */
  359. fbcopy((BYTE FAR *)szFileName,
  360.  (BYTE FAR *)fnp -> f_dir.dir_name, FNAME_SIZE);
  361. fbcopy((BYTE FAR *)szFileExt,
  362.  (BYTE FAR *)fnp -> f_dir.dir_ext, FEXT_SIZE);
  363. }
  364. /* Set the fnode to the desired mode                    */
  365. /* Updating the directory entry first.                  */
  366. fnp -> f_mode = RDWR;
  368. fnp -> f_dir.dir_size = 0l;
  369. fnp -> f_dir.dir_start = FREE;
  370. fnp -> f_dir.dir_attrib = attrib | D_ARCHIVE;
  371. fnp -> f_dir.dir_time = dos_gettime();
  372. fnp -> f_dir.dir_date = dos_getdate();
  374. fnp -> f_flags.f_dmod = TRUE;
  375. fnp -> f_flags.f_dnew = FALSE;
  376. fnp -> f_flags.f_ddir = TRUE;
  377. if(dir_write(fnp) != DIRENT_SIZE)
  378. {
  379. release_f_node(fnp);
  380. return DE_ACCESS;
  381. }
  383. /* Now change to file                                   */
  384. fnp -> f_offset = 0l;
  385. fnp -> f_highwater = 0l;
  387. fnp -> f_back = LONG_LAST_CLUSTER;
  388. fnp -> f_cluster = fnp -> f_dir.dir_start = FREE;
  389. fnp -> f_flags.f_dmod = TRUE;
  390. fnp -> f_flags.f_dnew = FALSE;
  391. fnp -> f_flags.f_ddir = FALSE;
  393. return xlt_fnp(fnp);
  394. }
  397. COUNT 
  398. dos_delete (BYTE FAR *path)
  399. {
  400. REG struct f_node FAR *fnp;
  402. /* first split the passed dir into components (i.e. - */
  403. /* path to new directory and name of new directory */
  404. if((fnp = split_path(path, szDirName, szFileName, szFileExt)) == NULL)
  405. {
  406. dir_close(fnp);
  407. return DE_PATHNOTFND;
  408. }
  410. /* Check that we don't have a duplicate name, so if we  */
  411. /* find one, it's an error.                             */
  412. if(find_fname(fnp, szFileName, szFileExt))
  413. {
  414. /* The only permissable attribute is archive,   */
  415. /* check for any other bit set. If it is, give  */
  416. /* an access error.                             */
  417. if(fnp -> f_dir.dir_attrib & ~D_ARCHIVE)
  418. {
  419. dir_close(fnp);
  420. return DE_ACCESS;
  421. }
  423. /* Ok, so we can delete. Start out by           */
  424. /* clobbering all FAT entries for this file     */
  425. /* (or, in English, truncate the FAT).          */
  426. wipe_out(fnp);
  427. fnp -> f_dir.dir_size = 0l;
  428. *(fnp -> f_dir.dir_name) = DELETED;
  430. /* The directory has been modified, so set the  */
  431. /* bit before closing it, allowing it to be     */
  432. /* updated                                      */
  433. fnp -> f_flags.f_dmod = TRUE;
  434. dir_close(fnp);
  436. /* SUCCESSful completion, return it             */
  437. return SUCCESS;
  438. }
  439. else
  440. {
  441. /* No such file, return the error               */ 
  442. dir_close(fnp);
  443. return DE_FILENOTFND;
  444. }
  445. }
  448. COUNT 
  449. dos_rmdir (BYTE FAR *path)
  450. {
  451. REG struct f_node FAR *fnp;
  452. REG struct f_node FAR *fnp1;
  453. BOOL found;
  455. /* first split the passed dir into comopnents (i.e. -   */
  456. /* path to new directory and name of new directory      */
  457. if((fnp = split_path(path, szDirName, szFileName, szFileExt)) == NULL)
  458. {
  459. dir_close(fnp);
  460. return DE_PATHNOTFND;
  461. }
  463. /* Check that we're not trying to remove the root!      */
  464. if((path[0] == '\') && (path[1] == NULL))
  465. {
  466. dir_close(fnp);
  467. return DE_ACCESS;
  468. }
  470. /* Check that we don't have a duplicate name, so if we  */
  471. /* find one, it's an error.                             */
  472. if(find_fname(fnp, szFileName, szFileExt))
  473. {
  474. /* The only permissable attribute is directory, */
  475. /* check for any other bit set. If it is, give  */
  476. /* an access error.                             */
  477. if(fnp -> f_dir.dir_attrib & ~D_DIR)
  478. {
  479. dir_close(fnp);
  480. return DE_ACCESS;
  481. }
  483. /* Check that the directory is empty. Only the  */
  484. /* "." and ".." are permissable.                */
  485. fnp -> f_flags.f_dmod = FALSE;
  486. fnp1 = dir_open((BYTE FAR *)path);
  487. dir_read(fnp1);
  488. if(fnp1 -> f_dir.dir_name[0] != '.')
  489. {
  490. dir_close(fnp);
  491. return DE_ACCESS;
  492. }
  494. dir_read(fnp1);
  495. if(fnp1 -> f_dir.dir_name[0] != '.')
  496. {
  497. dir_close(fnp);
  498. return DE_ACCESS;
  499. }
  501. /* Now search through the directory and make certain    */
  502. /* that there are no entries.                           */
  503. found = FALSE;
  504. while(dir_read(fnp1) == DIRENT_SIZE)
  505. {
  506. if(fnp1 -> f_dir.dir_name[0] == '')
  507. break;
  508. if(fnp1 -> f_dir.dir_name[0] == DELETED)
  509. continue;
  510. else
  511. {
  512. found = TRUE;
  513. break;
  514. }
  515. }
  517. dir_close(fnp1);
  518. /* If anything was found, exit with an error.   */
  519. if(found)
  520. {
  521. dir_close(fnp);
  522. return DE_ACCESS;
  523. }
  525. /* Ok, so we can delete. Start out by           */
  526. /* clobbering all FAT entries for this file     */
  527. /* (or, in English, truncate the FAT).          */
  528. wipe_out(fnp);
  529. fnp -> f_dir.dir_size = 0l;
  530. *(fnp -> f_dir.dir_name) = DELETED;
  532. /* The directory has been modified, so set the  */
  533. /* bit before closing it, allowing it to be     */
  534. /* updated                                      */
  535. fnp -> f_flags.f_dmod = TRUE;
  536. dir_close(fnp);
  538. /* SUCCESSful completion, return it             */
  539. return SUCCESS;
  540. }
  541. else
  542. {
  543. /* No such file, return the error               */
  544. dir_close(fnp);
  545. return DE_FILENOTFND;
  546. }
  547. }
  550. COUNT dos_rename(path1, path2)
  551. BYTE FAR *path1, FAR *path2;
  552. {
  553. REG struct f_node FAR *fnp1;
  554. REG struct f_node FAR *fnp2;
  555. BOOL is_free;
  557. /* first split the passed target into compnents (i.e. - path to */
  558. /* new file name and name of new file name                      */
  559. if((fnp2 = split_path(path2, szSecDirName, szSecFileName, szSecFileExt)) == NULL)
  560. {
  561. dir_close(fnp2);
  562. return DE_PATHNOTFND;
  563. }
  565. /* Check that we don't have a duplicate name, so if we find     */
  566. /* one, it's an error.                                          */
  567. if(find_fname(fnp2, szSecFileName, szSecFileExt))
  568. {
  569. dir_close(fnp2);
  570. return DE_ACCESS;
  571. }
  573. /* next split the passed source into compnents (i.e. - path to  */
  574. /* old file name and name of old file name                      */
  575. if((fnp1 = split_path(path1, szPriDirName, szPriFileName, szPriFileExt)) == NULL)
  576. {
  577. dir_close(fnp1);
  578. dir_close(fnp2);
  579. return DE_PATHNOTFND;
  580. }
  582. /* Reset the directory by a close followed by an open           */
  583. fnp2 -> f_flags.f_dmod = FALSE;
  584. dir_close(fnp2);
  585. fnp2 = dir_open((BYTE FAR *)szSecDirName);
  587. /* Now find a free slot to put the file into.                   */
  588. /* If it's the root and we don't have room, return an error.    */
  589. if(!(is_free = find_free(fnp2)) && (fnp2 -> f_flags.f_droot))
  590. {
  591. fnp2 -> f_flags.f_dmod = FALSE;
  592. dir_close(fnp1);
  593. dir_close(fnp2);
  594. return DE_TOOMANY;
  595. }
  597. /* Otherwise just expand the directory                          */
  598. else if(!is_free && !(fnp2 -> f_flags.f_droot))
  599. {
  600. COUNT ret;
  602. if(extend_dir(fnp2) != SUCCESS)
  603. return ret;
  604. }
  606. if(!find_fname(fnp1, szPriFileName, szPriFileExt))
  607. {
  608. /* No such file, return the error                       */
  609. dir_close(fnp1);
  610. dir_close(fnp2);
  611. return DE_FILENOTFND;
  612. }
  614. /* put the fnode's name into the directory.                     */
  615. fbcopy((BYTE FAR *)szSecFileName,
  616.  (BYTE FAR *)fnp2 -> f_dir.dir_name, FNAME_SIZE);
  617. fbcopy((BYTE FAR *)szSecFileExt,
  618.  (BYTE FAR *)fnp2 -> f_dir.dir_ext, FEXT_SIZE);
  620. /* Set the fnode to the desired mode                            */
  621. fnp2 -> f_dir.dir_size = fnp1 -> f_dir.dir_size;
  622. fnp2 -> f_dir.dir_start = fnp1 -> f_dir.dir_start;
  623. fnp2 -> f_dir.dir_attrib = fnp1 -> f_dir.dir_attrib;
  624. fnp2 -> f_dir.dir_time = fnp1 -> f_dir.dir_time;
  625. fnp2 -> f_dir.dir_date = fnp1 -> f_dir.dir_date;
  627. /* The directory has been modified, so set the bit before       */
  628. /* closing it, allowing it to be updated.                       */
  629. fnp1 -> f_flags.f_dmod = fnp2 -> f_flags.f_dmod = TRUE;
  630. fnp1 -> f_flags.f_dnew = fnp2 -> f_flags.f_dnew = FALSE;
  631. fnp1 -> f_flags.f_ddir = fnp2 -> f_flags.f_ddir = TRUE;
  633. fnp2 -> f_highwater = fnp2 -> f_offset = fnp1 -> f_dir.dir_size;
  635. /* Ok, so we can delete this one. Save the file info.           */
  636. fnp1 -> f_dir.dir_size = 0l;
  637. *(fnp1 -> f_dir.dir_name) = DELETED;
  639. dir_close(fnp1);
  640. dir_close(fnp2);
  642. /* SUCCESSful completion, return it                             */
  643. return SUCCESS;
  644. }
  647. /*                                                              */
  648. /* wipe out all FAT entries for create, delete, etc.            */
  649. /*                                                              */
  650. static VOID 
  651. wipe_out (struct f_node FAR *fnp)
  652. {
  653. REG UWORD st, next;
  654. struct dpb *dpbp = fnp -> f_dpb;
  656. /* if already free or not valid file, just exit         */
  657. if((fnp == NULL) || (fnp -> f_dir.dir_start == FREE))
  658. return;
  660. /* if there are no FAT entries, just exit               */
  661. if(fnp -> f_dir.dir_start == FREE)
  662. return;
  664. /* Loop from start until either a FREE entry is         */
  665. /* encountered (due to a fractured file system) of the  */
  666. /* last cluster is encountered.                         */
  667. for(st = fnp -> f_dir.dir_start ;
  668.   st != LONG_LAST_CLUSTER && st != LAST_CLUSTER;)
  669. {
  670. /* get the next cluster pointed to              */
  671. next = next_cluster(dpbp, st);
  673. /* just exit if a damaged file system exists    */
  674. if(next == FREE)
  675. return;
  677. /* zap the FAT pointed to                       */
  678. link_fat(dpbp, st, FREE);
  680. /* and the start of free space pointer          */
  681. if((dpbp -> dpb_cluster == UNKNCLUSTER)
  682.  || (dpbp -> dpb_cluster > st))
  683. dpbp -> dpb_cluster = st;
  685. /* and just follow the linked list              */
  686. st = next;
  687. }
  688. }
  691. static BOOL 
  692. find_free (struct f_node FAR *fnp)
  693. {
  694. while(dir_read(fnp) == DIRENT_SIZE)
  695. {
  696. if(fnp -> f_dir.dir_name[0] == ''
  697.  || fnp -> f_dir.dir_name[0] == DELETED)
  698. {
  699. return TRUE;
  700. }
  701. }
  702. return !fnp -> f_flags.f_dfull;
  703. }
  705. /*                                                              */
  706. /* dos_getdate for the file date                                */
  707. /*                                                              */
  708. date dos_getdate()
  709. {
  710. #ifndef NOTIME
  711. # ifndef IPL
  712. BYTE WeekDay, Month, MonthDay;
  713. COUNT Year;
  714. date Date;
  716. /* First - get the system date set by either the user   */
  717. /* on start-up or the CMOS clock                        */
  718. DosGetDate((BYTE FAR *)&WeekDay,
  719.  (BYTE FAR *)&Month,
  720.  (BYTE FAR *)&MonthDay,
  721.  (COUNT FAR *)& Year);
  722. Date = DT_ENCODE(Month, MonthDay, Year - EPOCH_YEAR);
  723. return Date;
  724. # else
  725. return 0;
  726. # endif
  727. #else
  728. return 0;
  729. #endif
  730. }
  734. /*                                                              */
  735. /* dos_gettime for the file time                                */
  736. /*                                                              */
  737. time dos_gettime()
  738. {
  739. #ifndef NOTIME
  740. # ifndef IPL
  741. BYTE Hour, Minute, Second, Hundredth;
  742. time Time;
  743. BYTE h;
  745. /* First - get the system time set by either the user   */
  746. /* on start-up or the CMOS clock                        */
  747. DosGetTime((BYTE FAR *)&Hour,
  748.  (BYTE FAR *)&Minute,
  749.  (BYTE FAR *)&Second,
  750.  (BYTE FAR *)&Hundredth);
  751. h = Second * 10 + ((Hundredth + 5) / 10);
  752. Time = TM_ENCODE(Hour, Minute, h);
  753. return Time;
  754. # else
  755. return 0;
  756. # endif
  757. #else
  758. return 0;
  759. #endif
  760. }
  763. #ifndef IPL
  764. /*                                                              */
  765. /* dos_getftime for the file time                               */
  766. /*                                                              */
  767. BOOL dos_getftime(fd, dp, tp)
  768. COUNT fd;
  769. date FAR *dp;
  770. time FAR *tp;
  771. {
  772. struct f_node FAR *fnp;
  774. /* Translate the fd into an fnode pointer, since all internal   */
  775. /* operations are achieved through fnodes.                      */
  776. fnp = xlt_fd(fd);
  778. /* If the fd was invalid because it was out of range or the     */
  779. /* requested file was not open, tell the caller and exit        */
  780. /* note: an invalid fd is indicated by a 0 return               */
  781. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  782. return FALSE;
  784. /* Get the date and time from the fnode and return              */
  785. *dp = fnp -> f_dir.dir_date;
  786. *tp = fnp -> f_dir.dir_time;
  788. return TRUE;
  789. }
  792. /*                                                              */
  793. /* dos_setftime for the file time                               */
  794. /*                                                              */
  795. BOOL dos_setftime(fd, dp, tp)
  796. COUNT fd;
  797. date FAR *dp;
  798. time FAR *tp;
  799. {
  800. struct f_node FAR *fnp;
  802. /* Translate the fd into an fnode pointer, since all internal   */
  803. /* operations are achieved through fnodes.                      */
  804. fnp = xlt_fd(fd);
  806. /* If the fd was invalid because it was out of range or the     */
  807. /* requested file was not open, tell the caller and exit        */
  808. /* note: an invalid fd is indicated by a 0 return               */
  809. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  810. return FALSE;
  812. /* Set the date and time from the fnode and return              */
  813. fnp -> f_dir.dir_date = *dp;
  814. fnp -> f_dir.dir_time = *tp;
  816. return TRUE;
  817. }
  820. /*                                                              */
  821. /* dos_getfsize for the file time                               */
  822. /*                                                              */
  823. LONG 
  824. dos_getcufsize (COUNT fd)
  825. {
  826. struct f_node FAR *fnp;
  828. /* Translate the fd into an fnode pointer, since all internal   */
  829. /* operations are achieved through fnodes.                      */
  830. fnp = xlt_fd(fd);
  832. /* If the fd was invalid because it was out of range or the     */
  833. /* requested file was not open, tell the caller and exit        */
  834. /* note: an invalid fd is indicated by a 0 return               */
  835. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  836. return -1l;
  838. /* Return the file size                                         */
  839. return fnp -> f_highwater;
  840. }
  843. /*                                                              */
  844. /* dos_getfsize for the file time                               */
  845. /*                                                              */
  846. LONG 
  847. dos_getfsize (COUNT fd)
  848. {
  849. struct f_node FAR *fnp;
  851. /* Translate the fd into an fnode pointer, since all internal   */
  852. /* operations are achieved through fnodes.                      */
  853. fnp = xlt_fd(fd);
  855. /* If the fd was invalid because it was out of range or the     */
  856. /* requested file was not open, tell the caller and exit        */
  857. /* note: an invalid fd is indicated by a 0 return               */
  858. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  859. return -1l;
  861. /* Return the file size                                         */
  862. return fnp -> f_dir.dir_size;
  863. }
  866. /*                                                              */
  867. /* dos_setfsize for the file time                               */
  868. /*                                                              */
  869. BOOL 
  870. dos_setfsize (COUNT fd, LONG size)
  871. {
  872. struct f_node FAR *fnp;
  874. /* Translate the fd into an fnode pointer, since all internal   */
  875. /* operations are achieved through fnodes.                      */
  876. fnp = xlt_fd(fd);
  878. /* If the fd was invalid because it was out of range or the     */
  879. /* requested file was not open, tell the caller and exit        */
  880. /* note: an invalid fd is indicated by a 0 return               */
  881. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  882. return FALSE;
  884. /* Change the file size                                         */
  885. fnp -> f_dir.dir_size = size;
  886. fnp -> f_highwater = size;
  887. return TRUE;
  888. }
  889. #endif
  892. /*                                                              */
  893. /* Find free cluster in disk FAT table                          */
  894. /*                                                              */
  895. static UWORD 
  896. find_fat_free (struct f_node FAR *fnp)
  897. {
  898. REG UWORD idx;
  900. /* Start from optimized lookup point for start of FAT   */
  901. if(fnp -> f_dpb -> dpb_cluster != UNKNCLUSTER)
  902. idx =  fnp -> f_dpb -> dpb_cluster;
  903. else
  904. idx = 2;
  906. /* Search the FAT table looking for the first free      */
  907. /* entry.                                               */
  908. for( ; idx < fnp -> f_dpb -> dpb_size; idx++)
  909. {
  910. if(next_cluster(fnp -> f_dpb, idx) == FREE)
  911. break;
  912. }
  914. /* No empty clusters, disk is FULL!                     */
  915. if(idx >= fnp -> f_dpb -> dpb_size)
  916. {
  917. fnp -> f_dpb -> dpb_cluster = UNKNCLUSTER;
  918. dir_close(fnp);
  919. return LONG_LAST_CLUSTER;
  920. }
  922. /* return the free entry                                */
  923. fnp -> f_dpb -> dpb_cluster = idx;
  924. return idx;
  925. }
  929. /*                                                              */
  930. /* crate a directory - returns success or a negative error      */
  931. /* number                                                       */
  932. /*                                                              */
  933. COUNT 
  934. dos_mkdir (BYTE FAR *dir)
  935. {
  936. REG struct f_node FAR *fnp;
  937. REG COUNT idx;
  938. struct buffer FAR *bp;
  939. BYTE FAR *p;
  940. UWORD free_fat;
  941. UWORD parent;
  943. /* first split the passed dir into comopnents (i.e. -   */
  944. /* path to new directory and name of new directory      */
  945. if((fnp = split_path(dir, szDirName, szFileName, szFileExt)) == NULL)
  946. {
  947. dir_close(fnp);
  948. return DE_PATHNOTFND;
  949. }
  951. /* Check that we don't have a duplicate name, so if we  */
  952. /* find one, it's an error.                             */
  953. if(find_fname(fnp, szFileName, szFileExt))
  954. {
  955. dir_close(fnp);
  956. return DE_ACCESS;
  957. }
  958. else
  959. {
  960. BOOL is_free;
  962. /* Reset the directory by a close followed by   */
  963. /* an open                                      */
  964. fnp -> f_flags.f_dmod = FALSE;
  965. parent = fnp -> f_dirstart;
  966. dir_close(fnp);
  967. fnp = dir_open((BYTE FAR *)szDirName);
  969. /* Get a free f_node pointer so that we can use */
  970. /* it in building the new file.                 */
  971. /* Note that if we're in the root and we don't  */
  972. /* find an empty slot, we need to abort.        */
  973. if(!(is_free = find_free(fnp)) && (fnp -> f_flags.f_droot))
  974. {
  975. fnp -> f_flags.f_dmod = FALSE;
  976. dir_close(fnp);
  977. return DE_TOOMANY;
  978. }
  980. /* Otherwise just expand the directory          */
  981. else if(!is_free && !(fnp -> f_flags.f_droot))
  982. {
  983. COUNT ret;
  985. if(extend_dir(fnp) != SUCCESS)
  986. return ret;
  987. }
  989. /* put the fnode's name into the directory.             */
  990. fbcopy((BYTE FAR *)szFileName,
  991.  (BYTE FAR *)fnp -> f_dir.dir_name, FNAME_SIZE);
  992. fbcopy((BYTE FAR *)szFileExt,
  993.  (BYTE FAR *)fnp -> f_dir.dir_ext, FEXT_SIZE);
  995. /* Set the fnode to the desired mode                            */
  996. fnp -> f_mode = WRONLY;
  997. fnp -> f_back = LONG_LAST_CLUSTER;
  999. fnp -> f_dir.dir_size = 0l;
  1000. fnp -> f_dir.dir_start = FREE;
  1001. fnp -> f_dir.dir_attrib = D_DIR;
  1002. fnp -> f_dir.dir_time = dos_gettime();
  1003. fnp -> f_dir.dir_date = dos_getdate();
  1005. fnp -> f_flags.f_dmod = TRUE;
  1006. fnp -> f_flags.f_dnew = FALSE;
  1007. fnp -> f_flags.f_ddir = TRUE;
  1009. fnp -> f_highwater = 0l;
  1010. fnp -> f_offset = 0l;
  1011. }
  1013. /* get an empty cluster, so that we make it into a      */
  1014. /* directory.                                           */
  1015. free_fat = find_fat_free(fnp);
  1017. /* No empty clusters, disk is FULL! Translate into a    */
  1018. /* useful error message.                                */
  1019. if(free_fat == LONG_LAST_CLUSTER)
  1020. {
  1021. dir_close(fnp);
  1022. return DE_HNDLDSKFULL;
  1023. }
  1025. /* Mark the cluster in the FAT as used                  */
  1026. fnp -> f_dir.dir_start = fnp -> f_cluster = free_fat;
  1027. link_fat(fnp -> f_dpb, (UCOUNT)free_fat, LONG_LAST_CLUSTER);
  1029. /* Craft the new directory. Note that if we're in a new */
  1030. /* directory just under the root, ".." pointer is 0.    */
  1031. bp = getblock((LONG)clus2phys(free_fat,
  1032. fnp -> f_dpb -> dpb_clssize,
  1033. fnp -> f_dpb -> dpb_data),
  1034. fnp -> f_dpb -> dpb_unit);
  1035. if(bp == NULL)
  1036. {
  1037. dir_close(fnp);
  1038. return DE_BLKINVLD;
  1039. }
  1041. /* Create the "." entry                                 */
  1042. bcopy(".       ", (BYTE *)DirEntBuffer.dir_name, FNAME_SIZE);
  1043. bcopy("   ", (BYTE *)DirEntBuffer.dir_ext, FEXT_SIZE);
  1044. DirEntBuffer.dir_attrib = D_DIR;
  1045. DirEntBuffer.dir_time = dos_gettime();
  1046. DirEntBuffer.dir_date = dos_getdate();
  1047. DirEntBuffer.dir_start = free_fat;
  1048. DirEntBuffer.dir_size = 0l;
  1050. /* And put it out                                       */
  1051. putdirent((struct dirent FAR *)&DirEntBuffer, (BYTE FAR *)bp ->b_buffer);
  1053. /* create the ".." entry                                */
  1054. bcopy("..      ", (BYTE *)DirEntBuffer.dir_name, FNAME_SIZE);
  1055. DirEntBuffer.dir_start = parent;
  1057. /* and put it out                                       */
  1058. putdirent((struct dirent FAR *)&DirEntBuffer, (BYTE FAR *)&bp -> b_buffer[DIRENT_SIZE]);
  1060. /* fill the rest of the block with zeros                */
  1061. for(p = (BYTE FAR *)&bp -> b_buffer[2 *DIRENT_SIZE];
  1062.  p < &bp -> b_buffer[BUFFERSIZE]; )
  1063. *p++ = NULL;
  1065. /* Mark the block to be written out                     */
  1066. bp -> b_flag |= BFR_DIRTY;
  1068. /* clear out the rest of the blocks in the cluster      */
  1069. for(idx = 1; idx < fnp -> f_dpb -> dpb_clssize; idx++)
  1070. {
  1071. REG COUNT i;
  1073. bp = getblock(
  1074. (LONG)clus2phys(fnp -> f_dir.dir_start,
  1075. fnp -> f_dpb -> dpb_clssize,
  1076. fnp -> f_dpb -> dpb_data) + idx,
  1077. fnp -> f_dpb -> dpb_unit);
  1078. if(bp == NULL)
  1079. {
  1080. dir_close(fnp);
  1081. return DE_BLKINVLD;
  1082. }
  1083. for(i = 0, p = (BYTE FAR *)bp -> b_buffer; i < BUFFERSIZE; i++)
  1084. *p++ = NULL;
  1085. bp -> b_flag |= BFR_DIRTY;
  1086. }
  1088. /* flush the drive buffers so that all info is written  */
  1089. flush_buffers((COUNT)(fnp -> f_dpb -> dpb_unit));
  1091. /* Close the directory so that the entry is updated     */
  1092. fnp -> f_flags.f_dmod = TRUE;
  1093. dir_close(fnp);
  1095. return SUCCESS;
  1096. }
  1097. #endif
  1100. BOOL 
  1101. last_link (struct f_node FAR *fnp)
  1102. {
  1103. return (((UWORD)fnp -> f_cluster == (UWORD)LONG_LAST_CLUSTER)
  1104.  || ((UWORD)fnp -> f_cluster == (UWORD)LAST_CLUSTER));
  1105. }
  1107. #ifndef IPL
  1108. static BOOL 
  1109. extend (struct f_node FAR *fnp)
  1110. {
  1111. UWORD free_fat;
  1113. /* get an empty cluster, so that we use it to extend the file.  */
  1114. free_fat = find_fat_free(fnp);
  1116. /* No empty clusters, disk is FULL! Translate into a useful     */
  1117. /* error message.                                               */
  1118. if(free_fat == LONG_LAST_CLUSTER)
  1119. return FALSE;
  1121. /* Now that we've found a free FAT entry, mark it as the last   */
  1122. /* entry and save.                                              */
  1123. link_fat(fnp -> f_dpb, (UCOUNT)fnp -> f_back, free_fat);
  1124. fnp -> f_cluster = free_fat;
  1125. link_fat(fnp -> f_dpb, (UCOUNT)free_fat, LONG_LAST_CLUSTER);
  1127. /* Mark the directory so that the entry is updated              */
  1128. fnp -> f_flags.f_dmod = TRUE;
  1129. return TRUE;
  1130. }
  1133. static COUNT 
  1134. extend_dir (struct f_node FAR *fnp)
  1135. {
  1136. REG COUNT idx;
  1138. if(!extend(fnp))
  1139. {
  1140. dir_close(fnp);
  1141. return DE_HNDLDSKFULL;
  1142. }
  1144. /* clear out the rest of the blocks in the cluster              */
  1145. for(idx = 0; idx < fnp -> f_dpb -> dpb_clssize; idx++)
  1146. {
  1147. REG COUNT i;
  1148. REG BYTE FAR *p;
  1149. REG struct buffer FAR *bp;
  1151. bp = getblock(
  1152. (LONG)clus2phys(fnp -> f_cluster,
  1153. fnp -> f_dpb -> dpb_clssize,
  1154. fnp -> f_dpb -> dpb_data) + idx,
  1155. fnp -> f_dpb -> dpb_unit);
  1156. if(bp == NULL)
  1157. {
  1158. dir_close(fnp);
  1159. return DE_BLKINVLD;
  1160. }
  1161. for(i = 0, p = (BYTE FAR *)bp -> b_buffer; i < BUFFERSIZE; i++)
  1162. *p++ = NULL;
  1163. bp -> b_flag |= BFR_DIRTY;
  1164. }
  1166. if(!find_free(fnp))
  1167. {
  1168. dir_close(fnp);
  1169. return DE_HNDLDSKFULL;
  1170. }
  1172. /* flush the drive buffers so that all info is written          */
  1173. flush_buffers((COUNT)(fnp -> f_dpb -> dpb_unit));
  1175. return SUCCESS;
  1177. }
  1180. static BOOL 
  1181. first_fat (struct f_node FAR *fnp)
  1182. {
  1183. UWORD free_fat;
  1185. /* get an empty cluster, so that we make it into a file.        */
  1186. free_fat = find_fat_free(fnp);
  1188. /* No empty clusters, disk is FULL! Translate into a useful     */
  1189. /* error message.                                               */
  1190. if(free_fat == LONG_LAST_CLUSTER)
  1191. return FALSE;
  1193. /* Now that we've found a free FAT entry, mark it as the last   */
  1194. /* entry and save it.                                           */
  1195. fnp -> f_dir.dir_start = free_fat;
  1196. link_fat(fnp -> f_dpb, (UCOUNT)free_fat, LONG_LAST_CLUSTER);
  1198. /* Mark the directory so that the entry is updated              */
  1199. fnp -> f_flags.f_dmod = TRUE;
  1200. return TRUE;
  1201. }
  1202. #endif
  1205. COUNT 
  1206. map_cluster (REG struct f_node FAR *fnp, COUNT mode)
  1207. {
  1208. ULONG idx;
  1209. WORD clssize, secsize;
  1211. /* Set internal index and cluster size.                 */
  1212. idx = fnp -> f_offset;
  1214. /* The variable clssize will be used later.             */
  1215. secsize = fnp -> f_dpb -> dpb_secsize;
  1216. clssize = secsize * fnp -> f_dpb -> dpb_clssize;
  1218. #ifndef IPL
  1219. /* If someone did a seek, but no writes have occured, we will   */
  1220. /* need to initialize the fnode.                                */
  1221. if((mode == XFR_WRITE) && (fnp -> f_dir.dir_start == FREE))
  1222. {        
  1223. if(!first_fat(fnp))
  1224. return DE_HNDLDSKFULL;
  1225. }
  1226. #endif
  1228. /* Now begin the linear search. The relative cluster is         */
  1229. /* maintained as part of the set of physical indices. It is     */
  1230. /* also the highest order index and is mapped directly into     */
  1231. /* physical cluster. Our search is performed by pacing an index */
  1232. /* up to the relative cluster position where the index falls    */
  1233. /* within the cluster.                                          */
  1234. /*                                                              */
  1235. /* NOTE: make sure your compiler does not optimize for loop     */
  1236. /* tests to the loop exit. We need to fall out immediately for  */
  1237. /* files whose length < cluster size.                           */
  1238. for(fnp -> f_cluster = fnp -> f_flags.f_ddir ?
  1239. fnp -> f_dirstart :
  1240. fnp -> f_dir.dir_start;
  1241.   idx >= clssize;
  1242.    idx -= clssize)
  1243. {
  1244. /* If this is a read and the next is a LAST_CLUSTER,    */
  1245. /* then we are going to read past EOF, return zero read */
  1246. if((mode == XFR_READ) && last_link(fnp))
  1247. return DE_SEEK;
  1248. #ifndef IPL
  1249. /* expand the list if we're going to write and have run into    */
  1250. /* the last cluster marker.                                     */
  1251. else if((mode == XFR_WRITE) && last_link(fnp))
  1252. {
  1254. if(!extend(fnp))
  1255. {
  1256. dir_close(fnp);
  1257. return DE_HNDLDSKFULL;
  1258. }
  1259. }
  1260. #endif
  1261. fnp -> f_back = fnp -> f_cluster;
  1262. fnp -> f_cluster = next_cluster(fnp -> f_dpb,fnp -> f_cluster);
  1263. }
  1264. return SUCCESS;
  1265. }
  1267. UCOUNT 
  1268. rdwrblock (COUNT fd, VOID FAR *buffer, UCOUNT count, COUNT mode, COUNT *err)
  1269. {
  1270. REG struct f_node FAR *fnp;
  1271. REG struct buffer FAR *bp;
  1272. UCOUNT xfr_cnt = 0, ret_cnt = 0;
  1273. LONG idx;
  1274. WORD secsize;
  1275. UCOUNT to_xfer = count;
  1277. #ifdef DEBUG
  1278. if(bDumpRdWrParms)
  1279. {
  1280. printf("rdwrblock: mode = %sn",
  1281.  mode == XFR_WRITE ? "WRITE" : "READ");
  1282. printf(" fd   buffer     countn --   ------     -----n");
  1283. printf(" %02d   %04x:%04x   %dn",
  1284.  fd, (COUNT)FP_SEG(buffer), (COUNT)FP_OFF(buffer), count);
  1285. }
  1286. #endif
  1287. /* Translate the fd into an fnode pointer, since all internal   */
  1288. /* operations are achieved through fnodes.                      */
  1289. fnp = xlt_fd(fd);
  1291. /* If the fd was invalid because it was out of range or the     */
  1292. /* requested file was not open, tell the caller and exit        */
  1293. /* note: an invalid fd is indicated by a 0 return               */
  1294. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  1295. {
  1296. *err = DE_INVLDHNDL;
  1297. return 0;
  1298. }
  1300. /* Test that we are really about to do a data transfer. If the  */
  1301. /* count is zero and the mode is XFR_READ, just exit. (Any */
  1302. /* read with a count of zero is a nop).                         */
  1303. /*                                                              */
  1304. /* A write (mode is XFR_WRITE) is a special case.  It sets the */
  1305. /* file length to the current length (truncates it).            */
  1306. /*                                                              */
  1307. /* NOTE: doing this up front saves a lot of headaches later.    */
  1308. if(count == 0)
  1309. {
  1310. if(mode == XFR_WRITE)
  1311. {
  1312. fnp -> f_highwater = fnp -> f_offset;
  1313. }
  1315. *err = SUCCESS;
  1316. return 0;
  1317. }
  1319. /* Another test is to check for a seek past EOF on an XFR_READ  */
  1320. /* operation.                                                   */
  1321. if(mode == XFR_READ
  1322.  && !fnp -> f_flags.f_ddir
  1323.  && (fnp -> f_offset >= fnp -> f_dir.dir_size))
  1324. {
  1325. *err = SUCCESS;
  1326. return 0;
  1327. }
  1329. /* test that we have a valid mode for this fnode                */
  1330. switch(mode)
  1331. {
  1332. case XFR_READ:
  1333. if(fnp -> f_mode != RDONLY && fnp -> f_mode != RDWR)
  1334. {
  1335. *err = DE_INVLDACC;
  1336. return 0;
  1337. }
  1338. break;
  1340. #ifndef IPL
  1341. case XFR_WRITE:
  1342. if(fnp -> f_mode != WRONLY && fnp -> f_mode != RDWR)
  1343. {
  1344. *err = DE_INVLDACC;
  1345. return 0;
  1346. }
  1347. break;
  1348. #endif
  1349. default:
  1350. *err = DE_INVLDACC;
  1351. return 0;
  1352. }
  1354. /* The variable secsize will be used later.                     */
  1355. secsize = fnp -> f_dpb -> dpb_secsize;
  1357. /* Adjust the far pointer from user space to supervisor space   */
  1358. buffer = adjust_far((VOID FAR *)buffer);
  1360. /* Do the data transfer. Use block transfer methods so that we  */
  1361. /* can utilize memory management in future DOS-C versions. */
  1362. while(ret_cnt < count)
  1363. {
  1364. /* Position the file to the fnode's pointer position. This is   */
  1365. /* done by updating the fnode's cluster, block (sector) and     */
  1366. /* byte offset so that read or write becomes a simple data move */
  1367. /* into or out of the block data buffer.                        */
  1368. if(fnp -> f_offset == 0l)
  1369. {
  1370. #ifndef IPL
  1371. /* For the write case, a newly created file     */
  1372. /* will have a start cluster of FREE. If we're  */
  1373. /* doing a write and this is the first time     */
  1374. /* through, allocate a new cluster to the file. */
  1375. if((mode == XFR_WRITE)
  1376.  && (fnp -> f_dir.dir_start == FREE))
  1377. if(!first_fat(fnp))
  1378. {
  1379. dir_close(fnp);
  1380. *err = DE_HNDLDSKFULL;
  1381. return ret_cnt;
  1382. }
  1383. #endif
  1384. /* complete the common operations of            */
  1385. /* initializing to the starting cluster and     */
  1386. /* setting all offsets to zero.                 */
  1387. fnp -> f_cluster = fnp -> f_dir.dir_start;
  1388. fnp -> f_back = LONG_LAST_CLUSTER;
  1389. fnp -> f_sector = 0;
  1390. fnp -> f_boff = 0;
  1391. }
  1393. /* The more difficult scenario is the (more common)     */
  1394. /* file offset case. Here, we need to take the fnode's  */
  1395. /* offset pointer (f_offset) and translate it into a    */
  1396. /* relative cluster position, cluster block (sector)    */
  1397. /* offset (f_sector) and byte offset (f_boff). Once we  */
  1398. /* have this information, we need to translate the      */
  1399. /* relative cluster position into an absolute cluster   */
  1400. /* position (f_cluster). This is unfortunate because it */
  1401. /* requires a linear search through the file's FAT      */
  1402. /* entries. It made sense when DOS was originally       */
  1403. /* designed as a simple floppy disk operating system    */
  1404. /* where the FAT was contained in core, but now         */
  1405. /* requires a search through the FAT blocks.            */
  1406. /*                                                      */
  1407. /* The algorithm in this function takes advantage of    */
  1408. /* the blockio block buffering scheme to simplify the   */
  1409. /* task.                                                */
  1410. else
  1411. switch(map_cluster(fnp, mode))
  1412. {
  1413. case DE_SEEK:
  1414. *err = DE_SEEK;
  1415. dir_close(fnp);
  1416. return ret_cnt;
  1418. default:
  1419. dir_close(fnp);
  1420. *err = DE_HNDLDSKFULL;
  1421. return ret_cnt;
  1423. case SUCCESS:
  1424. break;
  1425. }
  1426. #ifndef IPL
  1427. /* XFR_WRITE case only - if we're at the end, the next  */
  1428. /* FAT is an EOF marker, so just extend the file length */
  1429. if(mode == XFR_WRITE && last_link(fnp))
  1430. if(!extend(fnp))
  1431. {
  1432. dir_close(fnp);
  1433. *err = DE_HNDLDSKFULL;
  1434. return ret_cnt;
  1435. }
  1436. #endif
  1438. /* Compute the block within the cluster and the offset  */
  1439. /* within the block.                                    */
  1440. fnp -> f_sector =
  1441.  (fnp -> f_offset / secsize) & fnp -> f_dpb -> dpb_clsmask;
  1442. fnp -> f_boff = fnp -> f_offset % secsize;
  1444. #ifdef DSK_DEBUG
  1445. printf("%d links; dir offset %ld, starting at cluster %dn",
  1446. fnp -> f_count,
  1447. fnp -> f_diroff,
  1448. fnp -> f_cluster);
  1449. #endif
  1450. /* Do an EOF test and return whatever was transferred   */
  1451. /* but only for regular files in XFR_READ mode          */
  1452. if((mode == XFR_READ) && !(fnp -> f_flags.f_ddir)
  1453.   && (fnp -> f_offset >= fnp -> f_dir.dir_size))
  1454. {
  1455. *err = SUCCESS;
  1456. return ret_cnt;
  1457. }
  1459. /* Get the block we need from cache                     */
  1460. bp = getblock(
  1461. (LONG)clus2phys(fnp -> f_cluster,
  1462. fnp -> f_dpb -> dpb_clssize,
  1463. fnp -> f_dpb -> dpb_data) + fnp -> f_sector,
  1464. fnp -> f_dpb -> dpb_unit);
  1466. if(bp == (struct buffer *)0)
  1467. {
  1468. *err = DE_BLKINVLD;
  1469. return ret_cnt;
  1470. }
  1472. /* transfer a block                                     */
  1473. /* Transfer size as either a full block size, or the    */
  1474. /* requested transfer size, whichever is smaller.       */
  1475. /* Then compare to what is left, since we can transfer  */
  1476. /* a maximum of what is left.                           */
  1477. switch(mode)
  1478. {
  1479. case XFR_READ:
  1480. if(fnp -> f_flags.f_ddir)
  1481. xfr_cnt = min(to_xfer,
  1482.  secsize - fnp -> f_boff);
  1483. else
  1484. xfr_cnt = min(min(to_xfer,
  1485.  secsize - fnp -> f_boff),
  1486.   fnp -> f_dir.dir_size - fnp -> f_offset);
  1487. fbcopy((BYTE FAR *)&bp -> b_buffer[fnp -> f_boff],
  1488.  buffer,
  1489.   xfr_cnt);
  1490. break;
  1492. #ifndef IPL
  1493. case XFR_WRITE:
  1494. xfr_cnt = min(to_xfer, secsize - fnp -> f_boff);
  1495. fbcopy(buffer,
  1496.  (BYTE FAR *)&bp -> b_buffer[fnp -> f_boff],
  1497.   xfr_cnt);
  1498. bp -> b_flag |= BFR_DIRTY;
  1499. break;
  1500. #endif
  1502. default:
  1503. *err =  DE_INVLDACC;
  1504. return ret_cnt;
  1505. }
  1507. /* update pointers and counters                         */
  1508. ret_cnt += xfr_cnt;
  1509. to_xfer -= xfr_cnt;
  1510. fnp -> f_offset += xfr_cnt;
  1511. buffer = add_far((VOID FAR *)buffer, (ULONG)xfr_cnt);
  1512. if(mode == XFR_WRITE && (fnp -> f_offset > fnp -> f_highwater))
  1513. fnp -> f_highwater = fnp -> f_offset;
  1514. }
  1515. *err = SUCCESS;
  1516. return ret_cnt;
  1517. }
  1519. COUNT 
  1520. dos_read (COUNT fd, VOID FAR *buffer, UCOUNT count)
  1521. {
  1522. COUNT err, xfr;
  1524. xfr = rdwrblock(fd, buffer, count, XFR_READ, &err);
  1525. return err != SUCCESS ? err : xfr;
  1526. }
  1529. #ifndef IPL
  1530. COUNT 
  1531. dos_write (COUNT fd, VOID FAR *buffer, UCOUNT count)
  1532. {
  1533. REG struct f_node FAR *fnp;
  1534. COUNT err, xfr;
  1536. /* First test if we need to fill to new EOF. */
  1538. /* Translate the fd into an fnode pointer, since all internal   */
  1539. /* operations are achieved through fnodes.                      */
  1540. fnp = xlt_fd(fd);
  1542. /* If the fd was invalid because it was out of range or the     */
  1543. /* requested file was not open, tell the caller and exit        */
  1544. /* note: an invalid fd is indicated by a 0 return               */
  1545. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  1546. {
  1547. return DE_INVLDHNDL;
  1548. }
  1550. /* Future note: for security purposes, this should be set to */
  1551. /* blocks of 0.  This satisfies spec and guarantees no secure */
  1552. /* info is written to disk. */
  1553. /* Also, with real memory management, this may cause a page */
  1554. /* fault. */
  1555. if(fnp -> f_offset > fnp -> f_highwater)
  1556. {
  1557. ULONG lCount = fnp -> f_offset - fnp -> f_highwater;
  1559. while(lCount > 0)
  1560. {
  1561. rdwrblock(fd, buffer,
  1562. lCount > 512l ? 512 : (UCOUNT)lCount,
  1563. XFR_WRITE, &err);
  1564. lCount -= 512;
  1565. }
  1566. }
  1568. xfr = rdwrblock(fd, buffer, count, XFR_WRITE, &err);
  1569. return err != SUCCESS ? err : xfr;
  1570. }
  1571. #endif
  1574. /* Position the file pointer to the desired offset                      */
  1575. /* Returns a long current offset or a negative error code               */
  1576. LONG 
  1577. dos_lseek (COUNT fd, LONG foffset, COUNT origin)
  1578. {
  1579. REG struct f_node FAR *fnp;
  1581. /* Translate the fd into a useful pointer                       */
  1583. fnp = xlt_fd(fd);
  1585. /* If the fd was invalid because it was out of range or the     */
  1586. /* requested file was not open, tell the caller and exit                */
  1587. /* note: an invalid fd is indicated by a 0 return               */
  1589. if(fnp == (struct f_node FAR *)0 || fnp -> f_count <= 0)
  1590. return (LONG)DE_INVLDHNDL;
  1592. /* now do the actual lseek adjustment to the file poitner       */
  1594. switch(origin)
  1595. {
  1596. /* offset from beginning of file                                */
  1597. case 0:
  1598. return fnp -> f_offset = (ULONG)foffset;
  1600. /* offset from current location                                 */
  1601. case 1:
  1602. return fnp -> f_offset += foffset;
  1604. /* offset from eof */
  1605. case 2:
  1606. return fnp -> f_offset = fnp -> f_highwater + foffset;
  1608. /* default to an invalid function                               */
  1609. default:
  1610. return (LONG)DE_INVLDFUNC;
  1611. }
  1612. }
  1615. UWORD 
  1616. dos_free (struct dpb *dpbp)
  1617. {
  1618. /* There's an unwritten rule here. All fs       */
  1619. /* cluster start at 2 and run to max_cluster+2  */
  1620. REG UWORD i, cnt = 0;
  1621. UWORD max_cluster = ((ULONG)dpbp -> dpb_size
  1622.     * (ULONG)dpbp -> dpb_clssize - dpbp -> dpb_data + 1)
  1623.     / dpbp -> dpb_clssize + 2; 
  1625. if(dpbp -> dpb_nfreeclst != UNKNCLUSTER)
  1626. return dpbp -> dpb_nfreeclst;
  1627. else
  1628. {
  1629. for(i = 2; i < max_cluster; i++)
  1630. {
  1631. if(next_cluster(dpbp, i) == 0)
  1632. ++cnt;
  1633. }
  1634. dpbp -> dpb_nfreeclst = cnt;
  1635. return cnt;
  1636. }
  1637. }
  1639. VOID 
  1640. dos_pwd (struct dpb *dpbp, BYTE FAR *s)
  1641. {
  1642. fsncopy((BYTE FAR *)&dpbp -> dpb_path[1], s, 64);
  1643. }
  1645. #ifndef IPL
  1646. COUNT 
  1647. dos_cd (struct dpb *dpbp, BYTE FAR *s)
  1648. {
  1649. BYTE FAR *p;
  1650. struct f_node FAR *fnp;
  1652. /* Get the current directory so that we initialize all access   */
  1653. /* relative to root.                                            */
  1654. truename(s, PriPathName);
  1656. /* now test for its existance. If it doesn't, return an error.  */
  1657. /* If it does, copy the path to the current directory           */
  1658. /* structure.                                                   */
  1659. if((fnp = dir_open((BYTE FAR *)PriPathName)) == NULL)
  1660. return DE_PATHNOTFND;
  1661. else
  1662. {
  1663. dir_close(fnp);
  1664. scopy(&PriPathName[2], dpbp -> dpb_path);
  1665. return SUCCESS;
  1666. }
  1667. }
  1668. #endif
  1671. struct f_node FAR *
  1672. get_f_node (void)
  1673. {
  1674. REG i;
  1676. for(i = 0; i < NFILES; i++)
  1677. {
  1678. if(f_nodes[i].f_count == 0)
  1679. {
  1680. ++f_nodes[i].f_count;
  1681. return &f_nodes[i];
  1682. }
  1683. }
  1684. return (struct f_node FAR *)0;
  1685. }
  1688. VOID 
  1689. release_f_node (struct f_node FAR *fnp)
  1690. {
  1691. if(fnp -> f_count > 0)
  1692. --fnp -> f_count;
  1693. else
  1694. fnp -> f_count = 0;
  1695. }
  1698. #ifndef IPL
  1699. VOID 
  1700. dos_setdta (BYTE FAR *newdta)
  1701. {
  1702. dta = newdta;
  1703. }
  1706. COUNT 
  1707. dos_getfattr (BYTE FAR *name, UWORD FAR *attrp)
  1708. {
  1709. struct f_node FAR *fnp;
  1710. COUNT fd;
  1712. /* Translate the fd into an fnode pointer, since all internal   */
  1713. /* operations are achieved through fnodes.                      */
  1714. if((fd = dos_open(name, O_RDONLY)) < SUCCESS)
  1715. return DE_FILENOTFND;
  1716. /* note: an invalid fd is indicated by a 0 return               */
  1717. if((fnp = xlt_fd(fd)) == (struct f_node FAR *)0)
  1718. return DE_TOOMANY;
  1720. /* If the fd was invalid because it was out of range or the     */
  1721. /* requested file was not open, tell the caller and exit        */
  1722. if(fnp -> f_count <= 0)
  1723. return DE_FILENOTFND;
  1725. /* Get the attribute from the fnode and return          */
  1726. *attrp = fnp -> f_dir.dir_attrib;
  1727. dos_close(fd);
  1728. return SUCCESS;
  1729. }
  1732. COUNT 
  1733. dos_setfattr (BYTE FAR *name, UWORD FAR *attrp)
  1734. {
  1735. struct f_node FAR *fnp;
  1736. COUNT fd;
  1738. /* Translate the fd into an fnode pointer, since all internal   */
  1739. /* operations are achieved through fnodes.                      */
  1740. if((fd = dos_open(name, O_RDONLY)) < SUCCESS)
  1741. return DE_FILENOTFND;
  1742. /* note: an invalid fd is indicated by a 0 return               */
  1743. if((fnp = xlt_fd(fd)) == (struct f_node FAR *)0)
  1744. return DE_TOOMANY;
  1746. /* If the fd was invalid because it was out of range or the     */
  1747. /* requested file was not open, tell the caller and exit        */
  1748. if(fnp -> f_count <= 0)
  1749. return DE_FILENOTFND;
  1751. /* Set the attribute from the fnode and return          */
  1752. fnp -> f_dir.dir_attrib = *attrp;
  1753. fnp -> f_flags.f_dmod = TRUE;
  1754. dos_close(fd);
  1755. return SUCCESS;
  1756. }
  1757. #endif
  1760. COUNT 
  1761. media_check (REG struct dpb *dpbp)
  1762. {
  1763. bpb FAR *bpbp;
  1764. ULONG   size;
  1765. REG     COUNT i;
  1767. /* First test if anyone has changed the removable media         */
  1768. FOREVER
  1769. {
  1770. MediaReqHdr.r_length = sizeof(request);
  1771. MediaReqHdr.r_unit = dpbp -> dpb_subunit;
  1772. MediaReqHdr.r_command = C_MEDIACHK;
  1773. MediaReqHdr.r_mcmdesc = dpbp -> dpb_mdb;
  1774. MediaReqHdr.r_status = 0;
  1775. execrh((request FAR *)&MediaReqHdr, dpbp -> dpb_device);
  1776. if(!(MediaReqHdr.r_status & S_ERROR) && (MediaReqHdr.r_status & S_DONE))
  1777. break;
  1778. else
  1779. {
  1780. loop1:
  1781. switch(block_error(&MediaReqHdr, dpbp -> dpb_unit))
  1782. {
  1783. case ABORT:
  1784. case FAIL:
  1785. return DE_INVLDDRV;
  1787. case RETRY:
  1788. continue;
  1790. case CONTINUE:
  1791. break;
  1793. default:
  1794. goto loop1;
  1795. }
  1796. }
  1797. }
  1799. switch(MediaReqHdr.r_mcretcode | dpbp -> dpb_flags)
  1800. {
  1801. case M_NOT_CHANGED:
  1802. /* It was definitely not changed, so ignore it          */
  1803. return SUCCESS;
  1805. /* If it is forced or the media may have changed,       */
  1806. /* rebuild the bpb                                      */
  1807. case M_DONT_KNOW:
  1808. flush_buffers(dpbp -> dpb_unit);
  1810. /* If it definitely changed, don't know (falls through) */
  1811. /* or has been changed, rebuild the bpb.                */
  1812. case M_CHANGED:
  1813. default:
  1814. setinvld(dpbp -> dpb_unit);
  1815. FOREVER
  1816. {
  1817. MediaReqHdr.r_length = sizeof(request);
  1818. MediaReqHdr.r_unit = dpbp -> dpb_subunit;
  1819. MediaReqHdr.r_command = C_BLDBPB;
  1820. MediaReqHdr.r_mcmdesc = dpbp -> dpb_mdb;
  1821. MediaReqHdr.r_status = 0;
  1822. execrh((request FAR *)&MediaReqHdr, dpbp -> dpb_device);
  1823. if(!(MediaReqHdr.r_status & S_ERROR) && (MediaReqHdr.r_status & S_DONE))
  1824. break;
  1825. else
  1826. {
  1827. loop2:
  1828. switch(block_error(&MediaReqHdr, dpbp -> dpb_unit))
  1829. {
  1830. case ABORT:
  1831. case FAIL:
  1832. return DE_INVLDDRV;
  1834. case RETRY:
  1835. continue;
  1837. case CONTINUE:
  1838. break;
  1840. default:
  1841. goto loop2;
  1842. }
  1843. }
  1844. }
  1845. bpbp = MediaReqHdr.r_bpptr;
  1846. dpbp -> dpb_mdb = bpbp -> bpb_mdesc;
  1847. dpbp -> dpb_secsize = bpbp -> bpb_nbyte;
  1848. dpbp -> dpb_clssize = bpbp -> bpb_nsector;
  1849. dpbp -> dpb_clsmask = bpbp -> bpb_nsector - 1;
  1850. dpbp -> dpb_fatstrt = bpbp -> bpb_nreserved;
  1851. dpbp -> dpb_fats = bpbp -> bpb_nfat;
  1852. dpbp -> dpb_dirents = bpbp -> bpb_ndirent;
  1853. size =  bpbp -> bpb_nsize == 0 ?
  1854.  bpbp -> bpb_huge :
  1855.  (ULONG)bpbp -> bpb_nsize;
  1856. dpbp -> dpb_size = size / ((ULONG)bpbp -> bpb_nsector);
  1857. dpbp -> dpb_fatsize = bpbp -> bpb_nfsect;
  1858. dpbp -> dpb_dirstrt = dpbp -> dpb_fatstrt
  1859. + dpbp -> dpb_fats * dpbp -> dpb_fatsize + 1;
  1860. dpbp -> dpb_data = dpbp -> dpb_dirstrt
  1861. + ((DIRENT_SIZE * dpbp -> dpb_dirents
  1862. + (dpbp -> dpb_secsize - 1))
  1863. / dpbp -> dpb_secsize);
  1864. dpbp -> dpb_flags = 0;
  1865. dpbp -> dpb_next = (struct dpb FAR *)-1;
  1866. dpbp -> dpb_cluster = UNKNCLUSTER;
  1867. dpbp -> dpb_nfreeclst = UNKNCLUSTER;
  1868. for(i = 1, dpbp -> dpb_shftcnt = 0;
  1869.  i < (sizeof(dpbp -> dpb_shftcnt) * 8); /* 8 bit bytes in C */
  1870.  dpbp -> dpb_shftcnt++, i <<= 1)
  1871. {
  1872. if(i >= bpbp -> bpb_nsector)
  1873. break;
  1874. }
  1875. return SUCCESS;
  1876. }
  1877. }
  1880. /* translate the fd into an f_node pointer                              */
  1882. struct f_node FAR *
  1883. xlt_fd (COUNT fd)
  1884. {
  1885. return fd > NFILES ? (struct f_node FAR *)0 : &f_nodes[fd];
  1886. }
  1889. COUNT 
  1890. xlt_fnp (struct f_node FAR *fnp)
  1891. {
  1892. return fnp - f_nodes;
  1893. }
  1896. struct dhdr FAR *
  1897. select_unit (COUNT drive)
  1898. {
  1899. /* Just get the header from the dhdr array                      */
  1900. return blk_devices[drive].dpb_device;
  1901. }