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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
his.c
资源名称：3.0-20000220-SNAP.tar.gz　[点击查看]
上传用户：minyiyu
上传日期：2018-12-24
资源大小：864k
文件大小：10k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

his.c：源码内容
  1. /*  $Revision: 1.1 $
  2. **
  3. **  History file routines.
  4. */
  5. #include "innbbsconf.h"
  6. #include "bbslib.h"
  7. #include "his.h"
  9. #define STATIC static
  10. /*STATIC char HIShistpath[] = _PATH_HISTORY;*/
  11. STATIC FILE *HISwritefp;
  12. STATIC int HISreadfd;
  13. STATIC int HISdirty;
  14. STATIC int HISincore = XINDEX_DBZINCORE;
  15. STATIC char *LogName = "xindexchan";
  16. #ifndef EXPIREDAYS
  17. #define EXPIREDAYS 4
  18. #endif
  20. #ifndef DEFAULT_HIST_SIZE
  21. #define DEFAULT_HIST_SIZE 100000
  22. #endif
  24. hisincore(flag)
  25. int     flag;
  26. {
  27. HISincore = flag;
  28. }
  29. makedbz(histpath, entry)
  30. char   *histpath;
  31. long    entry;
  32. {
  33. long    size;
  34. size = dbzsize(entry);
  35. dbzfresh(histpath, size, 't', 0, 1);
  36. dbmclose();
  37. }
  39. void    HISsetup();
  40. void    HISclose();
  42. void
  43. mkhistory(srchist)
  44. char   *srchist;
  45. {
  46. FILE   *hismaint;
  47. time_t  lasthist, now;
  48. char    maintbuff[256];
  49. char   *ptr;
  50. hismaint = fopen(srchist, "r");
  51. if (hismaint == NULL) {
  52. return;
  53. } {
  54. char    newhistpath[1024];
  55. char    newhistdirpath[1024];
  56. char    newhistpagpath[1024];
  57. sprintf(newhistpath, "%s.n", srchist);
  58. sprintf(newhistdirpath, "%s.n.dir", srchist);
  59. sprintf(newhistpagpath, "%s.n.pag", srchist);
  60. if (!isfile(newhistdirpath) || !isfile(newhistpagpath)) {
  61. makedbz(newhistpath, DEFAULT_HIST_SIZE);
  62. }
  63. myHISsetup(newhistpath);
  64. while (fgets(maintbuff, sizeof(maintbuff), hismaint) != NULL) {
  65. datum   key;
  66. ptr = (char *) strchr(maintbuff, 't');
  67. if (ptr != NULL) {
  68. *ptr = '';
  69. ptr++;
  70. }
  71. key.dptr = maintbuff;
  72. key.dsize = strlen(maintbuff);
  73. myHISwrite(&key, ptr);
  74. }
  75. (void) HISclose();
  76. /*
  77.  * rename(newhistpath, srchist);
  78.  * rename(newhistdirpath, fileglue("%s.dir", srchist));
  79.  * rename(newhistpagpath, fileglue("%s.pag", srchist));
  80.  */
  81. }
  82. fclose(hismaint);
  83. }
  84. time_t
  85. gethisinfo()
  86. {
  87. FILE   *hismaint;
  88. time_t  lasthist, now;
  89. char    maintbuff[4096];
  90. char   *ptr;
  91. hismaint = fopen(HISTORY, "r");
  92. if (hismaint == NULL) {
  93. return 0;
  94. }
  95. fgets(maintbuff, sizeof(maintbuff), hismaint);
  96. fclose(hismaint);
  97. ptr = (char *) strchr(maintbuff, 't');
  98. if (ptr != NULL) {
  99. ptr++;
  100. lasthist = atol(ptr);
  101. return lasthist;
  102. }
  103. return 0;
  104. }
  106. void
  107. HISmaint()
  108. {
  109. FILE   *hismaint;
  110. time_t  lasthist, now;
  111. char    maintbuff[4096];
  112. char   *ptr;
  113. if (!isfile(HISTORY)) {
  114. makedbz(HISTORY, DEFAULT_HIST_SIZE);
  115. }
  116. hismaint = fopen(HISTORY, "r");
  117. if (hismaint == NULL) {
  118. return;
  119. }
  120. fgets(maintbuff, sizeof(maintbuff), hismaint);
  121. ptr = (char *) strchr(maintbuff, 't');
  122. if (ptr != NULL) {
  123. ptr++;
  124. lasthist = atol(ptr);
  125. time(&now);
  126. if (lasthist + 86400 * Expiredays * 2 < now) {
  127. char    newhistpath[1024];
  128. char    newhistdirpath[1024];
  129. char    newhistpagpath[1024];
  130. (void) HISclose();
  131. sprintf(newhistpath, "%s.n", HISTORY);
  132. sprintf(newhistdirpath, "%s.n.dir", HISTORY);
  133. sprintf(newhistpagpath, "%s.n.pag", HISTORY);
  134. if (!isfile(newhistdirpath)) {
  135. makedbz(newhistpath, DEFAULT_HIST_SIZE);
  136. }
  137. myHISsetup(newhistpath);
  138. while (fgets(maintbuff, sizeof(maintbuff), hismaint) != NULL) {
  139. datum   key;
  140. ptr = (char *) strchr(maintbuff, 't');
  141. if (ptr != NULL) {
  142. *ptr = '';
  143. ptr++;
  144. lasthist = atol(ptr);
  145. } else {
  146. continue;
  147. }
  148. if (lasthist + 99600 * Expiredays < now)
  149. continue;
  150. key.dptr = maintbuff;
  151. key.dsize = strlen(maintbuff);
  152. myHISwrite(&key, ptr);
  153. }
  154. (void) HISclose();
  155. rename(HISTORY, (char *) fileglue("%s.o", HISTORY));
  156. rename(newhistpath, HISTORY);
  157. rename(newhistdirpath, (char *) fileglue("%s.dir", HISTORY));
  158. rename(newhistpagpath, (char *) fileglue("%s.pag", HISTORY));
  159. (void) HISsetup();
  160. }
  161. }
  162. fclose(hismaint);
  163. }
  166. /*
  167. **  Set up the history files.
  168. */
  169. void
  170. HISsetup()
  171. {
  172. myHISsetup(HISTORY);
  173. }
  175. int
  176. myHISsetup(histpath)
  177. char   *histpath;
  178. {
  179. if (HISwritefp == NULL) {
  180. /* Open the history file for appending formatted I/O. */
  181. if ((HISwritefp = fopen(histpath, "a")) == NULL) {
  182. syslog(LOG_CRIT, "%s cant fopen %s %m", LogName, histpath);
  183. exit(1);
  184. }
  185. CloseOnExec((int) fileno(HISwritefp), TRUE);
  187. /* Open the history file for reading. */
  188. if ((HISreadfd = open(histpath, O_RDONLY)) < 0) {
  189. syslog(LOG_CRIT, "%s cant open %s %m", LogName, histpath);
  190. exit(1);
  191. }
  192. CloseOnExec(HISreadfd, TRUE);
  194. /* Open the DBZ file. */
  195. /* (void)dbzincore(HISincore); */
  196. (void) dbzincore(HISincore);
  197. (void) dbzwritethrough(1);
  198. if (dbminit(histpath) < 0) {
  199. syslog(LOG_CRIT, "%s cant dbminit %s %m", histpath, LogName);
  200. exit(1);
  201. }
  202. }
  203. }
  206. /*
  207. **  Synchronize the in-core history file (flush it).
  208. */
  209. void
  210. HISsync()
  211. {
  212. if (HISdirty) {
  213. if (dbzsync()) {
  214. syslog(LOG_CRIT, "%s cant dbzsync %m", LogName);
  215. exit(1);
  216. }
  217. HISdirty = 0;
  218. }
  219. }
  222. /*
  223. **  Close the history files.
  224. */
  225. void
  226. HISclose()
  227. {
  228. if (HISwritefp != NULL) {
  229. /*
  230.  * Since dbmclose calls dbzsync we could replace this line
  231.  * with "HISdirty = 0;".  Oh well, it keeps the abstraction
  232.  * clean.
  233.  */
  234. HISsync();
  235. if (dbmclose() < 0)
  236. syslog(LOG_ERR, "%s cant dbmclose %m", LogName);
  237. if (fclose(HISwritefp) == EOF)
  238. syslog(LOG_ERR, "%s cant fclose history %m", LogName);
  239. HISwritefp = NULL;
  240. if (close(HISreadfd) < 0)
  241. syslog(LOG_ERR, "%s cant close history %m", LogName);
  242. HISreadfd = -1;
  243. }
  244. }
  247. #ifdef HISset
  248. /*
  249. **  File in the DBZ datum for a Message-ID, making sure not to copy any
  250. **  illegal characters.
  251. */
  252. STATIC void
  253. HISsetkey(p, keyp)
  254. register char *p;
  255. datum  *keyp;
  256. {
  257. static BUFFER MessageID;
  258. register char *dest;
  259. register int i;
  260. /* Get space to hold the ID. */
  261. i = strlen(p);
  262. if (MessageID.Data == NULL) {
  263. MessageID.Data = NEW(char, i + 1);
  264. MessageID.Size = i;
  265. } else if (MessageID.Size < i) {
  266. RENEW(MessageID.Data, char, i + 1);
  267. MessageID.Size = i;
  268. }
  269. for (keyp->dptr = dest = MessageID.Data; *p; p++)
  270. if (*p == HIS_FIELDSEP || *p == 'n')
  271. *dest++ = HIS_BADCHAR;
  272. else
  273. *dest++ = *p;
  274. *dest = '';
  276. keyp->dsize = dest - MessageID.Data + 1;
  277. }
  278. #endif
  279. /*
  280. **  Get the list of files under which a Message-ID is stored.
  281. */
  282. char   *
  283. HISfilesfor(key, output)
  284. datum  *key;
  285. datum  *output;
  286. {
  287. char   *dest;
  288. datum   val;
  289. off_t   offset;
  290. register char *p;
  291. register int i;
  292. int     Used;
  293. /* Get the seek value into the history file. */
  294. val = dbzfetch(*key);
  295. if (val.dptr == NULL || val.dsize != sizeof offset) {
  296. /* printf("fail here val.dptr %dn",val.dptr); */
  297. return NULL;
  298. }
  299. /* Get space. */
  300. if (output->dptr == NULL) {
  301. printf("fail here output->dptr nulln");
  302. return NULL;
  303. }
  304. /* Copy the value to an aligned spot. */
  305. for (p = val.dptr, dest = (char *) &offset, i = sizeof offset; --i >= 0;)
  306. *dest++ = *p++;
  307. if (lseek(HISreadfd, offset, SEEK_SET) == -1) {
  308. printf("fail here lseek %dn", offset);
  309. return NULL;
  310. }
  311. /* Read the text until n or EOF. */
  312. for (output->dsize = 0, Used = 0;;) {
  313. i = read(HISreadfd,
  314. &output->dptr[output->dsize], LEN - 1);
  315. if (i <= 0) {
  316. printf("fail here i %dn", i);
  317. return NULL;
  318. }
  319. Used += i;
  320. output->dptr[Used] = '';
  321. if ((p = (char *) strchr(output->dptr, 'n')) != NULL) {
  322. *p = '';
  323. break;
  324. }
  325. }
  327. /* Move past the first two fields -- Message-ID and date info. */
  328. if ((p = (char *) strchr(output->dptr, HIS_FIELDSEP)) == NULL) {
  329. printf("fail here no HIS_FILEn");
  330. return NULL;
  331. }
  332. return p + 1;
  333. /*
  334.  * if ((p = (char*)strchr(p + 1, HIS_FIELDSEP)) == NULL) return NULL;
  335.  */
  337. /* Translate newsgroup separators to slashes, return the fieldstart. */
  338. }
  339. /*
  340. **  Have we already seen an article?
  341. */
  342. #ifdef HISh
  343. BOOL
  344. HIShavearticle(MessageID)
  345. char   *MessageID;
  346. {
  347. datum   key;
  348. datum   val;
  349. HISsetkey(MessageID, &key);
  350. val = dbzfetch(key);
  351. return val.dptr != NULL;
  352. }
  353. #endif
  356. /*
  357. **  Turn a history filename entry from slashes to dots.  It's a pity
  358. **  we have to do this.
  359. */
  360. STATIC void
  361. HISslashify(p)
  362. register char *p;
  363. {
  364. register char *last;
  365. for (last = NULL; *p; p++) {
  366. if (*p == '/') {
  367. *p = '.';
  368. last = p;
  369. } else if (*p == ' ' && last != NULL)
  370. *last = '/';
  371. }
  372. if (last)
  373. *last = '/';
  374. }
  377. IOError(error)
  378. char   *error;
  379. {
  380. fprintf(stderr, "%sn", error);
  381. }
  382. /*BOOL*/
  383. myHISwrite(key, remain)
  384. datum  *key;
  385. char   *remain;
  386. {
  387. static char NOPATHS[] = "";
  388. long    offset;
  389. datum   val;
  390. int     i;
  391. val = dbzfetch(*key);
  392. if (val.dptr != NULL) {
  393. return FALSE;
  394. }
  395. flock(fileno(HISwritefp), LOCK_EX);
  396. offset = ftell(HISwritefp);
  397. i = fprintf(HISwritefp, "%s%c%s",
  398. key->dptr, HIS_FIELDSEP, remain);
  399. if (i == EOF || fflush(HISwritefp) == EOF) {
  400. /* The history line is now an orphan... */
  401. IOError("history");
  402. syslog(LOG_ERR, "%s cant write history %m", LogName);
  403. flock(fileno(HISwritefp), LOCK_UN);
  404. return FALSE;
  405. }
  406. /* Set up the database values and write them. */
  407. val.dptr = (char *) &offset;
  408. val.dsize = sizeof offset;
  409. if (dbzstore(*key, val) < 0) {
  410. IOError("my history database");
  411. syslog(LOG_ERR, "%s cant dbzstore %m", LogName);
  412. flock(fileno(HISwritefp), LOCK_UN);
  413. return FALSE;
  414. }
  415. if (++HISdirty >= ICD_SYNC_COUNT)
  416. HISsync();
  417. flock(fileno(HISwritefp), LOCK_UN);
  418. return TRUE;
  419. }
  422. /*
  423. **  Write a history entry.
  424. */
  425. BOOL
  426. HISwrite(key, date, paths)
  427. datum  *key;
  428. char   *paths;
  429. long    date;
  430. {
  431. static char NOPATHS[] = "";
  432. long    offset;
  433. datum   val;
  434. int     i;
  435. flock(fileno(HISwritefp), LOCK_EX);
  436. offset = ftell(HISwritefp);
  437. i = fprintf(HISwritefp, "%s%c%ld%c%sn",
  438. key->dptr, HIS_FIELDSEP, (long) date, HIS_FIELDSEP,
  439. paths);
  440. if (i == EOF || fflush(HISwritefp) == EOF) {
  441. /* The history line is now an orphan... */
  442. IOError("history");
  443. syslog(LOG_ERR, "%s cant write history %m", LogName);
  444. flock(fileno(HISwritefp), LOCK_UN);
  445. return FALSE;
  446. }
  447. /* Set up the database values and write them. */
  448. val.dptr = (char *) &offset;
  449. val.dsize = sizeof offset;
  450. if (dbzstore(*key, val) < 0) {
  451. IOError("history database");
  452. syslog(LOG_ERR, "%s cant dbzstore %m", LogName);
  453. flock(fileno(HISwritefp), LOCK_UN);
  454. return FALSE;
  455. }
  456. if (++HISdirty >= ICD_SYNC_COUNT)
  457. HISsync();
  458. flock(fileno(HISwritefp), LOCK_UN);
  459. return TRUE;
  460. }