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

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

操作系统开发

开发平台：

DOS

FATDIR.C：源码内容
  1. /****************************************************************/
  2. /*                                                              */
  3. /*                          fatdir.c                            */
  4. /*                            DOS-C                             */
  5. /*                                                              */
  6. /*                 FAT File System dir 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"
  33. /* $Logfile:   C:/dos-c/src/fs/fatdir.c_v  $ */
  34. #ifdef VERSION_STRINGS
  35. static BYTE *fatdirRcsId = "$Header:   C:/dos-c/src/fs/fatdir.c_v   1.9   22 Jan 1998  4:09:00   patv  $";
  36. #endif
  38. /* $Log:   C:/dos-c/src/fs/fatdir.c_v  $
  39.  * 
  40.  *    Rev 1.9   22 Jan 1998  4:09:00   patv
  41.  * Fixed pointer problems affecting SDA
  42.  * 
  43.  *    Rev 1.8   04 Jan 1998 23:14:36   patv
  44.  * Changed Log for strip utility
  45.  * 
  46.  *    Rev 1.7   03 Jan 1998  8:36:02   patv
  47.  * Converted data area to SDA format
  48.  * 
  49.  *    Rev 1.6   16 Jan 1997 12:46:30   patv
  50.  * pre-Release 0.92 feature additions
  51.  * 
  52.  *    Rev 1.5   29 May 1996 21:15:18   patv
  53.  * bug fixes for v0.91a
  54.  * 
  55.  *    Rev 1.4   19 Feb 1996  3:20:12   patv
  56.  * Added NLS, int2f and config.sys processing
  57.  * 
  58.  *    Rev 1.2   01 Sep 1995 17:48:38   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:34   patv
  65.  * Initial revision.
  66.  */
  67. /* $EndLog$ */
  69. VOID pop_dmp(dmatch FAR *, struct f_node FAR *);
  71. struct f_node FAR *
  72. dir_open (BYTE FAR *dirname)
  73. {
  74. struct f_node FAR *fnp;
  75. COUNT drive;
  76. BYTE *p;
  77. WORD i;
  78. BYTE *s, *pszPath = &TempCDS.cdsCurrentPath[2];
  80. /* Allocate an fnode if possible - error return (0) if not.     */
  81. if((fnp = get_f_node()) == (struct f_node FAR *)0)
  82. {
  83. return (struct f_node FAR *)NULL;
  84. }
  86. /* Force the fnode into read-write mode                         */
  87. fnp -> f_mode = RDWR;
  89. /* and initialize temporary CDS */
  90. TempCDS.cdsFlags = 0;
  92. /* determine what drive we are using...                         */
  93. dirname = adjust_far(dirname);
  94. ParseDosName(dirname, &drive, (BYTE *)0, (BYTE *)0, (BYTE *)0);
  96. /* If the drive was specified, drive is non-negative and */
  97. /* corresponds to the one passed in, i.e., 0 = A, 1 = B, etc. */
  98. /* We use that and skip the "D:" part of the string. */
  99. /* Otherwise, just use the default drive */ 
  100. if(drive >= 0)
  101. {
  102. dirname += 2; /* Assume FAT style drive */
  103. TempCDS.cdsDpb = &blk_devices[drive];
  104. }
  105. else
  106. {
  107. TempCDS.cdsDpb = &blk_devices[drive = default_drive];
  108. }
  109. fnp -> f_dpb = (struct dpb *)TempCDS.cdsDpb;
  110. TempCDS.cdsCurrentPath[0] = 'A' + drive;
  111. TempCDS.cdsCurrentPath[1] = ':';
  112. TempCDS.cdsJoinOffset = 2;
  114. if (drive >= nblkdev)
  115. {
  116. release_f_node(fnp);
  117. return NULL;
  118. }
  120. /* Generate full path name                                      */
  121. ParseDosPath(dirname,
  122.  (COUNT *)0, pszPath, (BYTE *)TempCDS.cdsDpb -> dpb_path);
  124. /* Perform all directory common handling after all special */
  125. /* handling has been performed. */
  126. ++TempCDS.cdsDpb -> dpb_count;
  128. if(media_check((struct dpb *)TempCDS.cdsDpb) < 0)
  129. {
  130. --TempCDS.cdsDpb -> dpb_count;
  131. release_f_node(fnp);
  132. return (struct f_node FAR *)0;
  133. }
  134. fnp -> f_diroff = 0l;
  135. fnp -> f_flags.f_dmod = FALSE;  /* a brand new fnode */
  136. fnp -> f_flags.f_dnew = TRUE;
  137. fnp -> f_dsize = DIRENT_SIZE * TempCDS.cdsDpb -> dpb_dirents;
  140. /* Walk the directory tree to find the starting cluster */
  141. /* */
  142. /* Set the root flags since we always start from the root */
  144. fnp -> f_flags.f_droot = TRUE;
  145. for(p = pszPath; *p != ''; )
  146. {
  147. /* skip all path seperators */
  148. while(*p == '\')
  149. ++p;
  150. /* don't continue if we're at the end */
  151. if(*p == '')
  152. break;
  154. /* Convert the name into an absolute name for */
  155. /* comparison... */
  156. /* first the file name with trailing spaces... */
  157. for(i = 0; i < FNAME_SIZE; i++)
  158. {
  159. if(*p != '' && *p != '.' && *p != '/' && *p != '\')
  160. TempBuffer[i] = *p++;
  161. else
  162. break;
  163. }
  165. for( ; i < FNAME_SIZE; i++)
  166. TempBuffer[i] = ' ';
  168. /* and the extension (don't forget to   */
  169. /* add trailing spaces)...              */
  170. if(*p == '.')
  171. ++p;
  172. for(i = 0; i < FEXT_SIZE; i++)
  173. {
  174. if(*p != '' && *p != '.' && *p != '/' && *p != '\')
  175. TempBuffer[i+FNAME_SIZE] = *p++;
  176. else
  177. break;
  178. }
  179. for( ; i < FEXT_SIZE; i++)
  180. TempBuffer[i+FNAME_SIZE] = ' ';
  182. /* Now search through the directory to  */
  183. /* find the entry...                    */
  184. i = FALSE;
  186. upMem((BYTE FAR *)TempBuffer, FNAME_SIZE+FEXT_SIZE);
  188. while(dir_read(fnp) == DIRENT_SIZE)
  189. {
  190. if(fnp -> f_dir.dir_name[0] != '' && fnp -> f_dir.dir_name[0] != DELETED)
  191. {
  192. if(fcmp((BYTE FAR *)TempBuffer, (BYTE FAR *)fnp -> f_dir.dir_name, FNAME_SIZE+FEXT_SIZE))
  193. {
  194. i = TRUE;
  195. break;
  196. }
  197. }
  198. }
  200. if(!i || !(fnp -> f_dir.dir_attrib & D_DIR))
  201. {
  202. --TempCDS.cdsDpb -> dpb_count;
  203. release_f_node(fnp);
  204. return (struct f_node FAR *)0;
  205. }
  206. else
  207. {
  208. /* make certain we've moved off */
  209. /* root                         */
  210. fnp -> f_flags.f_droot = FALSE;
  211. fnp -> f_flags.f_ddir = TRUE;
  212. /* set up for file read/write   */
  213. fnp -> f_offset = 0l;
  214. fnp -> f_highwater = 0l;
  215. fnp -> f_cluster = fnp -> f_dir.dir_start;
  216. fnp -> f_dirstart = fnp -> f_dir.dir_start;
  217. /* reset the directory flags    */
  218. fnp -> f_diroff = 0l;
  219. fnp -> f_flags.f_dmod = FALSE;
  220. fnp -> f_flags.f_dnew = TRUE;
  221. fnp -> f_dsize = DIRENT_SIZE * TempCDS.cdsDpb -> dpb_dirents;
  222. }
  223. }
  225. return fnp;
  226. }
  229. COUNT 
  230. dir_read (REG struct f_node FAR *fnp)
  231. {
  232. REG i, j;
  233. struct buffer FAR *bp;
  235. /* Directories need to point to their current offset, not for   */
  236. /* next op. Therefore, if it is anything other than the first   */
  237. /* directory entry, we will update the offset on entry rather   */
  238. /* than wait until exit. If it was new, clear the special new   */
  239. /* flag.                                                        */
  240. if(fnp -> f_flags.f_dnew)
  241. fnp -> f_flags.f_dnew = FALSE;
  242. else
  243. fnp -> f_diroff += DIRENT_SIZE;
  245. /* Determine if we hit the end of the directory. If we have,    */
  246. /* bump the offset back to the end and exit. If not, fill the   */
  247. /* dirent portion of the fnode, clear the f_dmod bit and leave, */
  248. /* but only for root directories                                */
  249. if(!(fnp -> f_flags.f_droot)
  250.   && fnp -> f_diroff >= fnp -> f_dsize)
  251. {
  252. fnp -> f_diroff -= DIRENT_SIZE;
  253. return 0;
  254. }
  255. else
  256. {
  257. if(fnp -> f_flags.f_droot)
  258. {
  259. if((fnp -> f_diroff / fnp -> f_dpb -> dpb_secsize
  260.   + fnp -> f_dpb -> dpb_dirstrt)
  261.   >= fnp -> f_dpb -> dpb_data)
  262. {
  263. fnp -> f_flags.f_dfull = TRUE;
  264. return 0;
  265. }
  267. bp = getblock((LONG)(fnp -> f_diroff / fnp -> f_dpb -> dpb_secsize
  268. + fnp -> f_dpb -> dpb_dirstrt),
  269. fnp -> f_dpb -> dpb_unit);
  270. bp -> b_flag &= ~(BFR_DATA | BFR_FAT);
  271. bp -> b_flag |= BFR_DIR;
  273. }
  274. else
  275. {
  276. REG UWORD secsize = fnp -> f_dpb -> dpb_secsize;
  278. /* Do a "seek" to the directory position        */
  279. fnp -> f_offset = fnp -> f_diroff;
  281. /* Search through the FAT to find the block     */
  282. /* that this entry is in.                       */
  283. if(map_cluster(fnp, XFR_READ) != SUCCESS)
  284. {
  285. fnp -> f_flags.f_dfull = TRUE;
  286. return 0;
  287. }
  289. /* If the returned cluster is FREE, return zero */
  290. /* bytes read.                                  */
  291. if(fnp -> f_cluster == FREE)
  292. return 0;
  294. /* If the returned cluster is LAST_CLUSTER or   */
  295. /* LONG_LAST_CLUSTER, return zero bytes read    */
  296. /* and set the directory as full.               */
  298. if(last_link(fnp))
  299. {
  300. fnp -> f_diroff -= DIRENT_SIZE;
  301. fnp -> f_flags.f_dfull = TRUE;
  302. return 0;
  303. }
  305. /* Compute the block within the cluster and the */
  306. /* offset within the block.                     */
  307. fnp -> f_sector =
  308.  (fnp -> f_offset / secsize)
  309.   & fnp -> f_dpb -> dpb_clsmask;
  310. fnp -> f_boff = fnp -> f_offset % secsize;
  312. /* Get the block we need from cache             */
  313. bp = getblock(
  314. (LONG)clus2phys(fnp -> f_cluster,
  315. fnp -> f_dpb -> dpb_clssize,
  316. fnp -> f_dpb -> dpb_data)
  317.  + fnp -> f_sector,
  318. fnp -> f_dpb -> dpb_unit);
  319. bp -> b_flag &= ~(BFR_DATA | BFR_FAT);
  320. bp -> b_flag |= BFR_DIR;
  321. }
  323. /* Now that we have the block for our entry, get the    */
  324. /* directory entry.                                     */
  325. if(bp != NULL)
  326. getdirent((BYTE FAR *)&bp -> b_buffer[fnp -> f_diroff % fnp -> f_dpb -> dpb_secsize],
  327. (struct dirent FAR *)&fnp -> f_dir);
  328. else
  329. {
  330. fnp -> f_flags.f_dfull = TRUE;
  331. return 0;
  332. }
  334. /* Update the fnode's directory info                    */
  335. fnp -> f_flags.f_dfull = FALSE;
  336. fnp -> f_flags.f_dmod = FALSE;
  338. /* and for efficiency, stop when we hit the first       */
  339. /* unused entry.                                        */
  340. if(fnp -> f_dir.dir_name[0] == '')
  341. return 0;
  342. else
  343. return DIRENT_SIZE;
  344. }
  345. }
  348. #ifndef IPL
  349. COUNT 
  350. dir_write (REG struct f_node FAR *fnp)
  351. {
  352. struct buffer FAR *bp;
  354. /* Update the entry if it was modified by a write or create...  */
  355. if(fnp -> f_flags.f_dmod)
  356. {
  358. /* Root is a consecutive set of blocks, so handling is  */
  359. /* simple.                                              */
  360. if(fnp -> f_flags.f_droot)
  361. {
  362. bp =
  363.  getblock(
  364.   (LONG)(fnp -> f_diroff / fnp -> f_dpb -> dpb_secsize
  365.    + fnp -> f_dpb -> dpb_dirstrt),
  366.     fnp -> f_dpb -> dpb_unit);
  367. bp -> b_flag &= ~(BFR_DATA | BFR_FAT);
  368. bp -> b_flag |= BFR_DIR;
  369. }
  371. /* All other directories are just files. The only       */
  372. /* special handling is resetting the offset so that we  */
  373. /* can continually update the same directory entry.     */
  374. else
  375. {
  376. REG UWORD secsize = fnp -> f_dpb -> dpb_secsize;
  378. /* Do a "seek" to the directory position        */
  379. /* and convert the fnode to a directory fnode.  */
  380. fnp -> f_offset = fnp -> f_diroff;
  381. fnp -> f_back = LONG_LAST_CLUSTER;
  382. fnp -> f_cluster = fnp -> f_dirstart;
  384. /* Search through the FAT to find the block     */
  385. /* that this entry is in.                       */
  386. if(map_cluster(fnp, XFR_READ) != SUCCESS)
  387. {
  388. fnp -> f_flags.f_dfull = TRUE;
  389. release_f_node(fnp);
  390. return 0;
  391. }
  393. /* If the returned cluster is FREE, return zero */
  394. /* bytes read.                                  */
  395. if(fnp -> f_cluster == FREE)
  396. {
  397. release_f_node(fnp);
  398. return 0;
  399. }
  401. /* Compute the block within the cluster and the */
  402. /* offset within the block.                     */
  403. fnp -> f_sector =
  404.  (fnp -> f_offset / secsize)
  405.   & fnp -> f_dpb -> dpb_clsmask;
  406. fnp -> f_boff = fnp -> f_offset % secsize;
  409. /* Get the block we need from cache             */
  410. bp = getblock(
  411. (LONG)clus2phys(fnp -> f_cluster,
  412. fnp -> f_dpb -> dpb_clssize,
  413. fnp -> f_dpb -> dpb_data)
  414.  + fnp -> f_sector,
  415. fnp -> f_dpb -> dpb_unit);
  416. bp -> b_flag &= ~(BFR_DATA | BFR_FAT);
  417. bp -> b_flag |= BFR_DIR;
  418. }
  420. /* Now that we have a block, transfer the diectory      */
  421. /* entry into the block.                                */
  422. if(bp == NULL)
  423. {
  424. release_f_node(fnp);
  425. return 0;
  426. }
  427. putdirent((struct dirent FAR *)&fnp -> f_dir,
  428.  (VOID FAR *)&bp -> b_buffer[fnp -> f_diroff % fnp -> f_dpb -> dpb_secsize]);
  429. bp -> b_flag |= BFR_DIRTY;
  430. }
  431. return DIRENT_SIZE;
  432. }
  433. #endif
  436. VOID 
  437. dir_close (REG struct f_node FAR *fnp)
  438. {
  439. REG COUNT disk = fnp -> f_dpb -> dpb_unit;
  441. /* Test for invalid f_nodes                                     */
  442. if(fnp == NULL)
  443. return;
  445. #ifndef IPL
  446. /* Write out the entry                                          */
  447. dir_write(fnp);
  449. #endif 
  450. /* Clear buffers after release                                  */
  451. flush_buffers(disk);
  452. setinvld(disk);
  454. /* and release this instance of the fnode                       */
  455. --(fnp -> f_dpb) -> dpb_count;
  456. release_f_node(fnp);
  457. }
  460. #ifndef IPL
  461. COUNT 
  462. dos_findfirst (UCOUNT attr, BYTE FAR *name)
  463. {
  464. REG struct f_node FAR *fnp;
  465. REG dmatch FAR *dmp = (dmatch FAR *)dta;
  466. REG COUNT i;
  467. COUNT nDrive;
  468. BYTE *p;
  470. /* The findfirst/findnext calls are probably the worst of the   */
  471. /* DOS calls. They must work somewhat on the fly (i.e. - open   */
  472. /* but never close). Since we don't want to lose fnodes every   */
  473. /* time a directory is searched, we will initialize the DOS     */
  474. /* dirmatch structure and then for every find, we will open the */
  475. /* current directory, do a seek and read, then close the fnode. */
  476.    
  477. /* Start out by initializing the dirmatch structure.            */
  478. dmp -> dm_drive = default_drive;
  479. dmp -> dm_entry = 0;
  480. dmp -> dm_cluster = 0;
  482. dmp -> dm_attr_srch = attr;
  484. /* Parse out the drive, file name and file extension. */
  485. ParseDosName(name, &nDrive, &LocalPath[2],
  486. SearchDir.dir_name, SearchDir.dir_ext);
  488. if(nDrive >= 0)
  489. {
  490. dmp -> dm_drive = nDrive;
  491. }
  492. else
  493. nDrive = default_drive;
  495. /* Now build a directory. */
  496. if(!LocalPath[2])
  497. strcpy(&LocalPath[2], ".");
  499. /* Build the match pattern out of the passed string             */
  500. for(p = SearchDir.dir_name, i = 0; i < FNAME_SIZE; i++)
  501. {
  502. /* test for a valid file name terminator                */
  503. if(*p != '')
  504. {
  505. /* If not a wildcard ('*'), just transfer       */
  506. if(*p != '*')
  507. dmp -> dm_name_pat[i] = *p++;
  508. else
  509. {
  510. /* swallow the wildcard                 */
  511. ++p;
  513. /* fill with character wildcard (?)     */
  514. for( ; i < FNAME_SIZE; i++)
  515. dmp -> dm_name_pat[i] = '?';
  516. /* and skip to seperator                */
  517. while(*p != ''
  518.  && *p != '.' && *p != '/' && *p != '\')
  519. ++p;
  521. break;
  522. }
  523. }
  524. else
  525. break;
  526. }
  527. for( ; i < FNAME_SIZE; i++)
  528. dmp -> dm_name_pat[i] = ' ';
  530. /* and the extension (don't forget to add trailing spaces)...   */
  531. i = 0;
  532. for(p = SearchDir.dir_ext; i < FEXT_SIZE; i++)
  533. {
  534. if(*p != '' && *p != '.' && *p != '/' && *p != '\')
  535. {
  536. if(*p != '*')
  537. dmp -> dm_name_pat[i+FNAME_SIZE] = *p++;
  538. else
  539. {
  540. for( ; i < FEXT_SIZE; i++)
  541. dmp -> dm_name_pat[i+FNAME_SIZE] = '?';
  542. break;
  543. }
  544. }
  545. else
  546. break;
  547. }
  548. for( ; i < FEXT_SIZE; i++)
  549. dmp -> dm_name_pat[i+FNAME_SIZE] = ' ';
  551. /* Now search through the directory to find the entry...        */
  552. upMem((BYTE FAR *)dmp -> dm_name_pat, FNAME_SIZE+FEXT_SIZE);
  554. /* Special handling - the volume id is only in the root         */
  555. /* directory and only searched for once.  So we need to open    */
  556. /* the root and return only the first entry that contains the   */
  557. /* volume id bit set.                                           */
  558. if(attr & D_VOLID)
  559. {
  560. /* Now open this directory so that we can read the      */
  561. /* fnode entry and do a match on it.                    */
  562. if((fnp = dir_open((BYTE FAR *)"\")) == NULL)
  563. return DE_PATHNOTFND;
  565. /* Now do the search                                    */
  566. while(dir_read(fnp) == DIRENT_SIZE)
  567. {
  568. /* Test the attribute and return first found    */
  569. if(fnp -> f_dir.dir_attrib & D_VOLID)
  570. {
  571. pop_dmp(dmp, fnp);
  572. dir_close(fnp);
  573. return SUCCESS;
  574. }
  575. }
  577. /* Now that we've done our failed search, close it and  */
  578. /* return an error.                                     */
  579. dir_close(fnp);
  580. return DE_FILENOTFND;
  581. }
  583. /* Otherwise just do a normal find next                         */
  584. else
  585. {
  586. /* Complete building the directory from the passed in */
  587. /* name */
  588. if(nDrive >= 0)
  589. {
  590. LocalPath[0] = 'A' + nDrive;
  591. }
  592. else
  593. {
  594. LocalPath[0] = 'A' + default_drive;
  595. }
  596. LocalPath[1] = ':';
  598. /* Now open this directory so that we can read the      */
  599. /* fnode entry and do a match on it.                    */
  600. if((fnp = dir_open((BYTE FAR *)LocalPath)) == NULL)
  601. return DE_PATHNOTFND;
  603. pop_dmp(dmp, fnp);
  604. dmp -> dm_entry = 0;
  605. if(!fnp -> f_flags.f_droot)
  606. {        
  607. dmp -> dm_cluster = fnp -> f_dirstart;
  608. dmp -> dm_dirstart = fnp -> f_dirstart;
  609. }
  610. else
  611. {
  612. dmp -> dm_cluster = 0;
  613. dmp -> dm_dirstart = 0;
  614. }
  615. dir_close(fnp);
  616. return dos_findnext();
  617. }
  618. }
  621. COUNT 
  622. dos_findnext (void)
  623. {
  624. REG dmatch FAR *dmp = (dmatch FAR *)dta;
  625. REG struct f_node FAR *fnp;
  626. BOOL found = FALSE;
  627. BYTE FAR *p, *q;
  629. /* assign our match parameters pointer.                         */
  630. dmp = (dmatch FAR *)dta;
  632. /* Allocate an fnode if possible - error return (0) if not.     */
  633. if((fnp = get_f_node()) == (struct f_node FAR *)0)
  634. {
  635. return DE_FILENOTFND;
  636. }
  638. /* Force the fnode into read-write mode                         */
  639. fnp -> f_mode = RDWR;
  641. /* Select the default to help non-drive specified path          */
  642. /* searches...                                                  */
  643. fnp -> f_dpb = &blk_devices[dmp -> dm_drive];
  644. ++(fnp -> f_dpb) -> dpb_count;
  645. if(media_check(fnp -> f_dpb) < 0)
  646. {
  647. --(fnp -> f_dpb) -> dpb_count;
  648. release_f_node(fnp);
  649. return DE_FILENOTFND;
  650. }
  653. fnp -> f_dsize = DIRENT_SIZE * (fnp -> f_dpb) -> dpb_dirents;
  655. /* Search through the directory to find the entry, but do a     */
  656. /* seek first.                                                  */
  657. if(dmp -> dm_entry > 0)
  658. fnp -> f_diroff = (dmp -> dm_entry - 1) * DIRENT_SIZE;
  660. fnp -> f_offset = fnp -> f_highwater = fnp -> f_diroff;
  661. fnp -> f_cluster = dmp -> dm_cluster;
  662. fnp -> f_flags.f_dmod = dmp -> dm_flags.f_dmod;
  663. fnp -> f_flags.f_droot = dmp -> dm_flags.f_droot;
  664. fnp -> f_flags.f_dnew = dmp -> dm_flags.f_dnew;
  665. fnp -> f_flags.f_ddir = dmp -> dm_flags.f_ddir;
  666. fnp -> f_flags.f_dfull = dmp -> dm_flags.f_dfull;
  668. fnp -> f_dirstart = dmp -> dm_dirstart;
  670. /* Loop through the directory                                   */
  671. while(dir_read(fnp) == DIRENT_SIZE)
  672. {
  673. ++dmp -> dm_entry;
  674. if(fnp -> f_dir.dir_name[0] != '' && fnp -> f_dir.dir_name[0] != DELETED)
  675. {
  676. if(fcmp_wild((BYTE FAR *)(dmp -> dm_name_pat), (BYTE FAR *)fnp -> f_dir.dir_name, FNAME_SIZE+FEXT_SIZE))
  677. {
  678. /* Test the attribute as the final step */
  679. if(fnp -> f_dir.dir_attrib & D_VOLID)
  680. continue;
  681. else if(
  682.  ((~(dmp -> dm_attr_srch | D_ARCHIVE | D_RDONLY) 
  683.   & fnp -> f_dir.dir_attrib)
  684.  & (D_DIR | D_SYSTEM | D_HIDDEN)) == 0)
  685. {
  686. found = TRUE;
  687. break;
  688. }
  689. else
  690. continue;
  691. }
  692. }
  693. }
  695. /* If found, transfer it to the dmatch structure                */
  696. if(found)
  697. pop_dmp(dmp, fnp);
  699. /* return the result                                            */
  700. --(fnp -> f_dpb) -> dpb_count;
  701. release_f_node(fnp);
  703. return found ? SUCCESS : DE_FILENOTFND;
  704. }
  706. static VOID pop_dmp(dmp, fnp)
  707. dmatch FAR *dmp;
  708. struct f_node FAR *fnp;
  709. {
  710. COUNT idx;
  711. BYTE FAR *p;
  712. BYTE FAR *q;
  714. dmp -> dm_attr_fnd = fnp -> f_dir.dir_attrib;
  715. dmp -> dm_time = fnp -> f_dir.dir_time;
  716. dmp -> dm_date = fnp -> f_dir.dir_date;
  717. dmp -> dm_size = fnp -> f_dir.dir_size;
  718. /* dmp -> dm_cluster = fnp -> f_cluster; */
  719. dmp -> dm_flags.f_droot = fnp -> f_flags.f_droot;
  720. dmp -> dm_flags.f_ddir = fnp -> f_flags.f_ddir;
  721. dmp -> dm_flags.f_dmod = fnp -> f_flags.f_dmod;
  722. dmp -> dm_flags.f_dnew = fnp -> f_flags.f_dnew;
  723. p = dmp -> dm_name;
  724. if(fnp -> f_dir.dir_name[0] == '.')
  725. {
  726. for(idx = 0, q = (BYTE FAR *)fnp -> f_dir.dir_name;
  727.  idx < FNAME_SIZE; idx++)
  728. {
  729. if(*q == ' ')
  730. break;
  731. *p++ = *q++;
  732. }
  733. }
  734. else
  735. {
  736. for(idx = 0, q = (BYTE FAR *)fnp -> f_dir.dir_name;
  737.  idx < FNAME_SIZE; idx++)
  738. {
  739. if(*q == ' ')
  740. break;
  741. *p++ = *q++;
  742. }
  743. if(fnp -> f_dir.dir_ext[0] != ' ')
  744. {
  745. *p++ = '.';
  746. for(idx = 0, q = (BYTE FAR *)fnp -> f_dir.dir_ext; idx < FEXT_SIZE; idx++)
  747. {
  748. if(*q == ' ')
  749. break;
  750. *p++ = *q++;
  751. }
  752. }
  753. }
  754. *p++ = NULL;
  755. }
  756. #endif