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

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

Telnet服务器

开发平台：

Unix_Linux

nocem.c：源码内容
  1. /*
  2.   NoCeM-INNBBSD
  3.   Yen-Ming Lee <leeym@cae.ce.ntu.edu.tw>
  4.   NCMparse(), NCMverify(), NCMcancel(): return 0 success, otherwise fail;
  5. */
  6. /*
  7. This patch is came from <leeym@cae.ce.ntu.edu.tw>, please view COPYRIGHT.nocem
  8. for Copyright notice.
  10. $Id: nocem.c,v 1.3 2000/02/14 05:52:44 edwardc Exp $
  11. */
  13. #include "nocem.h"
  14. #ifdef USE_NCM_PATCH /* for FB3 */
  16. #undef PGP2
  18. int ncmdebug = 0;
  20. char NCMVER[8];
  21. char ISSUER[STRLEN];
  22. char TYPE[8];
  23. char ACTION[8];
  24. char NCMID[STRLEN];
  25. char COUNT[8];
  26. char THRESHOLD[STRLEN];
  27. char KEYID[16];
  28. char SPAMMID_NOW[STRLEN];
  29. char SPAMMID[MAXSPAMMID][STRLEN];
  31. int NNTP = -1;
  32. FILE *NNTPrfp = NULL;
  33. FILE *NNTPwfp = NULL;
  34. char NNTPbuffer[1024];
  35. int num_spammid = 0;
  36. char errmsg[1024] = "nothing";
  38. /* ------------------------------------------------------------------ */
  39. /* NCM initial and maintain                                           */
  40. /* ------------------------------------------------------------------ */
  42. static int
  43. ncm_bytypecmp(a,b)
  44. ncmperm_t **a, **b;
  45. {
  46.   return strcasecmp((*a)->type, (*b)->type);
  47. }
  49. static int
  50. ncmcmp(a,b)
  51. ncmperm_t *a, *b;
  52. {
  53.   return strcasecmp(a->issuer, b->issuer);
  54. }
  56. #if 0
  57. ncmperm_t *search_issuer(issuer)
  58. char *issuer;
  59. {
  60.   ncmperm_t ncmt, *find;
  61.   ncmt.issuer = "*";
  62.   find = (ncmperm_t*)bsearch((char*)&ncmt, NCMPERM, NCMCOUNT, sizeof(ncmperm_t), ncmcmp);
  63.   if (find)
  64.     return find;
  65.   ncmt.issuer = issuer;
  66.   find = (ncmperm_t*)bsearch((char*)&ncmt, NCMPERM, NCMCOUNT, sizeof(ncmperm_t), ncmcmp);
  67.   return find;
  68. }
  69. #else
  70. ncmperm_t *search_issuer(issuer)
  71. char *issuer;
  72. {
  73.   ncmperm_t ncmt, *find;
  74.   int i;
  75.   for (i = 0; i < NCMCOUNT; i++)
  76.   {
  77.     find = &NCMPERM[i];
  78.     if (strstr(find->issuer, "*"))
  79.       return find;
  80.     if (strstr(issuer,find->issuer))
  81.       return find;
  82.   }
  83.   return NULL;
  84. }
  85. #endif
  87. int
  88. readNCMfile(inndhome)
  89. char *inndhome;
  90. {
  91.   FILE *fp;
  92.   char buff[256];
  93.   struct stat st;
  94.   int i, count;
  95.   char *ptr, *ncmpermptr;
  97.   sprintf(buff,"%s/ncmperm.bbs", inndhome);
  98.   fp = fopen(buff,"r");
  99.   if (fp == NULL) {
  100.      fprintf(stderr,"read fail %s",buff);
  101.      return -1;
  102.   }
  103.   if (fstat(fileno(fp),&st) != 0) {
  104.       fprintf(stderr,"stat fail %s", buff);
  105.       return -1;
  106.   }
  107.   if (NCMPERM_BUF == NULL) {
  108.       NCMPERM_BUF = (char*) mymalloc( st.st_size +1);
  109.   } else {
  110.       NCMPERM_BUF = (char*) myrealloc( NCMPERM_BUF, st.st_size +1);
  111.   }
  112.   i = 0, count =0;
  113.   while (fgets(buff, sizeof buff, fp) != NULL) {
  114.      if (buff[0] == '#') continue;
  115.      if (buff[0] == 'n') continue;
  116.      strcpy(NCMPERM_BUF+i, buff);
  117.      i += strlen(buff);
  118.      count ++;
  119.   }
  120.   fclose(fp);
  121.   if (NCMPERM == NULL) {
  122.      NCMPERM = (ncmperm_t*) mymalloc(sizeof(ncmperm_t) * (count+1));
  123.      NCMPERM_BYTYPE = (ncmperm_t**) mymalloc(sizeof(ncmperm_t*) * (count+1));
  124.   } else {
  125.      NCMPERM = (ncmperm_t*) myrealloc(NCMPERM, sizeof(ncmperm_t) * (count+1));
  126.      NCMPERM_BYTYPE = (ncmperm_t**) myrealloc(NCMPERM_BYTYPE, sizeof(ncmperm_t*) * (count+1));
  127.   }
  128.   NCMCOUNT = 0;
  129.   for (ptr = NCMPERM_BUF; (ncmpermptr = (char*)strchr(ptr,'n')) != NULL; ptr = ncmpermptr +1, NCMCOUNT++) {
  130.       char *nptr;
  131.       *ncmpermptr = '';
  132.       NCMPERM[NCMCOUNT].issuer = "";
  133.       NCMPERM[NCMCOUNT].type = "";
  134.       NCMPERM[NCMCOUNT].perm = 0;
  135.       NCMPERM_BYTYPE[NCMCOUNT] = NCMPERM+NCMCOUNT;
  136.       for (nptr= ptr ;*nptr && (*nptr == 't'); ) nptr++;
  137.       if (*nptr == '') continue;
  138.       NCMPERM[NCMCOUNT].issuer = nptr;
  139.       for (nptr++; *nptr && !(*nptr == 't'); ) nptr++;
  140.       if (*nptr == '') continue;
  141.       *nptr = '';
  142.       for (nptr++ ;*nptr && (*nptr == 't'); ) nptr++;
  143.       if (*nptr == '') continue;
  144.       NCMPERM[NCMCOUNT].type = nptr;
  145.       for (nptr++; *nptr && !(*nptr == 't'); ) nptr++;
  146.       if (*nptr == '') continue;
  147.       *nptr = '';
  148.       for (nptr++;*nptr && (*nptr == 't'); ) nptr++;
  149.       if (*nptr == '') continue;
  150.       NCMPERM[NCMCOUNT].perm = (strstr(nptr, "y") || strstr(nptr, "Y"));
  151.       for (nptr++; *nptr && !strchr("rn",*nptr); ) nptr++;
  152.       /*if (*nptr == '') continue;*/
  153.       *nptr = '';
  154.   }
  155.   qsort(NCMPERM, NCMCOUNT, sizeof(ncmperm_t), ncmcmp);
  156.   qsort(NCMPERM_BYTYPE, NCMCOUNT, sizeof(ncmperm_t*), ncm_bytypecmp);
  157.   NCMregister();
  158.   return 0;
  159. }
  161. NCMupdate(char *issuer, char *type)
  162. {
  163.   FILE *fp;
  164.   char buff[256];
  166.   sprintf(buff,"%s/ncmperm.bbs", INNDHOME);
  167.   if (!isfile(buff))
  168.   {
  169.     if ((fp = fopen(buff, "w")) == NULL)
  170.     {
  171.       fprintf(stderr,"write fail %s",buff);
  172.       return -1;
  173.     }
  174.     fprintf(fp, "# This is ncmperm.bbs, it's auto-generated by program for first timen");
  175.     fprintf(fp, "# The columns *MUST* be separated by [TAB]n");
  176.     fprintf(fp, "# If you wanna accept someone's NoCeM notice, change his perm from 'no' to 'yes'n");
  177.     fprintf(fp, "# put "*" in Issuer column means to match alln");
  178.     fprintf(fp, "# Any questions ? please e-mail %sn", LeeymEMAIL);
  179.     fprintf(fp, "# IssuerttTypetPermn");
  180.     fflush(fp);
  181.     fclose(fp);
  182.     bbslog("NCMupdate create %sn", buff);
  183.   }
  184.   if ((fp = fopen(buff, "a")) == NULL)
  185.   {
  186.     fprintf(stderr,"attach fail %s",buff);
  187.     return -1;
  188.   }
  189.   fprintf(fp, "%stt%stnon", issuer, type);
  190.   fflush(fp);
  191.   fclose(fp);
  192.   bbslog("NCMupdate add Issuer: %s , Type: %sn", ISSUER, TYPE);
  193.   sleep(1);
  194.   if (readNCMfile(INNDHOME) == -1)
  195.     bbslog("fail to readNCMfilen");
  196. }
  198. #ifdef SOLARIS
  199. int
  200. tcpcommand(char *arg, ...)
  201. {
  202.   va_list ap;
  203.   register char *fmt;
  204.   char   *ptr;
  205.   va_start(ap, arg);
  206.   fmt = va_arg(ap, char *);   
  207. #else
  208. int
  209. tcpcommand(va_alist)
  210. va_dcl
  211. {
  212.   va_list ap;
  213.   register char *fmt;
  214.   char *ptr;
  215.   va_start(ap);
  216.   fmt = va_arg(ap, char *);
  217. #endif
  218.   vfprintf(NNTPwfp, fmt, ap);
  219.   fprintf(NNTPwfp, "rn");
  220.   fflush(NNTPwfp);
  222.   fgets(NNTPbuffer, sizeof NNTPbuffer, NNTPrfp);
  223.   ptr = strchr(NNTPbuffer, 'r');
  224.   if (ptr)
  225.     *ptr = '';
  226.   ptr = strchr(NNTPbuffer, 'n');
  227.   if (ptr)
  228.     *ptr = '';
  229.   va_end(ap);
  230.   return atoi(NNTPbuffer);
  231. }
  233. int
  234. NCMregister()
  235. {
  236.   int status;
  237.   time_t now = time(NULL);
  238.   char hbuf[80];
  240.   gethostname(hbuf, 80);
  242.   if (!strcmp(hbuf, LeeymBBS))
  243.     return 1;
  245.   if ((NNTP = inetclient(LeeymBBS, "7777", "tcp")) < 0)
  246.   {
  247.     bbslog("NCMregister :Err: server %s %s error: cant connectn", LeeymBBS, "7777");
  248.     return 0;
  249.   }
  251.   if (!(NNTPrfp = fdopen(NNTP, "r")) || !(NNTPwfp = fdopen(NNTP, "w")))
  252.   {
  253.     bbslog("NCMregister :Err: fdopen failedn");
  254.     return 0;
  255.   }
  257.   fgets(NNTPbuffer, sizeof NNTPbuffer, NNTPrfp);
  258.   if (atoi(NNTPbuffer) != 200)
  259.   {
  260.     bbslog("NCMregister :Err: server error: %s", NNTPbuffer);
  261.     return 0;
  262.   }
  263.   status = tcpcommand("ADDHIST <%d-%s> NCMregister/%s/%s",
  264.   now, hbuf, VERSION, NCMINNBBSVER);
  265.   status = tcpcommand("QUIT");
  266.   fclose(NNTPwfp);
  267.   fclose(NNTPrfp);
  268.   close(NNTP);
  269.   return 1;
  270. }
  272. /* ------------------------------------------------------------------ */
  273. /* PGP verify                                                         */
  274. /* ------------------------------------------------------------------ */
  276. #ifdef PGP5
  277. int
  278. run_pgp(char *cmd, FILE **in, FILE **out)
  279. {
  280.   int pin[2], pout[2], child_pid;
  281.   char PGPPATH[80];
  283.   sprintf(PGPPATH, "%s/.pgp", BBSHOME);
  284.   setenv("PGPPATH", PGPPATH, 1);
  286.   *in = *out = NULL;
  288.   pipe(pin);
  289.   pipe(pout);
  291.   if(!(child_pid = fork()))
  292.   {
  293.     /*We're the child.*/
  294.     close(pin[1]);
  295.     dup2(pin[0], 0);
  296.     close(pin[0]);
  298.     close(pout[0]);
  299.     dup2(pout[1], 1);
  300.     close(pout[1]);
  302.     execl("/bin/sh", "sh", "-c", cmd, NULL);
  303.     _exit(127);
  304.   }
  305.   /*Only get here if we're the parent.*/
  306.   close(pout[1]);
  307.   *out = fdopen(pout[0], "r");
  309.   close(pin[0]);
  310.   *in = fdopen(pin[1], "w");
  312.   return(child_pid);
  313. }
  315. int
  316. verify_buffer(char *buf, char *passphrase)
  317. {
  318.   FILE *pgpin, *pgpout;
  319.   char tmpbuf[1024] = " ";
  320.   int ans = NOPGP;
  322.   setenv("PGPPASSFD", "0", 1);
  323.   run_pgp("/usr/local/bin/pgpv -f +batchmode=1 +OutputInformationFD=1",
  324.       &pgpin, &pgpout);
  325.   if(pgpin && pgpout)
  326.   {
  327.     fprintf(pgpin, "%sn", passphrase); /*Send the passphrase in, first*/
  328.     bzero(passphrase, strlen(passphrase)); /*Burn the passphrase*/
  329.     fprintf(pgpin, "%s", buf);
  330.     fclose(pgpin);
  332.     *buf = '';
  333.     fgets(tmpbuf, sizeof(tmpbuf), pgpout);
  334.     while(!feof(pgpout))
  335.     {
  336.       strcat(buf, tmpbuf);
  337.       fgets(tmpbuf, sizeof(tmpbuf), pgpout);
  338.     }
  340.     wait(NULL);
  342.     fclose(pgpout);
  343.   }
  345.   if (strstr(buf, "Good signature made"))
  346.   {
  347.     strcpy(errmsg, "Good signature");
  348.     ans = PGPGOOD;
  349.   }
  350.   else if (strstr(buf, "BAD signature made"))
  351.   {
  352.     strcpy(errmsg, "BAD signature");
  353.     ans = PGPBAD;
  354.   }
  355.   else if (strcpy(tmpbuf, strstr(buf, "Signature by unknown keyid:")))
  356.   {
  357.     sprintf(errmsg, "%s ", strtok(tmpbuf, "rn"));
  358.     strcpy(KEYID, strrchr(tmpbuf, ' ') + 1);
  359.     ans = PGPUN;
  360.   }
  362.   unsetenv("PGPPASSFD");
  363.   return ans;
  364. }
  366. int
  367. NCMverify()
  368. {
  369.   int ans;
  370.   char passphrase[80] = "Haha, I am Leeym..";
  371.   ans = verify_buffer(BODY, passphrase);
  372.   return ans;
  373. }
  374. #endif
  375. /* ------------------------------------------------------------------ */
  376. /* parse NoCeM Notice Headers/Body                                    */
  377. /* ------------------------------------------------------------------ */
  379. int
  380. readNCMheader(char *line)
  381. {
  382.   if (!strncasecmp(line, "Version", strlen("Version")))
  383.   {
  384.     strcpy(NCMVER, line + strlen("Version") + 2);
  385.     if (!strstr(NCMVER, "0.9"))
  386.     {
  387.       sprintf(errmsg, "unknown version: %s", NCMVER);
  388.       return P_FAIL;
  389.     }
  390.   }
  391.   else if (!strncasecmp(line, "Issuer", strlen("Issuer")))
  392.   {
  393.     strcpy(ISSUER, line + strlen("Issuer") + 2);
  394.     FROM = ISSUER;
  395.   }
  396.   else if (!strncasecmp(line, "Type", strlen("Type")))
  397.   {
  398.     strcpy(TYPE, line + strlen("Type") + 2);
  399.   }
  400.   else if (!strncasecmp(line, "Action", strlen("Action")))
  401.   {
  402.     strcpy(ACTION, line + strlen("Action") + 2);
  403.     if (!strstr(ACTION, "hide"))
  404.     {
  405.       sprintf(errmsg, "unsupported action: %s", ACTION);
  406.       return P_FAIL;
  407.     }
  408.   }
  409.   else if (!strncasecmp(line, "Notice-ID", strlen("Notice-ID")))
  410.   {
  411.     strcpy(NCMID, line + strlen("Notice-ID") + 2);
  412.   }
  413.   else if (!strncasecmp(line, "Count", strlen("Count")))
  414.   {
  415.     strcpy(COUNT, line + strlen("Count") + 2);
  416.   }
  417.   else if (!strncasecmp(line, "Threshold", strlen("Threshold")))
  418.   {
  419.     strcpy(THRESHOLD, line + strlen("Threshold") + 2);
  420.   }
  422.   return P_OKAY;
  423. }
  425. int
  426. readNCMbody(char *line)
  427. {
  428.   char buf[256], *group;
  429.   strcpy(buf, line);
  431.   if (!strstr(buf, "t"))
  432.     return P_FAIL;
  434.   group = strrchr(line, 't') + 1;
  436.   if (buf[0] == '<' && strstr(buf, ">"))
  437.   {
  438.     strtok(buf, "t");
  439.     strcpy(SPAMMID_NOW, buf);
  440.   }
  442.   if (num_spammid && !strcmp(SPAMMID[num_spammid-1], SPAMMID_NOW))
  443.     return 0;
  445.   if (search_group(group))
  446.     strcpy(SPAMMID[num_spammid++], SPAMMID_NOW);
  447. }
  449. int
  450. NCMparse()
  451. {
  452.   char *fptr, *ptr;
  453.   int type = TEXT;
  455.   for (fptr = BODY, ptr = strchr(fptr, 'n'); ptr != NULL && *ptr != ''; fptr = ptr + 1, ptr = strchr(fptr, 'n'))
  456.   {
  457.     int ch = *ptr;
  458.     int ch2 = *(ptr-1);
  460.     *ptr = '';
  461.     if (*(ptr-1) == 'r')
  462.       *(ptr-1) = '';
  464.     if (num_spammid > MAXSPAMMID)
  465.       return P_OKAY;
  467.     if (!strncmp(fptr, "@@", 2))
  468.     {
  469.       if (strstr(fptr, "BEGIN NCM HEADERS"))
  470.         type = NCMHDR;
  471.       else if (strstr(fptr, "BEGIN NCM BODY"))
  472.       {
  473.         if (NCMVER && ISSUER && TYPE && ACTION && COUNT && NCMID)
  474.         {
  475.           ncmperm_t *ncmt;
  476.           ncmt = (ncmperm_t *) search_issuer(ISSUER);
  477.           if (ncmt == NULL)
  478.           {
  479.             NCMupdate(ISSUER, TYPE);
  480.             sprintf(errmsg, "unknown issuer: %s, %s", ISSUER, MSGID);
  481.             return P_UNKNOWN;
  482.           }
  483.           if (ncmt->perm == NULL)
  484.           {
  485.             sprintf(errmsg, "disallow issuer: %s, %s", ISSUER, MSGID);
  486.             return P_DISALLOW;
  487.           }
  488.         }
  489.         else
  490.         {
  491.           strcpy(errmsg, "HEADERS syntax not correct");
  492.           return P_FAIL;
  493.         }
  494.         type = NCMBDY;
  495.       }
  496.       else if (strstr(fptr, "END NCM BODY"))
  497.         type = TEXT;
  498.       else
  499.       {
  500.         strcpy(errmsg, "NCM Notice syntax not correct");
  501.         return P_FAIL;
  502.       }
  503.       *ptr = ch;
  504.       *(ptr-1) = ch2;
  505.       continue;
  506.     }
  508.     if (type == NCMHDR && readNCMheader(fptr) == P_FAIL)
  509.       return P_FAIL;
  510.     else if (type == NCMBDY)
  511.       readNCMbody(fptr);
  512.     *ptr = ch;
  513.     *(ptr-1) = ch2; 
  514.   }
  515.   if (NCMVER && ISSUER && TYPE && ACTION && COUNT && NCMID)
  516.       return P_OKAY;
  517.   else
  518.   {
  519.     strcpy(errmsg, "HEADERS syntax not correct");
  520.     return P_FAIL;
  521.   }
  523.   strcpy(errmsg, "I don't know..");
  524.   return P_FAIL;
  525. }
  527. int
  528. NCMcancel()
  529. {
  530.   int i, rel, num_ok, num_fail;
  531.   for (i = rel = num_ok = num_fail = 0; i < num_spammid; i++)
  532.   {
  533.     rel = cancel_article_front(SPAMMID[i]);
  534.     if (rel)
  535.       num_fail++;
  536.     else
  537.       num_ok++;
  538.   }
  539.   bbslog("NCMcancel %s %s, count:%d spam:%d, ok:%d fail:%dn",
  540.         ISSUER, MSGID, atoi(COUNT), num_spammid, num_ok, num_fail);
  541.   return 0;
  542. }
  544. /* ------------------------------------------------------------------ */
  545. /* NoCeM-innbbsd                                                      */
  546. /* ------------------------------------------------------------------ */
  548. initial_nocem()
  549. {
  550.   bzero(SPAMMID[0], strlen(SPAMMID[0]) * num_spammid);
  551.   num_spammid = 0;
  552.   bzero(SPAMMID_NOW, strlen(SPAMMID_NOW));
  553. }
  555. int
  556. receive_nocem()
  557. {
  558.   int rel;
  559.   ncmperm_t *ncmt;
  561.   if (ncmdebug)
  562.     bbslog("NCM: receive %sn", MSGID);
  564.   initial_nocem();
  566.   rel = NCMparse();
  568.   if (rel != P_OKAY)
  569.   {
  570.     if (rel != P_DISALLOW)
  571.       bbslog("NCMparse %sn", errmsg);
  572.     return 0;
  573.   }
  575.   if (!num_spammid)
  576.   {
  577.     bbslog("NCMparse: nothing to canceln"); 
  578.     return 0;
  579.   }
  580. #ifdef PGP5
  581.   if (ncmdebug)
  582.     bbslog("NCM: verifying PGP signn");
  584.   rel = NCMverify();
  586.   if (rel != PGPGOOD)
  587.   {
  588.     bbslog("NCMverify %s, %s, %sn", errmsg, MSGID, ISSUER);
  589.     return 0;
  590.   }
  591. #endif
  593.   if (ncmdebug)
  594.     bbslog("NCM: canceling spam in NoCeM Noticen");
  595.   return NCMcancel();
  596. }
  598. #endif /* USE_NCM_PATCH */