home *** CD-ROM | disk | FTP | other *** search
/ Piper's Pit BBS/FTP: ibm 0010 - 0019 / ibm0010-0019 / ibm0010.tar / ibm0010 / REFLECT.ZIP / UNIXDIR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-02-14  |  13.1 KB  |  721 lines
  1. #include <stdio.h>
  2. #ifdef hpux
  3. #define SYSTEM5 1
  4. #endif
  5. #define BYTE unsigned char
  6. #define WORD unsigned short 
  7. #define LONG long 
  8. #define FAST register
  9. #define VOID int
  10. #define BOOL int
  11. #define COUNT int 
  12. #define GLOBAL
  13. #define IMPORT extern
  14. #define LOCAL static
  15. #define YES 1
  16. #define NO 0
  17. #define QUIT_SHUTDOWN 1 
  18. #define PATHSIZE 80 
  19. #ifndef NULL
  20. #define NULL 0
  21. #endif
  22. #define BU_FNSZ 72 
  23. #define BU_MAXRSZ 256 
  24. #define BU_VERSZ 4 
  25. #define BU_MAXBUCK 1024 
  26. #define BU_HDRSZ 154 
  27. #define CKPT_OKAY 0 
  28. #define CKPT_INITIATE 1 
  29. struct DIR {
  30. LONG syn_next; 
  31. LONG dfirst; 
  32. LONG dlast; 
  33. WORD fdate; 
  34. WORD ftime; 
  35. LONG fsize; 
  36. WORD ddate; 
  37. WORD dtime; 
  38. BYTE dattr; 
  39. BYTE fname[BU_FNSZ]; 
  40. };
  41. struct HDR {
  42. BYTE version[BU_VERSZ]; 
  43. WORD recsize; 
  44. WORD buckets; 
  45. BYTE hrec_count; 
  46. WORD hblocking; 
  47. LONG free_first; 
  48. LONG free_last; 
  49. LONG file_last; 
  50. WORD bu_date; 
  51. WORD bu_time; 
  52. BYTE c_status; 
  53. BYTE c_dupname; 
  54. LONG c_prior; 
  55. LONG c_current; 
  56. LONG c_bucket; 
  57. LONG c_nfirst; 
  58. LONG c_newdir; 
  59. LONG c_odfirst; 
  60. LONG c_odlast; 
  61. struct DIR c_dir; 
  62. };
  63. LONG htab[BU_MAXBUCK] = {0}; 
  64. BYTE bu_rec[BU_MAXRSZ] = {0}; 
  65. BYTE bu_rec2[BU_MAXRSZ] = {0}; 
  66. BYTE *bu_ptr = {0}; 
  67. LONG bu_link = {0}; 
  68. GLOBAL struct DIR dir = {0}; 
  69. GLOBAL struct HDR hdr = {0}; 
  70. LONG prior = {0}; 
  71. LONG current = {0}; 
  72. LONG bucket = {0}; 
  73. GLOBAL WORD ferrno = {0}; 
  74. GLOBAL char *ferrtx = {0}; 
  75. long file_size();
  76. BYTE Bread();
  77. BYTE bgchar();
  78. WORD bgword();
  79. LONG bglink();
  80. LONG bglong();
  81. GLOBAL LONG host_rec_len = 0;
  82. #define NOON 0x6000 
  83. #define ONE_PM 0x7000 
  84. #define PC_FILE_SPEC_SIZE 81
  85. #define BACKUP_FILE_NAME_SIZE 81
  86. char backup_file_name[BACKUP_FILE_NAME_SIZE] = "BACKUP";
  87. char pc_file_spec[PC_FILE_SPEC_SIZE] = "\\*.*";
  88. char display_buf[78];
  89. char display_init1[] = {"     Size =          Create/Mod =   -  -      :   "};
  90. char display_init2[] = {"  Backup =   -  -      :   "};
  91. int sub_search = NO;
  92. int name_only = NO;
  93. VOID main(ac, av)
  94. int ac;
  95. char **av;
  96. {
  97. BOOL more;
  98. int i, j;
  99. parse_parms(ac, av);
  100. if (!Binit(backup_file_name, NO))
  101. printf("UNABLE TO OPEN BACKUP FILE - '%s'\n",backup_file_name);
  102. else
  103. if (!Bopenf(pc_file_spec, sub_search))
  104. printf("NO PC FILES FOUND FOR - %s %s\n",pc_file_spec,
  105. ((sub_search)? "/s": ""));
  106. else
  107. {
  108. for (i = 0; (display_init1[i] != 0); i++)
  109. display_buf[i] = display_init1[i];
  110. for (j = 0; (display_init2[j] != 0); j++)
  111. {
  112. display_buf[i] = display_init2[j];
  113. i++;
  114. }
  115. display_buf[77] = NULL;
  116. do
  117. display_file_info();
  118. while (more = Bopenn());
  119. }
  120. }
  121. VOID parse_parms(argc, argv)
  122. int argc;
  123. char **argv;
  124. {
  125. char *argp;
  126. int i;
  127. if (argc < 2)
  128. return;
  129. parse_10:
  130. argp = *++argv;
  131. if (*argp != '\\')
  132. goto parse_20;
  133. for (i = 0; *argp != 0; ++argp)
  134. {
  135. if ((*argp >= 97) && (*argp <= 122))
  136. pc_file_spec[i] = (*argp - 32);
  137. else
  138. pc_file_spec[i] = *argp;
  139. i = i + 1;
  140. }
  141. pc_file_spec[i] = '\000';
  142. argp = *++argv;
  143. parse_20:
  144. if (argp == 0)
  145. return;
  146. if (*argp == '/')
  147. goto parse_30;
  148. for (i = 0; *argp != 0; ++argp)
  149. {
  150. backup_file_name[i] = *argp;
  151. i = i + 1;
  152. }
  153. backup_file_name[i] = '\000';
  154. argp = *++argv;
  155. parse_30:
  156. if (argp == 0)
  157. return;
  158. if (*argp != '/')
  159. {
  160. argp = *++argv;
  161. goto parse_30;
  162. }
  163. ++argp;
  164. if ((*argp == 'S') || (*argp == 's'))
  165. sub_search = YES;
  166. if ((*argp == 'N') || (*argp == 'n'))
  167. name_only = YES;
  168. goto parse_30;
  169. }
  170. VOID display_file_info()
  171. {
  172. int i;
  173. char ch;
  174. printf("%s\n", dir.fname);
  175. if (!name_only)
  176. {
  177. convert_size(dir.fsize, &display_buf[12]);
  178. convert_word(((dir.ddate >> 5) & 0x000F), &display_buf[34], YES);
  179. convert_word((dir.ddate & 0x001F), &display_buf[37], NO);
  180. convert_word(((dir.ddate >> 9) + 80), &display_buf[40], NO);
  181. if (dir.dtime >= NOON)
  182. {
  183. display_buf[49] = 'p';
  184. if (dir.dtime >= ONE_PM)
  185. dir.dtime = (dir.dtime - NOON);
  186. }
  187. else
  188. {
  189. display_buf[49] = 'a';
  190. }
  191. convert_word((dir.dtime >> 11), &display_buf[44], YES);
  192. convert_word(((dir.dtime >> 5) & 0x003F), &display_buf[47], NO);
  193. convert_word(((dir.fdate >> 5) & 0x000F), &display_buf[61], YES);
  194. convert_word((dir.fdate & 0x001F), &display_buf[64], NO);
  195. convert_word(((dir.fdate >> 9) + 80), &display_buf[67], NO);
  196. if (dir.ftime >= NOON)
  197. {
  198. display_buf[76] = 'p';
  199. if (dir.ftime >= ONE_PM)
  200. dir.ftime = (dir.ftime - NOON);
  201. }
  202. else
  203. {
  204. display_buf[76] = 'a';
  205. }
  206. convert_word((dir.ftime >> 11), &display_buf[71], YES);
  207. convert_word(((dir.ftime >> 5) & 0x003F), &display_buf[74], NO);
  208. printf("%s\n", display_buf);
  209. }
  210. }
  211. VOID convert_size(lg, dest_ptr)
  212. LONG lg;
  213. char *dest_ptr;
  214. {
  215. int i;
  216. char *ptr;
  217. LONG l;
  218. for (ptr = dest_ptr; ptr < (dest_ptr + 7); ptr++)
  219. *ptr = ' ';
  220. for (l = 1000000; l >= 10; l = l / 10)
  221. {
  222. if ((lg / l % 10) != 0)
  223. break;
  224. }
  225. for (; l >= 1; l = l / 10)
  226. *dest_ptr++ = ((lg / l % 10) | 0x30);
  227. }
  228. VOID convert_word(wd, dest_ptr, suppress_leading_zero)
  229. WORD wd;
  230. char *dest_ptr;
  231. BOOL suppress_leading_zero;
  232. {
  233. *dest_ptr = (((wd / 10 % 10) | 0x30) & 0x3F);
  234. if (suppress_leading_zero && (*dest_ptr == 0x30))
  235. *dest_ptr = 0x20;
  236. *++dest_ptr = (wd % 10) | 0x30;
  237. }
  238. VOID shutdown(errcode, errtext)
  239. WORD errcode;
  240. BYTE *errtext;
  241. {
  242. quit(QUIT_SHUTDOWN);
  243. }
  244. VOID quit(i)
  245. {
  246. exit(i);
  247. }
  248. #ifdef SYSTEM5
  249. #include <fcntl.h>
  250. #endif
  251. #include <signal.h>
  252. #include <sys/types.h>
  253. #include <sys/stat.h>
  254. #include <errno.h>
  255. extern int errno; 
  256. static int u_fd = -1; 
  257. static int u_eof = NO; 
  258. VOID file_open(fn)
  259. char *fn; 
  260. {
  261. u_eof = NO;
  262. u_fd = fl_open(fn, 0); 
  263. }
  264. int file_read(buf, blen)
  265. char *buf; 
  266. int blen; 
  267. {
  268. int i;
  269. if (u_eof)
  270. return(0);
  271. if ((i = fl_read(u_fd, buf, blen)) != blen)
  272. u_eof = YES;
  273. return(i);
  274. }
  275. int file_close()
  276. {
  277. return(fl_close(u_fd));
  278. }
  279. long file_size(fn)
  280. char *fn; 
  281. {
  282. struct stat sbuf;
  283. if (stat(fn, &sbuf) == -1)
  284. {
  285. ferrno = errno;
  286. ferrtx = "stat() failed";
  287. #ifdef ENOTDIR
  288. if (errno == ENOTDIR)
  289. ferrtx = "a component of the path prefix is not a directory.";
  290. #endif
  291. #ifdef ENOENT
  292. if (errno == ENOENT)
  293. return(-1L);
  294. #endif
  295. #ifdef EACCES
  296. if (errno == EACCES)
  297. ferrtx = "read permission is denied for the specified file.";
  298. #endif
  299. return(-2L);
  300. }
  301. return(sbuf.st_size);
  302. }
  303. static int RF_rsize = 0;
  304. static int RF_fd = 0;
  305. VOID RF_open(nm, rsize)
  306. char *nm;
  307. int rsize;
  308. {
  309. RF_rsize = rsize;
  310. RF_fd = fl_open(nm, 2);
  311. }
  312. VOID RF_read(buf, rnum)
  313. char *buf;
  314. LONG rnum;
  315. {
  316. RF_position(rnum);
  317. if (fl_read(RF_fd, buf, RF_rsize) != RF_rsize)
  318. shutdown(-45, "Invalid backup file record.");
  319. }
  320. int RF_close()
  321. {
  322. return(fl_close(RF_fd));
  323. }
  324. VOID RF_position(rnum)
  325. LONG rnum; 
  326. {
  327. long rval;
  328. long lseek();
  329. if ((rval = lseek(RF_fd, rnum * RF_rsize, 0)) == -1L)
  330. {
  331. ferrno = errno;
  332. ferrtx = "lseek failed.";
  333. #ifdef EBADF
  334. if (errno == EBADF)
  335. ferrtx = "lseek: invalid file handle.";
  336. #endif
  337. #ifdef EINVAL
  338. if (errno == EINVAL)
  339. ferrtx = "lseek: invalid origin or offset.";
  340. #endif
  341. shutdown(ferrno, ferrtx);
  342. }
  343. }
  344. int fl_open(fn, open_flag)
  345. char *fn;
  346. int open_flag;
  347. {
  348. int r_value;
  349. #ifdef SYSTEM5
  350. if (open_flag = 0) 
  351. open_flag = O_RDONLY;
  352. else 
  353. open_flag = O_RDWR;
  354. #endif
  355. if ((r_value = open(fn, open_flag)) == -1)
  356. {
  357. ferrno = errno;
  358. ferrtx = "open failed; file not found or inaccessible.";
  359. #ifdef ENOTDIR
  360. if (errno == ENOTDIR)
  361. ferrtx = "a component of the path prefix is not a directory.";
  362. #endif
  363. #ifdef ENOENT
  364. if (errno == ENOENT)
  365. ferrtx = "the specified file does not exist.";
  366. #endif
  367. #ifdef EACCES
  368. if (errno == EACCES)
  369. ferrtx = "read permission is denied for the specified file.";
  370. #endif
  371. shutdown(ferrno, ferrtx);
  372. }
  373. return(r_value);
  374. }
  375. int fl_close(fd)
  376. int fd;
  377. {
  378. if (close(fd) == -1)
  379. {
  380. ferrno = errno;
  381. ferrtx = "close failed.";
  382. #ifdef EBADF
  383. if (errno == EBADF)
  384. ferrtx = "close: bad file handle.";
  385. #endif
  386. return(-1);
  387. }
  388. else
  389. return(0);
  390. }
  391. int fl_read(fd, buf, blen)
  392. int fd;
  393. char *buf; 
  394. int blen; 
  395. {
  396. int i, progress;
  397. progress = 0;
  398. for (i = 1; (i >= 1) && blen; buf += i, blen -= i, progress += i)
  399. i = read(fd, buf, blen);
  400. if (i == -1)
  401. shutdown(errno, "read failed.");
  402. return(progress);
  403. }
  404. BOOL Binit(fname, create_it, rec_size, ibuckets)
  405. char *fname;
  406. BOOL create_it;
  407. int rec_size, ibuckets;
  408. {
  409. int i;
  410. if (file_size(fname) < BU_HDRSZ)
  411. return(NO);
  412. file_open(fname);
  413. file_read(bu_rec, BU_HDRSZ); 
  414. hdr_read();
  415. if (file_close() == -1)
  416. shutdown(ferrno, ferrtx);
  417. RF_open(fname, hdr.recsize);
  418. if (hdr.c_status != CKPT_INITIATE)
  419. for (i = 1; i <= hdr.hrec_count; ++i)
  420. hash_read((LONG) i);
  421. if (hdr.c_status != CKPT_OKAY)
  422. return(NO);
  423. return(YES);
  424. }
  425. BOOL Bopenf(path, subdirs_ok)
  426. char *path;
  427. BOOL subdirs_ok;
  428. {
  429. if (Bcompile(path, subdirs_ok)) 
  430. {
  431. if (!Bposition((WORD) 0, YES)) 
  432. return(NO);
  433. while (!Bmatch(dir.fname))
  434. {
  435. if (!Badvance(YES)) 
  436. return(NO);
  437. }
  438. return(YES);
  439. }
  440. else
  441. return(Blookup(path));
  442. }
  443. BOOL Bopenn()
  444. {
  445. while (Badvance(YES))
  446. {
  447. if (Bmatch(dir.fname))
  448. return(YES);
  449. }
  450. return(NO);
  451. }
  452. BYTE Bread()
  453. {
  454. return(bgchar());
  455. }
  456. BOOL Badvance(keep_going)
  457. BOOL keep_going;
  458. {
  459. prior = current;
  460. current = dir.syn_next;
  461. if (current > 0L)
  462. {
  463. dir_read(current);
  464. return(YES);
  465. }
  466. if (!keep_going)
  467. return(NO);
  468. return(Bposition((WORD) bucket+1, YES));
  469. }
  470. WORD Bhash(name)
  471. char *name;
  472. {
  473. WORD hash_value;
  474. int i;
  475. hash_value = 0;
  476. while (*name)
  477. hash_value += *name++;
  478. return(hash_value % hdr.buckets);
  479. }
  480. BOOL Blookup(name)
  481. char *name;
  482. {
  483. int rval;
  484. if (!Bposition(Bhash(name), NO))
  485. return(NO);
  486. while ((rval = strncmp(name, dir.fname, BU_FNSZ)) > 0) 
  487. {
  488. if (!Badvance(NO))
  489. return(NO);
  490. }
  491. return(rval == 0);
  492. }
  493. BOOL Bposition(hash_value, keep_going)
  494. WORD hash_value;
  495. BOOL keep_going;
  496. {
  497. prior = 0; 
  498. current = 0;
  499. for (bucket = hash_value; bucket < hdr.buckets; ++bucket)
  500. {
  501. current = htab[bucket];
  502. if (current > 0L)
  503. {
  504. dir_read(current);
  505. return(YES);
  506. }
  507. if (!keep_going)
  508. return(NO);
  509. }
  510. return(NO);
  511. }
  512. #define SD_CHAR '\\' 
  513. #define AUTOSIZE 300
  514. #define SUBDIR '\001'
  515. #define FCHAR 'C'
  516. #define FDOT 'D'
  517. #define FANY 'A'
  518. #define FSUBDIR 'S'
  519. #define FSUCCEED 'Y'
  520. #define FFAIL 'F'
  521. LOCAL BYTE autotab[AUTOSIZE+1] = {0};
  522. LOCAL BYTE *autoix = NULL;
  523. LOCAL add_chr(c)
  524. BYTE c;
  525. {
  526. if (autoix >= autotab + AUTOSIZE)
  527. shutdown(-35, "Internal error.");
  528. *autoix++ = c;
  529. }
  530. BOOL Bcompile(pname, subs_ok)
  531. FAST BYTE *pname;
  532. BOOL subs_ok;
  533. {
  534. FAST BYTE *p, *q, *r;
  535. COUNT i;
  536. BOOL wild = NO;
  537. BYTE buf[PATHSIZE+2];
  538. if ((i = strlen(pname)) > PATHSIZE || i < 1)
  539. shutdown(-46, "Internal error.");
  540. if (subs_ok)
  541. {
  542. for (p = q = pname; *p; ++p)
  543. if (*p == SD_CHAR)
  544. q = p + 1;
  545. for (p = buf; pname < q;)
  546. *p++ = *pname++;
  547. *p++ = SUBDIR;
  548. while (*p++ = *pname++)
  549. ;
  550. pname = buf;
  551. }
  552. for (autoix = autotab; *pname; ++pname)
  553. switch (*pname)
  554. {
  555. case '*':
  556. for (i = 0; i < 8; ++i)
  557. add_chr(FANY);
  558. while (*pname != '.' && *pname != SD_CHAR && *pname)
  559. ++pname;
  560. --pname;
  561. wild = YES;
  562. break;
  563. case '?':
  564. add_chr(FANY);
  565. wild = YES;
  566. break;
  567. case SUBDIR:
  568. add_chr(FSUBDIR);
  569. wild = YES;
  570. break;
  571. case '.':
  572. add_chr(FDOT);
  573. break;
  574. default:
  575. add_chr(FCHAR);
  576. add_chr(*pname);
  577. }
  578. if (wild)
  579. {
  580. add_chr(FCHAR);
  581. add_chr(NULL);
  582. add_chr(FSUCCEED);
  583. return(YES);
  584. }
  585. else
  586. {
  587. autoix = autotab;
  588. add_chr(FFAIL);
  589. return(NO);
  590. }
  591. }
  592. BOOL Bmatch(s)
  593. FAST BYTE *s;
  594. {
  595. FAST BYTE *p, *q;
  596. for (p = autotab; ;)
  597. switch (*p++)
  598. {
  599. case FCHAR:
  600. if (*p++ != *s++)
  601. return(NO);
  602. break;
  603. case FDOT:
  604. if (*s == '.')
  605. ++s;
  606. else if (*s)
  607. return(NO);
  608. break;
  609. case FSUBDIR:
  610. for (q = s; *q; ++q)
  611. if (*q == SD_CHAR)
  612. s = q + 1;
  613. break;
  614. case FANY:
  615. if (*s == SD_CHAR)
  616. return(NO);
  617. if (*s && *s != '.')
  618. ++s;
  619. break;
  620. case FSUCCEED:
  621. return(YES);
  622. default: 
  623. return(NO);
  624. }
  625. }
  626. BYTE bgchar()
  627. {
  628. if ((bu_ptr - bu_rec) >= hdr.recsize)
  629. {
  630. RF_read(bu_rec, bu_link);
  631. bu_link = bglink();
  632. }
  633. return(*bu_ptr++);
  634. }
  635. VOID bgstr(s, c)
  636. BYTE *s;
  637. int c;
  638. {
  639. while (c--)
  640. *s++ = bgchar();
  641. }
  642. WORD bgword()
  643. {
  644. BYTE c;
  645. c = bgchar();
  646. return( (c<<8) + (bgchar() & 0xff));
  647. }
  648. LONG bglong()
  649. {
  650. WORD w;
  651. w = bgword();
  652. return( (((LONG) w) << 16) + (bgword() & 0xffff));
  653. }
  654. LONG bglink()
  655. {
  656. bu_ptr = bu_rec;
  657. return(bglong());
  658. }
  659. VOID hdr_read()
  660. {
  661. bu_ptr = bu_rec;
  662. hdr.recsize = BU_HDRSZ; 
  663. bgstr(hdr.version, BU_VERSZ);
  664. hdr.recsize = bgword();
  665. hdr.buckets = bgword();
  666. hdr.hrec_count = bgchar();
  667. hdr.hblocking = bgword();
  668. hdr.free_first = bglong();
  669. hdr.free_last = bglong();
  670. hdr.file_last = bglong();
  671. hdr.bu_date = bgword();
  672. hdr.bu_time = bgword();
  673. hdr.c_status = bgchar();
  674. hdr.c_dupname = bgchar();
  675. hdr.c_prior = bglong();
  676. hdr.c_current = bglong();
  677. hdr.c_bucket = bglong();
  678. hdr.c_nfirst = bglong();
  679. hdr.c_newdir = bglong();
  680. hdr.c_odfirst = bglong();
  681. hdr.c_odlast = bglong();
  682. hdr.c_dir.syn_next = bglong();
  683. hdr.c_dir.dfirst = bglong();
  684. hdr.c_dir.dlast = bglong();
  685. hdr.c_dir.fdate = bgword();
  686. hdr.c_dir.ftime = bgword();
  687. hdr.c_dir.fsize = bglong();
  688. hdr.c_dir.ddate = bgword();
  689. hdr.c_dir.dtime = bgword();
  690. hdr.c_dir.dattr = bgchar();
  691. bgstr(hdr.c_dir.fname, BU_FNSZ);
  692. }
  693. VOID hash_read(r)
  694. LONG r; 
  695. {
  696. FAST int offset, i;
  697. RF_read(bu_rec, r);
  698. offset = (r-1) * hdr.hblocking;
  699. bu_ptr = bu_rec;
  700. for (i = 0; i < hdr.hblocking; ++i)
  701. if (offset < hdr.buckets)
  702. htab[offset++] = bglong();
  703. }
  704. VOID dir_read(r)
  705. LONG r;
  706. {
  707. RF_read(bu_rec, r);
  708. dir.syn_next = bglink();
  709. dir.dfirst = bglong();
  710. dir.dlast = bglong();
  711. dir.fdate = bgword();
  712. dir.ftime = bgword();
  713. dir.fsize = bglong();
  714. dir.ddate = bgword();
  715. dir.dtime = bgword();
  716. dir.dattr = bgchar();
  717. bgstr(dir.fname, BU_FNSZ);
  718. bu_ptr = bu_rec + hdr.recsize + 1; 
  719. bu_link = dir.dfirst; 
  720. }
  721.