home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / UTIL / WWIVE / MYWIVE.ZIP / UTILITY.C < prev    next >
C/C++ Source or Header  |  1993-05-06  |  21KB  |  928 lines
  1. #include "vars.h"
  2. #pragma hdrstop
  3. #include <dir.h>
  4. #include <math.h>
  5.  
  6. /* functions for external programs to call */
  7.  
  8. #pragma warn -par
  9.  
  10. void far interrupt inlii(unsigned bp, unsigned di, unsigned si,
  11.                            unsigned ds, unsigned es, unsigned dx,
  12.                            unsigned cx, unsigned bx, unsigned ax,
  13.                            unsigned ip, unsigned cs, unsigned flags,
  14.                            char *s1, char *s2, int i1, int i2)
  15. {
  16.   inli(s1,s2,i1,i2);
  17. }
  18.  
  19. void far interrupt checkai(unsigned bp, unsigned di, unsigned si,
  20.                            unsigned ds, unsigned es, unsigned dx,
  21.                            unsigned cx, unsigned bx, unsigned ax,
  22.                            unsigned ip, unsigned cs, unsigned flags,
  23.                            int *i1, int *i2)
  24. {
  25.   checka(i1,i2);
  26. }
  27.  
  28. void far interrupt plai(unsigned bp, unsigned di, unsigned si,
  29.                            unsigned ds, unsigned es, unsigned dx,
  30.                            unsigned cx, unsigned bx, unsigned ax,
  31.                            unsigned ip, unsigned cs, unsigned flags,
  32.                            char *s1, int *i1)
  33. {
  34.   pla(s1,i1);
  35. }
  36.  
  37. void far interrupt outchri(unsigned bp, unsigned di, unsigned si,
  38.                            unsigned ds, unsigned es, unsigned dx,
  39.                            unsigned cx, unsigned bx, unsigned ax,
  40.                            unsigned ip, unsigned cs, unsigned flags,
  41.                            char ch)
  42. {
  43.   outchr(ch);
  44. }
  45.  
  46. void far interrupt outstri(unsigned bp, unsigned di, unsigned si,
  47.                            unsigned ds, unsigned es, unsigned dx,
  48.                            unsigned cx, unsigned bx, unsigned ax,
  49.                            unsigned ip, unsigned cs, unsigned flags,
  50.                            char *s1)
  51. {
  52.   outstr(s1);
  53. }
  54.  
  55. void far interrupt nli(unsigned bp, unsigned di, unsigned si,
  56.                            unsigned ds, unsigned es, unsigned dx,
  57.                            unsigned cx, unsigned bx, unsigned ax,
  58.                            unsigned ip, unsigned cs, unsigned flags)
  59. {
  60.   nl();
  61. }
  62.  
  63. void far interrupt pli(unsigned bp, unsigned di, unsigned si,
  64.                            unsigned ds, unsigned es, unsigned dx,
  65.                            unsigned cx, unsigned bx, unsigned ax,
  66.                            unsigned ip, unsigned cs, unsigned flags,
  67.                            char *s1)
  68. {
  69.   pl(s1);
  70. }
  71.  
  72. void far interrupt emptyi(unsigned bp, unsigned di, unsigned si,
  73.                            unsigned ds, unsigned es, unsigned dx,
  74.                            unsigned cx, unsigned bx, unsigned ax,
  75.                            unsigned ip, unsigned cs, unsigned flags)
  76. {
  77.   ax=empty();
  78. }
  79.  
  80. void far interrupt inkeyi(unsigned bp, unsigned di, unsigned si,
  81.                            unsigned ds, unsigned es, unsigned dx,
  82.                            unsigned cx, unsigned bx, unsigned ax,
  83.                            unsigned ip, unsigned cs, unsigned flags)
  84. {
  85.   ax=(unsigned) empty();
  86. }
  87.  
  88. void far interrupt getkeyi(unsigned bp, unsigned di, unsigned si,
  89.                            unsigned ds, unsigned es, unsigned dx,
  90.                            unsigned cx, unsigned bx, unsigned ax,
  91.                            unsigned ip, unsigned cs, unsigned flags)
  92. {
  93.   ax=(unsigned) getkey();
  94. }
  95.  
  96. void far interrupt inputi(unsigned bp, unsigned di, unsigned si,
  97.                            unsigned ds, unsigned es, unsigned dx,
  98.                            unsigned cx, unsigned bx, unsigned ax,
  99.                            unsigned ip, unsigned cs, unsigned flags,
  100.                            char *s1, int i)
  101. {
  102.   input(s1,i);
  103. }
  104.  
  105. void far interrupt inputli(unsigned bp, unsigned di, unsigned si,
  106.                            unsigned ds, unsigned es, unsigned dx,
  107.                            unsigned cx, unsigned bx, unsigned ax,
  108.                            unsigned ip, unsigned cs, unsigned flags,
  109.                            char *s1, int i)
  110. {
  111.   inputl(s1,i);
  112. }
  113.  
  114. void far interrupt yni(unsigned bp, unsigned di, unsigned si,
  115.                            unsigned ds, unsigned es, unsigned dx,
  116.                            unsigned cx, unsigned bx, unsigned ax,
  117.                            unsigned ip, unsigned cs, unsigned flags)
  118. {
  119.   ax=yn();
  120. }
  121.  
  122. void far interrupt nyi(unsigned bp, unsigned di, unsigned si,
  123.                            unsigned ds, unsigned es, unsigned dx,
  124.                            unsigned cx, unsigned bx, unsigned ax,
  125.                            unsigned ip, unsigned cs, unsigned flags)
  126. {
  127.   ax=ny();
  128. }
  129.  
  130. void far interrupt ansici(unsigned bp, unsigned di, unsigned si,
  131.                            unsigned ds, unsigned es, unsigned dx,
  132.                            unsigned cx, unsigned bx, unsigned ax,
  133.                            unsigned ip, unsigned cs, unsigned flags,
  134.                            int i1)
  135. {
  136.   ansic(i1);
  137. }
  138.  
  139. void far interrupt oneki(unsigned bp, unsigned di, unsigned si,
  140.                            unsigned ds, unsigned es, unsigned dx,
  141.                            unsigned cx, unsigned bx, unsigned ax,
  142.                            unsigned ip, unsigned cs, unsigned flags,
  143.                            char *s1)
  144. {
  145.   ax=(unsigned) onek(s1);
  146. }
  147.  
  148. void far interrupt prti(unsigned bp, unsigned di, unsigned si,
  149.                            unsigned ds, unsigned es, unsigned dx,
  150.                            unsigned cx, unsigned bx, unsigned ax,
  151.                            unsigned ip, unsigned cs, unsigned flags,
  152.                            int i1, char *s1)
  153. {
  154.   prt(i1,s1);
  155. }
  156.  
  157. void far interrupt mpli(unsigned bp, unsigned di, unsigned si,
  158.                            unsigned ds, unsigned es, unsigned dx,
  159.                            unsigned cx, unsigned bx, unsigned ax,
  160.                            unsigned ip, unsigned cs, unsigned flags,
  161.                            int i1)
  162. {
  163.   mpl(i1);
  164. }
  165.  
  166. #pragma warn +par
  167.  
  168. /* end of functions for external programs to call */
  169.  
  170. void reset_act_sl()
  171. {
  172.   actsl = thisuser.sl;
  173. }
  174.  
  175. void remove_from_temp(char *fn, char *dir, int po)
  176. {
  177.   int i,i1,f1,ok;
  178.   char s[81],s1[81];
  179.   struct ffblk ff;
  180.   uploadsrec u;
  181.  
  182.   sprintf(s1,"%s%s",dir,stripfn(fn));
  183.   f1=findfirst(s1,&ff,0);
  184.   ok=1;
  185.   nl();
  186.   while ((f1==0) && (ok)) {
  187.     sprintf(s,"%s%s",dir,ff.ff_name);
  188.     if (po)
  189.       npr("Deleting %s\r\n",ff.ff_name);
  190.     _chmod(s,1,0);
  191.     unlink(s);
  192.     f1=findnext(&ff);
  193.   }
  194. }
  195.  
  196. void check_event()
  197. {
  198.   double tl;
  199.  
  200.   if (syscfg.executetime) {
  201.     tl=time_event-timer();
  202.     if (tl<0.0)
  203.       tl += 24.0*3600.0;
  204.     if ((tl-last_time)>2.0)
  205.       do_event=1;
  206.     last_time=tl;
  207.   }
  208. }
  209.  
  210. void run_event()
  211. {
  212.   if ((do_event) && (syscfg.executetime)) {
  213.     do_event=0;
  214.     nl();
  215.     pl("Now running external event.");
  216.     nl();
  217.     if (syscfg.executestr[0]) {
  218.       holdphone(1);
  219.       shrink_out(syscfg.executestr,0,0,0,1);
  220.       /* run_external(syscfg.executestr); */
  221.       holdphone(0);
  222.     } else
  223.       end_bbs(oklevel);
  224.   }
  225.   clrscrb();
  226. }
  227.  
  228. double freek(int dr)
  229. {
  230.   float d;
  231.   struct dfree df;
  232.  
  233.   getdfree(dr,&df);
  234.   d=(float) df.df_avail;
  235.   d*=((float) df.df_bsec);
  236.   d*=((float) df.df_sclus);
  237.   d/=1024.0;
  238.   if (df.df_sclus<0)
  239.   d=-1.0;
  240.   return(d);
  241. }
  242.  
  243. unsigned char years_old(unsigned char m, unsigned char d, unsigned char y)
  244. {
  245.   struct date today;
  246.   int a;
  247.  
  248.   getdate(&today);
  249.   a=(int) (today.da_year-1900-y);
  250.   if (today.da_mon<m)
  251.     --a;
  252.   else
  253.     if ((today.da_mon==m) && (today.da_day<d))
  254.       --a;
  255.   return((unsigned char)a);
  256. }
  257.  
  258. void itimer()
  259. /* This function initializes the high-resolution timer */
  260. {
  261.   outportb(0x43,0x34);
  262.   outportb(0x40,0x00);
  263.   outportb(0x40,0x00);
  264.  
  265. }
  266.  
  267. double timer()
  268. /* This function returns the time, in seconds since midnight. */
  269. {
  270.   double cputim;
  271.   unsigned short int h,m,l1,l2;
  272.  
  273.   disable();
  274.   outportb(0x43,0x00);
  275.   m=peek(0x0040,0x006c);
  276.   h=peek(0x0040,0x006e);
  277.   l1=inportb(0x40);
  278.   l2=inportb(0x40);
  279.   enable();
  280.   l1=((l2*256)+l1) ^ 65535;
  281.   cputim=((h*65536. + m)*65536. + l1)*8.380955e-7;
  282.   return (cputim);
  283. }
  284.  
  285. long timer1()
  286. /* This function returns the time, in ticks since midnight. */
  287. {
  288.   unsigned short h,m;
  289.   long l;
  290.  
  291.   m=peek(0x0040,0x006c);
  292.   h=peek(0x0040,0x006e);
  293.   l=((long)h)*65536 + ((long)m);
  294.   return(l);
  295. }
  296.  
  297. int sysop1()
  298. /* This function returns the status of scoll lock.  If scroll lock is active
  299.  * (ie, the user has hit scroll lock + the light is lit if there is a
  300.  * scoll lock LED), the sysop is assumed to be available.
  301.  */
  302. {
  303.   if ((peekb(0,1047) & 0x10)==0)
  304.     return(0);
  305.   else
  306.     return(1);
  307. }
  308.  
  309. int okansi()
  310. /* This function checks the status of the current user's record to see if
  311.  * the user has specified that he wants ANSI graphics displayed.
  312.  */
  313. {
  314.   if (thisuser.sysstatus & sysstatus_ansi)
  315.     return(1);
  316.   else
  317.     return(0);
  318. }
  319.  
  320. void frequent_init()
  321. /* This should be called after a user is logged off, and will initialize
  322.  * screen-access variables.
  323.  */
  324. {
  325.   curlsub=-1;
  326.   ansiptr=0;
  327.   curatr=0x07;
  328.   outcom=0;
  329.   incom=0;
  330.   charbufferpointer=0;
  331.   andwith=0xff;
  332.   checkit=0;
  333.   topline=0;
  334.   screenlinest=defscreenbottom+1;
  335.   if (!restoring_shrink)
  336.     clrscrb();
  337.   endofline[0]=0;
  338.   hangup=0;
  339.   hungup=0;
  340.   chatcall=0;
  341.   chatreason[0]=0;
  342.   useron=0;
  343.   change_color=0;
  344.   chatting=0;
  345.   echo=1;
  346.   irt[0]=0;
  347.   irt_name[0]=0;
  348.   okskey=0;
  349.   lines_listed=0;
  350.   read_user(1,&thisuser);
  351.   if (thisuser.inact & inact_deleted)
  352.     fwaiting=0;
  353.   else
  354.     fwaiting=thisuser.waiting;
  355.   okmacro=1;
  356.   okskey=1;
  357.   helpl=0;
  358.   ihelp=0;
  359.   mailcheck=0;
  360.   smwcheck=0;
  361.   in_extern=0;
  362.   gatfn[0]=0;
  363.   use_workspace=0;
  364.   extratimecall=0.0;
  365.   two_color=0;
  366.   using_modem=0;
  367.   set_global_handle(0);
  368.   live_user=1;
  369.   _chmod(dszlog,1,0);
  370.   unlink(dszlog);
  371. }
  372.  
  373. void read_in_file(char *fn, messagerec *m, int maxary)
  374. {
  375.   int i,i1,i2;
  376.   char *buf,s[81];
  377.   long l,l1;
  378.  
  379.   for (i=0; i<maxary; i++) {
  380.     m[i].stored_as=0L;
  381.     m[i].storage_type=255;
  382.   }
  383.   sprintf(s,"%s%s",syscfg.gfilesdir,fn);
  384.   i=open(s,O_RDWR | O_BINARY);
  385.   if (i<0) {
  386.     printf("%s NOT FOUND.\n",s);
  387.     end_bbs(noklevel);
  388.   }
  389.   l=filelength(i);
  390.   buf=(char *) farmalloc(l);
  391.   lseek(i,0L,SEEK_SET);
  392.   if (buf==NULL) {
  393.     printf("NOT ENOUGH MEMORY.\n");
  394.     end_bbs(noklevel);
  395.   }
  396.   read(i,(void *) buf,l);
  397.   close(i);
  398.   i1=0;
  399.   for (l1=0; l1<l; l1++) {
  400.     if (buf[l1]=='`') {
  401.       i1=1;
  402.       i2=0;
  403.     } else
  404.       if (i1) {
  405.         if ((buf[l1]>='0') && (buf[l1]<='9')) {
  406.           i2*=10;
  407.           i2+=(buf[l1])-'0';
  408.         } else {
  409.           while ((l1<l) && (buf[l1]!=10))
  410.             ++l1;
  411.           ++l1;
  412.           if ((i2>=0) && (i2<maxary))
  413.             m[i2].stored_as=l1;
  414.           i1=0;
  415.         }
  416.       }
  417.   }
  418.   farfree((void *) buf);
  419. }
  420.  
  421. void far *mallocx(unsigned long l)
  422. {
  423.   void *x;
  424.  
  425.   x=farmalloc(l);
  426.   if (!x) {
  427.     printf("NOT ENOUGH MEMORY.\n");
  428.     end_bbs(noklevel);
  429.   }
  430.   return(x);
  431. }
  432.  
  433. void fix_user_rec(userrec *u)
  434. {
  435.   u->name[30]=0;
  436.   u->realname[20]=0;
  437.   u->zipcode[6]=0;
  438.   u->phone[12]=0;
  439.   u->pw[8]=0;
  440.   u->laston[8]=0;
  441.   u->note[40]=0;
  442.   u->macros[0][80]=0;
  443.   u->macros[1][80]=0;
  444.   u->macros[2][80]=0;
  445. }
  446.  
  447. void close_user()
  448. {
  449.   if (userfile!=-1) {
  450.     close(userfile);
  451.     userfile=-1;
  452.   }
  453. }
  454.  
  455. void open_user()
  456. {
  457.   char s[81];
  458.  
  459.   if (userfile==-1) {
  460.     sprintf(s,"%sUSER.LST",syscfg.datadir);
  461.     userfile=open(s,O_RDWR | O_BINARY);
  462.     if (userfile<0) {
  463.       userfile=-1;
  464.     }
  465.   }
  466. }
  467.  
  468. int number_userrecs()
  469. {
  470.   open_user();
  471.   return((int) (filelength(userfile)/syscfg.userreclen)-1);
  472. }
  473.  
  474. void read_user(unsigned int un, userrec *u)
  475. {
  476.   long pos;
  477.   char s[80];
  478.   int i;
  479.  
  480.   open_user();
  481.   if ((userfile<0) || (un>number_userrecs())) {
  482.     u->inact=inact_deleted;
  483.     fix_user_rec(u);
  484.     return;
  485.   }
  486.  
  487.   if (((useron) && (un==usernum)) || ((wfc) && (un==1))) {
  488.     *u=thisuser;
  489.     fix_user_rec(u);
  490.     return;
  491.   }
  492.   pos=((long) syscfg.userreclen) * ((long) un);
  493.   lseek(userfile,pos,SEEK_SET);
  494.   i=read(userfile, (void *)u, syscfg.userreclen);
  495.   if (i==-1) {
  496.     open_user();
  497.     if ((userfile<0) || (un>number_userrecs())) {
  498.       u->inact=inact_deleted;
  499.       fix_user_rec(u);
  500.       return;
  501.     }
  502.     pos=((long) syscfg.userreclen) * ((long) un);
  503.     lseek(userfile,pos,SEEK_SET);
  504.     i=read(userfile, (void *)u, syscfg.userreclen);
  505.     if (i==-1) {
  506.       pl("COULDN'T READ USER.");
  507.     }
  508.     close_user();
  509.   }
  510.   fix_user_rec(u);
  511. }
  512.  
  513. void write_user(unsigned int un, userrec *u)
  514. {
  515.   long pos;
  516.   char s[80];
  517.   unsigned char oldsl;
  518.   int i;
  519.  
  520.   if (userfile==-1) {
  521.     sprintf(s,"%sUSER.LST",syscfg.datadir);
  522.     userfile=open(s,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  523.   }
  524.   if (((useron) && (un==usernum)) || ((wfc) && (un==1))) {
  525.     thisuser=*u;
  526.   }
  527.   pos=((long) syscfg.userreclen) * ((long) un);
  528.   lseek(userfile,pos,SEEK_SET);
  529.   i=write(userfile, (void *)u, syscfg.userreclen);
  530.   if (i==-1) {
  531.     sprintf(s,"%sUSER.LST",syscfg.datadir);
  532.     userfile=open(s,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  533.     pos=((long) syscfg.userreclen) * ((long) un);
  534.     lseek(userfile,pos,SEEK_SET);
  535.     i=write(userfile, (void *)u, syscfg.userreclen);
  536.     if (i==-1) {
  537.       pl("COULDN'T WRITE USER.");
  538.     }
  539.     close_user();
  540.   }
  541. }
  542.  
  543. void save_status()
  544. {
  545.   char s[80];
  546.  
  547.   sprintf(s,"%sSTATUS.DAT",syscfg.datadir);
  548.   statusfile=open(s,O_RDWR | O_BINARY);
  549.   write(statusfile, (void *)(&status), sizeof(statusrec));
  550.   close(statusfile);
  551.   statusfile=-1;
  552. }
  553.  
  554. double ratio()
  555. {
  556.   double r;
  557.  
  558.   if (thisuser.dk==0)
  559.     return(99.999);
  560.   r=((float) thisuser.uk) / ((float) thisuser.dk);
  561.   if (r>99.998)
  562.     r=99.998;
  563.   return(r);
  564. }
  565.  
  566. double post_ratio()
  567. {
  568.   double r;
  569.  
  570.   if (thisuser.logons==0)
  571.     return(99.999);
  572.   r=((float) thisuser.msgpost) / ((float) thisuser.logons);
  573.   if (r>99.998)
  574.     r=99.998;
  575.   return(r);
  576. }
  577.  
  578. char *nam(userrec *u1, unsigned int un)
  579. {
  580.   static char o[81];
  581.   int i,f,p;
  582.   userrec u;
  583.  
  584.   u=*u1;
  585.   f=1;
  586.   for (p=0; p<strlen(u.name); p++) {
  587.     if (f) {
  588.       if ((u.name[p]>='A') && (u.name[p]<='Z'))
  589.     f=0;
  590.       o[p]=u.name[p];
  591.     } else {
  592.       if ((u.name[p]>='A') && (u.name[p]<='Z'))
  593.         o[p]=u.name[p]-'A'+'a';
  594.       else {
  595.         if ((u.name[p]>=' ') && (u.name[p]<='/'))
  596.           f=1;
  597.         o[p]=u.name[p];
  598.       }
  599.     }
  600.   }
  601.   o[p++]=32;
  602.   o[p++]='#';
  603.   itoa(un,&o[p],10);
  604.   return(o);
  605. }
  606.  
  607. char *nam1(userrec *u1, unsigned int un, unsigned int sy)
  608. {
  609.   static char o[81];
  610.   char s[10];
  611.  
  612.   strcpy(o,nam(u1,un));
  613.   if (sy) {
  614.     sprintf(s," @%u",sy);
  615.     strcat(o,s);
  616.   }
  617.   return(o);
  618. }
  619.  
  620. double nsl()
  621. {
  622.   double tlt,tlc,tot,tpl,tpd,dd,rtn;
  623.   slrec xx;
  624.  
  625.   dd=timer();
  626.   if (useron) {
  627.     if (timeon>(dd+60.0))
  628.       timeon -= 24.0*3600.0;
  629.     tot=(dd-timeon);
  630.     xx=syscfg.sl[actsl];
  631.     tpl=((double) xx.time_per_logon) * 60.0;
  632.     tpd=((double) xx.time_per_day) * 60.0;
  633.     tlc = tpl - tot + (thisuser.extratime) + extratimecall;
  634.     tlt = tpd - tot - ((double) thisuser.timeontoday) + (thisuser.extratime);
  635.  
  636.     tlt=(((tlc)<(tlt)) ? (tlc) : (tlt));
  637.     if (tlt<0.0)
  638.       tlt=0.0;
  639.     if (tlt>32767.0)
  640.       tlt=32767.0;
  641.     rtn=tlt;
  642.   } else {
  643.     rtn=1.00;
  644.   }
  645.   if (syscfg.executetime) {
  646.     tlt=time_event-dd;
  647.     if (tlt<0.0)
  648.       tlt += 24.0*3600.0;
  649.     if (rtn>tlt)
  650.       rtn=tlt;
  651.     check_event();
  652.     if (do_event)
  653.       rtn=0.0;
  654.   }
  655.   if (rtn<0.0)
  656.     rtn=0.0;
  657.   if (rtn>32767.0)
  658.     rtn=32767.0;
  659.   return(rtn);
  660. }
  661.  
  662. char *date()
  663. {
  664.   static char ds[9];
  665.   struct date today;
  666.  
  667.   getdate(&today);
  668.   sprintf(ds,"%02d/%02d/%02d",today.da_mon,today.da_day,today.da_year-1900);
  669.   return(ds);
  670. }
  671.  
  672. char *times()
  673. {
  674.   static char ti[9];
  675.   int h,m,s;
  676.   double t;
  677.  
  678.   t=timer();
  679.   h=(int) (t/3600.0);
  680.   t-=((double) (h)) * 3600.0;
  681.   m=(int) (t/60.0);
  682.   t-=((double) (m)) * 60.0;
  683.   s=(int) (t);
  684.   sprintf(ti,"%02d:%02d:%02d",h,m,s);
  685.   return(ti);
  686. }
  687.  
  688.  
  689. unsigned int finduser(char *s)
  690. {
  691.   int un;
  692.   smalrec *sr;
  693.   userrec u;
  694.   char *ss;
  695.  
  696.   if (strcmp(s,"NEW")==0)
  697.     return(-1);
  698.   if (strcmp(s,"!-@NETWORK@-!")==0)
  699.     return(-2);
  700.   if (strcmp(s,"!-@REMOTE@-!")==0)
  701.     return(-3);
  702.   if (strncmp(s,"!=@",3)==0) {
  703.     ss=s+strlen(s)-3;
  704.     if (strcmp(ss,"@=!")==0) {
  705.       strcpy(s,s+3);
  706.       s[strlen(s)-3]=0;
  707.       return(-4);
  708.     }
  709.   }
  710.   if ((un=atoi(s))>0) {
  711.     if (un>number_userrecs())
  712.       return(0);
  713.     read_user(un,&u);
  714.     if (u.inact & inact_deleted)
  715.       return(0);
  716.     return(un);
  717.   }
  718.   sr=(smalrec *) bsearch((void *)s,
  719.              (void *)smallist,
  720.              (size_t)status.users,
  721.              (size_t)sizeof(smalrec),
  722.              (int _Cdecl (*) (const void *, const void *))strcmp);
  723.   if (sr==0L)
  724.     return(0);
  725.   else {
  726.     read_user(sr->number,&u);
  727.     if (u.inact & inact_deleted)
  728.       return(0);
  729.     else
  730.       return(sr -> number);
  731.   }
  732. }
  733.  
  734. void changedsl()
  735. {
  736.   int i,i1,i2,i3,i4,ok,dp,ddp;
  737.   subboardrec s;
  738.   directoryrec d;
  739.   usersubrec s1;
  740.  
  741.   topscreen();
  742.   dp=0;
  743.   dc[dp++]='/';
  744.   ddp=0;
  745.   dcd[ddp++]='/';
  746.   for (i=0; i<3; i++) {
  747.     s1.keys[i]=0;
  748.   }
  749.   s1.subnum=-1;
  750.   for (i=0; i<MAX_SUBS; i++)
  751.     usub[i]=s1;
  752.   for (i=0; i<MAX_DIRS; i++)
  753.     udir[i]=s1;
  754.   i1=1;
  755.   i2=0;
  756.   i3=0;
  757.   for (i=0; i<num_subs; i++) {
  758.     ok=1;
  759.     s=subboards[i];
  760.     if (actsl<s.readsl)
  761.       ok=0;
  762.     if (thisuser.age<s.age)
  763.       ok=0;
  764.     if ((s.ar!=0) && (((thisuser.ar) & (s.ar))==0))
  765.       ok=0;
  766.     if ((s.anony & anony_ansi_only) && (!okansi()))
  767.       ok=0;
  768.     if (ok) {
  769.       s1.subnum=i;
  770.       if (s.key!=0) {
  771.         s1.keys[0]=s.key;
  772.         s1.keys[1]=0;
  773.         s1.subnum=i;
  774.         usub[i3++]=s1;
  775.       } else {
  776.         if ((i1 % 10)==0)
  777.           dc[dp++]=('0'+(i1/10));
  778.         itoa(i1++,s1.keys,10);
  779.         s1.subnum=i;
  780.         for (i4=i3; i4>i2; i4--)
  781.           usub[i4]=usub[i4-1];
  782.         i3++;
  783.         usub[i2++]=s1;
  784.       }
  785.     }
  786.   }
  787.   i1=1;
  788.   i2=0;
  789.   for (i=0; i<num_dirs; i++) {
  790.     ok=1;
  791.     d=directories[i];
  792.     if (thisuser.dsl<d.dsl)
  793.       ok=0;
  794.     if (thisuser.age<d.age)
  795.       ok=0;
  796.     if (d.dar)
  797.       if ((d.dar & thisuser.dar)==0)
  798.         ok=0;
  799.     if (ok) {
  800.       s1.subnum=i;
  801.       if (i==0)
  802.         strcpy(s1.keys,"0");
  803.       else {
  804.         if ((i1 % 10)==0)
  805.           dcd[ddp++]=('0'+(i1/10));
  806.         itoa(i1++,s1.keys,10);
  807.       }
  808.       udir[i2++]=s1;
  809.     }
  810.   }
  811.   dcd[ddp]=0;
  812.   dc[dp]=0;
  813. }
  814.  
  815. void isr(int un, char *name)
  816. {
  817.   int cp,i;
  818.   char s[81];
  819.   smalrec sr;
  820.  
  821.   cp=0;
  822.   while ((cp<status.users) && (strcmp(name,(smallist[cp].name))>0))
  823.     ++cp;
  824.   memmove(&(smallist[cp+1]),&(smallist[cp]),sizeof(smalrec)*(status.users-cp));
  825.   strcpy(sr.name,name);
  826.   sr.number=un;
  827.   smallist[cp]=sr;
  828.   sprintf(s,"%sNAMES.LST",syscfg.datadir);
  829.   i=open(s,O_RDWR | O_BINARY | O_TRUNC);
  830.   if (i<0) {
  831.     printf("%s NOT FOUND.\n",s);
  832.     end_bbs(noklevel);
  833.   }
  834.   ++status.users;
  835.   save_status();
  836.   write(i,(void *) (smallist), (sizeof(smalrec) * status.users));
  837.   close(i);
  838. }
  839.  
  840. void dsr(char *name)
  841. {
  842.   int cp,i;
  843.   char s[81];
  844.   smalrec sr;
  845.  
  846.   cp=0;
  847.   while ((cp<status.users) && (strcmp(name,(smallist[cp].name))!=0))
  848.     ++cp;
  849.   if (strcmp(name,(smallist[cp].name))) {
  850.     sprintf(s,"%s NOT ABLE TO BE DELETED#*#*#*#*#*#*#*#",name);
  851.     sl1(0,s);
  852.     sl1(0,"#*#*#*# Run //resetf to fix it");
  853.     return;
  854.   }
  855.   memmove(&(smallist[cp]),&(smallist[cp+1]),sizeof(smalrec)*(status.users-cp));
  856.   sprintf(s,"%sNAMES.LST",syscfg.datadir);
  857.   i=open(s,O_RDWR | O_BINARY | O_TRUNC | O_CREAT, S_IREAD | S_IWRITE);
  858.   if (i<0) {
  859.     printf("%s COULDN'T BE CREATED.\n",s);
  860.     end_bbs(noklevel);
  861.   }
  862.   --status.users;
  863.   save_status();
  864.   write(i,(void *) (smallist), (sizeof(smalrec) * status.users));
  865.   close(i);
  866. }
  867.  
  868. void wait(double d)
  869. {
  870.   long l1;
  871.  
  872.   l1=((long) (18.2*d));
  873.   l1 += timer1();
  874.  
  875.   enable();
  876.   while (timer1()<l1)
  877.     ;
  878. }
  879.  
  880. void wait1(long l)
  881. {
  882.   long l1;
  883.  
  884.   l1 = timer1()+l;
  885.  
  886.   enable();
  887.   while (timer1()<l1)
  888.     ;
  889. }
  890.  
  891. double freek1(char *s)
  892. {
  893.   int d;
  894.  
  895.   d=cdir[0];
  896.   if (s[1]==':')
  897.     d=s[0];
  898.   d=d-'A'+1;
  899.   return(freek(d));
  900. }
  901.  
  902. int exist(char *s)
  903. {
  904.   int f;
  905.  
  906.   f=open(s,O_RDONLY | O_BINARY);
  907.   close(f);
  908.   if (f>0)
  909.     return(1);
  910.   else
  911.     return(0);
  912. }
  913.  
  914. void add_ass(int i, char *ss)
  915. {
  916.   char s[81],s1[10];
  917.  
  918.   strcpy(s,"*** ");
  919.   sysoplog(s);
  920.   strcat(s,ss);
  921.   sysoplog(s);
  922.   itoa(i,s1,10);
  923.   strcpy(s,"*** ASS-PTS: ");
  924.   strcat(s,s1);
  925.   sysoplog(s);
  926.   thisuser.ass_pts += i;
  927. }
  928.