home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / W / WWIVSOR.ZIP / NETSUP.C < prev    next >
Text File  |  1995-05-21  |  26KB  |  1,078 lines
  1. /*****************************************************************************
  2.  
  3.                 WWIV Version 4
  4.                     Copyright (C) 1988-1995 by Wayne Bell
  5.  
  6. Distribution of the source code for WWIV, in any form, modified or unmodified,
  7. without PRIOR, WRITTEN APPROVAL by the author, is expressly prohibited.
  8. Distribution of compiled versions of WWIV is limited to copies compiled BY
  9. THE AUTHOR.  Distribution of any copies of WWIV not compiled by the author
  10. is expressly prohibited.
  11.  
  12.  
  13. *****************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vars.h"
  18.  
  19. #pragma hdrstop
  20.  
  21. #include <dir.h>
  22. #include <errno.h>
  23. #include "subxtr.h"
  24.  
  25.  
  26.  
  27. #define utoa(s,v,r) ultoa((unsigned long)(s),v,r)
  28.  
  29.  
  30. void rename_pend(char *dir, char *file)
  31. {
  32.   char s[81], s1[81], s2[81];
  33.   int i;
  34.  
  35.   sprintf(s,"%s%s",dir, file);
  36.  
  37.   if (atoi(file+1))
  38.     strcpy(s2,"P1-");
  39.   else
  40.     strcpy(s2,"P0-");
  41.  
  42.   for (i=0; i<1000; i++) {
  43.     sprintf(s1,"%s%s%u.NET", dir, s2, i);
  44.     if (!rename(s, s1) || (errno!=EACCES))
  45.       break;
  46.   }
  47. }
  48.  
  49. /****************************************************************************/
  50.  
  51. void checkup(struct ftime *f1, struct ftime *f2, int *tf)
  52. {
  53.   if ((f1->ft_year)>(f2->ft_year))
  54.     *tf=1;
  55.   else
  56.     if (f1->ft_year==f2->ft_year)
  57.       if (f1->ft_month>f2->ft_month)
  58.     *tf=1;
  59.       else
  60.     if (f1->ft_month==f2->ft_month)
  61.       if (f1->ft_day>f2->ft_day)
  62.         *tf=1;
  63.       else
  64.         if (f1->ft_day==f2->ft_day)
  65.           if (f1->ft_hour>f2->ft_hour)
  66.         *tf=1;
  67.           else
  68.         if (f1->ft_hour==f2->ft_hour)
  69.           if (f1->ft_min>f2->ft_min)
  70.             *tf=1;
  71.           else
  72.             if (f1->ft_min==f2->ft_min)
  73.               if (f1->ft_tsec>f2->ft_tsec)
  74.             *tf=1;
  75. }
  76.  
  77.  
  78. int checkup2(struct ftime *f, char *x)
  79. {
  80.   int q;
  81.   char s[81];
  82.   struct ftime f2;
  83.  
  84.   sprintf(s,"%s%s",net_data,x);
  85.   q=sh_open1(s,O_RDONLY);
  86.   if (q>0) {
  87.     getftime(q,&f2);
  88.     sh_close(q);
  89.     q=0;
  90.     checkup(&f2,f,&q);
  91.   } else
  92.     q=1;
  93.   return(q);
  94. }
  95.  
  96.  
  97. int check_bbsdata(void)
  98. {
  99.   char s[81];
  100.   int ok,ok2;
  101.   struct ftime ft;
  102.  
  103.   sprintf(s,"%sCONNECT.UPD",net_data);
  104.   if ((ok=exist(s))==0) {
  105.     sprintf(s,"%sBBSLIST.UPD",net_data);
  106.     ok=exist(s);
  107.   }
  108.   if (ok  && status.net_edit_stuff) {
  109.     holdphone(1);
  110.     sprintf(s,"NETEDIT .%d /U", net_num);
  111.     extern_prog(s, EFLAG_NETPROG|EFLAG_SHRINK);
  112.   } else {
  113.     sprintf(s,"%sBBSDATA.NET",net_data);
  114.     ok=sh_open1(s,O_RDONLY);
  115.     if (ok>0) {
  116.       getftime(ok,&ft);
  117.       sh_close(ok);
  118.       ok=checkup2(&ft,"BBSLIST.NET")||checkup2(&ft,"CONNECT.NET");
  119.       ok2=checkup2(&ft,"CALLOUT.NET");
  120.     } else
  121.       ok=ok2=1;
  122.   }
  123.   sprintf(s,"%sBBSLIST.NET",net_data);
  124.   if (!exist(s))
  125.     ok=ok2=0;
  126.   sprintf(s,"%sCONNECT.NET",net_data);
  127.   if (!exist(s))
  128.     ok=ok2=0;
  129.   sprintf(s,"%sCALLOUT.NET",net_data);
  130.   if (!exist(s))
  131.     ok=ok2=0;
  132.   if (ok||ok2) {
  133.     if (status.net_version>=33)
  134.       sprintf(s,"NETWORK3%s .%d",(ok?" Y":""), net_num);
  135.     else
  136.       sprintf(s,"NETWORK3%s",(ok?" Y":""));
  137.     holdphone(1);
  138.  
  139.     extern_prog(s, EFLAG_NETPROG|EFLAG_SHRINK);
  140.     lock_status();
  141.     ++status.filechange[filechange_net];
  142.     save_status();
  143.  
  144.     zap_call_out_list();
  145.     zap_contacts();
  146.     zap_bbs_list();
  147.     if (ok>=0)
  148.       return(1);
  149.   }
  150.   return(0);
  151. }
  152.  
  153.  
  154. void cleanup_net(void)
  155. {
  156.   char s[81],cl[81];
  157.   int ok,ok2,abort,nn,any,f1,nl=0;
  158.   struct ffblk ff;
  159.  
  160.   if ((net_networks[0].sysnum==0) && (net_num_max==1))
  161.     return;
  162.  
  163.   any=1;
  164.  
  165.   while (any && (nl++ < 10)) {
  166.     any=0;
  167.  
  168.     for (nn=0; nn<net_num_max; nn++) {
  169.  
  170.       set_net_num(nn);
  171.  
  172.       if (!net_sysnum)
  173.         continue;
  174.  
  175.       set_protect(0);
  176.       clrscrb();
  177.  
  178.       ok2=1;
  179.       abort=0;
  180.       while ((ok2) && (!abort)) {
  181.         ok2=0;
  182.         ok=0;
  183.  
  184.         sprintf(s,"%sP*.%3.3d",net_data,instance);
  185.         f1=findfirst(s,&ff,0);
  186.         while (f1==0) {
  187.           ok=1;
  188.           rename_pend(net_data, ff.ff_name);
  189.           f1=findnext(&ff);
  190.         }
  191.  
  192.         if (instance==1) {
  193.           if (!ok) {
  194.             sprintf(s,"%sP*.NET",net_data);
  195.             ok=(findfirst(s,&ff,0)==0);
  196.           }
  197.           if (ok) {
  198.             holdphone(1);
  199.             hangup=0;
  200.             using_modem=0;
  201.             if (status.net_version>=33)
  202.               sprintf(cl,"NETWORK1 .%d",net_num);
  203.             else
  204.               strcpy(cl,"NETWORK1");
  205.             if (extern_prog(cl, EFLAG_NETPROG|EFLAG_SHRINK)<0)
  206.               abort=1;
  207.             else
  208.               any=1;
  209.             ok2=1;
  210.           }
  211.           sprintf(s,"%sLOCAL.NET",net_data);
  212.           if (exist(s)) {
  213.             holdphone(1);
  214.             any=1;
  215.             ok=1;
  216.             hangup=0;
  217.             using_modem=0;
  218.             if (status.net_version>=33)
  219.               sprintf(cl,"NETWORK2 .%d",net_num);
  220.             else
  221.               strcpy(cl,"NETWORK2");
  222. #ifdef OLD
  223.             sprintf(s,"%sNETUP.XXX",net_data);
  224.             if (exist(s))
  225. #endif
  226.               if (extern_prog(cl, EFLAG_NETPROG|EFLAG_SHRINK)<0)
  227.                 abort=1;
  228.               else
  229.                 any=1;
  230. #ifdef OLD
  231.             else {
  232.               if (extern_prog(cl, EFLAG_NETPROG)<0)
  233.                 abort=1;
  234.               else
  235.                 any=1;
  236.             }
  237. #endif
  238.             ok2=1;
  239.             read_status();
  240.             curlsub=-1;
  241.             if (wfc) {
  242.               wfc=0;
  243.               read_user(1,&thisuser);
  244.               fwaiting=thisuser.waiting;
  245.               wfc=1;
  246.             }
  247.           }
  248.           if (check_bbsdata())
  249.             ok2=1;
  250.           if (ok2) {
  251.             clrscrb();
  252.             zap_contacts();
  253.           }
  254.         }
  255.       }
  256.     }
  257.   }
  258.   holdphone(0);
  259. }
  260.  
  261. void do_callout(int sn)
  262. {
  263.   int i,i1,i2;
  264.   char s[81],s1[81];
  265.   long l;
  266.   net_system_list_rec *csne;
  267.  
  268.   time(&l);
  269.   i=-1;
  270.   i2=-1;
  271.   if (!net_networks[net_num].con)
  272.     read_call_out_list();
  273.   for (i1=0; i1<net_networks[net_num].num_con; i1++)
  274.     if (net_networks[net_num].con[i1].sysnum==sn)
  275.       i=i1;
  276.   if (!net_networks[net_num].ncn)
  277.     read_contacts();
  278.   for (i1=0; i1<net_networks[net_num].num_ncn; i1++)
  279.     if (net_networks[net_num].ncn[i1].systemnumber==sn)
  280.       i2=i1;
  281.   if (i!=-1) {
  282.     csne=next_system(net_networks[net_num].con[i].sysnum);
  283.     if (csne) {
  284.       sprintf(s,"NETWORK /N%u /A%s /P%s /S%u /T%ld",
  285.         sn,
  286.         (net_networks[net_num].con[i].options & options_sendback)?"1":"0",
  287.         csne->phone,
  288.         modem_i->defl.com_speed,
  289.         l);
  290.       if (net_networks[net_num].con[i].macnum) {
  291.         sprintf(s1," /M%d",(int) net_networks[net_num].con[i].macnum);
  292.         strcat(s,s1);
  293.       }
  294.       if (status.net_version>=33) {
  295.         sprintf(s1," .%d",net_num);
  296.         strcat(s,s1);
  297.       }
  298.       if (strncmp(csne->phone,"000",3)) {
  299.         npr("%s%s - ",get_string(910),csne->name);
  300.         if (net_num_max>1)
  301.           npr("%s ",net_name);
  302.         npr("@%u",sn);
  303.         nl();
  304.         describe_area_code(atoi(csne->phone),s1);
  305.         npr("%s%s",get_string(999),s1);
  306.         nl();
  307.         if ((i2!=-1) && (net_networks[net_num].ncn[i2].bytes_waiting)) {
  308.           npr("%s%ldk\r\n", get_string(1520),
  309.               bytes_to_k(net_networks[net_num].ncn[i2].bytes_waiting));
  310.         }
  311.         outstr(get_string(1000));
  312.         pl(s);
  313.         ansic(7);
  314.         pl(charstr(80,205));
  315.         holdphone(1);
  316.         Wait(2.5);
  317.         extern_prog(s, EFLAG_NETPROG|EFLAG_SHRINK);
  318.         zap_contacts();
  319.         read_status();
  320.         last_time_c=l;
  321.         global_xx=0;
  322.         cleanup_net();
  323.         holdphone(0);
  324.         imodem(0);
  325.       }
  326.     }
  327.   }
  328. }
  329.  
  330.  
  331. int ok_to_call(int i)
  332. {
  333.   int ok;
  334.   struct time ti;
  335.   char ch,h,l;
  336.   net_call_out_rec *con;
  337.  
  338.   con=&(net_networks[net_num].con[i]);
  339.  
  340.   ok=((con->options & options_no_call)==0);
  341.   if (con->options & options_receive_only)
  342.     ok=0;
  343.   ch=dow();
  344.   gettime(&ti);
  345.   if (con->options & options_ATT_night) {
  346.     if ((ch!=0) && (ch!=6)) {
  347.       if ((ti.ti_hour<23) && (ti.ti_hour>=7))
  348.         ok=0;
  349.     }
  350.     if (ch==0) {
  351.       if ((ti.ti_hour<23) && (ti.ti_hour>=16))
  352.         ok=0;
  353.     }
  354.   }
  355.   if (con->options & options_PCP_night) {
  356.     if ((ch!=0) && (ch!=6)) {
  357.       if ((ti.ti_hour<18) && (ti.ti_hour>=7))
  358.         ok=0;
  359.       if ((ti.ti_hour==6) && (ti.ti_min>30))
  360.         ok=0;
  361.     }
  362.   }
  363.  
  364.   l=con->min_hr;
  365.   h=con->max_hr;
  366.   if ((l>-1) && (h>-1) && (h!=l)) {
  367.     if ((h==0) || (h==24)) {
  368.       if (ti.ti_hour<l)
  369.         ok=0;
  370.       else
  371.         if ((ti.ti_hour==l) && (ti.ti_min<12))
  372.           ok=0;
  373.         else
  374.           if ((ti.ti_hour==23) && (ti.ti_min>30))
  375.             ok=0;
  376.     } else
  377.       if ((l==0) || (l==24)) {
  378.         if (ti.ti_hour>=h)
  379.           ok=0;
  380.         else
  381.           if ((ti.ti_hour==h-1) && (ti.ti_min>30))
  382.             ok=0;
  383.           else
  384.             if ((ti.ti_hour==0) && (ti.ti_min<12))
  385.               ok=0;
  386.       } else
  387.         if (h>l) {
  388.           if ((ti.ti_hour<l) || (ti.ti_hour>=h))
  389.             ok=0;
  390.           else
  391.             if ((ti.ti_hour==l) && (ti.ti_min<12))
  392.               ok=0;
  393.             else
  394.               if ((ti.ti_hour==h-1) && (ti.ti_min>30))
  395.                 ok=0;
  396.         } else {
  397.           if ((ti.ti_hour>=h) && (ti.ti_hour<l))
  398.             ok=0;
  399.           else
  400.             if ((ti.ti_hour==l) && (ti.ti_min<12))
  401.               ok=0;
  402.             else
  403.               if ((ti.ti_hour==h-1) && (ti.ti_min>30))
  404.                 ok=0;
  405.         }
  406.   }
  407.  
  408.   return(ok);
  409. }
  410.  
  411.  
  412.  
  413. #define WEIGHT 30.0
  414.  
  415. void fixup_long(long *f, long l)
  416. {
  417.   if (*f>l)
  418.     *f=l;
  419.  
  420.   if (*f+(SECONDS_PER_DAY*30L)<l)
  421.     *f=l-SECONDS_PER_DAY*30L;
  422. }
  423.  
  424. void free_vars(float **weight, int **try)
  425. {
  426.   int nn;
  427.  
  428.   if (weight || try) {
  429.     for (nn=0; nn<net_num_max; nn++) {
  430.       if (try && try[nn])
  431.         bbsfree(try[nn]);
  432.       if (weight && weight[nn])
  433.         bbsfree(weight[nn]);
  434.     }
  435.     if (try)
  436.       bbsfree(try);
  437.     if (weight)
  438.       bbsfree(weight);
  439.   }
  440. }
  441.  
  442. void attempt_callout(void)
  443. {
  444.   int **try,i,i1,i2,ok,net_only,nn, num_call_sys, num_ncn,any;
  445.   float **weight,fl,fl1,fl2;
  446.   long l,l1;
  447.   net_call_out_rec *con;
  448.   net_contact_rec *ncn;
  449.  
  450.   read_status();
  451.  
  452.   net_only=1;
  453.   if (syscfg.netlowtime!= syscfg.nethightime) {
  454.     if (syscfg.nethightime>syscfg.netlowtime) {
  455.       if ((timer()<=(syscfg.netlowtime*60.0)) || (timer()>=(syscfg.nethightime*60.0)))
  456.         net_only=0;
  457.     } else {
  458.       if ((timer()<=(syscfg.netlowtime*60.0)) && (timer()>=(syscfg.nethightime*60.0)))
  459.         net_only=0;
  460.     }
  461.   } else
  462.     net_only=0;
  463.   time(&l);
  464.   if (last_time_c>l)
  465.     last_time_c=0L;
  466.   if (labs(last_time_c-l)<120)
  467.     return;
  468.   if (last_time_c==0L) {
  469.     last_time_c=l;
  470.     return;
  471.   }
  472.  
  473.   if ((try=(int **)malloca(sizeof(int *) * net_num_max))==NULL)
  474.     return;
  475.   if ((weight=(float **)malloca(sizeof(float *) * net_num_max))==NULL) {
  476.     bbsfree(try);
  477.     return;
  478.   }
  479.   memset(try, 0, sizeof(int *) * net_num_max);
  480.   memset(weight, 0, sizeof(float *) * net_num_max);
  481.  
  482.   fl2=0.0;
  483.   any=0;
  484.  
  485.   for (nn=0; nn<net_num_max; nn++) {
  486.     set_net_num(nn);
  487.     if (!net_sysnum)
  488.       continue;
  489.  
  490.     /* if (!net_networks[net_num].con) */
  491.     read_call_out_list();
  492.     /* if (!net_networks[net_num].ncn) */
  493.     read_contacts();
  494.  
  495.     con=net_networks[net_num].con;
  496.     ncn=net_networks[net_num].ncn;
  497.     num_call_sys=net_networks[net_num].num_con;
  498.     num_ncn=net_networks[net_num].num_ncn;
  499.  
  500.     try[nn]=(int *)malloca(sizeof(int)*num_call_sys);
  501.     if (!try[nn])
  502.       break;
  503.     weight[nn]=(float *)malloca(sizeof(float)*num_call_sys);
  504.     if (!weight[nn])
  505.       break;
  506.  
  507.     for (i=0; i<num_call_sys; i++) {
  508.       try[nn][i]=0;
  509.       ok=ok_to_call(i);
  510.       i2=-1;
  511.       for (i1=0; i1<num_ncn; i1++)
  512.         if (ncn[i1].systemnumber==con[i].sysnum)
  513.           i2=i1;
  514.       if ((ok) && (i2!=-1)) {
  515.         if (ncn[i2].bytes_waiting==0L)
  516.           if (con[i].call_anyway) {
  517.             l1=(l-ncn[i2].lastcontact+60*3)/SECONDS_PER_HOUR/24;
  518.             if (((unsigned char)l1 < con[i].call_anyway) ||
  519.                ((con[i].options & options_sendback)==0))
  520.               if (!net_only)
  521.                 ok=0;
  522.           } else
  523.             ok=0;
  524.         if (con[i].options & options_once_per_day) {
  525.           if (labs(l-ncn[i2].lastcontactsent)<
  526.              (20L*SECONDS_PER_HOUR/con[i].times_per_day))
  527.             ok=0;
  528.         }
  529.  
  530.         if (ok)
  531.           if ((bytes_to_k(ncn[i2].bytes_waiting)<con[i].min_k)
  532.              && (labs(l-ncn[i2].lastcontact)<SECONDS_PER_DAY))
  533.             ok=0;
  534.  
  535.         fixup_long((long *)&(ncn[i2].lastcontactsent),l);
  536.         fixup_long((long *)&(ncn[i2].lasttry),l);
  537.         if (ok) {
  538.           if (ncn[i2].bytes_waiting==0L)
  539.             fl=5.0*WEIGHT;
  540.           else
  541.             fl=1024.0/((float)ncn[i2].bytes_waiting)*WEIGHT*60.0;
  542.           fl1=(float) (l-ncn[i2].lasttry);
  543.           if ((fl<fl1) || (net_only)) {
  544.             try[nn][i]=1;
  545.             fl1=fl1/fl;
  546.             if (fl1<1.0)
  547.               fl1=1.0;
  548.             if (fl1>5.0)
  549.               fl1=5.0;
  550.             weight[nn][i]=fl1;
  551.             fl2 += fl1;
  552.             any++;
  553.           }
  554.         }
  555.       }
  556.     }
  557.   }
  558.  
  559.   if (any) {
  560.     fl=fl2*((float)rand())/32767.0;
  561.     fl1=0.0;
  562.     for (nn=0; nn<net_num_max; nn++) {
  563.       set_net_num(nn);
  564.       if (!net_sysnum)
  565.         continue;
  566.  
  567.       i1=-1;
  568.       for (i=0; (i<net_networks[net_num].num_con); i++) {
  569.         if (try[nn][i]) {
  570.           fl1 += weight[nn][i];
  571.           if (fl1>=fl) {
  572.             i1=i;
  573.             break;
  574.           }
  575.         }
  576.       }
  577.       if (i1!=-1) {
  578.         free_vars(weight, try);
  579.         weight=NULL;
  580.         try=NULL;
  581.         do_callout(net_networks[net_num].con[i1].sysnum);
  582.         time(&l);
  583.         last_time_c=l;
  584.         break;
  585.       }
  586.     }
  587.   }
  588.  
  589.   free_vars(weight, try);
  590.  
  591.   set_net_num(0);
  592. }
  593.  
  594. void force_callout(int dw)
  595. {
  596.   int i,i1,i2,ok,sn,nn,onxi,odci,nv,nitu,abort=0;
  597.   unsigned int nr=1,tc=0;
  598.   long l;
  599.   char ch,s[101],onx[20],*ss,*ss1,*ss2,*mmk;
  600.   net_system_list_rec *csne;
  601.   unsigned long lc, cc;
  602.  
  603.   if ((instance!=1) && (status.net_version <34))
  604.     return;
  605.  
  606.   time(&l);
  607.   nl();
  608.   prt(2,get_string(911));
  609.   mpl(5);
  610.   input(s,5);
  611.   sn=atoi(s);
  612.   if (!sn)
  613.     return;
  614.  
  615.   odc[0]=0;
  616.   odci=0;
  617.   onx[0]='Q';
  618.   onx[1]=0;
  619.   onxi=1;
  620.   nv=0;
  621.   ss=malloca(net_num_max*3);
  622.   ss1=ss+net_num_max;
  623.   ss2=ss1+net_num_max;
  624.  
  625.   for (nn=0; nn<net_num_max; nn++) {
  626.     set_net_num(nn);
  627.     if ((!net_sysnum) || (net_sysnum==sn))
  628.       continue;
  629.  
  630.     if (!net_networks[net_num].con)
  631.       read_call_out_list();
  632.  
  633.     i=-1;
  634.     for (i1=0; i1<net_networks[net_num].num_con; i1++) {
  635.       if (net_networks[net_num].con[i1].sysnum == sn) {
  636.         i=i1;
  637.         break;
  638.       }
  639.     }
  640.  
  641.     if (i!=-1) {
  642.       if (!net_networks[net_num].ncn)
  643.         read_contacts();
  644.  
  645.       i2=-1;
  646.       for (i1=0; i1<net_networks[net_num].num_ncn; i1++) {
  647.         if (net_networks[net_num].ncn[i1].systemnumber==sn) {
  648.           i2=i1;
  649.           break;
  650.         }
  651.       }
  652.  
  653.       if (i2!=-1) {
  654.         ss[nv]=nn;
  655.         ss1[nv]=i;
  656.         ss2[nv++]=i2;
  657.       }
  658.     }
  659.   }
  660.  
  661.   nitu=-1;
  662.   if (nv) {
  663.     if (nv==1)
  664.       nitu=0;
  665.     else {
  666.       nl();
  667.       for (i=0; i<nv; i++) {
  668.         set_net_num(ss[i]);
  669.         csne=next_system(sn);
  670.         if (csne) {
  671.           if (i<9) {
  672.             onx[onxi++]=i+'1';
  673.             onx[onxi]=0;
  674.           } else {
  675.             odci=(i+1)/10;
  676.             odc[odci-1]=odci+'0';
  677.             odc[odci]=0;
  678.           }
  679.           npr("%d. %s (%s)\r\n",i+1,net_name, csne->name);
  680.         }
  681.       }
  682.       pl(get_string(12));
  683.       nl();
  684.       prt(2,get_string(13));
  685.       itoa(i+1,s,10);
  686.       mpl(strlen(s));
  687.       if (nv<9) {
  688.         ch=onek(onx);
  689.         if (ch!='Q')
  690.           nitu=ch-'1';
  691.       } else {
  692.         mmk=mmkey(2);
  693.         if (*mmk!='Q')
  694.           nitu=atoi(mmk)-1;
  695.       }
  696.     }
  697.   }
  698.  
  699.   if (nitu!=-1) {
  700.     set_net_num(ss[nitu]);
  701.     ok=ok_to_call(ss1[nitu]);
  702.  
  703.     if (!ok) {
  704.       nl();
  705.       prt(5,get_string(465));
  706.       if (yn())
  707.         ok=1;
  708.     }
  709.     if (ok) {
  710.       if (net_networks[net_num].ncn[ss2[nitu]].bytes_waiting==0L)
  711.         if (!(net_networks[net_num].con[ss1[nitu]].options & options_sendback))
  712.           ok=0;
  713.       if (ok) {
  714.         if (dw) {
  715.           nl();
  716.           prt(2,get_string(968));
  717.           mpl(5);
  718.           input(s,5);
  719.           nr=atoi(s);
  720.         }
  721.         if(dw==2) {
  722.           sl1(1,"");
  723.           if(useron) {
  724.             write_user(usernum,&thisuser);
  725.             write_qscn(usernum,qsc,0);
  726.             useron=0;
  727.           }
  728.           hang_it_up();
  729.           wait1(90);
  730.         }
  731.         if ((!dw) || (nr<1))
  732.           nr=1;
  733.  
  734.         read_contacts();
  735.         lc=net_networks[net_num].ncn[ss2[nitu]].lastcontact;
  736.         while ((tc<nr) && (!abort)) {
  737.           if (kbhitb()) {
  738.             while (kbhitb()) {
  739.               ch=upcase(getchd1());
  740.               if (!abort)
  741.                 abort=(ch==27);
  742.             }
  743.           }
  744.           tc++;
  745.           set_net_num(ss[nitu]);
  746.           read_contacts();
  747.           cc=net_networks[net_num].ncn[ss2[nitu]].lastcontact;
  748.           if ((abort) || (cc!=lc)) {
  749.             break;
  750.           } else {
  751.             clrscrb();
  752.             sprintf(s,"%s%d%s%d%s%d%s",
  753.               get_string(969),
  754.               nr,
  755.               get_string(977),
  756.               tc,
  757.               get_string(978),
  758.               nr-tc,
  759.               get_string(979));
  760.             pl(s);
  761.             if (nr==tc) {
  762.               bbsfree(ss);
  763.               ss=NULL;
  764.             }
  765.             do_callout(sn);
  766.           }
  767.         }
  768.       }
  769.     }
  770.   }
  771.   if (ss)
  772.     bbsfree(ss);
  773. }
  774.  
  775.  
  776. void print_pending_list(void)
  777. {
  778.   int i,i1,i2,nn,num_ncn, num_call_sys,abort=0;
  779.   char s[100],ch,s1[100];
  780.   long l,l2;
  781.   unsigned long ss;
  782.   net_call_out_rec *con;
  783.   net_contact_rec *ncn;
  784.  
  785.   if ((net_networks[0].sysnum==0) && (net_num_max==1))
  786.     return;
  787.  
  788.   read_status();
  789.  
  790.   time(&l);
  791.   ss=thisuser.sysstatus;
  792.   thisuser.sysstatus |= sysstatus_pause_on_page;
  793.  
  794.   nln(2);
  795.   pla(get_string(912),&abort);
  796.   if (net_num_max>1) {
  797.     pla(get_string(913),&abort);
  798.     pla(get_string(914),&abort);
  799.     pla(get_string(961),&abort);
  800.   } else {
  801.     pla(get_string(915),&abort);
  802.     pla(get_string(916),&abort);
  803.     pla(get_string(962),&abort);
  804.   }
  805.  
  806.   for (nn=0; nn<net_num_max; nn++) {
  807.  
  808.     set_net_num(nn);
  809.  
  810.     if (!net_sysnum)
  811.       continue;
  812.  
  813.     if ((!net_networks[net_num].con) || (instance!=1))
  814.       read_call_out_list();
  815.     read_contacts();
  816.  
  817.     con=net_networks[net_num].con;
  818.     ncn=net_networks[net_num].ncn;
  819.     num_call_sys=net_networks[net_num].num_con;
  820.     num_ncn=net_networks[net_num].num_ncn;
  821.  
  822.     for (i1=0; i1<num_call_sys; i1++) {
  823.       i2=-1;
  824.       for (i=0; i<num_ncn; i++) {
  825.         if (con[i1].sysnum==ncn[i].systemnumber) {
  826.           i2=i;
  827.           break;
  828.         }
  829.       }
  830.       if (i2!=-1) {
  831.         if (ok_to_call(i1)) {
  832.           if (ok_modem_stuff) {
  833.             if ((bytes_to_k(ncn[i2].bytes_waiting)>=con[i1].min_k) ||
  834.                (labs(l-ncn[i2].lastcontact)>=SECONDS_PER_DAY)) {
  835.                 ch='*';
  836.             } else {
  837.               ch='+';
  838.             }
  839.           } else {
  840.             ch='-';
  841.           }
  842.         } else {
  843.           ch=' ';
  844.         }
  845.         if (ncn[i2].lastcontactsent) {
  846.           sprintf(s1,"%4ld:",(l-ncn[i2].lastcontactsent)/SECONDS_PER_HOUR);
  847.           l2=(((l-ncn[i2].lastcontactsent)%SECONDS_PER_HOUR)/60);
  848.           itoa(l2,s,10);
  849.           if (l2<10) {
  850.             strcat(s1,"0");
  851.             strcat(s1,s);
  852.           } else
  853.             strcat(s1,s);
  854.         } else
  855.           strcpy(s1,get_string(917));
  856.         if (net_num_max>1) {
  857.           sprintf(s,"%s7│5 %c%s%-11.11s%s%-6u%s%6ldk%s%11s 7│",
  858.             charstr(14,' '),
  859.             ch,
  860.             get_string(974),
  861.             net_name,
  862.             get_string(974),
  863.             ncn[i2].systemnumber,
  864.             get_string(974),
  865.             bytes_to_k(ncn[i2].bytes_waiting),
  866.             get_string(974),
  867.             s1);
  868.         } else {
  869.           sprintf(s,"%s7│5 %c%s%-6u%s%6ldk%s%11s 7│",
  870.             charstr(21,' '),
  871.             ch,
  872.             get_string(974),
  873.             ncn[i2].systemnumber,
  874.             get_string(974),
  875.             bytes_to_k(ncn[i2].bytes_waiting),
  876.             get_string(974),
  877.             s1);
  878.         }
  879.         pla(s,&abort);
  880.       }
  881.     }
  882.   }
  883.  
  884.   for (nn=0; nn<net_num_max; nn++) {
  885.  
  886.     set_net_num(nn);
  887.  
  888.     if (!net_sysnum)
  889.       continue;
  890.  
  891.     sprintf(s,"%sDEAD.NET",net_data);
  892.     i=sh_open1(s,O_RDONLY | O_BINARY);
  893.     if (i>0) {
  894.       l=filelength(i);
  895.       sh_close(i);
  896.       if (net_num_max>1) {
  897.         sprintf(s,
  898.           "%s%s%-11.11s%s%6ldk%s",
  899.           charstr(14,' '),
  900.           get_string(966),
  901.           net_name,
  902.           get_string(967),
  903.           bytes_to_k(l),
  904.           get_string(964));
  905.       } else {
  906.         sprintf(s,
  907.           "%s%s%6ldk%s",
  908.           charstr(21,' '),
  909.           get_string(965),
  910.           bytes_to_k(l),
  911.           get_string(964));
  912.       }
  913.       pla(s,&abort);
  914.     }
  915.   }
  916.   for (nn=0; nn<net_num_max; nn++) {
  917.  
  918.     set_net_num(nn);
  919.  
  920.     if (!net_sysnum)
  921.       continue;
  922.  
  923.     sprintf(s,"%sCHECK.NET",net_data);
  924.     i=sh_open1(s,O_RDONLY | O_BINARY);
  925.     if (i>0) {
  926.       l=filelength(i);
  927.       sh_close(i);
  928.       if (net_num_max>1) {
  929.         sprintf(s,
  930.           "%s%s%-11.11s%s%6ldk",
  931.           charstr(14,' '),
  932.           get_string(966),
  933.           net_name,
  934.           get_string(967),
  935.           bytes_to_k(l));
  936.         strcat(s,get_string(1242));
  937.       } else {
  938.         sprintf(s,
  939.           "%s%s%6ldk",
  940.           charstr(21,' '),
  941.           get_string(965),
  942.           bytes_to_k(l));
  943.         strcat(s,get_string(1242));
  944.       }
  945.       pla(s,&abort);
  946.     }
  947.   }
  948.  
  949.  
  950.   if (net_num_max>1)
  951.     pla(get_string(918),&abort);
  952.   else
  953.     pla(get_string(963),&abort);
  954.   nl();
  955.   thisuser.sysstatus=ss;
  956.   if((!useron) && (lines_listed))
  957.     pausescr();
  958. }
  959.  
  960. /****************************************************************************/
  961.  
  962.  
  963. void gate_msg(net_header_rec *nh, char *text, unsigned short nn, char *byname, unsigned int *list, unsigned short fnn)
  964. {
  965.   char newname[256], fn[100], qn[200], on[200];
  966.   char *ti, nm[205], *ss;
  967.   int f,i;
  968.   unsigned short ntl;
  969.  
  970.   if (strlen(text)<80) {
  971.     ti=text;
  972.     text+=strlen(ti)+1;
  973.     ntl=nh->length-strlen(ti)-1;
  974.     ss=strchr(text,'\r');
  975.     if (ss && (ss-text<200) && (ss-text<ntl)) {
  976.       strncpy(nm,text,ss-text);
  977.       nm[ss-text]=0;
  978.       ss++;
  979.       if (*ss=='\n')
  980.         ss++;
  981.       nh->length-=(ss-text);
  982.       ntl-=(ss-text);
  983.       text=ss;
  984.  
  985.       qn[0]=on[0]=0;
  986.  
  987.       if ((fnn==65535) || (nh->fromsys == net_networks[fnn].sysnum)) {
  988.  
  989.         strcpy(newname,nm);
  990.         ss=strrchr(newname,'@');
  991.         if (ss) {
  992.           sprintf(ss+1,"%u",net_networks[nn].sysnum);
  993.           ss=strrchr(nm,'@');
  994.           if (ss) {
  995.             ++ss;
  996.             while ((*ss>='0') && (*ss<='9'))
  997.               ++ss;
  998.             strcat(newname,ss);
  999.           }
  1000.           strcat(newname,"\r\n");
  1001.           nh->fromsys = net_networks[nn].sysnum;
  1002.         }
  1003.       } else {
  1004.         if ((nm[0]=='`') && (nm[1]=='`')) {
  1005.           for (i=strlen(nm)-2; i>0; i--) {
  1006.             if ((nm[i]=='`') && (nm[i+1]=='`')) {
  1007.               break;
  1008.             }
  1009.           }
  1010.           if (i>0) {
  1011.             i+=2;
  1012.             strncpy(qn,nm,i);
  1013.             qn[i]=' ';
  1014.             qn[i+1]=0;
  1015.           }
  1016.         } else
  1017.           i=0;
  1018.         if (qn[0]==0) {
  1019.           ss=strrchr(nm,'#');
  1020.           if (ss) {
  1021.             if ((ss[1]>='0') && (ss[1]<='9')) {
  1022.               *ss=0;
  1023.               ss--;
  1024.               while ((ss>nm) && (*ss==' ')) {
  1025.                 *ss=0;
  1026.                 ss--;
  1027.               }
  1028.             }
  1029.           }
  1030.           if (nm[0]) {
  1031.             if (nh->fromuser)
  1032.               sprintf(qn,"``%s`` ",nm);
  1033.             else
  1034.               strcpy(on,nm);
  1035.           }
  1036.         }
  1037.         if ((on[0]==0) && (nh->fromuser==0)) {
  1038.           strcpy(on,nm+i);
  1039.         }
  1040.         if (on[0])
  1041.           sprintf(newname,"%s%s %s AT %u\r\n",qn, net_networks[fnn].name,
  1042.                   on, nh->fromsys);
  1043.         else
  1044.           sprintf(newname,"%s%s #%u AT %u\r\n",qn, net_networks[fnn].name,
  1045.                   nh->fromuser, nh->fromsys);
  1046.  
  1047.         nh->fromsys=net_networks[nn].sysnum;
  1048.         nh->fromuser=0;
  1049.       }
  1050.  
  1051.  
  1052.       nh->length += strlen(newname);
  1053.       if ((nh->main_type == main_type_email_name) ||
  1054.           (nh->main_type == main_type_new_post))
  1055.         nh->length += strlen(byname)+1;
  1056.       sprintf(fn,"%sP1%s",net_networks[nn].dir,nete);
  1057.       f=sh_open(fn,O_RDWR|O_BINARY|O_CREAT, S_IREAD|S_IWRITE);
  1058.       if (f) {
  1059.         sh_lseek(f,0L,SEEK_END);
  1060.         if (!list)
  1061.           nh->list_len=0;
  1062.         if (nh->list_len)
  1063.           nh->tosys=0;
  1064.         sh_write(f,nh, sizeof(net_header_rec));
  1065.         if (nh->list_len)
  1066.           sh_write(f,list,2*(nh->list_len));
  1067.         if ((nh->main_type == main_type_email_name) ||
  1068.             (nh->main_type == main_type_new_post))
  1069.           sh_write(f,byname, strlen(byname)+1);
  1070.         sh_write(f,ti,strlen(ti)+1);
  1071.         sh_write(f,newname,strlen(newname));
  1072.         sh_write(f,text,ntl);
  1073.         sh_close(f);
  1074.       }
  1075.     }
  1076.   }
  1077. }
  1078.