home *** CD-ROM | disk | FTP | other *** search
/ The Unsorted BBS Collection / thegreatunsorted.tar / thegreatunsorted / programming / asm_programming / MJRDEVEL.ARC / REGISTRY.C < prev    next >
Text File  |  1989-03-01  |  17KB  |  542 lines
  1. /***************************************************************************
  2.  *                                                                         *
  3.  *   REGISTRY.C                                                            *
  4.  *                                                                         *
  5.  *   Copyright (C) 1988,1989 GALACTICOMM, Inc.    All Rights Reserved.     *
  6.  *                                                                         *
  7.  *   This is the Major BBS user "registry" module.                         *
  8.  *                                                                         *
  9.  *                                  - T. Stryker & S. Brinker 1/24/88      *
  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 "registry.h"
  19. #include "portable.h"
  20.  
  21. int inireg(),regnot(),regrou(),reglst(),dfsthn(),delreg(),clsreg();
  22.  
  23. #define REGSTT      18        /* User Registry state                  */
  24. struct module module18={      /* module interface block               */
  25.      'R',                     /*    main menu select character        */
  26.      "Registry of Users",     /*    description for main menu         */
  27.      inireg,                  /*    system initialization routine     */
  28.      regnot,                  /*    user logon supplemental routine   */
  29.      regrou,                  /*    input routine if selected         */
  30.      reglst,                  /*    status-input routine if selected  */
  31.      NULL,                    /*    hangup (lost carrier) routine     */
  32.      NULL,                    /*    midnight cleanup routine          */
  33.      delreg,                  /*    delete-account routine            */
  34.      clsreg                   /*    finish-up (sys shutdown) routine  */
  35. };
  36.  
  37. static
  38. FILE *regmb;                  /* registry named-message file block pointer */
  39. static
  40. BTVFILE *regbb;               /* registry btrieve message file block ptr.  */
  41.  
  42. #define PROSIZ 900            /* profile size (gen purp. text block)       */
  43. #define SUMSIZ 40             /* number of bytes allowed for summary       */
  44.  
  45. struct regrec {               /* user registry structures                  */
  46.      char userid[UIDSIZ];     /* user-id of registry record                */
  47.      char sumlin[SUMSIZ];     /* one-line summary for directory            */
  48.      char profil[PROSIZ];     /* user's "profile"                          */
  49.      char spare[1002-950];    /* spare space, decrease when adding         */
  50. };
  51. struct regusr {
  52.      int fldidx;              /* current field index for creation, editing */
  53.      int flags;               /* registry user's bit-definable flags       */
  54.      long fpos;               /* file position for directory output        */
  55.      struct regrec regblk;    /* user's current registry record in mem.    */
  56. };                            /* dynamically allocated regusr array        */
  57.  
  58.                               /* definition of registry bit "flags"        */
  59. #define CRTMNU 1              /* show create menu                          */
  60. #define UPDYOU 2              /* need to update "your" user file           */
  61. #define GOTONE 4              /* gotten a user-id lookup once already      */
  62.  
  63. #define MAXFLD 30             /* maximum number of fields in profile       */
  64. #define MAXLIN 20             /* maximum number of lines per directory page*/
  65.  
  66. static
  67. struct regidx {
  68.      int fidx;                /* index for prf messages                    */
  69.      int fsiz;                /* size for btumils, etc.                    */
  70. } regidx[MAXFLD];
  71.  
  72. static
  73. int numfds,                   /* number of configured fields               */
  74.     regnlv;                   /* registry allows non-live entry flag       */
  75. extern
  76. struct module *module[NMODS]; /* array of module ptrs                      */
  77.  
  78. #define regptr ((struct regusr *)vdaptr)
  79.  
  80. inireg()                           /* initialize registry module           */
  81. {
  82.      regmb=opnmsg("registry.mcv");
  83.      inimid(REGSTT,REGSEL,REGMNU);
  84.      regnlv=ynopt(REGNLV);
  85.      dclvda(sizeof(struct regusr));
  86.      makrar();
  87.      regbb=opnbtv("registry.dat",sizeof(struct regrec));
  88. }
  89.  
  90. makrar()                           /* make registry array from msg. file   */
  91. {
  92.      int curidx;
  93.  
  94.      curidx=0;
  95.      for (numfds=0 ; numfds < MAXFLD ; numfds++) {
  96.           if ((regidx[numfds].fsiz=atoi(getmsg(FLDSIZ1+2*numfds))) != 0) {
  97.                regidx[numfds].fidx=curidx;
  98.                curidx+=regidx[numfds].fsiz+1;
  99.           }
  100.           else if (curidx > PROSIZ) {
  101.                catastro("MAKRAR: BYTE COUNT TOO LARGE!");
  102.           }
  103.           else {
  104.                break;
  105.           }
  106.      }
  107. }
  108.  
  109. regnot()                           /* notify user to fill out registry     */
  110. {
  111.      setbtv(regbb);
  112.      setmbk(regmb);
  113.      if (usaptr->usedat[0] != '\0' && !qeqbtv(usaptr->userid,0)
  114.       && module[REGSTT]->select != '\0' && (regnlv || usrptr->class > FRELOA)) {
  115.           prfmsg(REGPLS);
  116.      }
  117. }
  118.  
  119. regrou()                           /* main registry input handler          */
  120. {
  121.      setmbk(regmb);
  122.      setbtv(regbb);
  123.      if (margc > 0 && (sameas(margv[0],"x") || sameas(margv[0],"exit"))) {
  124.           if (regptr->flags&UPDYOU) {
  125.                regptr->flags&=~UPDYOU;
  126.                geqbtv(NULL,usaptr->userid,0);
  127.                updbtv(®ptr->regblk);
  128.           }
  129.           switch (usrptr->substt) {
  130.           case 1:
  131.                prfmsg(EXIREG);
  132.                return(0);
  133.           case 4:
  134.           case 5:
  135.                prfmsg(NOTDUN);
  136.           case 2:
  137.           case 3:
  138.           case 6:
  139.           case 9:
  140.                btumil(usrnum,DFTIMX);
  141.                prfmsg(SHRMNU);
  142.                usrptr->substt=1;
  143.                break;
  144.           case 7:
  145.           case 8:
  146.                btumil(usrnum,DFTIMX);
  147.                prfmsg(EDTWHT);
  148.                usrptr->substt=6;
  149.                break;
  150.           }
  151.      }
  152.      else {
  153.           do {
  154.                bgncnc();
  155.                switch (usrptr->substt) {
  156.                case 0:
  157.                     setmem(regptr,vdasiz,0);
  158.                     cncchr();
  159.                     if (!acqbtv(&(regptr->regblk),usaptr->userid,0)) {
  160.                          regptr->flags|=CRTMNU;
  161.                          prfmsg(GENINF);
  162.                     }
  163.                     regmnu();
  164.                     usrptr->substt=1;
  165.                     break;
  166.                case 1:
  167.                     regrou1();
  168.                     break;
  169.                case 2:
  170.                     regrou2();
  171.                     break;
  172.                case 3:
  173.                     regrou3();
  174.                     break;
  175.                case 4:
  176.                     regrou4();
  177.                     break;
  178.                case 5:
  179.                     regrou5();
  180.                     break;
  181.                case 6:
  182.                     regrou6();
  183.                     break;
  184.                case 7:
  185.                     regrou7();
  186.                     break;
  187.                case 8:
  188.                     regrou8();
  189.                     break;
  190.                case 9:
  191.                     regrou9();
  192.                     break;
  193.                }
  194.           } while (!endcnc());
  195.      }
  196.      outprf(usrnum);
  197.      return(1);
  198. }
  199.  
  200. regrou1()                          /* registry menu sub-state handler      */
  201. {
  202.      if (margc == 0) {
  203.           prfmsg(SHRMNU);
  204.      }
  205.      else {
  206.           switch (cncchr()) {
  207.           case 'G':
  208.                prfmsg(GENINF);
  209.           case '?':
  210.                regmnu();
  211.                break;
  212.           case 'D':
  213.                prfmsg(DIRPMT);
  214.                btumil(usrnum,4);
  215.                usrptr->substt=2;
  216.                break;
  217.           case 'Y':
  218.                if (!regnlv && usrptr->class < PAYING) {
  219.                     prfmsg(NOYSIR);
  220.                     regmnu();
  221.                }
  222.                else if (regptr->flags&CRTMNU) {
  223.                     btumil(usrnum,regidx[0].fsiz);
  224.                     regptr->fldidx=0;
  225.                     prfmsg(BGNCRT);
  226.                     prfmsg(FLDPMT1);
  227.                     usrptr->substt=4;
  228.                }
  229.                else {
  230.                     geqbtv(®ptr->regblk,usaptr->userid,0);
  231.                     prfmsg(YOUARE);
  232.                     shwpro(EDTENT,SUMEDT);
  233.                     prfmsg(EDTWHT);
  234.                     usrptr->substt=6;
  235.                }
  236.                break;
  237.           case 'L':
  238.                prfmsg(UIDTOL);
  239.                usrptr->substt=9;
  240.                break;
  241.           default:
  242.                prfmsg(NOSUCH);
  243.                prfmsg(SHRMNU);
  244.           }
  245.      }
  246. }
  247.  
  248. regrou2()                          /* begin directory sub-state handler    */
  249. {
  250.      if (margc == 0) {
  251.           prfmsg(DIRPMT);
  252.      }
  253.      else if (sameas(margv[0],"?")) {
  254.           prfmsg(DINTRO,MAXLIN);
  255.      }
  256.      else {
  257.           if (qgebtv(cncuid(),0)) {
  258.                btumil(usrnum,DFTIMX);
  259.                gcrbtv(®ptr->regblk,0);
  260.                prfmsg(TITLIN);
  261.                prf("%-9s ... %s\r",
  262.                    regptr->regblk.userid,regptr->regblk.sumlin);
  263.                usrptr->substt=3;
  264.                btuinj(usrnum,240);
  265.                regptr->fpos=absbtv();
  266.           }
  267.           else {
  268.                prfmsg(NEXIST);
  269.                prfmsg(DIRPMT);
  270.           }
  271.      }
  272.      cncall();
  273. }
  274.  
  275. regrou3()                          /* listing directory sub-state handler  */
  276. {
  277.      btuclo(usrnum);
  278.      prfmsg(ABORTD);
  279.      prfmsg(SHRMNU);
  280.      usrptr->substt=1;
  281.      cncall();
  282. }
  283.  
  284. regrou4()                          /* fill out registry sub-state handler  */
  285. {
  286.      if (margc == 0 || sameas(margv[0],"?")) {
  287.           prfmsg(FLDPMT1+2*(regptr->fldidx));
  288.      }
  289.      else if (pfnlvl > 1) {
  290.           prfmsg(BCLEAN);
  291.           prfmsg(FLDPMT1+2*(regptr->fldidx));
  292.      }
  293.      else {
  294.           movmem(cncall(),
  295.                regptr->regblk.profil+regidx[regptr->fldidx].fidx,
  296.                regidx[regptr->fldidx].fsiz);
  297.           regptr->fldidx++;
  298.           if (regptr->fldidx < numfds) {
  299.                btumil(usrnum,regidx[regptr->fldidx].fsiz);
  300.                prfmsg(FLDPMT1+2*(regptr->fldidx));
  301.           }
  302.           else {
  303.                prfmsg(ENTSUM);
  304.                btumil(usrnum,SUMSIZ-1);
  305.                usrptr->substt=5;
  306.           }
  307.      }
  308.      cncall();
  309. }
  310.  
  311. regrou5()                          /* fill out summary sub-state handler   */
  312. {
  313.      if (margc == 0 || sameas(margv[0],"?")) {
  314.           prfmsg(ENTSUM);
  315.      }
  316.      else if (pfnlvl > 1) {
  317.           prfmsg(BCLEAN);
  318.           prfmsg(ENTSUM);
  319.      }
  320.      else {
  321.           movmem(cncall(),regptr->regblk.sumlin,SUMSIZ-1);
  322.           movmem(usaptr->userid,regptr->regblk.userid,UIDSIZ);
  323.           insbtv(®ptr->regblk);
  324.           btumil(usrnum,DFTIMX);
  325.           regptr->flags&=~CRTMNU;
  326.           prfmsg(THANKS);
  327.           prfmsg(SHRMNU);
  328.           usrptr->substt=1;
  329.      }
  330.      cncall();
  331. }
  332.  
  333. regrou6()                          /* edit registry sub-state handler      */
  334. {
  335.      int temp;
  336.  
  337.      if (margc == 0) {
  338.           prfmsg(EDTWHT);
  339.      }
  340.      else if (sameas(margv[0],"?")) {
  341.           prfmsg(YOUARE);
  342.           shwpro(EDTENT,SUMEDT);
  343.           prfmsg(EDTWHT);
  344.           cncall();
  345.      }
  346.      else {
  347.           if ((temp=cncint()) == 99) {
  348.                prfmsg(ENTNSM);
  349.                btumil(usrnum,SUMSIZ-1);
  350.                usrptr->substt=8;
  351.           }
  352.           else if (temp < 1 || temp > numfds) {
  353.                prfmsg(NOSUCH);
  354.                prfmsg(EDTWHT);
  355.                cncall();
  356.           }
  357.           else {
  358.                regptr->fldidx=temp-1;
  359.                btumil(usrnum,regidx[regptr->fldidx].fsiz);
  360.                prfmsg(ENTNEW,temp);
  361.                usrptr->substt=7;
  362.           }
  363.      }
  364. }
  365.  
  366. regrou7()                          /* enter new info sub-state handler     */
  367. {
  368.      if (margc == 0 || sameas(margv[0],"?")) {
  369.           prfmsg(NEWINF);
  370.           cncall();
  371.      }
  372.      else if (pfnlvl > 1) {
  373.           prfmsg(BCLEAN);
  374.           prfmsg(NEWINF);
  375.           cncall();
  376.      }
  377.      else {
  378.           movmem(cncall(),
  379.                regptr->regblk.profil+regidx[regptr->fldidx].fidx,
  380.                regidx[regptr->fldidx].fsiz);
  381.           regptr->flags|=UPDYOU;
  382.           btumil(usrnum,DFTIMX);
  383.           prfmsg(UPDATD);
  384.           prfmsg(EDTWHT);
  385.           usrptr->substt=6;
  386.      }
  387. }
  388.  
  389. regrou8()                          /* enter new summary sub-state handler  */
  390. {
  391.      if (margc == 0 || sameas(margv[0],"?")) {
  392.           prfmsg(ENTNSM);
  393.           cncall();
  394.      }
  395.      else if (pfnlvl > 1) {
  396.           prfmsg(BCLEAN);
  397.           prfmsg(ENTNSM);
  398.           cncall();
  399.      }
  400.      else {
  401.           movmem(cncall(),regptr->regblk.sumlin,SUMSIZ-1);
  402.           btumil(usrnum,DFTIMX);
  403.           regptr->flags|=UPDYOU;
  404.           prfmsg(UPDATD);
  405.           prfmsg(EDTWHT);
  406.           usrptr->substt=6;
  407.      }
  408. }
  409.  
  410. regrou9()                          /* look-up a user sub-state handler     */
  411. {
  412.      if (margc == 0 || sameas(margv[0],"?")) {
  413.           prfmsg((regptr->flags&GOTONE) ? UIDTLN : UIDTOL);
  414.      }
  415.      else if (strlen(margv[0]) < 3 && cncchr() == 'N') {
  416.           if (agtbtv(®ptr->regblk,regptr->regblk.userid,0)) {
  417.                prfmsg(ENTFOR,regptr->regblk.userid);
  418.                shwpro(RENTRY,SUMDSP);
  419.                regptr->flags|=GOTONE;
  420.                prfmsg(UIDTLN);
  421.           }
  422.           else {
  423.                btumil(usrnum,DFTIMX);
  424.                prfmsg(ALDONE);
  425.                prfmsg(SHRMNU);
  426.                usrptr->substt=1;
  427.           }
  428.      }
  429.      else {
  430.           if (acqbtv(®ptr->regblk,cncuid(),0)) {
  431.                prfmsg(ENTFOR,regptr->regblk.userid);
  432.                shwpro(RENTRY,SUMDSP);
  433.                regptr->flags|=GOTONE;
  434.                prfmsg(UIDTLN);
  435.           }
  436.           else {
  437.                prfmsg(NOSUID);
  438.                prfmsg((regptr->flags&GOTONE) ? UIDTLN : UIDTOL);
  439.           }
  440.      }
  441.      cncall();
  442. }
  443.  
  444. regmnu()                           /* display main registry menu           */
  445. {
  446.      prfmsg((regptr->flags&CRTMNU) ? CREMNU : EDTMNU);
  447. }
  448.  
  449. shwpro(msg,msg2)                   /* display a user's profile             */
  450. int msg,msg2;
  451. {
  452.      char *datptr,*orgbuf,*buf;
  453.      int i,hold,skount;
  454.  
  455.      datptr=regptr->regblk.profil;
  456.      buf=getmsg(msg);
  457.      orgbuf=buf;
  458.      i=0;
  459.      while (*buf != '\0') {
  460.           if ((skount=pcts(buf)) > 0) {
  461.                buf+=skount;
  462.                hold=*buf;
  463.                *buf='\0';
  464.                prf(orgbuf,datptr+regidx[i++].fidx);
  465.                *buf=hold;
  466.                orgbuf=buf;
  467.           }
  468.           else {
  469.                if (*buf == '\n') {
  470.                     *buf='\r';
  471.                }
  472.                buf+=1;
  473.           }
  474.      }
  475.      prf(orgbuf);
  476.      prfmsg(msg2,regptr->regblk.sumlin);
  477. }
  478.  
  479. pcts(buf)                          /* prf() utility for shwpro()           */
  480. char *buf;
  481. {
  482.      int i;
  483.  
  484.      if (*buf == '%') {
  485.           i=2;
  486.           while (*++buf == '-' || isdigit(*buf)) {
  487.                i+=1;
  488.           }
  489.           if (*buf == 's') {
  490.                return(i);
  491.           }
  492.           catastro("PCTS: %%-TOKEN NOT %%S IN DISPLAY MESSAGE");
  493.      }
  494.      return(0);
  495. }
  496.  
  497. reglst()                           /* status handler: registry listing     */
  498. {
  499.      setmbk(regmb);
  500.      if (usrptr->substt == 3 && status == 240) {
  501.           setbtv(regbb);
  502.           getdir();
  503.      }
  504. }
  505.  
  506. getdir()                           /* get records in registry directory    */
  507. {
  508.      if ((btuoba(usrnum)) >= 500) {
  509.           gabbtv(NULL,regptr->fpos,0);
  510.           if (qnxbtv()) {
  511.                movmem(regbb->data,®ptr->regblk,sizeof(struct regrec));
  512.                prf("%-9s ... %s\r",
  513.                    regptr->regblk.userid,regptr->regblk.sumlin);
  514.                outprf(usrnum);
  515.                regptr->fpos=absbtv();
  516.           }
  517.           else {
  518.                prfmsg(DIREND);
  519.                prfmsg(SHRMNU);
  520.                outprf(usrnum);
  521.                usrptr->substt=1;
  522.                return;
  523.           }
  524.      }
  525.      btuinj(usrnum,240);
  526. }
  527.  
  528. delreg(uid)                        /* delete utility: delete registry entry*/
  529. char *uid;
  530. {
  531.      setbtv(regbb);
  532.      if (acqbtv(NULL,uid,0)) {
  533.           delbtv();
  534.      }
  535. }
  536.  
  537. clsreg()                           /* close registry files for shutdown    */
  538. {
  539.      clsmsg(regmb);
  540.      clsbtv(regbb);
  541. }
  542.