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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 搜索引擎 > 查看源码
fs.c
资源名称：swish-efiles.1.3.2.tar.gz　[点击查看]
上传用户：qin5330
上传日期：2007-01-05
资源大小：114k
文件大小：10k
源码类别：

搜索引擎

开发平台：

Perl

fs.c：源码内容
  1. /*
  2. ** Copyright (C) 1995, 1996, 1997, 1998 Hewlett-Packard Company
  3. ** Originally by Kevin Hughes, kev@kevcom.com, 3/11/94
  4. **
  5. ** This program and library is free software; you can redistribute it and/or
  6. ** modify it under the terms of the GNU (Library) General Public License
  7. ** as published by the Free Software Foundation; either version 2
  8. ** of the License, or any later version.
  9. **
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. ** GNU (Library) General Public License for more details.
  14. **
  15. ** You should have received a copy of the GNU (Library) General Public License
  16. **  long with this program; if not, write to the Free Software
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18. **--------------------------------------------------------------------
  19. */
  20. #include "swish.h"
  21. #include "index.h"
  22. #include "hash.h"
  23. #include "mem.h"
  24. #include "file.h"
  25. #include "string.h"
  26. #include "list.h"
  28. static void indexadir(char *dir);
  29. static void indexafile(char *path);
  30. static void printfiles(struct sortentry *e);
  31. static void printdirs(struct sortentry *e);
  32. static int ishtml(char *filename);
  33. static int isoktitle(char *title);
  36. /* file system specific configuration parameters
  37. **/
  38. static struct swline *pathconlist = 0;
  39. static struct swline *dirconlist = 0;
  40. static struct swline *fileconlist = 0;
  41. static struct swline *titconlist = 0;
  42. static struct swline *fileislist = 0;
  43. static struct swline *suffixlist = 0;
  44. static struct swline *nocontentslist = 0;
  47. /* Have we already indexed a file or directory?
  48. ** This function is used to avoid multiple index entries
  49. ** or endless looping due to symbolic links.
  50. */
  52. static int already_indexed(char *path)
  53. {
  54. #ifndef NO_SYMBOLIC_FILE_LINKS
  55. static struct dev_ino {
  56. dev_t  dev;
  57. ino_t  ino;
  58. struct dev_ino *next;
  59. } *inode_hash[BIGHASHSIZE], *p;
  61. struct stat buf;
  62. char key[34];           /* Hash key -- allow for 64 bit inodes */
  63. unsigned hashval;
  65. if ( stat( path, &buf ) )
  66. return 0;
  68. /* Create hash key:  string contains device and inode. */
  69. sprintf( key, "%lx/%lx", (unsigned long)buf.st_dev,
  70. (unsigned long)buf.st_ino  );
  72. hashval = bighash(key); /* Search hash for this file. */
  73. for ( p = inode_hash[hashval]; p != NULL; p = p->next )
  74. if ( p->dev == buf.st_dev &&
  75. p->ino == buf.st_ino    )
  76. {                               /* We found it. */
  77. if ( verbose == 3 )
  78. printf( "Skipping %s:  %sn",
  79. path, "Already indexed." );
  80. return 1;
  81. }
  83. /* Not found, make new entry. */
  84. p = (struct dev_ino*)emalloc(sizeof(struct dev_ino));
  85. p->dev = buf.st_dev;
  86. p->ino = buf.st_ino;
  87. p->next = inode_hash[hashval];
  88. inode_hash[hashval] = p;
  89. #endif
  91. return 0;
  92. }
  95. /* Recursively goes into a directory and calls the word-indexing
  96. ** functions for each file that's found.
  97. */
  99. static void indexadir(char *dir)
  100. {
  101. int badfile;
  102. DIR *dfd;
  103. #ifdef NEXTSTEP
  104. struct direct *dp;
  105. #else
  106. struct dirent *dp;
  107. #endif
  108. static char s[MAXFILELEN], title[MAXSTRLEN];
  109. struct sortentry *sortfilelist, *sortdirlist;
  110. struct swline *tmplist;
  112. sortfilelist = sortdirlist = NULL;
  114. if (islink(dir) && !followsymlinks)
  115. return;
  117. if ( already_indexed(dir) )
  118. return;
  120. if (dir[strlen(dir) - 1] == '/')
  121. dir[strlen(dir) - 1] = '';
  123. if ((dfd = opendir(dir)) == NULL)
  124. return;
  126. while ((dp = readdir(dfd)) != NULL && dirconlist != NULL) {
  127. badfile = 0;
  128. tmplist = dirconlist;
  129. while (tmplist != NULL) {
  130. if (matchARegex(dp->d_name, tmplist->line)) {
  131. badfile = 1;
  132. break;
  133. }
  134. tmplist = tmplist->next;
  135. }
  136. if (badfile)
  137. return;
  138. }
  139. closedir(dfd);
  140. dfd = opendir(dir);
  142. while ((dp = readdir(dfd)) != NULL) {
  144. if ((dp->d_name)[0] == '.')
  145. continue;
  146. if (islink(dp->d_name) && !followsymlinks)
  147. continue;
  149. badfile = 0;
  150. tmplist = fileislist;
  151. while (tmplist != NULL) {
  152. if (matchARegex(dp->d_name, tmplist->line)) {
  153. badfile = 1;
  154. break;
  155. }
  156. tmplist = tmplist->next;
  157. }
  158. if (badfile)
  159. continue;
  161. badfile = 0;
  162. tmplist = fileconlist;
  163. while (tmplist != NULL) {
  164. if (matchARegex(dp->d_name, tmplist->line)) {
  165. badfile = 1;
  166. break;
  167. }
  168. tmplist = tmplist->next;
  169. }
  170. if (badfile)
  171. continue;
  173. sprintf(s, "%s%s%s", dir, dir[strlen(dir) - 1] == '/' ?
  174. "" : "/", dp->d_name);
  175. if (islink(s) && !followsymlinks)
  176. continue;
  178. badfile = 0;
  179. tmplist = pathconlist;
  180. while (tmplist != NULL) {
  181. if (matchARegex(s, tmplist->line)) {
  182. badfile = 1;
  183. break;
  184. }
  185. tmplist = tmplist->next;
  186. }
  187. if (badfile)
  188. continue;
  190. if (!isdirectory(s)) {
  192. if ( already_indexed(s) )
  193. continue;
  195. if (!isoksuffix(dp->d_name, suffixlist))
  196. continue;
  198. if (ishtml(s)) {
  199. strcpy(title, (char *) parsetitle(s, s));
  200. if (!isoktitle(title))
  201. continue;
  202. }
  203. else {
  204. if (strrchr(s, '/') != NULL)
  205. strcpy(title, strrchr(s, '/') + 1);
  206. else
  207. strcpy(title, s);
  208. }
  209. sortfilelist = (struct sortentry *)
  210. addsortentry(sortfilelist, s, title);
  211. }
  212. else {
  213. sortdirlist = (struct sortentry *)
  214. addsortentry(sortdirlist, s, s);
  215. }
  216. }
  218. closedir(dfd);
  220. printfiles(sortfilelist);
  221. printdirs(sortdirlist);
  222. }
  224. /* Calls the word-indexing function for a single file.
  225. */
  227. static void indexafile(char *path)
  228. {
  229. int badfile;
  230. char *t, title[MAXSTRLEN];
  231. struct sortentry *fileentry;
  232. struct swline *tmplist;
  234. if (islink(path) && !followsymlinks)
  235. return;
  237. if ( already_indexed(path) )
  238. return;
  240. if (path[strlen(path) - 1] == '/')
  241. path[strlen(path) - 1] = '';
  243. badfile = 0;
  244. tmplist = fileislist;
  245. while (tmplist != NULL) {
  246. if (!matchARegex(path, tmplist->line)) {
  247. badfile = 1;
  248. break;
  249. }
  250. tmplist = tmplist->next;
  251. }
  252. if (badfile)
  253. return;
  255. badfile = 0;
  256. tmplist = fileconlist;
  257. while (tmplist != NULL) {
  258. if (matchARegex(path, tmplist->line)) {
  259. badfile = 1;
  260. break;
  261. }
  262. tmplist = tmplist->next;
  263. }
  264. if (badfile)
  265. return;
  267. badfile = 0;
  268. tmplist = pathconlist;
  269. while (tmplist != NULL) {
  270. if (matchARegex(path, tmplist->line)) {
  271. badfile = 1;
  272. break;
  273. }
  274. tmplist = tmplist->next;
  275. }
  276. if (badfile)
  277. return;
  279. if (!isoksuffix(path, suffixlist))
  280. return;
  282. if (ishtml(path)) {
  283. strcpy(title, (char *) parsetitle(path, path));
  284. if (!isoktitle(title))
  285. return;
  286. }
  287. else {
  288. if ((t = strrchr(path, '/')) != NULL)
  289. strcpy(title, t + 1);
  290. else
  291. strcpy(title, path);
  292. }
  294. fileentry = (struct sortentry *) emalloc(sizeof(struct sortentry));
  295. fileentry->filename = (char *) mystrdup(path);
  296. fileentry->title = (char *) mystrdup(title);
  297. fileentry->left = fileentry->right = NULL;
  299. printfiles(fileentry);
  300. }
  302. /* Indexes the words in the tree of files in alphabetical order.
  303. */
  305. static void printfiles(struct sortentry *e)
  306. {
  307. int wordcount;
  308. char *s;
  309. FILE *fp;
  311. if (e != NULL) {
  312. printfiles(e->left);
  313. if (verbose == 3) {
  314. if ((s = (char *) strrchr(e->filename, '/')) == NULL)
  315. printf("  %s", e->filename);
  316. else
  317. printf("  %s", s + 1);
  318. }
  319. if ((fp = fopen(e->filename, "r" )) != NULL ) {
  320. wordcount = countwords(fp, e->filename, e->title,
  321. isoksuffix(e->filename, nocontentslist) && nocontentslist != NULL);
  322. fclose(fp);
  323. }
  324. if (verbose == 3) {
  325. if (wordcount)
  326. printf(" (%d words)n", wordcount);
  327. else
  328. printf(" (no words)n");
  329. fflush(stdout);
  330. }
  331. free(e->filename);
  332. free(e->title);
  333. printfiles(e->right);
  334. free(e);
  335. }
  336. }
  338. /* Prints out the directory names as things are getting indexed.
  339. ** Calls indexadir() so directories in the tree are indexed,
  340. ** in alphabetical order...
  341. */
  343. static void printdirs(struct sortentry *e)
  344. {
  345. if (e != NULL) {
  346. printdirs(e->left);
  347. if (verbose == 3)
  348. printf("nIn dir "%s":n", e->filename);
  349. else if (verbose == 2)
  350. printf("Checking dir "%s"...n", e->filename);
  351. indexadir(e->filename);
  352. free(e->filename);
  353. free(e->title);
  354. printdirs(e->right);
  355. free(e);
  356. }
  357. }
  361. /* This checks is a filename has one of the following suffixes:
  362. ** "htm", "HTM", "html", "HTML", "shtml", "SHTML".
  363. */
  365. int ishtml(filename)
  366. char *filename;
  367. {
  368. char *c, suffix[MAXSUFFIXLEN];
  370. c = (char *) strrchr(filename, '.');
  372. if (c == NULL)
  373. return 0;
  374. strcpy(suffix, c + 1);
  375. if (suffix[0] == '')
  376. return 0;
  378. if (!strncmp(suffix, "htm", 3))
  379. return 1;
  380. else if (!strncmp(suffix, "HTM", 3))
  381. return 1;
  382. else if (!strncmp(suffix, "shtml", 5))
  383. return 1;
  384. else if (!strncmp(suffix, "SHTML", 5))
  385. return 1;
  386. return 0;
  387. }
  389. /* Check if a particular title should be ignored
  390. ** according to the settings in the configuration file.
  391. */
  393. int isoktitle(title)
  394. char *title;
  395. {
  396. int badfile;
  397. struct swline *tmplist;
  399. badfile = 0;
  400. tmplist = titconlist;
  401. while (tmplist != NULL) {
  402. if (matchARegex(title, tmplist->line)) {
  403. badfile = 1;
  404. break;
  405. }
  406. tmplist = tmplist->next;
  407. }
  408. if (badfile)
  409. return 0;
  410. else
  411. return 1;
  412. }
  414. /********************************************************/
  415. /* "Public" functions */
  416. /********************************************************/
  418. void fs_indexpath(char *path)
  419. {
  420.     if (isdirectory(path)) {
  421. if (verbose >= 2)
  422. printf("nChecking dir "%s"...n",
  423. path);
  424. indexadir(path);
  425.     }
  426.     else if (isfile(path)) {
  427. if (verbose >= 2)
  428. printf("nChecking file "%s"...n",
  429. path);
  430. indexafile(path);
  431.     }
  432. }
  434. int fs_vgetc(void *vp)
  435. {
  436. return fgetc((FILE *)vp);
  437. }
  440. int fs_vsize(void *vp)
  441. {
  442. struct stat stbuf;
  443. return fstat(fileno((FILE *)vp), &stbuf) ? -1 : stbuf.st_size;
  444. }
  447. int fs_parseconfline(char *line)
  448. {
  449.     int rv = 0;
  450.     
  451. if (grabCmdOptions(line, "IndexOnly", &suffixlist)) { rv = 1; }
  452. else if (lstrstr(line, "FileRules")) 
  453. {
  454. if (grabCmdOptions(line, "pathname contains", &pathconlist)) { rv = 1; }
  455. else if (grabCmdOptions(line, "directory contains", &dirconlist)) { rv = 1; }
  456. else if (grabCmdOptions(line, "filename contains", &fileconlist)) { rv = 1; }
  457. else if (grabCmdOptions(line, "title contains", &titconlist)) { rv = 1; }
  458. else if (grabCmdOptions(line, "filename is", &fileislist)) { rv = 1; }
  459. else if (grabCmdOptions(line, "pathname contains", &pathconlist)) { rv = 1; }
  460. }
  461.     
  462.     return rv;
  463. }
  465. struct _indexing_data_source_def FileSystemIndexingDataSource = {
  466.   "File-System",
  467.   "fs",
  468.   fs_indexpath,
  469.   fs_vgetc,
  470.   fs_vsize,
  471.   fs_parseconfline
  472. };