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

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

Telnet服务器

开发平台：

Unix_Linux

record.c：源码内容
  1. /*
  2.     Pirate Bulletin Board System
  3.     Copyright (C) 1990, Edward Luke, lush@Athena.EE.MsState.EDU
  4.     Eagles Bulletin Board System
  5.     Copyright (C) 1992, Raymond Rocker, rocker@rock.b11.ingr.com
  6.                         Guy Vega, gtvega@seabass.st.usm.edu
  7.                         Dominic Tynes, dbtynes@seabass.st.usm.edu
  8.     Firebird Bulletin Board System
  9.     Copyright (C) 1996, Hsien-Tsung Chang, Smallpig.bbs@bbs.cs.ccu.edu.tw
  10.                         Peng Piaw Foong, ppfoong@csie.ncu.edu.tw
  12.     This program is free software; you can redistribute it and/or modify
  13.     it under the terms of the GNU General Public License as published by
  14.     the Free Software Foundation; either version 1, or (at your option)
  15.     any later version.
  17.     This program is distributed in the hope that it will be useful,
  18.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.     GNU General Public License for more details.
  21. */
  22. /*
  23. $Id: record.c,v 1.2 2000/01/24 12:10:27 edwardc Exp $
  24. */
  26. #include "bbs.h"
  28. #define BUFSIZE (8192)
  30. int
  31. safewrite(fd, buf, size)
  32. int     fd;
  33. char   *buf;
  34. int     size;
  35. {
  36. int     cc, sz = size, origsz = size;
  37. char   *bp = buf;
  38. #ifdef POSTBUG
  39. if (size == sizeof(struct fileheader)) {
  40. char    tmp[80];
  41. struct stat stbuf;
  42. struct fileheader *fbuf = (struct fileheader *) buf;
  43. setbpath(tmp, fbuf->filename);
  44. if (!isalpha(fbuf->filename[0]) || stat(tmp, &stbuf) == -1)
  45. if (fbuf->filename[0] != 'M' || fbuf->filename[1] != '.') {
  46. report("safewrite: foiled attempt to write bugged recordn");
  47. return origsz;
  48. }
  49. }
  50. #endif
  51. do {
  52. cc = write(fd, bp, sz);
  53. if ((cc < 0) && (errno != EINTR)) {
  54. report("safewrite err!");
  55. return -1;
  56. }
  57. if (cc > 0) {
  58. bp += cc;
  59. sz -= cc;
  60. }
  61. } while (sz > 0);
  62. return origsz;
  63. }
  64. #ifdef POSTBUG
  66. char    bigbuf[10240];
  67. int     numtowrite;
  68. int     bug_possible = 0;
  70. int
  71. saverecords(filename, size, pos)
  72. char   *filename;
  73. int     size, pos;
  74. {
  75. int     fd;
  76. if (!bug_possible)
  77. return 0;
  78. if ((fd = open(filename, O_RDONLY)) == -1)
  79. return -1;
  80. if (pos > 5)
  81. numtowrite = 5;
  82. else
  83. numtowrite = 4;
  84. lseek(fd, (off_t) ((pos - numtowrite - 1) * size), SEEK_SET);
  85. read(fd, bigbuf, numtowrite * size);
  86. }
  88. int
  89. restorerecords(filename, size, pos)
  90. char   *filename;
  91. int     size, pos;
  92. {
  93. int     fd;
  94. if (!bug_possible)
  95. return 0;
  96. if ((fd = open(filename, O_WRONLY)) == -1)
  97. return -1;
  98. flock(fd, LOCK_EX);
  99. lseek(fd, (off_t) ((pos - numtowrite - 1) * size), SEEK_SET);
  100. safewrite(fd, bigbuf, numtowrite * size);
  101. report("post bug poison set out!");
  102. flock(fd, LOCK_UN);
  103. bigbuf[0] = '';
  104. close(fd);
  105. }
  106. #endif
  108. long
  109. get_num_records(filename, size)
  110. char   *filename;
  111. int     size;
  112. {
  113. struct stat st;
  114. if (stat(filename, &st) == -1)
  115. return 0;
  116. return (st.st_size / size);
  117. }
  119. int
  120. append_record(filename, record, size)
  121. char   *filename;
  122. char   *record;
  123. int     size;
  124. {
  125. int     fd;
  126. #ifdef POSTBUG
  127. int     numrecs = (int) get_num_records(filename, size);
  128. bug_possible = 1;
  129. if (size == sizeof(struct fileheader) && numrecs && (numrecs % 4 == 0))
  130. saverecords(filename, size, numrecs + 1);
  131. #endif
  132. if ((fd = open(filename, O_WRONLY | O_CREAT, 0644)) == -1) {
  133. perror("open");
  134. return -1;
  135. }
  136. flock(fd, LOCK_EX);
  137. lseek(fd, 0, SEEK_END);
  138. if (safewrite(fd, record, size) == -1)
  139. report("apprec write err!");
  140. flock(fd, LOCK_UN);
  141. close(fd);
  142. #ifdef POSTBUG
  143. if (size == sizeof(struct fileheader) && numrecs && (numrecs % 4 == 0))
  144. restorerecords(filename, size, numrecs + 1);
  145. bug_possible = 0;
  146. #endif
  147. return 0;
  148. }
  150. void
  151. toobigmesg()
  152. {
  153. fprintf(stderr, "record size too big!!n");
  154. }
  156. int
  157. apply_record(filename, fptr, size)
  158. char   *filename;
  159. int     (*fptr) ();
  160. int     size;
  161. {
  162. char    abuf[BUFSIZE];
  163. int     fd;
  164. if (size > BUFSIZE) {
  165. toobigmesg();
  166. return -1;
  167. }
  168. if ((fd = open(filename, O_RDONLY, 0)) == -1)
  169. return -1;
  170. while (read(fd, abuf, size) == size)
  171. if ((*fptr) (abuf) == QUIT) {
  172. close(fd);
  173. return QUIT;
  174. }
  175. close(fd);
  176. return 0;
  177. }
  179. int
  180. search_record(filename, rptr, size, fptr, farg)
  181. char   *filename;
  182. char   *rptr;
  183. int     size;
  184. int     (*fptr) ();
  185. char   *farg;
  186. {
  187. int     fd;
  188. int     id = 1;
  189. if ((fd = open(filename, O_RDONLY, 0)) == -1)
  190. return 0;
  191. while (read(fd, rptr, size) == size) {
  192. if ((*fptr) (farg, rptr)) {
  193. close(fd);
  194. return id;
  195. }
  196. id++;
  197. }
  198. close(fd);
  199. return 0;
  200. }
  202. int
  203. get_record(filename, rptr, size, id)
  204. char   *filename;
  205. char   *rptr;
  206. int     size, id;
  207. {
  208. int     fd;
  209. if ((fd = open(filename, O_RDONLY, 0)) == -1)
  210. return -1;
  211. if (lseek(fd, (off_t) (size * (id - 1)), SEEK_SET) == -1) {
  212. close(fd);
  213. return -1;
  214. }
  215. if (read(fd, rptr, size) != size) {
  216. close(fd);
  217. return -1;
  218. }
  219. close(fd);
  220. return 0;
  221. }
  223. int
  224. get_records(filename, rptr, size, id, number)
  225. char   *filename;
  226. char   *rptr;
  227. int     size, id, number;
  228. {
  229. int     fd;
  230. int     n;
  231. if ((fd = open(filename, O_RDONLY, 0)) == -1)
  232. return -1;
  233. if (lseek(fd, (off_t) (size * (id - 1)), SEEK_SET) == -1) {
  234. close(fd);
  235. return 0;
  236. }
  237. if ((n = read(fd, rptr, size * number)) == -1) {
  238. close(fd);
  239. return -1;
  240. }
  241. close(fd);
  242. return (n / size);
  243. }
  245. int
  246. substitute_record(filename, rptr, size, id)
  247. char   *filename;
  248. char   *rptr;
  249. int     size, id;
  250. {
  251. int     fd;
  252. #ifdef POSTBUG
  253. if (size == sizeof(struct fileheader) && (id > 1) && ((id - 1) % 4 == 0))
  254. saverecords(filename, size, id);
  255. #endif
  256. if ((fd = open(filename, O_WRONLY | O_CREAT, 0644)) == -1)
  257. return -1;
  258. flock(fd, LOCK_EX);
  259. if (lseek(fd, (off_t) (size * (id - 1)), SEEK_SET) == -1)
  260. report("subrec seek err");
  261. if (safewrite(fd, rptr, size) != size)
  262. report("subrec write err");
  263. flock(fd, LOCK_UN);
  264. close(fd);
  265. #ifdef POSTBUG
  266. if (size == sizeof(struct fileheader) && (id > 1) && ((id - 1) % 4 == 0))
  267. restorerecords(filename, size, id);
  268. #endif
  269. return 0;
  270. }
  272. void
  273. tmpfilename(filename, tmpfile, deleted)
  274. char   *filename, *tmpfile, *deleted;
  275. {
  276. char   *ptr, *delfname, *tmpfname;
  277. strcpy(tmpfile, filename);
  278. delfname = ".deleted";
  279. tmpfname = ".tmpfile";
  280. if ((ptr = strrchr(tmpfile, '/')) != NULL) {
  281. strcpy(ptr + 1, delfname);
  282. strcpy(deleted, tmpfile);
  283. strcpy(ptr + 1, tmpfname);
  284. } else {
  285. strcpy(deleted, delfname);
  286. strcpy(tmpfile, tmpfname);
  287. }
  288. }
  290. int
  291. delete_record(filename, size, id)
  292. char   *filename;
  293. int     size, id;
  294. {
  295. char    tmpfile[STRLEN], deleted[STRLEN];
  296. char    abuf[BUFSIZE];
  297. int     fdr, fdw, fd;
  298. int     count;
  299. if (size > BUFSIZE) {
  300. toobigmesg();
  301. return -1;
  302. }
  303. tmpfilename(filename, tmpfile, deleted);
  304. if ((fd = open(".dellock", O_RDWR | O_CREAT | O_APPEND, 0644)) == -1)
  305. return -1;
  306. flock(fd, LOCK_EX);
  308. if ((fdr = open(filename, O_RDONLY, 0)) == -1) {
  309. report("delrec open err");
  310. flock(fd, LOCK_UN);
  311. close(fd);
  312. return -1;
  313. }
  314. if ((fdw = open(tmpfile, O_WRONLY | O_CREAT | O_EXCL, 0644)) == -1) {
  315. flock(fd, LOCK_UN);
  316. report("delrec tmp err");
  317. close(fd);
  318. close(fdr);
  319. return -1;
  320. }
  321. count = 1;
  322. while (read(fdr, abuf, size) == size)
  323. if (id != count++ && (safewrite(fdw, abuf, size) == -1)) {
  324. unlink(tmpfile);
  325. close(fdr);
  326. close(fdw);
  327. report("delrec write err");
  328. flock(fd, LOCK_UN);
  329. close(fd);
  330. return -1;
  331. }
  332. close(fdr);
  333. close(fdw);
  334. if (rename(filename, deleted) == -1 ||
  335. rename(tmpfile, filename) == -1) {
  336. flock(fd, LOCK_UN);
  337. report("delrec rename err");
  338. close(fd);
  339. return -1;
  340. }
  341. flock(fd, LOCK_UN);
  342. close(fd);
  343. return 0;
  344. }
  346. int
  347. delete_range(filename, id1, id2)
  348. char   *filename;
  349. int     id1, id2;
  350. {
  351. struct fileheader fhdr;
  352. char    tmpfile[STRLEN], deleted[STRLEN];
  353. int     fdr, fdw, fd;
  354. int     count;
  355. tmpfilename(filename, tmpfile, deleted);
  356. if ((fd = open(".dellock", O_RDWR | O_CREAT | O_APPEND, 0644)) == -1)
  357. return -1;
  358. flock(fd, LOCK_EX);
  360. if ((fdr = open(filename, O_RDONLY, 0)) == -1) {
  361. flock(fd, LOCK_UN);
  362. close(fd);
  363. return -1;
  364. }
  365. if ((fdw = open(tmpfile, O_WRONLY | O_CREAT | O_EXCL, 0644)) == -1) {
  366. close(fdr);
  367. flock(fd, LOCK_UN);
  368. close(fd);
  369. return -1;
  370. }
  371. count = 1;
  372. while (read(fdr, &fhdr, sizeof(fhdr)) == sizeof(fhdr)) {
  373. if (count < id1 || count > id2 || fhdr.accessed[0] & FILE_MARKED) {
  374. if ((safewrite(fdw, &fhdr, sizeof(fhdr)) == -1)) {
  375. unlink(tmpfile);
  376. close(fdw);
  377. close(fdr);
  378. flock(fd, LOCK_UN);
  379. close(fd);
  380. return -1;
  381. }
  382. } else {
  383. char   *t;
  384. char    buf[STRLEN], fullpath[STRLEN];
  385. strcpy(buf, filename);
  386. if ((t = strrchr(buf, '/')) != NULL)
  387. *t = '';
  388. sprintf(fullpath, "%s/%s", buf, fhdr.filename);
  389. unlink(fullpath);
  390. }
  391. count++;
  392. }
  393. close(fdw);
  394. close(fdr);
  395. if (rename(filename, deleted) == -1) {
  396. flock(fd, LOCK_UN);
  397. close(fd);
  398. return -1;
  399. }
  400. if (rename(tmpfile, filename) == -1) {
  401. flock(fd, LOCK_UN);
  402. close(fd);
  403. return -1;
  404. }
  405. flock(fd, LOCK_UN);
  406. close(fd);
  407. return 0;
  408. }
  410. int
  411. update_file(dirname, size, ent, filecheck, fileupdate)
  412. char   *dirname;
  413. int     size, ent;
  414. int     (*filecheck) ();
  415. void    (*fileupdate) ();
  416. {
  417. char    abuf[BUFSIZE];
  418. int     fd;
  419. if (size > BUFSIZE) {
  420. toobigmesg();
  421. return -1;
  422. }
  423. if ((fd = open(dirname, O_RDWR)) == -1)
  424. return -1;
  425. flock(fd, LOCK_EX);
  426. if (lseek(fd, (off_t) (size * (ent - 1)), SEEK_SET) != -1) {
  427. if (read(fd, abuf, size) == size)
  428. if ((*filecheck) (abuf)) {
  429. lseek(fd, (off_t) (-size), SEEK_CUR);
  430. (*fileupdate) (abuf);
  431. if (safewrite(fd, abuf, size) != size) {
  432. report("update err");
  433. flock(fd, LOCK_UN);
  434. close(fd);
  435. return -1;
  436. }
  437. flock(fd, LOCK_UN);
  438. close(fd);
  439. return 0;
  440. }
  441. }
  442. lseek(fd, 0, SEEK_SET);
  443. while (read(fd, abuf, size) == size) {
  444. if ((*filecheck) (abuf)) {
  445. lseek(fd, (off_t) (-size), SEEK_CUR);
  446. (*fileupdate) (abuf);
  447. if (safewrite(fd, abuf, size) != size) {
  448. report("update err");
  449. flock(fd, LOCK_UN);
  450. close(fd);
  451. return -1;
  452. }
  453. flock(fd, LOCK_UN);
  454. close(fd);
  455. return 0;
  456. }
  457. }
  458. flock(fd, LOCK_UN);
  459. close(fd);
  460. return -1;
  461. }
  463. int
  464. delete_file(dirname, size, ent, filecheck)
  465. char   *dirname;
  466. int     size, ent;
  467. int     (*filecheck) ();
  468. {
  469. char    abuf[BUFSIZE];
  470. int     fd;
  471. struct stat st;
  472. long    numents;
  473. if (size > BUFSIZE) {
  474. toobigmesg();
  475. return -1;
  476. }
  477. if ((fd = open(dirname, O_RDWR)) == -1)
  478. return -1;
  479. flock(fd, LOCK_EX);
  480. fstat(fd, &st);
  481. numents = ((long) st.st_size) / size;
  482. if (((long) st.st_size) % size != 0)
  483. fprintf(stderr, "align errn");
  484. if (lseek(fd, (off_t) (size * (ent - 1)), SEEK_SET) != -1) {
  485. if (read(fd, abuf, size) == size)
  486. if ((*filecheck) (abuf)) {
  487. int     i;
  488. for (i = ent; i < numents; i++) {
  489. if (lseek(fd, (off_t) (i * size), SEEK_SET) == -1)
  490. break;
  491. if (read(fd, abuf, size) != size)
  492. break;
  493. if (lseek(fd, (off_t) ((i - 1) * size), SEEK_SET) == -1)
  494. break;
  495. if (safewrite(fd, abuf, size) != size)
  496. break;
  497. }
  498. ftruncate(fd, (off_t) size * (numents - 1));
  499. flock(fd, LOCK_UN);
  500. close(fd);
  501. return 0;
  502. }
  503. }
  504. lseek(fd, 0, SEEK_SET);
  505. ent = 1;
  506. while (read(fd, abuf, size) == size) {
  507. if ((*filecheck) (abuf)) {
  508. int     i;
  509. for (i = ent; i < numents; i++) {
  510. if (lseek(fd, (off_t) ((i + 1) * size), SEEK_SET) == -1)
  511. break;
  512. if (read(fd, abuf, size) != size)
  513. break;
  514. if (lseek(fd, (off_t) (i * size), SEEK_SET) == -1)
  515. break;
  516. if (safewrite(fd, abuf, size) != size)
  517. break;
  518. }
  519. ftruncate(fd, (off_t) size * (numents - 1));
  520. flock(fd, LOCK_UN);
  521. close(fd);
  522. return 0;
  523. }
  524. ent++;
  525. }
  526. flock(fd, LOCK_UN);
  527. close(fd);
  528. return -1;
  529. }