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

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

Telnet服务器

开发平台：

Unix_Linux

dbzinnbbsd.c：源码内容
  1. #include "innbbsconf.h"
  2. #include "daemon.h"
  3. #include "innbbsd.h"
  4. #include <dirent.h>
  5. #include "bbslib.h"
  6. #include "inntobbs.h"
  7. #include "nntp.h"
  9. #ifdef GETRUSAGE
  10. #include <sys/time.h>
  11. #include <sys/resource.h>
  12. #endif
  14. #ifdef STDC
  15. #ifndef ARG
  16. #define ARG(x) (x)
  17. #else
  18. #define ARG(x) ()
  19. #endif
  20. #endif
  22. /*<  add <mid> <recno> ...
  23. >  200 OK
  24. <  quit
  25.  500 BYE
  27. >  300 DBZ Server ...
  28. <  query <mid>
  29. >  250 <recno> ...
  30. >  450 NOT FOUND!
  31. */
  33. static int CMDhelp ARG((ClientType *));
  34. static int CMDquit ARG((ClientType *));
  35. static int CMDihave ARG((ClientType *));
  36. static int CMDstat ARG((ClientType *));
  37. static int CMDaddhist ARG((ClientType *));
  38. static int CMDgrephist ARG((ClientType *));
  39. static int CMDmidcheck ARG((ClientType *));
  40. static int CMDshutdown ARG((ClientType *));
  41. static int CMDmode ARG((ClientType *));
  42. static int CMDreload ARG((ClientType *));
  43. static int CMDhismaint ARG((ClientType *));
  44. static int CMDverboselog ARG((ClientType *));
  45. static int CMDlistnodelist ARG((ClientType *));
  46. static int CMDlistnewsfeeds ARG((ClientType *));
  47. static int CMDpause ARG((ClientType *));
  48. static int CMDgo ARG((ClientType *));
  49. #ifdef GETRUSAGE
  50. static int CMDgetrusage ARG((ClientType *));
  51. static int CMDmallocmap ARG((ClientType *));
  52. #endif
  54. static daemoncmd_t cmds[] =
  55. /*  cmd-name, cmd-usage, min-argc, max-argc, errorcode, normalcode, cmd-func */
  56. {{"help", "help [cmd]", 1, 2, 99, 100, CMDhelp},
  57. {"quit", "quit", 1, 0, 99, 100, CMDquit},
  58. #ifndef DBZSERVER
  59. {"ihave", "ihave mid", 2, 2, 435, 335, CMDihave},
  60. #endif
  61. {"stat", "stat mid", 2, 2, 223, 430, CMDstat},
  62. {"addhist", "addhist <mid> <path>", 3, 3, NNTP_ADDHIST_BAD, NNTP_ADDHIST_OK, CMDaddhist},
  63. {"grephist", "grephist <mid>", 2, 2, NNTP_GREPHIST_BAD, NNTP_GREPHIST_OK, CMDgrephist},
  64. {"midcheck", "midcheck [on|off]", 1, 2, NNTP_MIDCHECK_BAD, NNTP_MIDCHECK_OK, CMDmidcheck},
  65. {"shutdown", "shutdown (local)", 1, 1, NNTP_SHUTDOWN_BAD, NNTP_SHUTDOWN_OK, CMDshutdown},
  66. {"mode", "mode (local)", 1, 1, NNTP_MODE_BAD, NNTP_MODE_OK, CMDmode},
  67. {"listnodelist", "listnodelist (local)", 1, 1, NNTP_MODE_BAD, NNTP_MODE_OK, CMDlistnodelist},
  68. {"listnewsfeeds", "listnewsfeeds (local)", 1, 1, NNTP_MODE_BAD, NNTP_MODE_OK, CMDlistnewsfeeds},
  69. {"reload", "reload (local)", 1, 1, NNTP_RELOAD_BAD, NNTP_RELOAD_OK, CMDreload},
  70. {"pause", "pause (local)", 1, 1, NNTP_RELOAD_BAD, NNTP_RELOAD_OK, CMDpause},
  71. {"go", "go (local)", 1, 1, NNTP_RELOAD_BAD, NNTP_RELOAD_OK, CMDgo},
  72. {"hismaint", "hismaint (local)", 1, 1, NNTP_RELOAD_BAD, NNTP_RELOAD_OK, CMDhismaint},
  73. {"verboselog", "verboselog [on|off](local)", 1, 2, NNTP_VERBOSELOG_BAD, NNTP_VERBOSELOG_OK, CMDverboselog},
  74. #ifdef GETRUSAGE
  75. {"getrusage", "getrusage (local)", 1, 1, NNTP_MODE_BAD, NNTP_MODE_OK, CMDgetrusage},
  76. #endif
  77. #ifdef MALLOCMAP
  78. {"mallocmap", "mallocmap (local)", 1, 1, NNTP_MODE_BAD, NNTP_MODE_OK, CMDmallocmap},
  79. #endif
  80. {NULL, NULL, 0, 0, 99, 100, NULL}
  81. };
  82. installinnbbsd()
  83. {
  84. installdaemon(cmds, 100, NULL);
  85. }
  86. #ifdef OLDLIBINBBSINND
  87. testandmkdir(dir)
  88. char   *dir;
  89. {
  90. if (!isdir(dir)) {
  91. char    path[MAXPATHLEN + 12];
  92. sprintf(path, "mkdir -p %s", dir);
  93. system(path);
  94. }
  95. }
  97. static char splitbuf[2048];
  98. static char joinbuf[1024];
  99. #define MAXTOK 50
  100. static char *Splitptr[MAXTOK];
  101. char  **
  102. split(line, pat)
  103. char   *line, *pat;
  104. {
  105. char   *p;
  106. int     i;
  107. for (i = 0; i < MAXTOK; ++i)
  108. Splitptr[i] = NULL;
  109. strncpy(splitbuf, line, sizeof splitbuf - 1);
  110. /* printf("%d %dn",strlen(line),strlen(splitbuf)); */
  111. splitbuf[sizeof splitbuf - 1] = '';
  112. for (i = 0, p = splitbuf; *p && i < MAXTOK - 1;) {
  113. for (Splitptr[i++] = p; *p && !strchr(pat, *p); p++);
  114. if (*p == '')
  115. break;
  116. for (*p++ = ''; *p && strchr(pat, *p); p++);
  117. }
  118. return Splitptr;
  119. }
  121. char  **
  122. BNGsplit(line)
  123. char   *line;
  124. {
  125. char  **ptr = split(line, ",");
  126. newsfeeds_t *nf1, *nf2;
  127. char   *n11, *n12, *n21, *n22;
  128. int     i, j;
  129. for (i = 0; ptr[i] != NULL; i++) {
  130. nf1 = (newsfeeds_t *) search_group(ptr[i]);
  131. for (j = i + 1; ptr[j] != NULL; j++) {
  132. if (strcmp(ptr[i], ptr[j]) == 0) {
  133. *ptr[j] = '';
  134. continue;
  135. }
  136. nf2 = (newsfeeds_t *) search_group(ptr[j]);
  137. if (nf1 && nf2) {
  138. if (strcmp(nf1->board, nf2->board) == 0) {
  139. *ptr[j] = '';
  140. continue;
  141. }
  142. for (n11 = nf1->board, n12 = (char *) strchr(n11, ',');
  143. n11 && *n11; n12 = (char *) strchr(n11, ',')) {
  144. if (n12)
  145. *n12 = '';
  146. for (n21 = nf2->board, n22 = (char *) strchr(n21, ',');
  147. n21 && *n21; n22 = (char *) strchr(n21, ',')) {
  148. if (n22)
  149. *n22 = '';
  150. if (strcmp(n11, n21) == 0) {
  151. *n21 = 't';
  152. }
  153. if (n22) {
  154. *n22 = ',';
  155. n21 = n22 + 1;
  156. } else
  157. break;
  158. }
  159. if (n12) {
  160. *n12 = ',';
  161. n11 = n12 + 1;
  162. } else
  163. break;
  164. }
  165. }
  166. }
  167. }
  168. return ptr;
  169. }
  171. char  **
  172. ssplit(line, pat)
  173. char   *line, *pat;
  174. {
  175. char   *p;
  176. int     i;
  177. for (i = 0; i < MAXTOK; ++i)
  178. Splitptr[i] = NULL;
  179. strncpy(splitbuf, line, 1024);
  180. for (i = 0, p = splitbuf; *p && i < MAXTOK;) {
  181. for (Splitptr[i++] = p; *p && !strchr(pat, *p); p++);
  182. if (*p == '')
  183. break;
  184. *p = 0;
  185. p++;
  186. /*    for (*p=''; strchr(pat,*p);p++);*/
  187. }
  188. return Splitptr;
  189. }
  191. char   *
  192. join(lineptr, pat, num)
  193. char  **lineptr, *pat;
  194. int     num;
  195. {
  196. int     i;
  197. joinbuf[0] = '';
  198. if (lineptr[0] != NULL)
  199. strncpy(joinbuf, lineptr[0], 1024);
  200. else {
  201. joinbuf[0] = '';
  202. return joinbuf;
  203. }
  204. for (i = 1; i < num; i++) {
  205. strcat(joinbuf, pat);
  206. if (lineptr[i] != NULL)
  207. strcat(joinbuf, lineptr[i]);
  208. else
  209. break;
  210. }
  211. return joinbuf;
  212. }
  213. #endif
  215. static int 
  216. CMDtnrpd(client)
  217. ClientType *client;
  218. {
  219. argv_t *argv = &client->Argv;
  220. fprintf(argv->out, "%d %sn", argv->dc->usage);
  221. return 0;
  222. }
  223. islocalconnect(client)
  224. ClientType *client;
  225. {
  226. if (strcmp(client->username, "localuser") != 0 ||
  227. strcmp(client->hostname, "localhost") != 0)
  228. return 0;
  229. return 1;
  230. }
  232. static  shutdownflag = 0;
  233. INNBBSDhalt()
  234. {
  235. shutdownflag = 1;
  236. }
  238. int 
  239. INNBBSDshutdown()
  240. {
  241. return shutdownflag;
  242. }
  244. static int 
  245. CMDshutdown(client)
  246. ClientType *client;
  247. {
  248. argv_t *argv = &client->Argv;
  249. buffer_t *in = &client->in;
  250. daemoncmd_t *p = argv->dc;
  251. if (!islocalconnect(client)) {
  252. fprintf(argv->out, "%d shutdown access deniedrn", p->errorcode);
  253. fflush(argv->out);
  254. verboselog("Shutdown Put: %d shutdown access deniedn", p->errorcode);
  255. return 1;
  256. }
  257. shutdownflag = 1;
  258. fprintf(argv->out, "%d shutdown startingrn", p->normalcode);
  259. fflush(argv->out);
  260. verboselog("Shutdown Put: %d shutdown startingn", p->normalcode);
  261. return 1;
  262. }
  264. static int 
  265. CMDmode(client)
  266. ClientType *client;
  267. {
  268. /* char cwdpath[MAXPATHLEN+1]; */
  269. argv_t *argv = &client->Argv;
  270. extern ClientType INNBBSD_STAT;
  271. buffer_t *in = &client->in;
  272. daemoncmd_t *p = argv->dc;
  273. time_t  uptime, now;
  274. int     i, j;
  275. time_t  lasthist;
  276. ClientType *client1 = &INNBBSD_STAT;
  277. if (!islocalconnect(client)) {
  278. fprintf(argv->out, "%d mode access deniedrn", p->errorcode);
  279. fflush(argv->out);
  280. verboselog("Mode Put: %d mode access deniedn", p->errorcode);
  281. return 1;
  282. }
  283. fprintf(argv->out, "%d modern", p->normalcode);
  284. fflush(argv->out);
  285. verboselog("Mode Put: %d moden", p->normalcode);
  286. uptime = innbbsdstartup();
  287. time(&now);
  288. fprintf(argv->out, "up since %salive %.2f daysrn", ctime(&uptime), (double) (now - innbbsdstartup()) / 86400);
  289. fprintf(argv->out, "BBSHOME %srn", BBSHOME);
  290. fprintf(argv->out, "MYBBSID %srn", MYBBSID);
  291. fprintf(argv->out, "ECHOMAIL %srn", ECHOMAIL);
  292. fprintf(argv->out, "INNDHOME %srn", INNDHOME);
  293. fprintf(argv->out, "HISTORY %srn", HISTORY);
  294. fprintf(argv->out, "LOGFILE %srn", LOGFILE);
  295. fprintf(argv->out, "INNBBSCONF %srn", INNBBSCONF);
  296. fprintf(argv->out, "BBSFEEDS %srn", BBSFEEDS);
  297. fprintf(argv->out, "Verbose log: %srn", isverboselog() ? "ON" : "OFF");
  298. fprintf(argv->out, "History Expire Days %drn", Expiredays);
  299. fprintf(argv->out, "History Expire Time %d:%drn", His_Maint_Hour, His_Maint_Min);
  300. lasthist = gethisinfo();
  301. if (lasthist > 0) {
  302. time_t  keep = lasthist, keep1;
  303. time(&now);
  304. fprintf(argv->out, "Oldest history entry created: %s", (char *) ctime(&keep));
  305. keep = Expiredays * 86400 * 2 + lasthist;
  306. keep1 = keep - now;
  307. fprintf(argv->out, "Next time to maintain history: (%.2f days later) %s", (double) keep1 / 86400, (char *) ctime(&keep));
  308. }
  309. fprintf(argv->out, "PID is %drn", getpid());
  310. fprintf(argv->out, "LOCAL ONLY %drn", LOCALNODELIST);
  311. fprintf(argv->out, "NONE NEWSFEEDS %drn", NONENEWSFEEDS);
  312. fprintf(argv->out, "Max connections %drn", Maxclient);
  313. #ifdef DEBUGCWD
  314. getwd(cwdpath);
  315. fprintf(argv->out, "Working directory %srn", cwdpath);
  316. #endif
  317. if (Channel)
  318. for (i = 0, j = 0; i < Maxclient; ++i) {
  319. if (Channel[i].fd == -1)
  320. continue;
  321. if (Channel + i == client)
  322. continue;
  323. j++;
  324. fprintf(argv->out, " %d) in->used %d, in->left %d %s@%srn", i,
  325. Channel[i].in.used, Channel[i].in.left,
  326. Channel[i].username, Channel[i].hostname);
  327. }
  328. fprintf(argv->out, "Total connections %drn", j);
  329. fprintf(argv->out, "Total rec: %d dup: %d fail: %d size: %d, stat rec: %d fail: %dn", client1->ihavecount, client1->ihaveduplicate, client1->ihavefail, client1->ihavesize, client1->statcount, client1->statfail);
  330. fprintf(argv->out, ".rn");
  331. fflush(argv->out);
  332. return 1;
  333. }
  335. static int
  336. CMDlistnodelist(client)
  337. ClientType *client;
  338. {
  339. int     nlcount;
  340. argv_t *argv = &client->Argv;
  341. buffer_t *in = &client->in;
  342. daemoncmd_t *p = argv->dc;
  343. if (!islocalconnect(client)) {
  344. fprintf(argv->out, "%d listnodelist access deniedrn", p->errorcode);
  345. fflush(argv->out);
  346. verboselog("Mallocmap Put: %d listnodelist access deniedn", p->errorcode);
  347. return 1;
  348. }
  349. fprintf(argv->out, "%d listnodelistrn", p->normalcode);
  350. for (nlcount = 0; nlcount < NLCOUNT; nlcount++) {
  351. nodelist_t *nl = NODELIST + nlcount;
  352. fprintf(argv->out, "%2d %s /\/\ %srn", nlcount + 1, nl->node == NULL ? "" : nl->node, nl->exclusion == NULL ? "" : nl->exclusion);
  353. fprintf(argv->out, "   %s:%s:%srn", nl->host == NULL ? "" : nl->host, nl->protocol == NULL ? "" : nl->protocol, nl->comments == NULL ? "" : nl->comments);
  354. }
  355. fprintf(argv->out, ".rn");
  356. fflush(argv->out);
  357. verboselog("Listnodelist Put: %d listnodelist completen", p->normalcode);
  358. return 1;
  359. }
  361. static int
  362. CMDlistnewsfeeds(client)
  363. ClientType *client;
  364. {
  365. argv_t *argv = &client->Argv;
  366. buffer_t *in = &client->in;
  367. daemoncmd_t *p = argv->dc;
  368. int     nfcount;
  369. if (!islocalconnect(client)) {
  370. fprintf(argv->out, "%d listnewsfeeds access deniedrn", p->errorcode);
  371. fflush(argv->out);
  372. verboselog("Mallocmap Put: %d listnewsfeeds access deniedn", p->errorcode);
  373. return 1;
  374. }
  375. fprintf(argv->out, "%d listnewsfeedsrn", p->normalcode);
  376. for (nfcount = 0; nfcount < NFCOUNT; nfcount++) {
  377. newsfeeds_t *nf = NEWSFEEDS + nfcount;
  378. fprintf(argv->out, "%3d %s<=>%srn", nfcount + 1, nf->newsgroups, nf->board);
  379. fprintf(argv->out, "    %srn", nf->path == NULL ? "(Null)" : nf->path);
  380. }
  381. fprintf(argv->out, ".rn");
  382. fflush(argv->out);
  383. verboselog("Listnewsfeeds Put: %d listnewsfeeds completen", p->normalcode);
  384. return 1;
  385. }
  386. #ifdef MALLOCMAP
  387. static int 
  388. CMDmallocmap(client)
  389. ClientType *client;
  390. {
  391. argv_t *argv = &client->Argv;
  392. buffer_t *in = &client->in;
  393. daemoncmd_t *p = argv->dc;
  394. struct rusage ru;
  395. int     savefd;
  396. if (!islocalconnect(client)) {
  397. fprintf(argv->out, "%d mallocmap access deniedrn", p->errorcode);
  398. fflush(argv->out);
  399. verboselog("Mallocmap Put: %d mallocmap access deniedn", p->errorcode);
  400. return 1;
  401. }
  402. fprintf(argv->out, "%d mallocmaprn", p->normalcode);
  403. savefd = dup(1);
  404. dup2(client->fd, 1);
  405. mallocmap();
  406. dup2(savefd, 1);
  407. close(savefd);
  408. fprintf(argv->out, ".rn");
  409. fflush(argv->out);
  410. verboselog("Mallocmap Put: %d mallocmap completen", p->normalcode);
  411. return 1;
  412. }
  413. #endif
  415. #ifdef GETRUSAGE
  416. static int 
  417. CMDgetrusage(client)
  418. ClientType *client;
  419. {
  420. argv_t *argv = &client->Argv;
  421. buffer_t *in = &client->in;
  422. daemoncmd_t *p = argv->dc;
  423. struct rusage ru;
  424. if (!islocalconnect(client)) {
  425. fprintf(argv->out, "%d getrusage access deniedrn", p->errorcode);
  426. fflush(argv->out);
  427. verboselog("Getrusage Put: %d getrusage access deniedn", p->errorcode);
  428. return 1;
  429. }
  430. fprintf(argv->out, "%d getrusagern", p->normalcode);
  431. if (getrusage(RUSAGE_SELF, &ru) == 0) {
  432. fprintf(argv->out, "user time used: %.6frn", (double) ru.ru_utime.tv_sec + (double) ru.ru_utime.tv_usec / 1000000.0);
  433. fprintf(argv->out, "system time used: %.6frn", (double) ru.ru_stime.tv_sec + (double) ru.ru_stime.tv_usec / 1000000.0);
  434. fprintf(argv->out, "maximum resident set size: %lurn", ru.ru_maxrss * getpagesize());
  435. fprintf(argv->out, "integral resident set size: %lurn", ru.ru_idrss * getpagesize());
  436. fprintf(argv->out, "page faults not requiring physical I/O: %drn", ru.ru_minflt);
  437. fprintf(argv->out, "page faults requiring physical I/O: %drn", ru.ru_majflt);
  438. fprintf(argv->out, "swaps: %drn", ru.ru_nswap);
  439. fprintf(argv->out, "block input operations: %drn", ru.ru_inblock);
  440. fprintf(argv->out, "block output operations: %drn", ru.ru_oublock);
  441. fprintf(argv->out, "messages sent: %drn", ru.ru_msgsnd);
  442. fprintf(argv->out, "messages received: %drn", ru.ru_msgrcv);
  443. fprintf(argv->out, "signals received: %drn", ru.ru_nsignals);
  444. fprintf(argv->out, "voluntary context switches: %drn", ru.ru_nvcsw);
  445. fprintf(argv->out, "involuntary context switches: %drn", ru.ru_nivcsw);
  446. }
  447. fprintf(argv->out, ".rn");
  448. fflush(argv->out);
  449. verboselog("Getrusage Put: %d getrusage completen", p->normalcode);
  450. return 1;
  451. }
  452. #endif
  454. static int 
  455. CMDhismaint(client)
  456. ClientType *client;
  457. {
  458. argv_t *argv = &client->Argv;
  459. buffer_t *in = &client->in;
  460. daemoncmd_t *p = argv->dc;
  461. if (!islocalconnect(client)) {
  462. fprintf(argv->out, "%d hismaint access deniedrn", p->errorcode);
  463. fflush(argv->out);
  464. verboselog("Hismaint Put: %d hismaint access deniedn", p->errorcode);
  465. return 1;
  466. }
  467. verboselog("Hismaint Put: %d hismaint startn", p->normalcode);
  468. HISmaint();
  469. fprintf(argv->out, "%d hismaint completern", p->normalcode);
  470. fflush(argv->out);
  471. verboselog("Hismaint Put: %d hismaint completen", p->normalcode);
  472. return 1;
  473. }
  475. static int INNBBSDpause = 0;
  477. static int 
  478. CMDgo(client)
  479. ClientType *client;
  480. {
  481. argv_t *argv = &client->Argv;
  482. buffer_t *in = &client->in;
  483. daemoncmd_t *p = argv->dc;
  484. if (!islocalconnect(client)) {
  485. fprintf(argv->out, "%d go access deniedrn", p->errorcode);
  486. fflush(argv->out);
  487. verboselog("Pause Put: %d go access deniedn", p->errorcode);
  488. return 1;
  489. }
  490. INNBBSDpause = 0;
  492. fprintf(argv->out, "%d go completern", p->normalcode);
  493. fflush(argv->out);
  494. verboselog("Pause Put: %d go completen", p->normalcode);
  495. return 1;
  496. }
  500. int
  501. isPause()
  502. {
  503. return INNBBSDpause;
  504. }
  506. static int 
  507. CMDpause(client)
  508. ClientType *client;
  509. {
  510. argv_t *argv = &client->Argv;
  511. buffer_t *in = &client->in;
  512. daemoncmd_t *p = argv->dc;
  513. if (!islocalconnect(client)) {
  514. fprintf(argv->out, "%d pause access deniedrn", p->errorcode);
  515. fflush(argv->out);
  516. verboselog("Pause Put: %d pause access deniedn", p->errorcode);
  517. return 1;
  518. }
  519. INNBBSDpause = 1;
  521. fprintf(argv->out, "%d pause completern", p->normalcode);
  522. fflush(argv->out);
  523. verboselog("Pause Put: %d pause completen", p->normalcode);
  524. return 1;
  525. }
  527. static int 
  528. CMDreload(client)
  529. ClientType *client;
  530. {
  531. argv_t *argv = &client->Argv;
  532. buffer_t *in = &client->in;
  533. daemoncmd_t *p = argv->dc;
  534. if (!islocalconnect(client)) {
  535. fprintf(argv->out, "%d reload access deniedrn", p->errorcode);
  536. fflush(argv->out);
  537. verboselog("Reload Put: %d reload access deniedn", p->errorcode);
  538. return 1;
  539. }
  540. initial_bbs("feed");
  541. fprintf(argv->out, "%d reload completern", p->normalcode);
  542. fflush(argv->out);
  543. verboselog("Reload Put: %d reload completen", p->normalcode);
  544. return 1;
  545. }
  547. static int 
  548. CMDverboselog(client)
  549. ClientType *client;
  550. {
  551. argv_t *argv = &client->Argv;
  552. buffer_t *in = &client->in;
  553. daemoncmd_t *p = argv->dc;
  554. if (!islocalconnect(client)) {
  555. fprintf(argv->out, "%d verboselog access deniedrn", p->errorcode);
  556. fflush(argv->out);
  557. verboselog("Reload Put: %d verboselog access deniedn", p->errorcode);
  558. return 1;
  559. }
  560. if (client->mode == 0) {
  561. if (argv->argc > 1) {
  562. if (strcasecmp(argv->argv[1], "off") == 0) {
  563. setverboseoff();
  564. } else {
  565. setverboseon();
  566. }
  567. }
  568. }
  569. fprintf(argv->out, "%d verboselog %srn", p->normalcode,
  570. isverboselog() ? "ON" : "OFF");
  571. fflush(argv->out);
  572. verboselog("%d verboselog %srn", p->normalcode,
  573. isverboselog() ? "ON" : "OFF");
  574. }
  576. static int 
  577. CMDmidcheck(client)
  578. ClientType *client;
  579. {
  580. argv_t *argv = &client->Argv;
  581. buffer_t *in = &client->in;
  582. daemoncmd_t *p = argv->dc;
  583. if (client->mode == 0) {
  584. if (argv->argc > 1) {
  585. if (strcasecmp(argv->argv[1], "off") == 0) {
  586. client->midcheck = 0;
  587. } else {
  588. client->midcheck = 1;
  589. }
  590. }
  591. }
  592. fprintf(argv->out, "%d mid check %srn", p->normalcode,
  593. client->midcheck == 1 ? "ON" : "OFF");
  594. fflush(argv->out);
  595. verboselog("%d mid check %srn", p->normalcode,
  596. client->midcheck == 1 ? "ON" : "OFF");
  597. }
  599. static int 
  600. CMDgrephist(client)
  601. ClientType *client;
  602. {
  603. argv_t *argv = &client->Argv;
  604. buffer_t *in = &client->in;
  605. daemoncmd_t *p = argv->dc;
  606. if (client->mode == 0) {
  607. if (argv->argc > 1) {
  608. char   *ptr;
  609. ptr = (char *) DBfetch(argv->argv[1]);
  610. if (ptr != NULL) {
  611. fprintf(argv->out, "%d %s OKrn", p->normalcode, ptr);
  612. fflush(argv->out);
  613. verboselog("Addhist Put: %d %s OKn", p->normalcode, ptr);
  614. return 0;
  615. } else {
  616. fprintf(argv->out, "%d %s not foundrn", p->errorcode, argv->argv[1]);
  617. fflush(argv->out);
  618. verboselog("Addhist Put: %d %s not foundn", p->errorcode, argv->argv[1]);
  619. return 1;
  620. }
  621. }
  622. }
  623. fprintf(argv->out, "%d grephist errorrn", p->errorcode);
  624. fflush(argv->out);
  625. verboselog("Addhist Put: %d grephist errorn", p->errorcode);
  626. return 1;
  627. }
  630. static int 
  631. CMDaddhist(client)
  632. ClientType *client;
  633. {
  634. argv_t *argv = &client->Argv;
  635. buffer_t *in = &client->in;
  636. daemoncmd_t *p = argv->dc;
  637. /*
  638.  * if (strcmp(client->username,"localuser") != 0 ||
  639.  * strcmp(client->hostname,"localhost") != 0) { fprintf(argv->out,"%d
  640.  * add hist access deniedrn", p->errorcode); fflush(argv->out);
  641.  * verboselog("Addhist Put: %d add hist access deniedn",
  642.  * p->errorcode); return 1; }
  643.  */
  644. if (client->mode == 0) {
  645. if (argv->argc > 2) {
  646. char   *ptr;
  647. ptr = (char *) DBfetch(argv->argv[1]);
  648. if (ptr == NULL) {
  649. if (storeDB(argv->argv[1], argv->argv[2]) < 0) {
  650. fprintf(argv->out, "%d add hist store DB errorrn", p->errorcode);
  651. fflush(argv->out);
  652. verboselog("Addhist Put: %d add hist store DB errorn", p->errorcode);
  653. return 1;
  654. } else {
  655. fprintf(argv->out, "%d add hist OKrn", p->normalcode);
  656. fflush(argv->out);
  657. verboselog("Addhist Put: %d add hist OKn", p->normalcode);
  658. return 0;
  659. }
  660. } else {
  661. fprintf(argv->out, "%d add hist duplicate errorrn", p->errorcode);
  662. fflush(argv->out);
  663. verboselog("Addhist Put: %d add hist duplicate errorn", p->errorcode);
  664. return 1;
  665. }
  666. }
  667. }
  668. fprintf(argv->out, "%d add hist errorrn", p->errorcode);
  669. fflush(argv->out);
  670. verboselog("Addhist Put: %d add hist errorn", p->errorcode);
  671. return 1;
  672. }
  674. static int 
  675. CMDstat(client)
  676. ClientType *client;
  677. {
  678. argv_t *argv = &client->Argv;
  679. char   *ptr, *frontptr;
  680. buffer_t *in = &client->in;
  681. daemoncmd_t *p;
  682. if (client->mode == 0) {
  683. client->statcount++;
  684. if (argv->argc > 1) {
  685. if (argv->argv[1][0] != '<') {
  686. fprintf(argv->out, "430 No such articlern");
  687. fflush(argv->out);
  688. verboselog("Stat Put: 430 No such articlen");
  689. client->statfail++;
  690. return 0;
  691. }
  692. ptr = (char *) DBfetch(argv->argv[1]);
  693. if (ptr != NULL) {
  694. fprintf(argv->out, "223 0 status %srn", argv->argv[1]);
  695. fflush(argv->out);
  696. client->mode = 0;
  697. verboselog("Stat Put: 223 0 status %sn", argv->argv[1]);
  698. return 1;
  699. } else {
  700. fprintf(argv->out, "430 No such articlern");
  701. fflush(argv->out);
  702. verboselog("Stat Put: 430 No such articlen");
  703. client->mode = 0;
  704. client->statfail++;
  705. }
  706. }
  707. }
  708. }
  709. #ifndef DBZSERVER
  710. static int 
  711. CMDihave(client)
  712. ClientType *client;
  713. {
  714. argv_t *argv = &client->Argv;
  715. char   *ptr = NULL, *frontptr;
  716. buffer_t *in = &client->in;
  717. daemoncmd_t *p;
  718. if (client->mode == 0) {
  719. client->ihavecount++;
  720. if (argv->argc > 1) {
  721. if (argv->argv[1][0] != '<') {
  722. fprintf(argv->out, "435 Bad Message-IDrn");
  723. fflush(argv->out);
  724. verboselog("Ihave Put: 435 Bad Message-IDn");
  725. client->ihavefail++;
  726. return 0;
  727. }
  728. if (client->midcheck == 1)
  729. ptr = (char *) DBfetch(argv->argv[1]);
  730. if (ptr != NULL && client->midcheck == 1) {
  731. fprintf(argv->out, "435 Duplicatern");
  732. fflush(argv->out);
  733. client->mode = 0;
  734. verboselog("Ihave Put: 435 Duplicaten");
  735. client->ihaveduplicate++;
  736. client->ihavefail++;
  737. return 1;
  738. } else {
  739. fprintf(argv->out, "335rn");
  740. fflush(argv->out);
  741. client->mode = 1;
  742. verboselog("Ihave Put: 335n");
  743. }
  744. }
  745. } else {
  746. client->mode = 0;
  747. readlines(client);
  748. if (HEADER[SUBJECT_H] && HEADER[FROM_H] && HEADER[DATE_H] &&
  749. HEADER[MID_H] && HEADER[NEWSGROUPS_H]) {
  750. char   *path1, *path2;
  751. int     rel;
  752. rel = 0;
  753. path1 = (char *) mymalloc(strlen(HEADER[PATH_H]) + 3);
  754. path2 = (char *) mymalloc(strlen(MYBBSID) + 3);
  755. sprintf(path1, "!%s!", HEADER[PATH_H]);
  756. sprintf(path2, "!%s!", MYBBSID);
  757. if (HEADER[CONTROL_H]) {
  758. bbslog("Control: %sn", HEADER[CONTROL_H]);
  759. if (strncasecmp(HEADER[CONTROL_H], "cancel ", 7) == 0) {
  760. rel = cancel_article_front(HEADER[CONTROL_H] + 7);
  761. } else {
  762. rel = receive_control();
  763. }
  764. } else if ((char *) strstr(path1, path2) != NULL) {
  765. bbslog(":Warn: Loop back article: %s!%sn", MYBBSID, HEADER[PATH_H]);
  766. } else {
  767. rel = receive_article();
  768. }
  769. free(path1);
  770. free(path2);
  771. if (rel == -1) {
  772. fprintf(argv->out, "400 server side failedrn");
  773. fflush(argv->out);
  774. verboselog("Ihave Put: 400n");
  775. clearfdset(client->fd);
  776. fclose(client->Argv.in);
  777. fclose(client->Argv.out);
  778. close(client->fd);
  779. client->fd = -1;
  780. client->mode = 0;
  781. client->ihavefail++;
  782. return;
  783. } else {
  784. fprintf(argv->out, "235rn");
  785. verboselog("Ihave Put: 235n");
  786. }
  787. fflush(argv->out);
  788. } else if (!HEADER[PATH_H]) {
  789. fprintf(argv->out, "437 No Path in "ihave %s" headerrn", HEADER[MID_H]);
  790. fflush(argv->out);
  791. verboselog("Put: 437 No Path in "ihave %s" headern", HEADER[MID_H]);
  792. client->ihavefail++;
  793. } else {
  794. fprintf(argv->out, "437 No colon-space in "ihave %s" headerrn", HEADER[MID_H]);
  795. fflush(argv->out);
  796. verboselog("Ihave Put: 437 No colon-space in "ihave %s" headern", HEADER[MID_H]);
  797. client->ihavefail++;
  798. }
  799. #ifdef DEBUG
  800. printf("subject is %sn", HEADER[SUBJECT_H]);
  801. printf("from is %sn", HEADER[FROM_H]);
  802. printf("Date is %sn", HEADER[DATE_H]);
  803. printf("Newsgroups is %sn", HEADER[NEWSGROUPS_H]);
  804. printf("mid is %sn", HEADER[MID_H]);
  805. printf("path is %sn", HEADER[PATH_H]);
  806. #endif
  807. }
  808. fflush(argv->out);
  809. return 0;
  810. }
  811. #endif
  813. static int 
  814. CMDhelp(client)
  815. ClientType *client;
  816. {
  817. argv_t *argv = &client->Argv;
  818. daemoncmd_t *p;
  819. if (argv->argc >= 1) {
  820. fprintf(argv->out, "%d Available Commandsrn", argv->dc->normalcode);
  821. for (p = cmds; p->name != NULL; p++) {
  822. fprintf(argv->out, "  %srn", p->usage);
  823. }
  824. fprintf(argv->out, "Report problems to %srn", ADMINUSER);
  825. }
  826. fputs(".rn", argv->out);
  827. fflush(argv->out);
  828. client->mode = 0;
  829. return 0;
  830. }
  832. static int 
  833. CMDquit(client)
  834. ClientType *client;
  835. {
  836. argv_t *argv = &client->Argv;
  837. fprintf(argv->out, "205 quitrn");
  838. fflush(argv->out);
  839. verboselog("Quit Put: 205 quitn");
  840. clearfdset(client->fd);
  841. fclose(client->Argv.in);
  842. fclose(client->Argv.out);
  843. close(client->fd);
  844. client->fd = -1;
  845. client->mode = 0;
  846. channeldestroy(client);
  847. /* exit(0); */
  848. }