home *** CD-ROM | disk | FTP | other *** search
/ The Unsorted BBS Collection / thegreatunsorted.tar / thegreatunsorted / programming / asm_programming / MJRDEVEL.ARC / CLASSI.C < prev    next >
Text File  |  1989-03-23  |  20KB  |  643 lines
  1. /***************************************************************************
  2.  *                                                                         *
  3.  *   CLASSI.C                                                              *
  4.  *                                                                         *
  5.  *   Copyright (C) 1987-1989 GALACTICOMM, Inc.    All Rights Reserved.     *
  6.  *                                                                         *
  7.  *   This is the Major BBS classified-ad service handler.                  *
  8.  *                                                                         *
  9.  *                                            - T. Stryker 7/2/86          *
  10.  *                                                                         *
  11.  ***************************************************************************/
  12.  
  13. #include "stdio.h"
  14. #include "ctype.h"
  15. #include "majorbbs.h"
  16. #include "usracc.h"
  17. #include "btvstf.h"
  18. #include "classi.h"
  19. #include "dosface.h"
  20. #include "portable.h"
  21.  
  22. int inicsi(),rsalrt(),classi(),dfsthn(),csimcu(),clscsi();
  23.  
  24. #define CSISTT      10        /* classified ad state                  */
  25. struct module module10={      /* module interface block               */
  26.      '*',                     /*    main menu select character (config'able) */
  27.      "",                      /*    description for main menu  (config'able) */
  28.      inicsi,                  /*    system initialization routine     */
  29.      rsalrt,                  /*    user logon supplemental routine   */
  30.      classi,                  /*    input routine if selected         */
  31.      dfsthn,                  /*    status-input routine if selected  */
  32.      NULL,                    /*    hangup (lost carrier) routine     */
  33.      csimcu,                  /*    midnight cleanup routine          */
  34.      NULL,                    /*    delete-account routine            */
  35.      clscsi                   /*    finish-up (sys shutdown) routine  */
  36. };
  37.  
  38. static
  39. FILE *csimb;                  /* classi named-message file block pointer   */
  40. static
  41. BTVFILE *adbb,                /* btrieve ad text file block pointer        */
  42.         *rspbb;               /* btrieve response text file block pointer  */
  43.  
  44. #define TPCSIZ 65             /* maximum ad topic length                   */
  45. #define ADTSIZ 1921           /* maximum ad body line length               */
  46. #define RSLSIZ 40             /* maximum response text length              */
  47.  
  48. struct csiad {                     /* classified ad btrieve record layout  */
  49.      long adno;                    /*   ad number from csitot              */
  50.      char topic[TPCSIZ];           /*   ad topic                           */
  51.      char advrtr[UIDSIZ];          /*   advertiser's user-id               */
  52.      char adtext[ADTSIZ];          /*   ad text block                      */
  53.      int crdate;                   /*   ad creation date                   */
  54.      char spare[2034-2000];        /*   spare space; decrease when adding  */
  55. };
  56.  
  57. struct csirsp {                    /* response btrieve file record layout  */
  58.      char resper[UIDSIZ];          /*   responder's user-id                */
  59.      long adno;                    /*   ad number this is in response to   */
  60.      char advrtr[UIDSIZ];          /*   user-id who placed that ad         */
  61.      int rspdat;                   /*   date of response                   */
  62.      char rsptxt[RSLSIZ];          /*   text of response                   */
  63. };
  64. struct csiusr {                    /* classified ad user data block        */
  65.      int edting;                   /*   using editor flag                  */
  66.      long fpos;                    /*   current file position              */
  67.      struct csiad adblk;           /*   ad data block                      */
  68.      struct csirsp rspblk;         /*   response data block                */
  69.      char dftinp;                  /*   default input char from last prompt*/
  70. };
  71. static
  72. int newstt;                   /* new substate for this state               */
  73.  
  74. #define csiptr ((struct csiusr *)vdaptr)
  75.  
  76. /*--- OPTIONS FROM CLASSI.MSG ---*/
  77.  
  78. int cadlif,                   /* Lifetime of a Classified Ad, in days      */
  79.     carlif,                   /* Lifetime of a response to an Ad, in days  */
  80.     nlvcad,                   /* Allow non-live users to place ads?        */
  81.     cadtck,                   /* Credits deducted per classified ad        */
  82.     nlvcar,                   /* Allow non-live users to respond to ads?   */
  83.     cartck;                   /* Credits deducted per response             */
  84.  
  85. inicsi()                      /* initialize classified ads stuff           */
  86. {
  87.      csimb=opnmsg("classi.mcv");
  88.      adbb=opnbtv("classadn.dat",sizeof(struct csiad));
  89.      rspbb=opnbtv("classrsn.dat",sizeof(struct csirsp));
  90.      cadlif=numopt(CADLIF,-1,32767);
  91.      carlif=numopt(CARLIF,-1,32767);
  92.      nlvcad=ynopt(NLVCAD);
  93.      cadtck=numopt(CADTCK,-32767,32767);
  94.      nlvcar=ynopt(NLVCAR);
  95.      cartck=numopt(CARTCK,-32767,32767);
  96.      inimid(CSISTT,CSISEL,CSIMNU);
  97.      dclvda(sizeof(struct csiusr));
  98. }
  99.  
  100. rsalrt()                      /* alert user of classi. responses waiting   */
  101. {
  102.      setbtv(rspbb);
  103.      if (qeqbtv(usaptr->userid,1)) {
  104.           prf("\7You have classified ad responses on file!\r");
  105.      }
  106. }
  107.  
  108. classi()                      /* classified ads MajorBBS interface handler */
  109. {
  110.      setmbk(csimb);
  111.      newstt=usrptr->substt;
  112.      if (usrptr->flags&INJOIP) {
  113.           prfmsg(newstt);
  114.      }
  115.      else {
  116.           chkdft(csiptr->dftinp);
  117.           if (margc == 0 && newstt != PRSRET && !csiptr->edting) {
  118.                prfmsg(newstt);
  119.           }
  120.           else if (margc == 1 && sameas(margv[0],"x")) {
  121.                if (newstt == REPRMT) {
  122.                     prfmsg(MAINEX);
  123.                     return(0);
  124.                }
  125.                csiptr->edting=0;
  126.                prfmsg(EX2MAI);
  127.                prfmsg(newstt=REPRMT);
  128.                btumil(usrnum,DFTIMX);
  129.           }
  130.           else if (usrptr->pfnacc > MAXPFN) {
  131.                btuinj(usrnum,RING);
  132.                return(1);
  133.           }
  134.           else if (pfnlvl > 2) {
  135.                errmsg(PFNMSG);
  136.           }
  137.           else if (pfnlvl == 2) {
  138.                errmsg(RAUNCH);
  139.           }
  140.           else {
  141.                do {
  142.                     bgncnc();
  143.                     if (!csiptr->edting) {
  144.                          btumil(usrnum,DFTIMX);
  145.                     }
  146.                     switch (newstt) {
  147.                     case 0:
  148.                          cncchr();
  149.                          prfmsg(INTRO);
  150.                          newstt=REPRMT;
  151.                          break;
  152.                     case REPRMT:
  153.                          switch (cncchr()) {
  154.                          case 'G':
  155.                               errmsg(GENINF);
  156.                               break;
  157.                          case 'S':
  158.                               prfmsg(newstt=SCORDA);
  159.                               break;
  160.                          case 'P':
  161.                               place();
  162.                               break;
  163.                          case 'M':
  164.                               prfmsg(newstt=MODIFA);
  165.                               break;
  166.                          case 'D':
  167.                               prfmsg(newstt=DELADN);
  168.                               break;
  169.                          case 'C':
  170.                               crr1();
  171.                               break;
  172.                          case '?':
  173.                               prfmsg(INTRO);
  174.                               break;
  175.                          default:
  176.                               errmsg(CNOTIL);
  177.                          }
  178.                          break;
  179.                     case SCORDA:
  180.                          sscorda();
  181.                          break;
  182.                     case SCOSCN:
  183.                          sscoscn();
  184.                          break;
  185.                     case SCORCQ:
  186.                          sscorcq();
  187.                          break;
  188.                     case SCORSQ:
  189.                          sscorsq();
  190.                          break;
  191.                     case SCORSC:
  192.                          sscorsc();
  193.                          break;
  194.                     case SCORSP:
  195.                          sscorsp();
  196.                          break;
  197.                     case ENTADT:
  198.                          sentadt();
  199.                          outprf(usrnum);
  200.                          usrptr->substt=newstt;
  201.                          return(1);
  202.                     case MODIFA:
  203.                          smodifa();
  204.                          break;
  205.                     case EDTAD:
  206.                          sedtad();
  207.                          outprf(usrnum);
  208.                          usrptr->substt=newstt;
  209.                          return(1);
  210.                     case DELADN:
  211.                          sdeladn();
  212.                          break;
  213.                     case PRSRET:
  214.                          rsputl(" << more >> ");
  215.                          break;
  216.                     case CLRRDR:
  217.                          sclrrdr();
  218.                          break;
  219.                     default:
  220.                          catastro("CLASSI SUBSTT ERROR");
  221.                     }
  222.                } while (!endcnc());
  223.           }
  224.      }
  225.      csidfi();
  226.      outprf(usrnum);
  227.      usrptr->substt=newstt;
  228.      return(1);
  229. }
  230.  
  231. static
  232. sscorda()                          /* begin classified ad scanning         */
  233. {
  234.      setbtv(adbb);
  235.      if (sameas(margv[0],"?")) {
  236.           errmsg(SCOHLP);
  237.           return;
  238.      }
  239.      if (margc != 1 || !isdigit(*nxtcmd)) {
  240.           cpykey(csiptr->adblk.topic,cncall(),TPCSIZ);
  241.           if (qgebtv(csiptr->adblk.topic,1)
  242.            || qltbtv(csiptr->adblk.topic,1)) {
  243.                gcrbtv(&(csiptr->adblk),1);
  244.           }
  245.           else {
  246.                blwoff(NOADS);
  247.                return;
  248.           }
  249.      }
  250.      else {
  251.           csiptr->adblk.adno=cnclon();
  252.           if (!acqbtv(&(csiptr->adblk),&(csiptr->adblk.adno),0)) {
  253.                errmsg(NSUCHN);
  254.                return;
  255.           }
  256.      }
  257.      showad();
  258.      prfmsg(newstt=SCOSCN);
  259. }
  260.  
  261. static
  262. sscoscn()                          /* scanning classified ad database      */
  263. {
  264.      setbtv(adbb);
  265.      gabbtv(&(csiptr->adblk),csiptr->fpos,1);
  266.      switch (cncchr()) {
  267.      case 'F':
  268.           if (!qnxbtv()) {
  269.                errmsg(SCOEND);
  270.           }
  271.           else {
  272.                gcrbtv(&(csiptr->adblk),1);
  273.                showad();
  274.                prfmsg(SCOSCN);
  275.           }
  276.           break;
  277.      case 'B':
  278.           if (!qprbtv()) {
  279.                errmsg(SCOBEG);
  280.           }
  281.           else {
  282.                gcrbtv(&(csiptr->adblk),1);
  283.                showad();
  284.                prfmsg(SCOSCN);
  285.           }
  286.           break;
  287.      case 'R':
  288.           prf("%s\r",csiptr->adblk.adtext);
  289.           if (!nlvcar && usrptr->class < PAYING) {
  290.                prfmsg(SCOAFR);
  291.                break;
  292.           }
  293.           movmem(usaptr->userid,csiptr->rspblk.resper,UIDSIZ);
  294.           csiptr->rspblk.adno=csiptr->adblk.adno;
  295.           setbtv(rspbb);
  296.           if (acqbtv(&csiptr->rspblk,csiptr->rspblk.resper,0)) {
  297.                prfmsg(SCOCRR,csiptr->rspblk.rsptxt);
  298.                prfmsg(newstt=SCORCQ);
  299.           }
  300.           else {
  301.                prfmsg(newstt=SCORSQ);
  302.           }
  303.           break;
  304.      default:
  305.           errmsg(CNOTIL);
  306.      }
  307. }
  308.  
  309. static                        /* ask user if he wishes to update response  */
  310. sscorcq()
  311. {
  312.      switch (cncchr()) {
  313.      case 'Y':
  314.           prfmsg(newstt=SCORSC);
  315.           btumil(usrnum,RSLSIZ-1);
  316.           break;
  317.      case 'N':
  318.           prfmsg(SCOAFR);
  319.           newstt=SCOSCN;
  320.           break;
  321.      default:
  322.           errmsg(YORN);
  323.      }
  324. }
  325.  
  326. static
  327. sscorsq()                     /* ask user if he/she wishes to respond to ad*/
  328. {
  329.      switch (cncchr()) {
  330.      case 'Y':
  331.           prfmsg(newstt=SCORSP);
  332.           btumil(usrnum,RSLSIZ-1);
  333.           break;
  334.      case 'N':
  335.           prfmsg(SCOAFR);
  336.           newstt=SCOSCN;
  337.           break;
  338.      default:
  339.           errmsg(YORN);
  340.      }
  341. }
  342.  
  343. static
  344. sscorsc()                     /* update response; continue scanning        */
  345. {
  346.      setbtv(rspbb);
  347.      geqbtv(NULL,csiptr->rspblk.resper,0);
  348.      cpykey(csiptr->rspblk.rsptxt,cncall(),RSLSIZ);
  349.      csiptr->rspblk.rspdat=today();
  350.      updbtv(&(csiptr->rspblk));
  351.      prfmsg(SCOAFR);
  352.      newstt=SCOSCN;
  353. }
  354.  
  355. static
  356. sscorsp()                     /* save response; continue with scanning     */
  357. {
  358.      setbtv(rspbb);
  359.      movmem(usaptr->userid,csiptr->rspblk.resper,UIDSIZ);
  360.      csiptr->rspblk.adno=csiptr->adblk.adno;
  361.      movmem(csiptr->adblk.advrtr,csiptr->rspblk.advrtr,UIDSIZ);
  362.      csiptr->rspblk.rspdat=today();
  363.      cpykey(csiptr->rspblk.rsptxt,cncall(),RSLSIZ);
  364.      insbtv(&(csiptr->rspblk));
  365.      usaptr->tckavl-=nlvcar ? 0 : cartck;
  366.      if (onsys(csiptr->adblk.advrtr)) {
  367.           prfmsg(GTRSPO,usaptr->userid,ltoa(csiptr->adblk.adno));
  368.           if (injoth()) {
  369.                prfmsg(PNOTIF,csiptr->adblk.advrtr);
  370.                outprf(usrnum);
  371.           }
  372.      }
  373.      prfmsg(SCOAFR);
  374.      newstt=SCOSCN;
  375. }
  376.  
  377. sentadt()                     /* editor interface while creating an ad     */
  378. {
  379.      if (dunedt()) {
  380.           makad();
  381.           prfmsg(SAVEAD,spr("%ld",csiptr->adblk.adno));
  382.           csiptr->edting=0;
  383.           prfmsg(newstt=REPRMT);
  384.           csidfi();
  385.      }
  386. }
  387.  
  388. static
  389. smodifa()                     /* select a classified ad to modify          */
  390. {
  391.      setbtv(adbb);
  392.      csiptr->adblk.adno=cnclon();
  393.      if (!acqbtv(&(csiptr->adblk),&(csiptr->adblk.adno),0)) {
  394.           blwoff(NSUCHN);
  395.           return;
  396.      }
  397.      if (!(sameas(csiptr->adblk.advrtr,usaptr->userid)
  398.         || (usrptr->flags&ISYSOP))) {
  399.           blwoff(UDONTO,spr("%ld",csiptr->adblk.adno));
  400.           return;
  401.      }
  402.      if (confli()) {
  403.           blwoff(USING);
  404.           return;
  405.      }
  406.      newstt=EDTAD;
  407.      csiptr->edting=1;
  408.      bgnedt(0,ADTSIZ,csiptr->adblk.adtext,TPCSIZ,csiptr->adblk.topic);
  409. }
  410.  
  411. sedtad()                      /* editor interface while modifying an ad    */
  412. {
  413.      if (dunedt()) {
  414.           setbtv(adbb);
  415.           geqbtv(NULL,&(csiptr->adblk.adno),0);
  416.           updbtv(&(csiptr->adblk));
  417.           csiptr->edting=0;
  418.           prfmsg(newstt=REPRMT);
  419.           csidfi();
  420.      }
  421. }
  422.  
  423. static
  424. sdeladn()                          /* delete a given classified ad         */
  425. {
  426.      setbtv(adbb);
  427.      csiptr->adblk.adno=cnclon();
  428.      if (!acqbtv(&(csiptr->adblk),&(csiptr->adblk.adno),0)) {
  429.           blwoff(NSUCHN);
  430.           return;
  431.      }
  432.      if (!(sameas(csiptr->adblk.advrtr,usaptr->userid)
  433.         || (usrptr->flags&ISYSOP))) {
  434.           blwoff(UCANTD,csiptr->adblk.adno);
  435.           return;
  436.      }
  437.      if (confli()) {
  438.           blwoff(USING);
  439.           return;
  440.      }
  441.      delbtv();
  442.      sv.csiopn-=1;
  443.      blwoff(OKGONE);
  444. }
  445.  
  446. static
  447. sclrrdr()                     /* verify deletion of a user's ad repsonses  */
  448. {
  449.      switch (cncchr()) {
  450.      case 'Y':
  451.           zaprdr();
  452.           blwoff(RSPCLD);
  453.           break;
  454.      case 'N':
  455.           blwoff(RSPNCL,carlif);
  456.           break;
  457.      default:
  458.           errmsg(YORN);
  459.      }
  460. }
  461.  
  462. makad()                            /* creates ad in the database           */
  463. {
  464.      setbtv(adbb);
  465.      csiptr->adblk.crdate=today();
  466.      csiptr->adblk.adno=sv.csitot;
  467.      movmem(usaptr->userid,csiptr->adblk.advrtr,UIDSIZ);
  468.      insbtv(&(csiptr->adblk));
  469.      usaptr->csicnt+=1;
  470.      usaptr->tckavl-=nlvcad ? 0 : cadtck;
  471.      sv.csitot+=1;
  472.      sv.csiopn+=1;
  473. }
  474.  
  475. confli()                      /* check for a conflict in deleting an ad    */
  476. {
  477.      long recpos;
  478.  
  479.      recpos=absbtv();
  480.      for (othusn=0,othusp=user ; othusn < nterms ; othusn++,othusp++) {
  481.           if (othusn != usrnum
  482.            && othusp->class > SUPIPG
  483.            && othusp->state == CSISTT
  484.            && othusp->substt != REPRMT
  485.            && ((struct csiusr *)vdarea+othusn)->fpos == recpos) {
  486.                return(1);
  487.           }
  488.      }
  489.      return(0);
  490. }
  491.  
  492. static
  493. errmsg(msgnum,p1)                  /* prf() error message utility          */
  494. int msgnum;
  495. long p1;
  496. {
  497.      prfmsg(msgnum,p1);
  498.      if (!csiptr->edting) {
  499.           prfmsg(newstt);
  500.      }
  501.      cncall();
  502. }
  503.  
  504. static
  505. blwoff(msgnum,parm)                /* prf() message; return to classi menu */
  506. int msgnum;
  507. long parm;
  508. {
  509.      prfmsg(msgnum,parm);
  510.      prfmsg(newstt=REPRMT);
  511.      cncall();
  512. }
  513.  
  514. showad()                           /* display a classified ad              */
  515. {
  516.      long absbtv();
  517.  
  518.      setbtv(adbb);
  519.      prfmsg(ADDISP,spr("%ld",csiptr->adblk.adno),csiptr->adblk.advrtr);
  520.      prf("%s\r",csiptr->adblk.topic);
  521.      csiptr->fpos=absbtv();
  522. }
  523.  
  524. place()                            /* place a classified ad                */
  525. {
  526.      if (!nlvcad) {
  527.           if (usaptr->tckavl <= cadtck) {
  528.                blwoff(NOLIVE);
  529.                return;
  530.           }
  531.      }
  532.      prfmsg(newstt=ENTADT);
  533.      outprf(usrnum);
  534.      csiptr->edting=1;
  535.      bgnedt(1,ADTSIZ,csiptr->adblk.adtext,TPCSIZ,csiptr->adblk.topic);
  536. }
  537.  
  538. crr1()                        /* display responses to your ads (if any)    */
  539. {
  540.      setbtv(rspbb);
  541.      if (!acqbtv(&(csiptr->rspblk),usaptr->userid,1)) {
  542.           blwoff(NORDRS);
  543.      }
  544.      else {
  545.           prfmsg(RDRRSP);
  546.           rsputl(NULL);
  547.      }
  548. }
  549.  
  550. rsputl(morstg)                /* display ad responses to a user            */
  551. char *morstg;
  552. {
  553.      int i;
  554.  
  555.      setbtv(rspbb);
  556.      if (morstg != NULL) {
  557.           gabbtv(&(csiptr->rspblk),csiptr->fpos,1);
  558.      }
  559.      for (i=0 ; i < 4 ; i++) {
  560.           prf(" From %-9s RE:#%s on %s: %s\r",csiptr->rspblk.resper,
  561.               spr("%ld",csiptr->rspblk.adno),ncdate(csiptr->rspblk.rspdat),
  562.               csiptr->rspblk.rsptxt);
  563.           if (!aqnbtv(&(csiptr->rspblk))) {
  564.                prfmsg(newstt=CLRRDR);
  565.                return;
  566.           }
  567.      }
  568.      if (morstg != NULL) {
  569.           prf(morstg);
  570.      }
  571.      else {
  572.           prfmsg(PRSRET);
  573.      }
  574.      csiptr->fpos=absbtv();
  575.      newstt=PRSRET;
  576. }
  577.  
  578. zaprdr()                           /* delete a user's responses            */
  579. {
  580.      setbtv(rspbb);
  581.      if (!acqbtv(&(csiptr->rspblk),usaptr->userid,1)) {
  582.           catastro("ZAPRDR: NO FIRST ENTRY");
  583.      }
  584.      delbtv();
  585.      while (aqnbtv(&(csiptr->rspblk))) {
  586.           delbtv();
  587.      }
  588. }
  589.  
  590. csidfi()                           /* default input character grabber      */
  591. {
  592.      char *lstchp;
  593.  
  594.      lstchp=prfptr-1;
  595.      if (!isspace(*lstchp)) {
  596.           csiptr->dftinp=*lstchp;
  597.           *(prfptr=lstchp)='\0';
  598.      }
  599.      else {
  600.           csiptr->dftinp='\0';
  601.      }
  602. }
  603.  
  604. csimcu()                      /* classified ads midnight cleanup routine   */
  605. {
  606.  
  607.      #define CSIUSR ((struct csiusr *)vdarea)
  608.      int ctoday;
  609.  
  610.      ctoday=cofdat(today());
  611.      setbtv(adbb);
  612.      sv.csiopn=0;
  613.      if (qlobtv(0)) {
  614.           do {
  615.                gcrbtv(&CSIUSR->adblk,0);
  616.                if (cadlif >= 0
  617.                 && ctoday-cofdat(CSIUSR->adblk.crdate) > cadlif) {
  618.                     delbtv();
  619.                }
  620.                else {
  621.                     sv.csiopn+=1;
  622.                }
  623.           } while (qnxbtv());
  624.      }
  625.      setbtv(rspbb);
  626.      if (qlobtv(0)) {
  627.           do {
  628.                gcrbtv(&CSIUSR->rspblk,0);
  629.                if (carlif >= 0
  630.                 && ctoday-cofdat(CSIUSR->rspblk.rspdat) > carlif) {
  631.                     delbtv();
  632.                }
  633.           } while (qnxbtv());
  634.      }
  635. }
  636.  
  637. clscsi()                      /* close classified ads files for shutdown   */
  638. {
  639.      clsmsg(csimb);
  640.      clsbtv(adbb);
  641.      clsbtv(rspbb);
  642. }
  643.