home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / lc / part02 < prev    next >
Encoding:
Text File  |  1992-08-13  |  44.6 KB  |  1,800 lines
  1. Newsgroups: comp.sources.misc
  2. From: kent@sparky.sterling.com (Kent Landfield)
  3. Subject:  v31i073:  lc - Categorize and List Files In Columns, Part02/02
  4. Message-ID: <1992Aug7.182810.4074@sparky.imd.sterling.com>
  5. X-Md4-Signature: ef161ba9ece1369061f82d8585b5c0e1
  6. Date: Fri, 7 Aug 1992 18:28:10 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: kent@sparky.sterling.com (Kent Landfield)
  10. Posting-number: Volume 31, Issue 73
  11. Archive-name: lc/part02
  12. Environment: UNIX, AmigaDOS, MINIX, Coherent
  13. Supersedes: lc: Volume 14, Issue 82-83
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then feed it
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  20. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  21. # Contents:  lc.c
  22. # Wrapped by kent@sparky on Fri Aug  7 12:44:03 1992
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 2 (of 2)."'
  26. if test -f 'lc.c' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'lc.c'\"
  28. else
  29.   echo shar: Extracting \"'lc.c'\" \(42153 characters\)
  30.   sed "s/^X//" >'lc.c' <<'END_OF_FILE'
  31. X/*
  32. X** This software is 
  33. X**
  34. X** Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989, 1990,
  35. X**               1991, 1992 by Kent Landfield.
  36. X**
  37. X** Permission is hereby granted to copy, distribute or otherwise 
  38. X** use any part of this package as long as you do not try to make 
  39. X** money from it or pretend that you wrote it.  This copyright 
  40. X** notice must be maintained in any copy made.
  41. X**
  42. X** Use of this software constitutes acceptance for use in an AS IS 
  43. X** condition. There are NO warranties with regard to this software.  
  44. X** In no event shall the author be liable for any damages whatsoever 
  45. X** arising out of or in connection with the use or performance of this 
  46. X** software.  Any use of this software is at the user's own risk.
  47. X**
  48. X**  If you make modifications to this software that you feel 
  49. X**  increases it usefulness for the rest of the community, please 
  50. X**  email the changes, enhancements, bug fixes as well as any and 
  51. X**  all ideas to me. Thanks!
  52. X**
  53. X**              Kent Landfield
  54. X**              kent@sterling.com
  55. X**              sparky!kent
  56. X**
  57. X**  Subsystem:   lc - List Columnwise/Categories
  58. X**
  59. X**  Abstract :   lc -- categorize files in a directory and list columnwize
  60. X**
  61. X**  Usage:       lc [ options ] [ directory ... ]
  62. X**
  63. X**  Options:
  64. X**               -a      List dot files as well.
  65. X**               -b      List block special files only
  66. X** JB            -B      Display the size in blocks
  67. X**               -c      List character special files only
  68. X** JB            -C      Sort down the columns instead of across
  69. X**               -d      List directories only
  70. X**               -D      Do not display singular files
  71. X**               -e      Mark executable files with '*'
  72. X**               -f      List regular files only
  73. X**               -F      List fifo files only
  74. X** JB            -i      Display the inode number
  75. X**               -I      Suppress unresolved symbolic link messages.
  76. X**               -L      Display symbolic links
  77. X**               -l      Mark symbolic links with '@'
  78. X**               -m      List shared memory name space entry files only
  79. X**               -M      List semaphore name space entry files only
  80. X**               -r      Do not sort the filenames before displaying.
  81. X**               -S      List socket file only
  82. X**               -s      List symbolic links only
  83. X**               -v      Print the version of lc 
  84. X** JB            -x      Only display those files the user owns or has access to
  85. X** JB            -X      Only display those files the user does not own and
  86. X**                       does not have access to.
  87. X**               -1      List files one per line instead of in columns
  88. X**
  89. X** The "only" options can be combined.
  90. X** If there is no 'directory' specified, the current directory is used.
  91. X** Not all options are supported on every system. (e.g. no symbolic links
  92. X** on your system ? Options -s, -L or -l won't be available..)
  93. X**
  94. X*/
  95. Xstatic char *sccsid = "@(#)lc.c    1.34 8/7/92  Kent Landfield";
  96. X#include "patchlevel.h"
  97. X
  98. X#include <stdio.h>
  99. X#ifdef BSD
  100. X#  include <strings.h>
  101. X#  include <sys/param.h>
  102. X#else
  103. X#  include <string.h>
  104. X#  include <sys/types.h>
  105. X#endif
  106. X#include <sys/stat.h>
  107. X#ifdef POSIX
  108. X#  include <limits.h>
  109. X#  include <dirent.h>
  110. X#else
  111. X#  ifdef BSD
  112. X#    ifdef DIRECT
  113. X#      include <sys/dir.h>
  114. X#    else
  115. X#      include <dirent.h>
  116. X#    endif
  117. X#  else
  118. X#    include <sys/dir.h>
  119. X#  endif
  120. X#endif
  121. X
  122. X#ifndef NAME_MAX
  123. X#  ifdef BSD
  124. X#    define NAME_MAX    MAXNAMLEN
  125. X#  else
  126. X#    ifdef DIRSIZ
  127. X#      define NAME_MAX  DIRSIZ
  128. X#    else
  129. X#      define NAME_MAX  14
  130. X#    endif
  131. X#  endif
  132. X#endif
  133. X
  134. X#ifndef PATH_MAX
  135. X#  ifdef MAXPATHLEN
  136. X#    define PATH_MAX    MAXPATHLEN
  137. X#  else
  138. X#    ifdef MAXNAMLEN
  139. X#      define PATH_MAX  MAXNAMLEN
  140. X#    else
  141. X#      define PATH_MAX  255
  142. X#    endif
  143. X#  endif
  144. X#endif
  145. X
  146. X#define BUFSIZE         PATH_MAX
  147. X
  148. X#define NODES_PER_HUNK  256
  149. X
  150. X#define TRUE            1
  151. X#define FALSE           0
  152. X
  153. X#ifndef S_IXUSR
  154. X#  define S_IXUSR       S_IEXEC
  155. X#endif
  156. X
  157. X#ifndef S_IXGRP
  158. X#  define S_IXGRP       (S_IEXEC >> 3)
  159. X#endif
  160. X
  161. X#ifndef S_IXOTH
  162. X#  define S_IXOTH       (S_IEXEC >> 6)
  163. X#endif
  164. X
  165. X#define DIR_ONLY        1<<0
  166. X#define FILE_ONLY       1<<2
  167. X#ifdef S_IFCHR
  168. X#  define CHAR_ONLY     1<<3
  169. X#endif
  170. X#ifdef S_IFBLK
  171. X#  define BLOCK_ONLY    1<<4
  172. X#endif
  173. X#ifndef apollo
  174. X# ifdef S_IFIFO
  175. X#  define FIFO_ONLY     1<<5
  176. X# endif
  177. X#endif
  178. X#ifdef S_IFLNK
  179. X#  define LNK_ONLY      1<<6
  180. X#endif
  181. X#ifdef S_IFSOCK
  182. X#  define SOCK_ONLY     1<<7
  183. X#endif
  184. X#ifdef S_IFNAM
  185. X#  define SEM_ONLY      1<<8
  186. X#  define SD_ONLY       1<<9
  187. X#endif
  188. X
  189. X#ifdef BSD
  190. X#  define strrchr       rindex
  191. X#  define strchr        index
  192. X#endif
  193. X
  194. X/*
  195. X** File name storage structure
  196. X*/
  197. X
  198. Xstruct list {
  199. X    int num;
  200. X    int max;
  201. X    char **names;
  202. X#ifdef LENS
  203. X    int maxlen;
  204. X#endif
  205. X};
  206. X
  207. X/*
  208. X** File name storage arrays
  209. X*/
  210. X
  211. X#ifdef LENS
  212. X
  213. X#ifdef S_IFBLK
  214. Xstruct list Blks = { 0, 0, (char **) NULL, 0 };
  215. X#endif
  216. X
  217. X#ifdef S_IFCHR
  218. Xstruct list Chrs = { 0, 0, (char **) NULL, 0 };
  219. X#endif
  220. X
  221. Xstruct list Dirs = { 0, 0, (char **) NULL, 0 };
  222. Xstruct list Fls = { 0, 0, (char **) NULL, 0 };
  223. X
  224. X#ifndef apollo
  225. X#ifdef S_IFIFO
  226. Xstruct list Fifos = { 0, 0, (char **) NULL, 0 };
  227. X#endif
  228. X#endif
  229. X
  230. X#ifdef S_IFLNK
  231. Xstruct list Lnks = { 0, 0, (char **) NULL, 0 };
  232. Xstruct list Lnksn = { 0, 0, (char **) NULL, 0 };
  233. X#endif
  234. X
  235. X#ifdef S_IFSOCK
  236. Xstruct list Socks = { 0, 0, (char **) NULL, 0 };
  237. X#endif
  238. X
  239. X#ifdef S_IFNAM
  240. Xstruct list Sds = { 0, 0, (char **) NULL, 0 };
  241. Xstruct list Sems = { 0, 0, (char **) NULL, 0 };
  242. X#endif
  243. X
  244. X#else   /* ifndef LENS */
  245. X
  246. X#ifdef S_IFBLK
  247. Xstruct list Blks = { 0, 0, (char **) NULL };
  248. X#endif
  249. X
  250. X#ifdef S_IFCHR
  251. Xstruct list Chrs = { 0, 0, (char **) NULL };
  252. X#endif
  253. X
  254. Xstruct list Dirs = { 0, 0, (char **) NULL };
  255. Xstruct list Fls = { 0, 0, (char **) NULL };
  256. X
  257. X#ifndef apollo
  258. X#ifdef S_IFIFO
  259. Xstruct list Fifos = { 0, 0, (char **) NULL };
  260. X#endif
  261. X#endif
  262. X
  263. X#ifdef S_IFLNK
  264. Xstruct list Lnks = { 0, 0, (char **) NULL };
  265. Xstruct list Lnksn = { 0, 0, (char **) NULL };
  266. X#endif
  267. X
  268. X#ifdef S_IFSOCK
  269. Xstruct list Socks = { 0, 0, (char **) NULL };
  270. X#endif
  271. X
  272. X#ifdef S_IFNAM
  273. Xstruct list Sds = { 0, 0, (char **) NULL };
  274. Xstruct list Sems = { 0, 0, (char **) NULL };
  275. X#endif
  276. X
  277. X#endif /* LENS */
  278. X
  279. Xchar *Progname;
  280. X
  281. Xint Allfiles = FALSE;       /* display '.' files as well    */
  282. Xint Display_single = TRUE;  
  283. Xint Executables = FALSE;    /* mark executable files        */
  284. Xint Level = 0;              
  285. Xint Maxlen = 0;             /* longest filename in category */
  286. Xint Only = FALSE;           /* limit display to types       */
  287. Xint Screen_width = 80;      /* display width 80/132         */
  288. Xint Single = FALSE;         /* display files one per line   */
  289. Xint Sort_wanted = TRUE;
  290. Xint Sort_down = FALSE;      /* sort by columns */
  291. Xint Display_inode = FALSE;  /* inode/file size */
  292. Xint Display_size = FALSE;   /* inode/file size */
  293. Xint Sort_offset = 0;        /* inode/file size */
  294. Xint Display_accessable = 0; /* accessable files */
  295. X
  296. X#define ACCESSABLE_ONLY    1
  297. X#define INACCESSABLE_ONLY  2
  298. X
  299. X#ifdef S_IFLNK
  300. Xint Ignore = FALSE;         /* ignore unresolved errors   */
  301. Xint Current = 0;
  302. Xint Disp_links = FALSE;
  303. Xint Mark_links = FALSE;
  304. Xint lstat();
  305. Xint readlink();
  306. X#endif
  307. X
  308. X#ifndef _BSD
  309. X# ifdef BSD
  310. X    extern char *sprintf();
  311. X    extern int  free();
  312. X    extern int  qsort();
  313. X    extern int  getuid();
  314. X    extern int  getgid();
  315. X    extern int  geteuid();
  316. X    extern int  getegid();
  317. X# else
  318. X    extern int  sprintf();
  319. X    extern void free();
  320. X    extern void qsort();
  321. X    extern uid_t getuid();
  322. X    extern uid_t geteuid();
  323. X    extern gid_t getgid();
  324. X    extern gid_t getegid();
  325. X# endif
  326. X extern int fprintf();
  327. X extern int printf();
  328. X extern int sscanf();
  329. X#endif
  330. X
  331. Xvoid lc();
  332. X
  333. Xextern char *getenv();
  334. Xextern char *malloc();
  335. Xextern char *realloc();
  336. Xextern int access();
  337. Xextern int fputs();
  338. Xextern int puts();
  339. Xextern int stat();
  340. Xextern void exit();
  341. X
  342. X/* S T R _ S A V  
  343. X *
  344. X *   str_sav() returns a pointer to a new string which is a dupli-
  345. X *   cate  of the string pointed to by s.  The space for the new
  346. X *   string is obtained using malloc(3).  If the new string  can-
  347. X *   not be created, the process prints an error message on stderr
  348. X *   and terminates.
  349. X */
  350. X
  351. Xchar *str_sav(s)
  352. X    char *s;
  353. X{
  354. X    char *p;
  355. X
  356. X    if ((p = malloc((unsigned)(strlen(s) + 1))) == (char *) NULL) {
  357. X        (void) fprintf(stderr, "%s: malloc: out of memory\n", Progname);
  358. X        exit(1);
  359. X    }
  360. X    (void) strcpy(p, s);
  361. X    return (p);
  362. X}
  363. X
  364. X/* D I R E C T O R Y
  365. X *
  366. X *  directory() is used to open and read the directory and pass
  367. X *  the filenames found to the routine lc();
  368. X */
  369. X#if (POSIX || BSD)
  370. Xvoid directory(dname)
  371. X    char *dname;
  372. X{
  373. X    register char *nbp;
  374. X    register char *nep;
  375. X    DIR *dstream;
  376. X    int i;
  377. X#ifdef DIRECT
  378. X    struct direct *dp;
  379. X#else
  380. X    struct dirent *dp;
  381. X#endif
  382. X
  383. X    /* add a slash to the end of the directory name */
  384. X    nbp = dname + strlen(dname);
  385. X#ifdef AMIGA
  386. X    if (*(nbp - 1) != ':') {
  387. X        *nbp++ = '/';
  388. X        *nbp = '\0';
  389. X    }
  390. X#else
  391. X    *nbp++ = '/';
  392. X    *nbp = '\0';
  393. X#endif
  394. X
  395. X    if ((dstream = opendir(dname)) == NULL) {
  396. X        (void) fprintf(stderr, "%s: can't open %s\n", Progname, dname);
  397. X        return;
  398. X    }
  399. X
  400. X    while ((dp = readdir(dstream)) != NULL) {
  401. X        if (strcmp(dp->d_name, ".") == 0
  402. X            || strcmp(dp->d_name, "..") == 0
  403. X            || (!Allfiles && *(dp->d_name) == '.'))
  404. X            continue;
  405. X
  406. X        for (i = 0, nep = nbp; dp->d_name[i] && i < NAME_MAX; i++)
  407. X            *nep++ = dp->d_name[i];
  408. X        *nep++ = '\0';
  409. X        lc(dname, 2);
  410. X    }
  411. X    (void) closedir(dstream);
  412. X    *--nbp = '\0';
  413. X    return;
  414. X}
  415. X
  416. X#else /* not POSIX or BSD */
  417. X
  418. X/* D I R E C T O R Y
  419. X *
  420. X *  directory() is used to open and read the directory and pass
  421. X *  the filenames found to the routine lc();
  422. X */
  423. Xvoid directory(dname)
  424. X    char *dname;
  425. X{
  426. X    register char *nbp;
  427. X    register char *nep;
  428. X    FILE *fd;
  429. X    int i;
  430. X    struct direct dir;
  431. X
  432. X    /* add a slash to the end of the directory name */
  433. X    nbp = dname + strlen(dname);
  434. X    *nbp++ = '/';
  435. X    *nbp = '\0';
  436. X
  437. X    if ((nbp + NAME_MAX + 2) >= (dname + BUFSIZE))  { /* dname too long */
  438. X        (void) fprintf(stderr, "%s: dirname too long: %s\n",
  439. X                       Progname, dname);
  440. X        return;
  441. X    }
  442. X
  443. X    if ((fd = fopen(dname, "r")) == (FILE *) NULL) { /* open the directory */
  444. X        (void) fprintf(stderr, "%s: can't open %s\n", Progname, dname);
  445. X        return;
  446. X    }
  447. X
  448. X    while (fread((char *) &dir, sizeof(dir), 1, fd) > 0) {
  449. X        if (dir.d_ino == 0
  450. X            || strcmp(dir.d_name, ".") == 0
  451. X            || strcmp(dir.d_name, "..") == 0)
  452. X            continue;
  453. X        for (i = 0, nep = nbp; i < NAME_MAX; i++)
  454. X            *nep++ = dir.d_name[i];
  455. X        *nep++ = '\0';
  456. X        lc(dname, 2);
  457. X    }
  458. X    (void) fclose(fd);
  459. X    *--nbp = '\0';     /* restore dname */
  460. X    return;
  461. X}
  462. X#endif
  463. X
  464. X/* G E T L I N K
  465. X *
  466. X *  getlink() calls readlink() which places the contents of the 
  467. X *  symbolic link referred to by fn in the buffer wk. The contents 
  468. X *  of the link are null terminated and the path is returned to
  469. X *  the calling funtion as a pointer to a storage area created
  470. X *  by using malloc(3);
  471. X */
  472. X
  473. X#ifdef S_IFLNK
  474. Xchar *getlink(fn)
  475. X    char *fn;
  476. X{
  477. X    char wk[PATH_MAX + 1];
  478. X    int rc;
  479. X
  480. X    rc = readlink(fn, wk, sizeof(wk));
  481. X    if (rc < 0)
  482. X        return ((char *) NULL);
  483. X    wk[rc] = '\0';
  484. X    return (str_sav(wk));
  485. X}
  486. X#endif
  487. X
  488. X/* P R I N T _ L I N E 
  489. X *
  490. X *  print_line() is used to format and output the files previously 
  491. X *  located. This routine could use a lot more smarts but currently
  492. X *  it is rather crude...
  493. X */
  494. X
  495. Xint print_line(files, ind)
  496. X    struct list *files;
  497. X    int ind;
  498. X{
  499. X    register char *frmt;
  500. X    char out_str[PATH_MAX + 5];
  501. X    int i;
  502. X    int prt_limit;
  503. X    int numrows = 0;
  504. X
  505. X    if (Single) {
  506. X#ifdef S_IFLNK
  507. X        if (Current == LNK_ONLY) {
  508. X            if (*(Lnksn.names + ind) != (char *) NULL)
  509. X                (void) printf("    %s -> %s\n",
  510. X                              *(Lnks.names + ind), *(Lnksn.names + ind));
  511. X            else
  512. X                (void) printf("    %s -> %s\n",
  513. X                              *(Lnks.names + ind), "UNRESOLVED");
  514. X            ind++;
  515. X            return (ind);
  516. X        }
  517. X#endif
  518. X        (void) puts(*(files->names + ind));
  519. X        ind++;
  520. X    }
  521. X    else if (Maxlen > ((Screen_width - 4) / 2)) {
  522. X        (void) printf("    %s\n", *(files->names + ind));
  523. X        ind++;
  524. X    }
  525. X    else {
  526. X         frmt = out_str;
  527. X         for (i = 0; i < 4; i++)
  528. X              *frmt++ = ' ';
  529. X
  530. X        /* The prt_limit may need to be smarter */
  531. X
  532. X         prt_limit = (Screen_width - 4) / (Maxlen + 1);
  533. X
  534. X         /*  sort by columns */
  535. X#ifdef LNK_ONLY
  536. X         if (Sort_down && Current != LNK_ONLY) {
  537. X#else       
  538. X         if (Sort_down) {
  539. X#endif
  540. X             numrows = (int)( (float)files->num / (float)prt_limit + 1.0);
  541. X             prt_limit = (int) ( (float)files->num / (float)numrows + (float)(numrows - 1) / (float)numrows);
  542. X         }
  543. X
  544. X         if (Maxlen == 3 || Maxlen == 1)
  545. X             prt_limit--;
  546. X
  547. X         while ((ind < files->num) && (prt_limit-- > 0)) {
  548. X              i = 0;
  549. X              do {
  550. X                   if (*(*(files->names + ind) + i) == '\0') {
  551. X                       while (i++ <= Maxlen)
  552. X                             *frmt++ = ' ';
  553. X                   }
  554. X                   else
  555. X                       *frmt++ = *(*(files->names + ind) + i);
  556. X                   i++;
  557. X              } while (i <= Maxlen);
  558. X#ifdef LNK_ONLY
  559. X              if (Sort_down && Current != LNK_ONLY)
  560. X#else       
  561. X              if (Sort_down)
  562. X#endif
  563. X                 ind += numrows;
  564. X              else
  565. X                 ind++;
  566. X         }
  567. X         *frmt = '\0';
  568. X         while (*--frmt == ' ')  /* strip trailing blanks */
  569. X             *frmt = '\0';
  570. X        
  571. X         (void) puts(out_str);
  572. X    }
  573. X    return (ind);
  574. X}
  575. X
  576. X/* S T R _ C M P
  577. X *
  578. X *  str_cmp is the comparison routine used by
  579. X *  qsort(3) to order the filenames inplace.
  580. X */
  581. X
  582. Xint str_cmp(s1, s2)
  583. X    char **s1;
  584. X    char **s2;
  585. X{
  586. X    /* inode/file sizes */
  587. X 
  588. X    return strcmp(&**s1 + Sort_offset, &**s2 + Sort_offset);
  589. X}
  590. X
  591. X/* P R _ I N F O
  592. X *
  593. X *  pr_info() is used to sort the data if required
  594. X *  and then pass it to print_line to actually output
  595. X *  the data.`
  596. X */
  597. X
  598. Xint pr_info(strng, files, flg, sort_needed)
  599. X    char *strng;
  600. X    struct list *files;
  601. X    int flg;
  602. X    int sort_needed;
  603. X{
  604. X    int pnum = 0;
  605. X
  606. X#ifdef LENS
  607. X    Maxlen = files->maxlen;
  608. X#endif
  609. X
  610. X#ifdef S_IFLNK
  611. X    if (!Single || Current == LNK_ONLY) {
  612. X        if (flg)
  613. X            (void) puts("");
  614. X        (void) puts(strng);
  615. X    }
  616. X#else
  617. X    if (!Single) {
  618. X        if (flg)
  619. X            (void) puts("");
  620. X        (void) puts(strng);
  621. X    }
  622. X#endif
  623. X
  624. X    if (sort_needed)
  625. X        qsort((char *) (files->names), files->num, sizeof(char *), str_cmp);
  626. X
  627. X    /* sort by columns */
  628. X    Maxlen++; /* this is to force an extra space between columns */
  629. X#ifdef LNK_ONLY
  630. X    if (Sort_down && Current != LNK_ONLY) {
  631. X#else
  632. X    if (Sort_down) {
  633. X#endif
  634. X        int numcols = (Screen_width - 4) / (Maxlen + 1);
  635. X        int numrows = (int)( (float)files->num / (float)numcols + 1.0);
  636. X         
  637. X        numcols = (int) ( (float)files->num / (float)numrows + (float)(numrows - 1) / (float)numrows);
  638. X 
  639. X        do {
  640. X                (void) print_line(files, pnum);
  641. X                pnum++;
  642. X        } while (pnum < numrows);
  643. X    }    
  644. X    else {
  645. X        do {
  646. X            pnum = print_line(files, pnum);
  647. X        } while (pnum < files->num);
  648. X    }    
  649. X    return (1);
  650. X}
  651. X
  652. X
  653. X/* P R I N T _ I N F O
  654. X *
  655. X *  print_info() is called to display all the filenames
  656. X *  located in the directory reading and storage functions.
  657. X */
  658. X
  659. Xvoid print_info()
  660. X{
  661. X    int flag = 0;
  662. X
  663. X#ifdef S_IFLNK
  664. X    int ssing;
  665. X
  666. X    Current = 0;
  667. X
  668. X    if (Lnks.num > 0 && (Disp_links == TRUE || Only & LNK_ONLY)) {
  669. X        ssing = Single;
  670. X        Single = TRUE;
  671. X        Current = LNK_ONLY;
  672. X#ifdef NOTDEF
  673. X        flag = pr_info("Symbolic Links: ", &Lnks, flag, 0);
  674. X#else
  675. X        flag = pr_info("Symbolic Links: ", &Lnks, flag, Sort_wanted);
  676. X#endif
  677. X        Single = ssing;
  678. X        Current = 0;
  679. X    }
  680. X#endif
  681. X
  682. X#ifdef S_IFSOCK
  683. X    if (Socks.num > 0 && (Only == 0 || Only & SOCK_ONLY))
  684. X        flag = pr_info("Sockets: ", &Socks, flag, Sort_wanted);
  685. X#endif
  686. X
  687. X#ifdef S_IFNAM
  688. X    if (Sems.num > 0 && (Only == 0 || Only & SEM_ONLY))
  689. X        flag = pr_info("Semaphore Files: ", &Sems, flag, Sort_wanted);
  690. X
  691. X    if (Sds.num > 0 && (Only == 0 || Only & SD_ONLY))
  692. X        flag = pr_info("Shared Data Files: ", &Sds, flag, Sort_wanted);
  693. X#endif
  694. X
  695. X#ifndef apollo
  696. X# ifdef S_IFIFO
  697. X    if (Fifos.num > 0 && (Only == 0 || Only & FIFO_ONLY))
  698. X        flag = pr_info("Fifo Files: ", &Fifos, flag, Sort_wanted);
  699. X# endif
  700. X#endif
  701. X
  702. X#ifdef S_IFCHR
  703. X    if (Chrs.num > 0 && (Only == 0 || Only & CHAR_ONLY))
  704. X        flag = pr_info("Character Special Files: ", &Chrs, flag, Sort_wanted);
  705. X#endif
  706. X
  707. X#ifdef S_IFBLK
  708. X    if (Blks.num > 0 && (Only == 0 || Only & BLOCK_ONLY))
  709. X        flag = pr_info("Block Special Files: ", &Blks, flag, Sort_wanted);
  710. X#endif
  711. X
  712. X    if (Dirs.num > 0 && (Only == 0 || Only & DIR_ONLY))
  713. X        flag = pr_info("Directories: ", &Dirs, flag, Sort_wanted);
  714. X
  715. X    if (Fls.num > 0 && (Only == 0 || Only & FILE_ONLY))
  716. X        flag = pr_info("Files: ", &Fls, flag, Sort_wanted);
  717. X
  718. X    return;
  719. X}
  720. X
  721. X/* B A S E N A M E
  722. X *
  723. X *  basename() is used to return the base file name of a
  724. X *  path refered to by name. The base file name is stored
  725. X *  into a storage location refered to by str. It is the
  726. X *  calling function's responsibility to assure adequate
  727. X *  storage is supplied.
  728. X */
  729. X
  730. Xvoid basename(name, str)
  731. X    char *name;
  732. X    char *str;
  733. X{
  734. X    char *p;
  735. X
  736. X    if ((p = strrchr(name, '/')) == (char *) NULL) {
  737. X#ifdef AMIGA
  738. X        if ((p = strchr(name, ':')) == (char *) NULL)
  739. X            (void) strcpy(str, name);
  740. X        else
  741. X            (void) strcpy(str, ++p);
  742. X#else
  743. X        (void) strcpy(str, name);
  744. X#endif
  745. X    }
  746. X    else
  747. X        (void) strcpy(str, ++p);
  748. X    return;
  749. X}
  750. X
  751. X/* A D D _ T O _ L I S T
  752. X *
  753. X * add_to_list() is used to add the supplied filename refered to
  754. X * by str to the appropriate category storage array.
  755. X */
  756. X
  757. Xvoid add_to_list(files, str)
  758. X    struct list *files;
  759. X    char *str;
  760. X{
  761. X    if (files->max == 0) {
  762. X        files->names = (char **) malloc(sizeof(char *) * NODES_PER_HUNK);
  763. X        if (files->names == (char **) NULL) {
  764. X            (void) fprintf(stderr,
  765. X                           "%s: malloc: out of memory\n", Progname);
  766. X            exit(1);
  767. X        }
  768. X        files->max = NODES_PER_HUNK;
  769. X    }
  770. X    else if (files->num == files->max) {
  771. X        files->names =
  772. X            (char **) realloc((char *) files->names,
  773. X                              (unsigned) sizeof(char *)
  774. X                              * (files->max + NODES_PER_HUNK));
  775. X        if (files->names == (char **) NULL) {
  776. X            (void) fprintf(stderr,
  777. X                           "%s: realloc: out of memory\n", Progname);
  778. X            exit(1);
  779. X        }
  780. X        files->max += NODES_PER_HUNK;
  781. X    }
  782. X    if (str == (char *) NULL)
  783. X        *(files->names + files->num++) = (char *) NULL;
  784. X    else
  785. X        *(files->names + files->num++) = str_sav(str);
  786. X    return;
  787. X}
  788. X
  789. X/* L C
  790. X *
  791. X * lc() is main function for determining the type of
  792. X * the file refered to by name.
  793. X */
  794. X
  795. Xvoid lc(name, cnt)
  796. X    char *name;
  797. X    int cnt;
  798. X{
  799. X#ifdef S_IFLNK
  800. X    char *link;
  801. X#endif
  802. X    char sav_str[BUFSIZE + 2 + 10]; /* inode/file size */
  803. X    char tmp[BUFSIZE + 2 + 10];     /* inode/file size */
  804. X    int mlen;
  805. X    struct stat sbuf;
  806. X    int display = TRUE;             /* access */
  807. X
  808. X#ifdef S_IFLNK
  809. X    if (lstat(name, &sbuf) < 0) {
  810. X        (void) fprintf(stderr, "%s: can't stat %s\n", Progname, name);
  811. X        return;
  812. X    }
  813. X#else
  814. X    if (stat(name, &sbuf) == -1) {
  815. X        (void) fprintf(stderr, "%s: can't stat %s\n", Progname, name);
  816. X        return;
  817. X    }
  818. X#endif
  819. X
  820. X    /*
  821. X    ** Only list files the user owns or has access to.
  822. X    */
  823. X
  824. X    if (Display_accessable &&
  825. X        Display_accessable != (ACCESSABLE_ONLY | INACCESSABLE_ONLY)) {   
  826. X        static int first = 1;
  827. X        static int uid;
  828. X        static int euid;
  829. X        static int gid;
  830. X        static int egid;
  831. X
  832. X        if (first) {
  833. X            first = 0;
  834. X            uid = getuid();
  835. X            euid = geteuid();
  836. X            gid = getgid();
  837. X            egid = getegid();
  838. X        }
  839. X        if (uid != sbuf.st_uid && euid != sbuf.st_uid &&
  840. X            gid != sbuf.st_gid && egid != sbuf.st_gid &&
  841. X            ((sbuf.st_mode & 0007) == 0) ) {
  842. X            if (Display_accessable & ACCESSABLE_ONLY)
  843. X                return;
  844. X        }
  845. X        else {
  846. X            if ((Display_accessable & INACCESSABLE_ONLY) &&
  847. X                    (sbuf.st_mode & S_IFMT) != S_IFDIR
  848. X#ifdef S_IFLNK
  849. X                 && (sbuf.st_mode & S_IFMT) != S_IFLNK
  850. X#endif
  851. X                                                        )
  852. X                return;
  853. X            if ((Display_accessable & INACCESSABLE_ONLY)
  854. X#ifdef S_IFLNK
  855. X                 && (sbuf.st_mode & S_IFMT) == S_IFLNK
  856. X#endif
  857. X                                                           )
  858. X                display = FALSE;
  859. X        }
  860. X    }
  861. X
  862. X    basename(name, sav_str);
  863. X
  864. X    /* inode/file size */
  865. X 
  866. X    *tmp = 0;
  867. X    if (Display_inode) 
  868. X        (void) sprintf(tmp, "%5d", sbuf.st_ino);
  869. X    
  870. X    if (Display_size) {
  871. X        /* Make our best guess here for the block size.  Allow the user */
  872. X        /* compiling the program to override any system constant by     */
  873. X        /* specifying the blocksize on the command line.   JB           */
  874. X 
  875. X#ifdef BLOCKSIZE
  876. X        long st_blocks = (BLOCKSIZE - 1 + sbuf.st_size) / BLOCKSIZE;
  877. X#else
  878. X# ifdef BSD
  879. X        long st_blocks = sbuf.st_blocks / BLK_MULTIPLE;
  880. X# else    
  881. X#  ifdef STD_BLK
  882. X        long st_blocks = (STD_BLK - 1 + sbuf.st_size) / STD_BLK;
  883. X#  else
  884. X#   ifdef BUFSIZ
  885. X        long st_blocks = (BUFSIZ - 1 + sbuf.st_size) / BUFSIZ;
  886. X#   else
  887. X        long st_blocks = (511 + sbuf.st_size) / 512;
  888. X#   endif
  889. X#  endif
  890. X# endif
  891. X#endif
  892. X
  893. X        if (*tmp)
  894. X            (void) sprintf(&tmp[strlen(tmp)], " %4d", st_blocks);
  895. X        else    
  896. X            (void) sprintf(tmp, "%4d", st_blocks);
  897. X 
  898. X    }
  899. X    if (*tmp) {
  900. X        Sort_offset = strlen(tmp) + 1;
  901. X        (void) sprintf(&tmp[strlen(tmp)], " %s", sav_str);
  902. X    }
  903. X    else
  904. X        (void) sprintf(tmp, "%s", sav_str);
  905. X    (void) strcpy(sav_str, tmp);
  906. X 
  907. X    mlen = strlen(sav_str);
  908. X
  909. X#ifndef LENS
  910. X    if (mlen > Maxlen)
  911. X        Maxlen = mlen;
  912. X#endif
  913. X
  914. X    switch (sbuf.st_mode & S_IFMT) {
  915. X
  916. X    case S_IFDIR:
  917. X        if (!Allfiles && sav_str[0] == '.' && Level != 0)
  918. X            break;
  919. X        if (cnt != 1)        /* dont store the dir name on entry */
  920. X            add_to_list(&Dirs, sav_str);
  921. X        /* never called - left for expansion to recursive     */
  922. X        /* searches of subdirectories. Right, re-write needed */
  923. X        /* in output facilities first...                      */
  924. X        if (Level++ == 0)
  925. X            directory(name);
  926. X#ifdef LENS
  927. X        if (mlen > Dirs.maxlen)
  928. X            Dirs.maxlen = mlen;
  929. X#endif
  930. X        break;
  931. X
  932. X    case S_IFREG:
  933. X        /* do not print .files unless enviromental variable */
  934. X        /* or option set.                                   */
  935. X        if (!Allfiles && sav_str[0] == '.')
  936. X            break;
  937. X        if (Executables
  938. X            && (sbuf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
  939. X            *(sav_str + mlen) = '*';
  940. X            ++mlen;
  941. X            *(sav_str + mlen) = '\0';
  942. X#ifndef LENS
  943. X            if (mlen > Maxlen)
  944. X                Maxlen = mlen;
  945. X#endif
  946. X        }
  947. X        add_to_list(&Fls, sav_str);
  948. X#ifdef LENS
  949. X        if (mlen > Fls.maxlen)
  950. X            Fls.maxlen = mlen;
  951. X#endif
  952. X        break;
  953. X
  954. X#ifdef S_IFCHR
  955. X    case S_IFCHR:
  956. X        if (!Allfiles && sav_str[0] == '.')
  957. X            break;
  958. X        add_to_list(&Chrs, sav_str);
  959. X#ifdef LENS
  960. X        if (mlen > Chrs.maxlen)
  961. X            Chrs.maxlen = mlen;
  962. X#endif
  963. X        break;
  964. X#endif
  965. X
  966. X#ifdef S_IFBLK
  967. X    case S_IFBLK:
  968. X        if (!Allfiles && sav_str[0] == '.')
  969. X            break;
  970. X        add_to_list(&Blks, sav_str);
  971. X#ifdef LENS
  972. X        if (mlen > Blks.maxlen)
  973. X            Blks.maxlen = mlen;
  974. X#endif
  975. X        break;
  976. X#endif
  977. X
  978. X#ifndef apollo
  979. X#ifdef S_IFIFO
  980. X    case S_IFIFO:
  981. X        if (!Allfiles && sav_str[0] == '.')
  982. X            break;
  983. X        add_to_list(&Fifos, sav_str);
  984. X#ifdef LENS
  985. X        if (mlen > Fifos.maxlen)
  986. X            Fifos.maxlen = mlen;
  987. X#endif
  988. X        break;
  989. X#endif
  990. X#endif
  991. X
  992. X#ifdef S_IFLNK
  993. X    case S_IFLNK:
  994. X        if (!Allfiles && sav_str[0] == '.')
  995. X            break;
  996. X        if (display)
  997. X            add_to_list(&Lnks, sav_str);
  998. X        link = getlink(name);
  999. X        if (display)
  1000. X            add_to_list(&Lnksn, link);
  1001. X        if (link != (char *) NULL)
  1002. X            free(link);
  1003. X#ifdef LENS
  1004. X        if (mlen > Lnks.maxlen && display)
  1005. X            Lnks.maxlen = mlen;
  1006. X#endif
  1007. X        if (stat(name, &sbuf) < 0) {
  1008. X            if (!Ignore) 
  1009. X                (void) fprintf(stderr,
  1010. X                               "%s: %s: can't resolve symbolic link\n",
  1011. X                               Progname, name);
  1012. X        }
  1013. X        else {
  1014. X            if (display && Mark_links) {
  1015. X                *(sav_str + mlen) = '@';
  1016. X                ++mlen;
  1017. X                *(sav_str + mlen) = '\0';
  1018. X#ifndef LENS
  1019. X                if (mlen > Maxlen)
  1020. X                    Maxlen = mlen;
  1021. X#endif
  1022. X            }
  1023. X
  1024. X            if (display ||  (sbuf.st_mode & S_IFMT) == S_IFDIR)
  1025. X                switch (sbuf.st_mode & S_IFMT) {
  1026. X
  1027. X            case S_IFDIR:
  1028. X                if (cnt != 1)        /*dont store the dir name on entry */
  1029. X                    add_to_list(&Dirs, sav_str);
  1030. X                /* never called - left for expansion to recursive */
  1031. X                /* searches of subdirectories                     */
  1032. X                if (Level++ == 0)
  1033. X                    directory(name);
  1034. X#ifdef LENS
  1035. X                if (mlen > Dirs.maxlen)
  1036. X                    Dirs.maxlen = mlen;
  1037. X#endif
  1038. X                break;
  1039. X
  1040. X            case S_IFREG:
  1041. X                if (Executables
  1042. X                    && (sbuf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
  1043. X                    *(sav_str + mlen) = '*';
  1044. X                    ++mlen;
  1045. X                    *(sav_str + mlen) = '\0';
  1046. X#ifndef LENS
  1047. X                    if (mlen > Maxlen)
  1048. X                        Maxlen = mlen;
  1049. X#endif
  1050. X                }
  1051. X                add_to_list(&Fls, sav_str);
  1052. X#ifdef LENS
  1053. X                if (mlen > Fls.maxlen)
  1054. X                    Fls.maxlen = mlen;
  1055. X#endif
  1056. X                break;
  1057. X
  1058. X#ifdef S_IFCHR
  1059. X            case S_IFCHR:
  1060. X                add_to_list(&Chrs, sav_str);
  1061. X#ifdef LENS
  1062. X                if (mlen > Chrs.maxlen)
  1063. X                    Chrs.maxlen = mlen;
  1064. X#endif
  1065. X                break;
  1066. X#endif
  1067. X
  1068. X#ifdef S_IFBLK
  1069. X            case S_IFBLK:
  1070. X                add_to_list(&Blks, sav_str);
  1071. X#ifdef LENS
  1072. X                if (mlen > Blks.maxlen)
  1073. X                    Blks.maxlen = mlen;
  1074. X#endif
  1075. X                break;
  1076. X#endif
  1077. X
  1078. X#ifndef apollo
  1079. X#ifdef S_IFIFO
  1080. X            case S_IFIFO:
  1081. X                add_to_list(&Fifos, sav_str);
  1082. X#ifdef LENS
  1083. X                if (mlen > Fifos.maxlen)
  1084. X                    Fifos.maxlen = mlen;
  1085. X#endif
  1086. X                break;
  1087. X#endif
  1088. X#endif
  1089. X
  1090. X#ifdef S_IFSOCK
  1091. X            case S_IFSOCK :
  1092. X                add_to_list(&Socks, sav_str);
  1093. X#ifdef LENS
  1094. X                if (mlen > Socks.maxlen)
  1095. X                    Socks.maxlen = mlen;
  1096. X#endif
  1097. X                break;
  1098. X#endif
  1099. X            }
  1100. X        }
  1101. X        break;
  1102. X#endif
  1103. X
  1104. X#ifdef S_IFSOCK
  1105. X    case S_IFSOCK:
  1106. X        if (!Allfiles && sav_str[0] == '.')
  1107. X            break;
  1108. X        add_to_list(&Socks, sav_str);
  1109. X#ifdef LENS
  1110. X        if (mlen > Socks.maxlen)
  1111. X            Socks.maxlen = mlen;
  1112. X#endif
  1113. X        break;
  1114. X#endif
  1115. X
  1116. X#ifdef S_IFNAM
  1117. X    case S_IFNAM:
  1118. X        switch (sbuf.st_rdev) {
  1119. X
  1120. X        case S_INSEM:
  1121. X            if (!Allfiles && sav_str[0] == '.')
  1122. X                break;
  1123. X            add_to_list(&Sems, sav_str);
  1124. X#ifdef LENS
  1125. X            if (mlen > Sems.maxlen)
  1126. X                Sems.maxlen = mlen;
  1127. X#endif
  1128. X            break;
  1129. X
  1130. X        case S_INSHD:
  1131. X            if (!Allfiles && sav_str[0] == '.')
  1132. X                break;
  1133. X            add_to_list(&Sds, sav_str);
  1134. X#ifdef LENS
  1135. X            if (mlen > Sds.maxlen)
  1136. X                Sds.maxlen = mlen;
  1137. X#endif
  1138. X            break;
  1139. X        }
  1140. X        break;
  1141. X#endif
  1142. X
  1143. X    }
  1144. X    return;
  1145. X}
  1146. X
  1147. X/* V A L I D _ O P T
  1148. X *
  1149. X * valid_opt() is used to translate user has supplied option
  1150. X * letters into something that this process can use. It sets
  1151. X * up the options and if a usage is requested, it sets up and
  1152. X * prints a usage message for the user.
  1153. X */
  1154. X
  1155. Xvoid valid_opt(c, usage)
  1156. X    char c;
  1157. X    int usage;
  1158. X{
  1159. X    char up[7];
  1160. X
  1161. X    up[0] = '\0';
  1162. X
  1163. X    switch(c) {
  1164. X
  1165. X    case 'a':
  1166. X        Allfiles = TRUE;
  1167. X        break;
  1168. X
  1169. X    case 'b':
  1170. X        Only |= BLOCK_ONLY;
  1171. X        break;
  1172. X
  1173. X    case 'B':
  1174. X        Display_size = TRUE;
  1175. X        break;
  1176. X 
  1177. X    case 'c':
  1178. X        Only |= CHAR_ONLY;
  1179. X        break;
  1180. X
  1181. X    case 'C':
  1182. X        Sort_down = TRUE;
  1183. X        break;
  1184. X
  1185. X    case 'd':
  1186. X        Only |= DIR_ONLY;
  1187. X        break;
  1188. X
  1189. X    case 'D':
  1190. X        Display_single = FALSE;
  1191. X        break;
  1192. X
  1193. X    case 'e':
  1194. X        Executables = TRUE;
  1195. X        break;
  1196. X
  1197. X    case 'f':
  1198. X        Only |= FILE_ONLY;
  1199. X        break;
  1200. X
  1201. X#ifndef apollo
  1202. X# ifdef S_IFIFO
  1203. X    case 'F':
  1204. X        Only |= FIFO_ONLY;
  1205. X        break;
  1206. X# endif
  1207. X#endif
  1208. X
  1209. X    case 'i':
  1210. X        Display_inode = TRUE;
  1211. X        break;
  1212. X
  1213. X#ifdef S_IFLNK
  1214. X    case 's':
  1215. X        Only |= LNK_ONLY;
  1216. X        break;
  1217. X
  1218. X    case 'l':
  1219. X        Mark_links = TRUE;
  1220. X        break;
  1221. X
  1222. X    case 'I':
  1223. X        Ignore = TRUE;
  1224. X        break;
  1225. X
  1226. X    case 'L':
  1227. X        Disp_links = TRUE;
  1228. X        break;
  1229. X#endif
  1230. X
  1231. X#ifdef S_IFNAM
  1232. X    case 'm':
  1233. X        Only |= SD_ONLY;
  1234. X        break;
  1235. X
  1236. X    case 'M':
  1237. X        Only |= SEM_ONLY;
  1238. X        break;
  1239. X#endif
  1240. X
  1241. X    case 'r':
  1242. X        Sort_wanted = FALSE;
  1243. X        break;
  1244. X
  1245. X#ifdef S_IFSOCK
  1246. X    case 'S':
  1247. X        Only |= SOCK_ONLY;
  1248. X        break;
  1249. X#endif
  1250. X
  1251. X    case '1':
  1252. X        Single = TRUE;
  1253. X        break;
  1254. X
  1255. X    case 'v':
  1256. X        (void) fprintf(stderr,"%s:\t%s\n\tRelease: %d\n\tPatch level: %d\n",
  1257. X                               Progname, sccsid, RELEASE, PATCHLEVEL);
  1258. X        exit(1);
  1259. X    /*NOTREACHED*/
  1260. X
  1261. X  case 'x':
  1262. X        Display_accessable += ACCESSABLE_ONLY;
  1263. X        break;
  1264. X 
  1265. X    case 'X':
  1266. X        Display_accessable += INACCESSABLE_ONLY;
  1267. X        break;
  1268. X
  1269. X    default:
  1270. X        if (usage == TRUE) {
  1271. X#ifdef S_IFLNK
  1272. X            (void) strcat(up, "IlLs");
  1273. X#endif
  1274. X#ifdef S_IFSOCK
  1275. X            (void) strcat(up, "S");
  1276. X#endif
  1277. X#ifdef S_IFNAM
  1278. X            (void) strcat(up, "mM");
  1279. X#endif
  1280. X            (void) fprintf(stderr,
  1281. X                    "usage: %s [-abBcCdDefFivxX1%s] [directories or files]\n",
  1282. X                     Progname, up);
  1283. X            exit(1);
  1284. X        }
  1285. X    }
  1286. X
  1287. X    return;
  1288. X}
  1289. X
  1290. X/* S E T _ E N V _ V A R S
  1291. X *
  1292. X * set_env_vars() is used get the environment variables that
  1293. X * lc uses. The environment variable LC can be used to setup
  1294. X * the default way in which the user likes to see a directory
  1295. X * listing. Command line options override those specified in
  1296. X * the environment.
  1297. X */
  1298. X
  1299. Xvoid set_env_vars()
  1300. X{
  1301. X    char *ep;
  1302. X
  1303. X    if ((ep = getenv("COLS")) != (char *) NULL) {
  1304. X        if (sscanf(ep, "%d", &Screen_width) == 0
  1305. X            || (Screen_width != 80 && Screen_width != 132))
  1306. X            Screen_width = 80;
  1307. X    }
  1308. X
  1309. X    if ((ep = getenv("LC")) != (char *) NULL) {
  1310. X        while (*ep != '\0') {
  1311. X            valid_opt(*ep, FALSE);
  1312. X            ep++;
  1313. X        }
  1314. X    }
  1315. X
  1316. X    return;
  1317. X}
  1318. X
  1319. X/* S P D I S T:   return the distance between two names
  1320. X *
  1321. X * very rough spelling metric:
  1322. X *          0 if the strings are identical
  1323. X *          1 if two chars are transposed
  1324. X *          2 if 1 char wrong, added or deleted
  1325. X *          3 otherwise
  1326. X */
  1327. X#define EQ(s, t) (strcmp(s, t) == 0)
  1328. X
  1329. Xint spdist(s, t)
  1330. X    char *s;
  1331. X    char *t;
  1332. X{
  1333. X    while (*s++ == *t) {
  1334. X        if (*t++ == '\0')
  1335. X            return 0;             /* exact match */
  1336. X    }
  1337. X    if (*--s) {
  1338. X        if (*t) {
  1339. X            if (s[1] && t[1] && *s == t[1] && *t == s[1] && EQ(s+2, t+2))
  1340. X                return 1;             /* transposition */
  1341. X            if (EQ(s+1, t+1))
  1342. X                return 2;             /* 1 char mismatch */
  1343. X        }
  1344. X        if (EQ(s+1, t))
  1345. X            return 2;                /* extra chacter */
  1346. X    }
  1347. X    if (*t && EQ(s, t+1))
  1348. X        return 2;                   /* missing character */
  1349. X    return 3;
  1350. X}
  1351. X
  1352. X/*    M I N D I S T       
  1353. X * 
  1354. X *  mindist() searches the directory for the best guess
  1355. X *  in the event the requested file was not located.
  1356. X */
  1357. X
  1358. X#if (POSIX || BSD)
  1359. Xint mindist(dir, guess, best)    /* set best, return distance 0..3 */
  1360. X    char *dir;
  1361. X    char *guess;
  1362. X    char *best;
  1363. X{
  1364. X    DIR *dfd;
  1365. X    int d;
  1366. X    int nd;
  1367. X#ifdef DIRECT
  1368. X    struct direct *dp;
  1369. X#else
  1370. X    struct dirent *dp;
  1371. X#endif
  1372. X
  1373. X    if (dir[0] == '\0')
  1374. X        dir = ".";
  1375. X    d = 3;                      /* minimum distance */
  1376. X
  1377. X    if ((dfd = opendir(dir)) == NULL)
  1378. X        return d;
  1379. X
  1380. X    while ((dp = readdir(dfd)) != NULL) {
  1381. X        if (dp->d_ino) {
  1382. X            nd = spdist(dp->d_name, guess);
  1383. X            if (nd <= d && nd != 3) {
  1384. X                (void) strcpy(best, dp->d_name);
  1385. X                d = nd;
  1386. X                if (d == 0)    /* exact match */
  1387. X                    break;
  1388. X            }
  1389. X        }
  1390. X    }
  1391. X    (void) closedir(dfd);
  1392. X    return d;
  1393. X}
  1394. X
  1395. X#else /* not POSIX or BSD */
  1396. X
  1397. X/*    M I N D I S T       
  1398. X * 
  1399. X *  mindist() searches the directory for the best guess
  1400. X *  in the event the requested file was not located.
  1401. X */
  1402. X
  1403. Xint mindist(dir, guess, best)    /* set best, return distance 0..3 */
  1404. X    char *dir;
  1405. X    char *guess;
  1406. X    char *best;
  1407. X{
  1408. X    FILE *fd;
  1409. X    int d;
  1410. X    int nd;
  1411. X    struct {
  1412. X        ino_t ino;
  1413. X        char name[NAME_MAX + 1];   /* 1 more than in dir.h */
  1414. X    } nbuf;
  1415. X
  1416. X    nbuf.name[NAME_MAX] = '\0';   /* +1 for terminal '\0' */
  1417. X    if (dir[0] == '\0')
  1418. X        dir = ".";
  1419. X    d = 3;                      /* minimum distance */
  1420. X    if ((fd = fopen(dir, "r")) == (FILE *) NULL)
  1421. X        return d;
  1422. X    while (fread((char *) &nbuf, sizeof(struct direct), 1, fd) > 0) {
  1423. X        if (nbuf.ino) {
  1424. X            nd = spdist(nbuf.name, guess);
  1425. X            if (nd <= d && nd != 3) {
  1426. X                (void) strcpy(best, nbuf.name);
  1427. X                d = nd;
  1428. X                if (d == 0)    /* exact match */
  1429. X                    break;
  1430. X            }
  1431. X        }
  1432. X    }
  1433. X    (void) fclose(fd);
  1434. X    return d;
  1435. X}
  1436. X#endif
  1437. X
  1438. X/* S P N A M E:    return correctly spelled filename
  1439. X *
  1440. X * spname(oldname, newname) char *oldname, *newname;
  1441. X *      returns  -1 if no reasonable match to oldname,
  1442. X *                0 if exact match,
  1443. X *                1 if corrected.
  1444. X * stores corrected name in newname.
  1445. X */
  1446. X
  1447. Xint spname(oldname, newname)
  1448. X    char *oldname;
  1449. X    char *newname;
  1450. X{
  1451. X    char *new = newname;
  1452. X    char *old = oldname;
  1453. X    char *p;
  1454. X    char best[NAME_MAX + 1];
  1455. X    char guess[NAME_MAX + 1];
  1456. X
  1457. X    for (;;) {
  1458. X        while (*old == '/')   /* skip slashes */
  1459. X            *new++ = *old++;
  1460. X        *new = '\0';
  1461. X        if (*old == '\0')     /* exact or corrected */
  1462. X            return (strcmp(oldname, newname) != 0);
  1463. X        p = guess;            /* copy next component into guess */
  1464. X        for (/* void */ ; *old != '/' && *old != '\0'; old++) {
  1465. X            if (p < (guess + NAME_MAX))
  1466. X                *p++ = *old;
  1467. X        }
  1468. X        *p = '\0';
  1469. X        if (mindist(newname, guess, best) >= 3)
  1470. X            return (-1);        /* hopeless */
  1471. X        for (p = best; *new = *p++; new++)   /* add to end */
  1472. X            /* void */;
  1473. X    }
  1474. X}
  1475. X
  1476. X/*  I N _ C D P A T H
  1477. X *
  1478. X *  in_cdpath() searches the CDPATH stored in the environment
  1479. X *  for the filename specified. If it is found, fill the
  1480. X *  storage area refered to by buffer with the corrected path.
  1481. X *  Return TRUE if located and FALSE if not located in the CDPATH.
  1482. X */
  1483. X 
  1484. Xint in_cdpath(requested_dir, buffer, check_spelling)
  1485. X    char *requested_dir;
  1486. X    char *buffer;
  1487. X    int  check_spelling; 
  1488. X{
  1489. X    static char *cdpath;
  1490. X    static int first = 1;
  1491. X
  1492. X    char *cp;
  1493. X    char *path;
  1494. X    char patbuf[BUFSIZE + 1];
  1495. X    int quit;
  1496. X
  1497. X    if (first) {
  1498. X        if ((cdpath = getenv("CDPATH")) != (char *) NULL)
  1499. X            cdpath = str_sav(cdpath);
  1500. X        first = 0;
  1501. X    }   
  1502. X
  1503. X    if (cdpath == (char *) NULL)
  1504. X        return (0);
  1505. X
  1506. X    (void) strcpy(patbuf, cdpath);
  1507. X    path = patbuf;
  1508. X
  1509. X    quit = 0;
  1510. X
  1511. X    while (!quit) {
  1512. X        cp = strchr(path, ':');
  1513. X        if (cp == (char *) NULL)
  1514. X            quit++;
  1515. X        else
  1516. X            *cp = '\0';
  1517. X 
  1518. X        if (*(path + 1) == '\0' && *path == '/')
  1519. X            (void) sprintf(buffer, "/%s", requested_dir);
  1520. X        else
  1521. X            (void) sprintf(buffer, "%s/%s",
  1522. X                           (*path ? path : "."), requested_dir);
  1523. X 
  1524. X        if (access(buffer, 0) == 0)
  1525. X            return (TRUE);
  1526. X 
  1527. X        if (check_spelling)
  1528. X        {
  1529. X            char bfr[BUFSIZ + 1];
  1530. X            (void) strcpy(bfr, buffer);
  1531. X            if (spname(bfr, buffer) == 1)
  1532. X                return (TRUE);
  1533. X        }
  1534. X        
  1535. X        path = ++cp;
  1536. X    }
  1537. X    return (FALSE);
  1538. X}
  1539. X
  1540. X
  1541. X/*  M A I N 
  1542. X * 
  1543. X *  Ye olde main();
  1544. X */
  1545. X
  1546. Xint main(argc, argv)
  1547. X    int argc;
  1548. X    char *argv[];
  1549. X{
  1550. X    char *argp;
  1551. X#ifdef S_IFLNK
  1552. X    char *link;
  1553. X    int lnk_found;
  1554. X#endif
  1555. X    char buf[BUFSIZE + 1];
  1556. X    int idx;
  1557. X    int nl;
  1558. X    struct stat sbuf;
  1559. X
  1560. X    nl = idx = FALSE;
  1561. X
  1562. X    /* get the base name of the command */
  1563. X
  1564. X    if ((Progname = strrchr(argv[0], '/')) == (char *) NULL) 
  1565. X        Progname = argv[0];
  1566. X    else
  1567. X        ++Progname;
  1568. X
  1569. X    set_env_vars();                       /* get environment variables */
  1570. X
  1571. X    /* All command line arguments must be */
  1572. X    /* lumped together such as `lc -aef`  */
  1573. X
  1574. X    if (argc > 1 && argv[1][0] == '-') {  /* if first parm is command */
  1575. X        argp = argv[1];
  1576. X
  1577. X        while (*(++argp))
  1578. X            valid_opt(*argp, TRUE);
  1579. X
  1580. X        ++argv;
  1581. X        --argc;
  1582. X    }
  1583. X
  1584. X    /*
  1585. X    ** The user has not specified a file or directory 
  1586. X    ** to be examined so assume that the current directory
  1587. X    ** is what the user is requesting.
  1588. X    */
  1589. X    if (argc == 1) {
  1590. X        (void) strcpy(buf, ".");
  1591. X        lc(buf, 1);
  1592. X        print_info();
  1593. X        return(0);
  1594. X    }
  1595. X
  1596. X    /*
  1597. X    ** The user has specified at least one file or 
  1598. X    ** directory to be examined.
  1599. X    */
  1600. X    if (argc > 2)
  1601. X        nl = TRUE;
  1602. X    while (--argc > 0) {
  1603. X        ++argv;
  1604. X        (void) strcpy(buf, *argv);
  1605. Xskipit:
  1606. X#ifdef S_IFLNK
  1607. X        lnk_found = 0;
  1608. X        if (lstat(buf, &sbuf) == -1) {
  1609. X            lnk_found = 1;
  1610. X#else
  1611. X        if (stat(buf, &sbuf) == -1) {
  1612. X#endif
  1613. X            if (in_cdpath(*argv, buf, FALSE) ||   /* Look for it in CDPATH */
  1614. X                (spname(*argv, buf) != -1)   ||   /* Look for it mispelled */
  1615. X                in_cdpath(*argv, buf, TRUE)) {    /* Mispelled in CDPATH ? */
  1616. X                /*
  1617. X                 ** Check to see if the requested is in the CDPATH
  1618. X                 ** and if not try to correct for typos. If that fails
  1619. X                 ** then check for typos in the CDPOATH. Always print
  1620. X                 ** the name of what was found...
  1621. X                 */
  1622. X
  1623. X                nl = TRUE;
  1624. X                goto skipit;
  1625. X            }
  1626. X#ifdef S_IFLNK
  1627. X            else if (lnk_found) 
  1628. X                (void) fprintf(stderr,"%s: %s: can't resolve symbolic link\n",
  1629. X                               Progname, *argv);
  1630. X#endif 
  1631. X            else 
  1632. X                (void)fprintf(stderr, "%s: can't find %s\n",
  1633. X                              Progname, *argv);
  1634. X        }
  1635. X        else {
  1636. X#ifdef S_IFLNK
  1637. X            if ((sbuf.st_mode & S_IFMT) == S_IFLNK)
  1638. X                (void) stat(buf, &sbuf);
  1639. X            /*
  1640. X            ** No need to check return code here: if stat() fails use
  1641. X            ** the sbuf retrieved with lstat() earlier.
  1642. X            */
  1643. X#endif
  1644. X            switch (sbuf.st_mode & S_IFMT) {
  1645. X
  1646. X            case S_IFREG:
  1647. X                if (Display_single)
  1648. X                   (void) printf("%s: file\n", buf);
  1649. X                break;
  1650. X
  1651. X#ifdef S_IFCHR
  1652. X            case S_IFCHR:
  1653. X                if (Display_single)
  1654. X                   (void) printf("%s: character special file\n", buf);
  1655. X                break;
  1656. X#endif
  1657. X
  1658. X#ifdef S_IFBLK
  1659. X            case S_IFBLK:
  1660. X                if (Display_single)
  1661. X                   (void) printf("%s: block special file\n", buf);
  1662. X                break;
  1663. X#endif
  1664. X
  1665. X#ifndef apollo
  1666. X#ifdef S_IFIFO
  1667. X            case S_IFIFO:
  1668. X                if (Display_single)
  1669. X                   (void) printf("%s: fifo file\n", buf);
  1670. X                break;
  1671. X#endif
  1672. X#endif
  1673. X
  1674. X#ifdef S_IFSOCK
  1675. X            case S_IFSOCK:
  1676. X                if (Display_single)
  1677. X                   (void) printf("%s: socket file\n", buf);
  1678. X                break;
  1679. X#endif
  1680. X
  1681. X#ifdef S_IFLNK
  1682. X            case S_IFLNK:
  1683. X                if (Display_single) {
  1684. X                   if ((link = getlink(buf)) != (char *) NULL) {
  1685. X                       (void) printf("%s: symbolic link to %s\n", buf,link);
  1686. X                       free(link);
  1687. X                   }
  1688. X                   else
  1689. X                       (void) printf("%s: unresolved symbolic link\n", buf);
  1690. X                }
  1691. X                break;
  1692. X#endif
  1693. X
  1694. X#ifdef S_IFNAM
  1695. X            case S_IFNAM:
  1696. X                if (Display_single) {
  1697. X                   if (sbuf.st_rdev == S_INSHD)
  1698. X                       (void) printf("%s: shared memory file\n", buf);
  1699. X                   if (sbuf.st_rdev == S_INSEM)
  1700. X                       (void) printf("%s: semaphore file\n", buf);
  1701. X                }
  1702. X                break;
  1703. X#endif
  1704. X
  1705. X            case S_IFDIR:
  1706. X                Maxlen = Level = 0;
  1707. X#ifdef S_IFBLK
  1708. X                Blks.num = 0;
  1709. X#ifdef LENS
  1710. X                Blks.maxlen = 0;
  1711. X#endif
  1712. X#endif
  1713. X
  1714. X#ifdef S_IFCHR
  1715. X                Chrs.num = 0;
  1716. X#ifdef LENS
  1717. X                Chrs.maxlen = 0;
  1718. X#endif
  1719. X#endif
  1720. X
  1721. X                Dirs.num = Fls.num = 0;
  1722. X#ifdef LENS
  1723. X                Dirs.maxlen = Fls.maxlen = 0;
  1724. X#endif
  1725. X
  1726. X#ifndef apollo
  1727. X#ifdef S_IFIFO
  1728. X                Fifos.num = 0;
  1729. X#ifdef LENS
  1730. X                Fifos.maxlen = 0;
  1731. X#endif
  1732. X#endif
  1733. X#endif
  1734. X
  1735. X#ifdef S_IFLNK
  1736. X                Lnks.num = Lnksn.num = 0;
  1737. X#ifdef LENS
  1738. X                Lnks.maxlen = Lnksn.maxlen = 0;
  1739. X#endif
  1740. X#endif
  1741. X
  1742. X#ifdef S_IFSOCK
  1743. X                Socks.num = 0;
  1744. X#ifdef LENS
  1745. X                Socks.maxlen = 0;
  1746. X#endif
  1747. X#endif
  1748. X
  1749. X#ifdef S_IFNAM
  1750. X                Sds.num = Sems.num = 0;
  1751. X#ifdef LENS
  1752. X                Sds.maxlen = Sems.maxlen = 0;
  1753. X#endif
  1754. X#endif
  1755. X
  1756. X                if (nl == TRUE) {
  1757. X                    if (idx > 0)
  1758. X                        (void) puts("");
  1759. X                    else
  1760. X                        ++idx;
  1761. X                    (void) fputs(": ", stdout);
  1762. X                    (void) fputs(buf, stdout);
  1763. X                    (void) puts(" :");
  1764. X                }
  1765. X                lc(buf, 1);
  1766. X                print_info();
  1767. X                break;
  1768. X
  1769. X            default:
  1770. X                (void) printf("%s: unknown file type\n", buf);
  1771. X                break;
  1772. X            }
  1773. X        }
  1774. X    }
  1775. X    return(0);
  1776. X}
  1777. END_OF_FILE
  1778.   if test 42153 -ne `wc -c <'lc.c'`; then
  1779.     echo shar: \"'lc.c'\" unpacked with wrong size!
  1780.   fi
  1781.   # end of 'lc.c'
  1782. fi
  1783. echo shar: End of archive 2 \(of 2\).
  1784. cp /dev/null ark2isdone
  1785. MISSING=""
  1786. for I in 1 2 ; do
  1787.     if test ! -f ark${I}isdone ; then
  1788.     MISSING="${MISSING} ${I}"
  1789.     fi
  1790. done
  1791. if test "${MISSING}" = "" ; then
  1792.     echo You have unpacked both archives.
  1793.     rm -f ark[1-9]isdone
  1794. else
  1795.     echo You still must unpack the following archives:
  1796.     echo "        " ${MISSING}
  1797. fi
  1798. exit 0
  1799. exit 0 # Just in case...
  1800.