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

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

操作系统开发

开发平台：

DOS

DOSFNS.C：源码内容
  2. /****************************************************************/
  3. /*                                                              */
  4. /*                           dosfns.c                           */
  5. /*                                                              */
  6. /*                         DOS 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"
  32. #ifdef VERSION_STRINGS
  33. static BYTE *dosfnsRcsId = "$Header:   C:/dos-c/src/fs/dosfns.c_v   1.9   04 Jan 1998 23:14:38   patv  $";
  34. #endif
  36. /* $Logfile:   C:/dos-c/src/fs/dosfns.c_v  $ */
  38. /* $Log:   C:/dos-c/src/fs/dosfns.c_v  $
  39.  * 
  40.  *    Rev 1.9   04 Jan 1998 23:14:38   patv
  41.  * Changed Log for strip utility
  42.  * 
  43.  *    Rev 1.8   03 Jan 1998  8:36:04   patv
  44.  * Converted data area to SDA format
  45.  * 
  46.  *    Rev 1.7   22 Jan 1997 12:59:56   patv
  47.  * pre-0.92 bug fixes
  48.  * 
  49.  *    Rev 1.6   16 Jan 1997 12:46:32   patv
  50.  * pre-Release 0.92 feature additions
  51.  * 
  52.  *    Rev 1.5   29 May 1996 21:15:20   patv
  53.  * bug fixes for v0.91a
  54.  * 
  55.  *    Rev 1.4   19 Feb 1996  3:20:08   patv
  56.  * Added NLS, int2f and config.sys processing
  57.  * 
  58.  *    Rev 1.2   01 Sep 1995 17:48:48   patv
  59.  * First GPL release.
  60.  * 
  61.  *    Rev 1.1   30 Jul 1995 20:50:24   patv
  62.  * Eliminated version strings in ipl
  63.  * 
  64.  *    Rev 1.0   02 Jul 1995  8:04:20   patv
  65.  * Initial revision.
  66.  */
  67. /* $EndLog$ */
  69. #include "globals.h"
  71. #ifdef PROTO
  72. BOOL check_break(VOID);
  73. sft FAR *get_sft(COUNT);
  74. WORD get_free_hndl(VOID);
  75. sft FAR *get_free_sft(WORD FAR *);
  76. BYTE FAR *get_root(BYTE FAR *);
  77. BOOL cmatch(COUNT, COUNT, COUNT);
  78. BOOL fnmatch(BYTE FAR *, BYTE FAR *, COUNT, COUNT);
  79. #else
  80. BOOL check_break();
  81. sft FAR *get_sft();
  82. WORD get_free_hndl();
  83. sft FAR *get_free_sft();
  84. BYTE FAR *get_root();
  85. BOOL cmatch();
  86. BOOL fnmatch();
  87. #endif
  90. BOOL 
  91. check_break (void)
  92. {
  93. if(break_ena && con_break())
  94. {
  95. handle_break();
  96. /* shouldn't return, but in case...     */
  97. return TRUE;
  98. }
  99. else
  100. return FALSE;
  101. }
  104. sft FAR *get_sft(hndl)
  105. COUNT hndl;
  106. {
  107. psp FAR *p = MK_FP(cu_psp,0);
  108. WORD sys_idx;
  109. sfttbl FAR *sp;
  111. if (hndl >= p -> ps_maxfiles)
  112.     return (sft FAR *)-1;
  114. /* Get the SFT block that contains the SFT      */
  115. if (p -> ps_filetab[hndl] == 0xff)
  116.     return (sft FAR *)-1;
  118. sys_idx = p -> ps_filetab[hndl];
  119. for(sp = sfthead; sp != (sfttbl FAR *)-1; sp = sp -> sftt_next)
  120. {
  121. if(sys_idx < sp -> sftt_count)
  122. break;
  123. else
  124. sys_idx -= sp -> sftt_count;
  125. }
  127. /* If not found, return an error                */
  128. if(sp == (sfttbl FAR *)-1)
  129. return (sft FAR *)-1;
  131. /* finally, point to the right entry            */
  132. return (sft FAR *)&(sp -> sftt_table[sys_idx]);
  133. }
  136. UCOUNT 
  137. DosRead (COUNT hndl, UCOUNT n, BYTE FAR *bp, COUNT FAR *err)
  138. {
  139. sft FAR *s;
  140. WORD sys_idx;
  141. sfttbl FAR *sp;
  142. UCOUNT ReadCount;
  144. /* Test that the handle is valid                */
  145. if(hndl < 0)
  146. {
  147. *err = DE_INVLDHNDL;
  148. return 0;
  149. }
  151. /* Get the SFT block that contains the SFT      */
  152. if((s = get_sft(hndl)) == (sft FAR *)-1)
  153. {
  154. *err = DE_INVLDHNDL;
  155. return 0;
  156. }
  158. /* If not open or write permission - exit       */
  159. if(s -> sft_count == 0 || (s -> sft_mode & SFT_MWRITE))
  160. {
  161. *err = DE_INVLDACC;
  162. return 0;
  163. }
  165. /* Do a device read if device                   */
  166. if(s -> sft_flags & SFT_FDEVICE)
  167. {
  168. request rq;
  170. /* First test for eof and exit          */
  171. /* immediately if it is                 */
  172. if(!(s -> sft_flags & SFT_FEOF) || (s -> sft_flags & SFT_FNUL))
  173. {
  174. s -> sft_flags &= ~SFT_FEOF;
  175. *err = SUCCESS;
  176. return 0;
  177. }
  179. /* Now handle raw and cooked modes      */
  180. if(s -> sft_flags & SFT_FBINARY)
  181. {
  182. rq.r_length = sizeof(request);
  183. rq.r_command = C_INPUT;
  184. rq.r_count = n;
  185. rq.r_trans = (BYTE FAR *)bp;
  186. rq.r_status = 0;
  187. execrh((request FAR *)&rq, s -> sft_dev);
  188. if(rq.r_status & S_ERROR)
  189. {
  190. REG i;
  191. BYTE buff[FNAME_SIZE+1];
  193. fbcopy(s -> sft_name, (BYTE FAR *)buff, FNAME_SIZE);
  194. buff[FNAME_SIZE+1] = 0;
  195. for(i = FNAME_SIZE; i > 0; i--)
  196. if(buff[i] == ' ')
  197. buff[i] = 0;
  198. else
  199. break;
  200. char_error(&rq, buff);
  201. }
  202. else
  203. {
  204. *err = SUCCESS;
  205. return rq.r_count;
  206. }
  207. }
  208. else if(s -> sft_flags & SFT_FSTDIN)
  209. {
  210. if(!check_break())
  211. {
  212. kb_buf.kb_size = LINESIZE - 1;
  213. kb_buf.kb_count = 0;
  214. sti((keyboard FAR *)&kb_buf);
  215. fbcopy((BYTE FAR *)kb_buf.kb_buf, bp, kb_buf.kb_count);
  216. *err = SUCCESS;
  217. return kb_buf.kb_count;
  218. }
  219. else
  220. {
  221. *err = SUCCESS;
  222. return 0;
  223. }
  224. }
  225. else
  226. {
  227. if(!check_break())
  228. {
  229. *bp = _sti();
  230. *err = SUCCESS;
  231. return 1;
  232. }
  233. else
  234. {
  235. *err = SUCCESS;
  236. return 0;
  237. }
  238. }
  239. }
  240. else /* a block read                            */
  241. {
  242. if(!check_break())
  243. {
  244. COUNT rc;
  246. ReadCount = rdwrblock(s -> sft_status, bp, n, XFR_READ, &rc);
  247. if(rc != SUCCESS)
  248. {
  249. *err = rc;
  250. return 0;
  251. }
  252. else
  253. {
  254. *err = SUCCESS;
  255. return ReadCount;
  256. }
  257. }
  258. else
  259. {
  260. *err = SUCCESS;
  261. return 0;
  262. }
  263. }
  264. *err = SUCCESS;
  265. return 0;
  266. }
  268. UCOUNT 
  269. DosWrite (COUNT hndl, UCOUNT n, BYTE FAR *bp, COUNT FAR *err)
  270. {
  271. sft FAR *s;
  272. WORD sys_idx;
  273. sfttbl FAR *sp;
  274. UCOUNT ReadCount;
  276. /* Test that the handle is valid                */
  277. if(hndl < 0)
  278. {
  279. *err = DE_INVLDHNDL;
  280. return 0;
  281. }
  283. /* Get the SFT block that contains the SFT      */
  284. if((s = get_sft(hndl)) == (sft FAR *)-1)
  285. {
  286. *err = DE_INVLDHNDL;
  287. return 0;
  288. }
  290. /* If this is not opened and it's not a write   */
  291. /* another error                                */
  292. if(s -> sft_count == 0 ||
  293.  (!(s -> sft_mode & SFT_MWRITE) && !(s -> sft_mode & SFT_MRDWR)))
  294. {
  295. *err = DE_ACCESS;
  296. return 0;
  297. }
  299. /* Do a device write if device                  */
  300. if(s -> sft_flags & SFT_FDEVICE)
  301. {
  302. request rq;
  304. /* set to no EOF                        */
  305. s -> sft_flags &= ~SFT_FEOF;
  307. /* if null just report full transfer    */
  308. if(s -> sft_flags & SFT_FNUL)
  309. {
  310. *err = SUCCESS;
  311. return n;
  312. }
  314. /* Now handle raw and cooked modes      */
  315. if(s -> sft_flags & SFT_FBINARY)
  316. {
  317. rq.r_length = sizeof(request);
  318. rq.r_command = C_OUTPUT;
  319. rq.r_count = n;
  320. rq.r_trans = (BYTE FAR *)bp;
  321. rq.r_status = 0;
  322. execrh((request FAR *)&rq, s -> sft_dev);
  323. if(rq.r_status & S_ERROR)
  324. {
  325. REG i;
  326. BYTE buff[FNAME_SIZE+1];
  328. fbcopy(s -> sft_name, (BYTE FAR *)buff, FNAME_SIZE);
  329. buff[FNAME_SIZE+1] = 0;
  330. for(i = FNAME_SIZE; i > 0; i--)
  331. if(buff[i] == ' ')
  332. buff[i] = 0;
  333. else
  334. break;
  335. char_error(&rq, buff);
  336. }
  337. else
  338. {
  339. *err = SUCCESS;
  340. return rq.r_count;
  341. }
  342. }
  343. else
  344. {
  345. REG c, cnt = n, xfer = 0;
  347. while(cnt-- && (*bp != CTL_Z) && !check_break())
  348. {
  349. rq.r_length = sizeof(request);
  350. rq.r_command = C_OUTPUT;
  351. rq.r_count = 1;
  352. rq.r_trans = (BYTE FAR *)bp++;
  353. rq.r_status = 0;
  354. execrh((request FAR *)&rq, s -> sft_dev);
  355. if(rq.r_status & S_ERROR)
  356. {
  357. REG i;
  358. BYTE buff[FNAME_SIZE+1];
  360. fbcopy(s -> sft_name, (BYTE FAR *)buff, FNAME_SIZE);
  361. buff[FNAME_SIZE+1] = 0;
  362. for(i = FNAME_SIZE; i > 0; i--)
  363. if(buff[i] == ' ')
  364. buff[i] = 0;
  365. else
  366. break;
  367. char_error(&rq, buff);
  368. }
  369. ++xfer;
  370. }
  371. *err = SUCCESS;
  372. return xfer;
  373. }
  374. }
  375. else /* a block write                           */
  376. {
  377. if(!check_break())
  378. {
  379. COUNT rc;
  381. ReadCount = rdwrblock(s -> sft_status, bp, n, XFR_WRITE, &rc);
  382. if(rc < SUCCESS)
  383. {
  384. *err = rc;
  385. return 0;
  386. }
  387. else
  388. {
  389. *err = SUCCESS;
  390. return ReadCount;
  391. }
  392. }
  393. else
  394. {
  395. *err = SUCCESS;
  396. return 0;
  397. }
  398. }
  399. *err = SUCCESS;
  400. return 0;
  401. }
  403. COUNT 
  404. DosSeek (COUNT hndl, LONG new_pos, COUNT mode, ULONG *set_pos)
  405. {
  406. sft FAR *s;
  408. /* Test for invalid mode                        */
  409. if(mode < 0 || mode > 2)
  410. return DE_INVLDFUNC;
  412. /* Test that the handle is valid                */
  413. if(hndl < 0)
  414. return DE_INVLDHNDL;
  416. /* Get the SFT block that contains the SFT      */
  417. if((s = get_sft(hndl)) == (sft FAR *)-1)
  418. return DE_INVLDHNDL;
  420. /* Do special return for character devices      */
  421. if(s -> sft_flags & SFT_FDEVICE)
  422. {
  423. *set_pos = 0l;
  424. return SUCCESS;
  425. }
  426. else
  427. {
  428. *set_pos = dos_lseek(s -> sft_status, new_pos, mode);
  429. if((LONG)*set_pos < 0)
  430. return (int)*set_pos;
  431. else
  432. return SUCCESS;
  433. }
  434. }
  437. static WORD 
  438. get_free_hndl (void)
  439. {
  440. psp FAR *p = MK_FP(cu_psp,0);
  441. WORD hndl;
  443. for(hndl = 0; hndl < p -> ps_maxfiles; hndl++)
  444. {
  445. if(p -> ps_filetab[hndl] == 0xff)
  446. return hndl;
  447. }
  448. return 0xff;
  449. }
  451. static sft FAR *get_free_sft(sft_idx)
  452. WORD FAR *sft_idx;
  453. {
  454. WORD sys_idx = 0;
  455. sfttbl FAR *sp;
  457. /* Get the SFT block that contains the SFT      */
  458. for(sp = sfthead; sp != (sfttbl FAR *)-1; sp = sp -> sftt_next)
  459. {
  460. REG WORD i;
  462. for(i = 0; i < sp -> sftt_count; i++)
  463. {
  464. if(sp -> sftt_table[i].sft_count == 0)
  465. {
  466. *sft_idx = sys_idx + i;
  467. return (sft FAR *)&sp -> sftt_table[sys_idx + i];
  468. }
  469. }
  470. sys_idx += i;
  471. }
  472. /* If not found, return an error                */
  473. return (sft FAR *)-1;
  474. }
  477. static BYTE FAR *
  478. get_root (BYTE FAR *fname)
  479. {
  480. BYTE FAR *froot;
  481. REG WORD length;
  483. /* find the end                                 */
  484. for(length = 0, froot = fname; !froot != ''; ++froot)
  485. ++length;
  486. /* now back up to first path seperator or start */
  487. for(--froot; length > 0 && !(*froot == '/' || *froot == '\'); --froot)
  488. ;
  489. return ++froot;
  490. }
  493. /* Ascii only file name match routines                  */
  494. static BOOL 
  495. cmatch (COUNT s, COUNT d, COUNT mode)
  496. {
  497. if(s >= 'a' && s <= 'z')
  498. s -= 'a' - 'A';
  499. if(d >= 'a' && d <= 'z')
  500. d -= 'a' - 'A';
  501. if(mode && s == '?' && (d >= 'A' && s <= 'Z'))
  502. return TRUE;
  503. return s == d;
  504. }
  506. static BOOL 
  507. fnmatch (BYTE FAR *s, BYTE FAR *d, COUNT n, COUNT mode)
  508. {
  509. while(n--)
  510. {
  511. if(!cmatch(*s++, *d++, mode))
  512. return FALSE;
  513. }
  514. return TRUE;
  515. }
  518. #ifndef IPL
  519. COUNT 
  520. DosCreat (BYTE FAR *fname, COUNT attrib)
  521. {
  522. psp FAR *p = MK_FP(cu_psp,0);
  523. WORD hndl, sft_idx;
  524. sft FAR *sftp;
  525. struct dhdr FAR *dhp;
  526. BYTE FAR *froot;
  527. WORD i;
  529. /* get a free handle                            */
  530. if((hndl = get_free_hndl()) == 0xff)
  531. return DE_TOOMANY;
  533. /* now get a free system file table entry       */
  534. if((sftp = get_free_sft((WORD FAR *)&sft_idx)) == (sft FAR *)-1)
  535. return DE_TOOMANY;
  537. /* check for a device                           */
  538. froot = get_root(fname);
  539. for(i = 0; i < FNAME_SIZE; i++)
  540. {
  541. if(*froot != '' && *froot != '.')
  542. PriPathName[i] = *froot++;
  543. else
  544. break;
  545. }
  547. for( ; i < FNAME_SIZE; i++)
  548. PriPathName[i] = ' ';
  550. /* if we have an extension, can't be a device   */
  551. if(*froot != '.');
  552. {
  553. for(dhp = (struct dhdr FAR *)&nul_dev; dhp != (struct dhdr FAR *)-1; dhp = dhp -> dh_next)
  554. {
  555. if(fnmatch((BYTE FAR *)PriPathName, (BYTE FAR *)dhp -> dh_name, FNAME_SIZE, FALSE))
  556. {
  557. sftp -> sft_count += 1;
  558. sftp -> sft_mode = SFT_MRDWR;
  559. sftp -> sft_attrib = attrib;
  560. sftp -> sft_flags = 
  561.   (dhp -> dh_attr & ~SFT_MASK) | SFT_FDEVICE | SFT_FEOF;
  562. sftp -> sft_psp = cu_psp;
  563. fbcopy((BYTE FAR *)PriPathName, sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  564. sftp -> sft_dev = dhp;
  565. p -> ps_filetab[hndl] = sft_idx;
  566. return hndl;
  567. }
  568. }
  569. }
  570. sftp -> sft_status = dos_creat(fname, attrib);
  571. if(sftp -> sft_status >= 0)
  572. {
  573. p -> ps_filetab[hndl] = sft_idx;
  574. sftp -> sft_count += 1;
  575. sftp -> sft_mode = SFT_MRDWR;
  576. sftp -> sft_attrib = attrib;
  577. sftp -> sft_flags = 0;
  578. sftp -> sft_psp = cu_psp;
  579. fbcopy((BYTE FAR *)PriPathName, sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  580. return hndl;
  581. }
  582. else
  583. return sftp -> sft_status;
  584. }
  585. #endif
  588. COUNT 
  589. CloneHandle (COUNT hndl)
  590. {
  591. sft FAR *sftp;
  593. /* now get the system file table entry                          */
  594. if((sftp = get_sft(hndl)) == (sft FAR *)-1)
  595. return DE_INVLDHNDL;
  597. /* now that we have the system file table entry, get the fnode  */
  598. /* index, and increment the count, so that we've effectively    */
  599. /* cloned the file.                                             */
  600. sftp -> sft_count += 1;
  601. return hndl;
  602. }
  605. COUNT 
  606. DosDup (COUNT Handle)
  607. {
  608. psp FAR *p = MK_FP(cu_psp,0);
  609. COUNT NewHandle;
  610. sft FAR *Sftp;
  612. /* Get the SFT block that contains the SFT                      */
  613. if((Sftp = get_sft(Handle)) == (sft FAR *)-1)
  614. return DE_INVLDACC;
  616. /* If not open - exit                                           */
  617. if(Sftp -> sft_count <= 0)
  618. return DE_INVLDACC;
  620. /* now get a free handle                                        */
  621. if((NewHandle = get_free_hndl()) == 0xff)
  622. return DE_TOOMANY;
  624. /* If everything looks ok, bump it up.                          */
  625. if((Sftp -> sft_flags & SFT_FDEVICE) || (Sftp -> sft_status >= 0))
  626. {
  627. p -> ps_filetab[NewHandle] = p -> ps_filetab[Handle];
  628. Sftp -> sft_count += 1;
  629. return NewHandle;
  630. }
  631. else
  632. return DE_INVLDACC;
  633. }
  638. COUNT 
  639. DosForceDup (COUNT OldHandle, COUNT NewHandle)
  640. {
  641. psp FAR *p = MK_FP(cu_psp,0);
  642. sft FAR *Sftp;
  644. /* Get the SFT block that contains the SFT                      */
  645. if((Sftp = get_sft(OldHandle)) == (sft FAR *)-1)
  646. return DE_INVLDACC;
  648. /* If not open - exit                                           */
  649. if(Sftp -> sft_count <= 0)
  650. return DE_INVLDACC;
  652. /* now close the new handle if it's open                        */
  653. if(p -> ps_filetab[NewHandle] != 0xff)
  654. {
  655. COUNT ret;
  657. if((ret = DosClose(NewHandle)) != SUCCESS)
  658. return ret;
  659. }
  661. /* If everything looks ok, bump it up.                          */
  662. if((Sftp -> sft_flags & SFT_FDEVICE) || (Sftp -> sft_status >= 0))
  663. {
  664. p -> ps_filetab[NewHandle] = p -> ps_filetab[OldHandle];
  666. Sftp -> sft_count += 1;
  667. return SUCCESS;
  668. }
  669. else
  670. return DE_INVLDACC;
  671. }
  674. COUNT 
  675. DosOpen (BYTE FAR *fname, COUNT mode)
  676. {
  677. psp FAR *p = MK_FP(cu_psp,0);
  678. WORD hndl, sft_idx;
  679. sft FAR *sftp;
  680. struct dhdr FAR *dhp;
  681. BYTE FAR *froot;
  682. WORD i;
  684. /* test if mode is in range                     */
  685. if((mode & ~SFT_OMASK) != 0)
  686. return DE_INVLDACC;
  688. mode &= 3;
  690. if (cu_psp != DOS_PSP)
  691. {
  692.     /* get a free handle                            */
  693.     if((hndl = get_free_hndl()) == 0xff)
  694. return DE_TOOMANY;
  695. }
  697. /* now het a free system file table entry       */
  698. if((sftp = get_free_sft((WORD FAR *)&sft_idx)) == (sft FAR *)-1)
  699. return DE_TOOMANY;
  701. /* check for a device                           */
  702. froot = get_root(fname);
  703. for(i = 0; i < FNAME_SIZE; i++)
  704. {
  705. if(*froot != '' && *froot != '.')
  706. PriPathName[i] = *froot++;
  707. else
  708. break;
  709. }
  711. for( ; i < FNAME_SIZE; i++)
  712. PriPathName[i] = ' ';
  714. /* if we have an extension, can't be a device   */
  715. if(*froot != '.');
  716. {
  717. for(dhp = (struct dhdr FAR *)&nul_dev; dhp != (struct dhdr FAR *)-1; dhp = dhp -> dh_next)
  718. {
  719. if(fnmatch((BYTE FAR *)PriPathName, (BYTE FAR *)dhp -> dh_name, FNAME_SIZE, FALSE))
  720. {
  721. sftp -> sft_count += 1;
  722. sftp -> sft_mode = mode;
  723. sftp -> sft_attrib = 0;
  724. sftp -> sft_flags = 
  725.   (dhp -> dh_attr & ~SFT_MASK) | SFT_FDEVICE | SFT_FEOF;
  726. sftp -> sft_psp = cu_psp;
  727. fbcopy((BYTE FAR *)PriPathName, sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  728. sftp -> sft_dev = dhp;
  730. if (cu_psp != DOS_PSP)
  731.     p -> ps_filetab[hndl] = sft_idx;
  732. return hndl;
  733. }
  734. }
  735. }
  736. sftp -> sft_status = dos_open(fname, mode);
  737. if(sftp -> sft_status >= 0)
  738. {
  739. if (cu_psp != DOS_PSP)
  740.     p -> ps_filetab[hndl] = sft_idx;
  742. sftp -> sft_count += 1;
  743. sftp -> sft_mode = mode;
  744. sftp -> sft_attrib = 0;
  745. sftp -> sft_flags = 0;
  746. sftp -> sft_psp = cu_psp;
  747. fbcopy((BYTE FAR *)PriPathName, sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  748. return hndl;
  749. }
  750. else
  751. return sftp -> sft_status;
  752. }
  755. COUNT 
  756. DosClose (COUNT hndl)
  757. {
  758. psp FAR *p = MK_FP(cu_psp,0);
  759. sft FAR *s;
  761. /* Test that the handle is valid                */
  762. if(hndl < 0)
  763. return DE_INVLDHNDL;
  765. /* Get the SFT block that contains the SFT      */
  766. if((s = get_sft(hndl)) == (sft FAR *)-1)
  767. return DE_INVLDHNDL;
  769. /* If this is not opened another error          */
  770. if(s -> sft_count == 0)
  771. return DE_ACCESS;
  773. /* now just drop the count if a device, else    */
  774. /* call file system handler                     */
  775. if(s -> sft_flags & SFT_FDEVICE)
  776. {
  777. p -> ps_filetab[hndl] = 0xff;
  779. return SUCCESS;
  780. }
  781. else
  782. {
  783. p -> ps_filetab[hndl] = 0xff;
  784. s -> sft_count -= 1;
  785. if(s -> sft_count > 0)
  786. return SUCCESS;
  787. else
  788. return dos_close(s -> sft_status);
  789. }
  790. }
  792. VOID 
  793. DosGetFree (COUNT drive, COUNT FAR *spc, COUNT FAR *navc, COUNT FAR *bps, COUNT FAR *nc)
  794. {
  795. struct dpb *dpbp;
  797. /* first check for valid drive          */
  798. if(drive < 0 || drive > nblkdev)
  799. {
  800. *spc = -1;
  801. return;
  802. }
  804. /* next - "log" in the drive            */
  805. drive = (drive == 0 ? default_drive : drive - 1);
  806. dpbp = &blk_devices[drive];
  807. ++(dpbp -> dpb_count);
  808. // dpbp -> dpb_flags = -1;
  809. if((media_check(dpbp) < 0) || (dpbp -> dpb_count <= 0))
  810. {
  811. *spc = -1;
  812. return;
  813. }
  815. /* get the data vailable from dpb       */
  816. *nc = dpbp -> dpb_size;
  817. *spc = dpbp -> dpb_clssize;
  818. *bps = dpbp -> dpb_secsize;
  820. /* now tell fs to give us free cluster  */
  821. /* count                                */
  822. *navc = dos_free(dpbp);
  823. --(dpbp -> dpb_count);
  824. }
  827. COUNT 
  828. DosGetCuDir (COUNT drive, BYTE FAR *s)
  829. {
  830. REG struct dpb *dpbp;
  832. /* first check for valid drive          */
  833. if(drive < 0 || drive > nblkdev)
  834. return DE_INVLDDRV;
  836. /* next - "log" in the drive            */
  837. drive = (drive == 0 ? default_drive : drive - 1);
  838. dpbp = &blk_devices[drive];
  839. // dpbp -> dpb_flags = -1;
  840. ++(dpbp -> dpb_count);
  841. if((media_check(dpbp) < 0) || (dpbp -> dpb_count <= 0))
  842. return DE_INVLDDRV;
  844. /* now get fs to give current           */
  845. /* directory                            */
  846. dos_pwd(dpbp, s);
  847. --(dpbp -> dpb_count);
  848. return SUCCESS;
  849. }
  852. COUNT 
  853. DosChangeDir (BYTE FAR *s)
  854. {
  855. REG struct dpb *dpbp;
  856. REG COUNT drive;
  857. struct f_node FAR *fp;
  858. COUNT ret;
  860. /* test for path existance from fs      */
  861. if((fp = dir_open((BYTE FAR *)s)) == (struct f_node FAR *)0)
  862. return DE_PATHNOTFND;
  863. else
  864. dir_close(fp);
  866. /* Parse and extract drive              */
  867. if(*(s + 1) == ':')
  868. {
  869. drive = *s - '@';
  870. if (drive > 26) drive -= 'a' - 'A';
  871. }
  872. else
  873. drive = 0;
  875. /* first check for valid drive          */
  876. if(drive < 0 || drive > nblkdev)
  877. return DE_INVLDDRV;
  879. /* next - "log" in the drive            */
  880. drive = (drive == 0 ? default_drive : drive - 1);
  881. dpbp = &blk_devices[drive];
  882. ++(dpbp -> dpb_count);
  883. // dpbp -> dpb_flags = -1;
  884. if((media_check(dpbp) < 0) || (dpbp -> dpb_count <= 0))
  885. return DE_INVLDDRV;
  887. /* now get fs to change to new          */
  888. /* directory                            */
  889. ret = dos_cd(dpbp, s);
  890. --(dpbp -> dpb_count);
  891. return ret;
  892. }
  894. COUNT 
  895. DosFindFirst (UCOUNT attr, BYTE FAR *name)
  896. {
  897. return dos_findfirst(attr, name);
  898. }
  901. COUNT 
  902. DosFindNext (void)
  903. {
  904. return dos_findnext();
  905. }
  908. #ifndef IPL
  909. COUNT DosGetFtime(hndl, dp, tp)
  910. COUNT hndl;
  911. date FAR *dp;
  912. time FAR *tp;
  913. {
  914. sft FAR *s;
  915. sfttbl FAR *sp;
  917. /* Test that the handle is valid                */
  918. if(hndl < 0)
  919. return DE_INVLDHNDL;
  921. /* Get the SFT block that contains the SFT      */
  922. if((s = get_sft(hndl)) == (sft FAR *)-1)
  923. return DE_INVLDHNDL;
  925. /* If this is not opened another error          */
  926. if(s -> sft_count == 0)
  927. return DE_ACCESS;
  929. /* call file system handler                     */
  930. return dos_getftime(s -> sft_status, dp, tp);
  931. }
  933. COUNT DosSetFtime(hndl, dp, tp)
  934. COUNT hndl;
  935. date FAR *dp;
  936. time FAR *tp;
  937. {
  938. sft FAR *s;
  939. sfttbl FAR *sp;
  941. /* Test that the handle is valid                */
  942. if(hndl < 0)
  943. return DE_INVLDHNDL;
  945. /* Get the SFT block that contains the SFT      */
  946. if((s = get_sft(hndl)) == (sft FAR *)-1)
  947. return DE_INVLDHNDL;
  949. /* If this is not opened another error          */
  950. if(s -> sft_count == 0)
  951. return DE_ACCESS;
  953. /* call file system handler                     */
  954. return dos_setftime(s -> sft_status, dp, tp);
  955. }
  956. #endif
  958. COUNT 
  959. DosGetFattr (BYTE FAR *name, UWORD FAR *attrp)
  960. {
  961. return dos_getfattr(name, attrp);
  962. }
  965. COUNT 
  966. DosSetFattr (BYTE FAR *name, UWORD FAR *attrp)
  967. {
  968. return dos_setfattr(name, attrp);
  969. }