home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: DFÜ und Kommunikation / SOS-DFUE.ISO / programm / dos / utility / pccp076 / sndfax.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-04  |  17.0 KB  |  921 lines
  1. /* Copyright (C) 1992,1993 Peter Edward Cann */
  2.  
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<fcntl.h>
  6. #include<dos.h>
  7. #include<time.h>
  8. #include<signal.h>
  9. #include"port.h"
  10.  
  11. /* A real programmer would probably put these in a .h file,
  12.  * but a) they're not very big; b) if they change we're in
  13.  * deep stuff anyway, and c) I'm much too lazy. */
  14. struct
  15.     {
  16.     unsigned bits;
  17.     unsigned mask;
  18.     }
  19.     whites[]=
  20.         {
  21.         {0x00ac, 0x00ff},
  22.         {0x0038, 0x003f},
  23.         {0x000e, 0x000f},
  24.         {0x0001, 0x000f},
  25.         {0x000d, 0x000f},
  26.         {0x0003, 0x000f},
  27.         {0x0007, 0x000f},
  28.         {0x000f, 0x000f},
  29.         {0x0019, 0x001f},
  30.         {0x0005, 0x001f},
  31.         {0x001c, 0x001f},
  32.         {0x0002, 0x001f},
  33.         {0x0004, 0x003f},
  34.         {0x0030, 0x003f},
  35.         {0x000b, 0x003f},
  36.         {0x002b, 0x003f},
  37.         {0x0015, 0x003f},
  38.         {0x0035, 0x003f},
  39.         {0x0072, 0x007f},
  40.         {0x0018, 0x007f},
  41.         {0x0008, 0x007f},
  42.         {0x0074, 0x007f},
  43.         {0x0060, 0x007f},
  44.         {0x0010, 0x007f},
  45.         {0x000a, 0x007f},
  46.         {0x006a, 0x007f},
  47.         {0x0064, 0x007f},
  48.         {0x0012, 0x007f},
  49.         {0x000c, 0x007f},
  50.         {0x0040, 0x00ff},
  51.         {0x00c0, 0x00ff},
  52.         {0x0058, 0x00ff},
  53.         {0x00d8, 0x00ff},
  54.         {0x0048, 0x00ff},
  55.         {0x00c8, 0x00ff},
  56.         {0x0028, 0x00ff},
  57.         {0x00a8, 0x00ff},
  58.         {0x0068, 0x00ff},
  59.         {0x00e8, 0x00ff},
  60.         {0x0014, 0x00ff},
  61.         {0x0094, 0x00ff},
  62.         {0x0054, 0x00ff},
  63.         {0x00d4, 0x00ff},
  64.         {0x0034, 0x00ff},
  65.         {0x00b4, 0x00ff},
  66.         {0x0020, 0x00ff},
  67.         {0x00a0, 0x00ff},
  68.         {0x0050, 0x00ff},
  69.         {0x00d0, 0x00ff},
  70.         {0x004a, 0x00ff},
  71.         {0x00ca, 0x00ff},
  72.         {0x002a, 0x00ff},
  73.         {0x00aa, 0x00ff},
  74.         {0x0024, 0x00ff},
  75.         {0x00a4, 0x00ff},
  76.         {0x001a, 0x00ff},
  77.         {0x009a, 0x00ff},
  78.         {0x005a, 0x00ff},
  79.         {0x00da, 0x00ff},
  80.         {0x0052, 0x00ff},
  81.         {0x00d2, 0x00ff},
  82.         {0x004c, 0x00ff},
  83.         {0x00cc, 0x00ff},
  84.         {0x002c, 0x00ff},
  85.         {0x001b, 0x001f},
  86.         {0x0009, 0x001f},
  87.         {0x003a, 0x003f},
  88.         {0x0076, 0x007f},
  89.         {0x006c, 0x00ff},
  90.         {0x00ec, 0x00ff},
  91.         {0x0026, 0x00ff},
  92.         {0x00a6, 0x00ff},
  93.         {0x0016, 0x00ff},
  94.         {0x00e6, 0x00ff},
  95.         {0x0066, 0x01ff},
  96.         {0x0166, 0x01ff},
  97.         {0x0096, 0x01ff},
  98.         {0x0196, 0x01ff},
  99.         {0x0056, 0x01ff},
  100.         {0x0156, 0x01ff},
  101.         {0x00d6, 0x01ff},
  102.         {0x01d6, 0x01ff},
  103.         {0x0036, 0x01ff},
  104.         {0x0136, 0x01ff},
  105.         {0x00b6, 0x01ff},
  106.         {0x01b6, 0x01ff},
  107.         {0x0032, 0x01ff},
  108.         {0x0132, 0x01ff},
  109.         {0x00b2, 0x01ff},
  110.         {0x0006, 0x003f},
  111.         {0x01b2, 0x01ff}
  112.         },
  113.     blacks[]=
  114.         {
  115.         {0x03b0, 0x03ff},
  116.         {0x0002, 0x0007},
  117.         {0x0003, 0x0003},
  118.         {0x0001, 0x0003},
  119.         {0x0006, 0x0007},
  120.         {0x000c, 0x000f},
  121.         {0x0004, 0x000f},
  122.         {0x0018, 0x001f},
  123.         {0x0028, 0x003f},
  124.         {0x0008, 0x003f},
  125.         {0x0010, 0x007f},
  126.         {0x0050, 0x007f},
  127.         {0x0070, 0x007f},
  128.         {0x0020, 0x00ff},
  129.         {0x00e0, 0x00ff},
  130.         {0x0030, 0x01ff},
  131.         {0x03a0, 0x03ff},
  132.         {0x0060, 0x03ff},
  133.         {0x0040, 0x03ff},
  134.         {0x0730, 0x07ff},
  135.         {0x00b0, 0x07ff},
  136.         {0x01b0, 0x07ff},
  137.         {0x0760, 0x07ff},
  138.         {0x00a0, 0x07ff},
  139.         {0x0740, 0x07ff},
  140.         {0x00c0, 0x07ff},
  141.         {0x0530, 0x0fff},
  142.         {0x0d30, 0x0fff},
  143.         {0x0330, 0x0fff},
  144.         {0x0b30, 0x0fff},
  145.         {0x0160, 0x0fff},
  146.         {0x0960, 0x0fff},
  147.         {0x0560, 0x0fff},
  148.         {0x0d60, 0x0fff},
  149.         {0x04b0, 0x0fff},
  150.         {0x0cb0, 0x0fff},
  151.         {0x02b0, 0x0fff},
  152.         {0x0ab0, 0x0fff},
  153.         {0x06b0, 0x0fff},
  154.         {0x0eb0, 0x0fff},
  155.         {0x0360, 0x0fff},
  156.         {0x0b60, 0x0fff},
  157.         {0x05b0, 0x0fff},
  158.         {0x0db0, 0x0fff},
  159.         {0x02a0, 0x0fff},
  160.         {0x0aa0, 0x0fff},
  161.         {0x06a0, 0x0fff},
  162.         {0x0ea0, 0x0fff},
  163.         {0x0260, 0x0fff},
  164.         {0x0a60, 0x0fff},
  165.         {0x04a0, 0x0fff},
  166.         {0x0ca0, 0x0fff},
  167.         {0x0240, 0x0fff},
  168.         {0x0ec0, 0x0fff},
  169.         {0x01c0, 0x0fff},
  170.         {0x0e40, 0x0fff},
  171.         {0x0140, 0x0fff},
  172.         {0x01a0, 0x0fff},
  173.         {0x09a0, 0x0fff},
  174.         {0x0d40, 0x0fff},
  175.         {0x0340, 0x0fff},
  176.         {0x05a0, 0x0fff},
  177.         {0x0660, 0x0fff},
  178.         {0x0e60, 0x0fff},
  179.         {0x03c0, 0x03ff},
  180.         {0x0130, 0x0fff},
  181.         {0x0930, 0x0fff},
  182.         {0x0da0, 0x0fff},
  183.         {0x0cc0, 0x0fff},
  184.         {0x02c0, 0x0fff},
  185.         {0x0ac0, 0x0fff},
  186.         {0x06c0, 0x1fff},
  187.         {0x16c0, 0x1fff},
  188.         {0x0a40, 0x1fff},
  189.         {0x1a40, 0x1fff},
  190.         {0x0640, 0x1fff},
  191.         {0x1640, 0x1fff},
  192.         {0x09c0, 0x1fff},
  193.         {0x19c0, 0x1fff},
  194.         {0x05c0, 0x1fff},
  195.         {0x15c0, 0x1fff},
  196.         {0x0dc0, 0x1fff},
  197.         {0x1dc0, 0x1fff},
  198.         {0x0940, 0x1fff},
  199.         {0x1940, 0x1fff},
  200.         {0x0540, 0x1fff},
  201.         {0x1540, 0x1fff},
  202.         {0x0b40, 0x1fff},
  203.         {0x1b40, 0x1fff},
  204.         {0x04c0, 0x1fff},
  205.         {0x14c0, 0x1fff}
  206.         };
  207.  
  208. /* This is max n bytes+ of Phase C for Federal stripe. Know thy math!!! */
  209. /* To save 5 k, we do DLE shielding at Tx time. */
  210.  
  211. #define SFXBUFSIZ 5200
  212.  
  213. unsigned char sfxbuf[SFXBUFSIZ];
  214.  
  215. int sfxbufi;
  216.  
  217. unsigned char wkngbyte, wbmask;
  218.  
  219. putsym(bitsw, maskw)
  220.     unsigned bitsw, maskw;
  221.     {
  222.     unsigned srcmask;
  223.     for(srcmask=1;srcmask&maskw;srcmask<<=1)
  224.         {
  225.         if(bitsw&srcmask)
  226.             wkngbyte|=wbmask;
  227.         if(!(wbmask<<=1))
  228.             {
  229.             sfxbuf[sfxbufi++]=wkngbyte;
  230.             wkngbyte=0;
  231.             wbmask=0x01;
  232.             }
  233.         }
  234.     }
  235.  
  236. initsym()
  237.     {
  238.     wkngbyte=0;
  239.     wbmask=0x01;
  240.     }
  241.  
  242. puteol()
  243.     {
  244.     if(wbmask!=0x01)   /* Might as well save a byte */
  245.         sfxbuf[sfxbufi++]=wkngbyte;
  246.     initsym();
  247.     sfxbuf[sfxbufi++]=0x00;
  248.     sfxbuf[sfxbufi++]=0x80;
  249.     }
  250.  
  251. putwhite(n)
  252.     int n;
  253.     {
  254.     int m;
  255.     if((n<0)||(n>1728))
  256.         {
  257.         printf("\nProbable code error; bad white run length %d.\n", n);
  258.         exit(71);
  259.         }
  260.     if(m=(n&~63))
  261.         {
  262.         m>>=6;
  263.         m+=63;
  264.         putsym(whites[m].bits, whites[m].mask);
  265.         }
  266.     m=n&63;
  267.     putsym(whites[m].bits, whites[m].mask);
  268.     }
  269.  
  270. putblack(n)
  271.     int n;
  272.     {
  273.     int m;
  274.     if((n<0)||(n>1728))
  275.         {
  276.         printf("\nProbable code error, bad black run length %d.\n", n);
  277.         exit(72);
  278.         }
  279.     if(m=(n&~63))
  280.         {
  281.         m>>=6;
  282.         m+=63;
  283.         putsym(blacks[m].bits, blacks[m].mask);
  284.         }
  285.     m=n&63;
  286.     putsym(blacks[m].bits, blacks[m].mask);
  287.     }
  288.  
  289. /* 7-segment bit significance:
  290.  *
  291.  *     --0--
  292.  *    1     2
  293.  *     --3--
  294.  *    4     5
  295.  *     --6--
  296.  *
  297.  * Code ten decimal is the hyphen.
  298.  */
  299.  
  300. unsigned char segmaps[]=
  301.     {0x77,0x24,0x5d,0x6d,0x2e,0x6b,0x7b,0x25,0x7f,0x6f,0x08,0x00};
  302.  
  303. unsigned char fedstr[80];
  304.  
  305. makeheader(page)
  306.     int page;
  307.     {
  308.     int white, row, i, pixcnt;
  309.     char pagestr[8], *ssptr, *tsptr;
  310.     sfxbufi=0;
  311.     sprintf(pagestr, "%d", page);
  312.     for(ssptr=pagestr,tsptr=&fedstr[72];*ssptr;ssptr++,tsptr++)
  313.         (*tsptr)=(*ssptr)-'0';
  314.     puteol();
  315.     putwhite(1728);
  316.     puteol();
  317.     putwhite(1728);
  318.     puteol();
  319.     putwhite(1728);
  320.     puteol();
  321.     for(row=0;row<3;row++)
  322.         {
  323.         pixcnt=0;
  324.         white=64;
  325.         for(i=0,ssptr=fedstr;i<80;++i,++ssptr)
  326.             {
  327.             if(segmaps[*ssptr]&1)
  328.                 {
  329.                 putwhite(white);
  330.                 pixcnt+=white;
  331.                 white=0;
  332.                 putblack(16);
  333.                 pixcnt+=16;
  334.                 }
  335.             else 
  336.                 {
  337.                 if(segmaps[*ssptr]&2)
  338.                     {
  339.                     putwhite(white);
  340.                     pixcnt+=white;
  341.                     white=0;
  342.                     putblack(3);
  343.                     pixcnt+=3;
  344.                     }
  345.                 else
  346.                     white+=3;
  347.                 white+=10;
  348.                 if(segmaps[*ssptr]&4)
  349.                     {
  350.                     putwhite(white);
  351.                     pixcnt+=white;
  352.                     white=0;
  353.                     putblack(3);
  354.                     pixcnt+=3;
  355.                     }
  356.                 else
  357.                     white+=3;
  358.                 }
  359.             white+=4;
  360.             }
  361.         putwhite(1728-pixcnt);
  362.         puteol();
  363.         }
  364.     for(row=0;row<10;row++)
  365.         {
  366.         pixcnt=0;
  367.         white=64;
  368.         for(i=0,ssptr=fedstr;i<80;++i,++ssptr)
  369.             {
  370.             if(segmaps[*ssptr]&2)
  371.                 {
  372.                 putwhite(white);
  373.                 pixcnt+=white;
  374.                 white=0;
  375.                 putblack(3);
  376.                 pixcnt+=3;
  377.                 }
  378.             else
  379.                 white+=3;
  380.             white+=10;
  381.             if(segmaps[*ssptr]&4)
  382.                 {
  383.                 putwhite(white);
  384.                 pixcnt+=white;
  385.                 white=0;
  386.                 putblack(3);
  387.                 pixcnt+=3;
  388.                 }
  389.             else
  390.                 white+=3;
  391.             white+=4;
  392.             }
  393.         putwhite(1728-pixcnt);
  394.         puteol();
  395.         }
  396.     for(row=0;row<3;row++)
  397.         {
  398.         pixcnt=0;
  399.         white=64;
  400.         for(i=0,ssptr=fedstr;i<80;++i,++ssptr)
  401.             {
  402.             if(segmaps[*ssptr]&8)
  403.                 {
  404.                 putwhite(white);
  405.                 pixcnt+=white;
  406.                 white=0;
  407.                 putblack(16);
  408.                 pixcnt+=16;
  409.                 }
  410.             else
  411.                 {
  412.                 if(segmaps[*ssptr]&18) /* 16 | 2; cute, eh? */
  413.                     {
  414.                     putwhite(white);
  415.                     pixcnt+=white;
  416.                     white=0;
  417.                     putblack(3);
  418.                     pixcnt+=3;
  419.                     }
  420.                 else
  421.                     white+=3;
  422.                 white+=10;
  423.                 if(segmaps[*ssptr]&36) /* 32 | 4 */
  424.                     {
  425.                     putwhite(white);
  426.                     pixcnt+=white;
  427.                     white=0;
  428.                     putblack(3);
  429.                     pixcnt+=3;
  430.                     }
  431.                 else
  432.                     white+=3;
  433.                 }
  434.             white+=4;
  435.             }
  436.         putwhite(1728-pixcnt);
  437.         puteol();
  438.         }
  439.     for(row=0;row<10;row++)
  440.         {
  441.         pixcnt=0;
  442.         white=64;
  443.         for(i=0,ssptr=fedstr;i<80;++i,++ssptr)
  444.             {
  445.             if(segmaps[*ssptr]&16)
  446.                 {
  447.                 putwhite(white);
  448.                 pixcnt+=white;
  449.                 white=0;
  450.                 putblack(3);
  451.                 pixcnt+=3;
  452.                 }
  453.             else
  454.                 white+=3;
  455.             white+=10;
  456.             if(segmaps[*ssptr]&32)
  457.                 {
  458.                 putwhite(white);
  459.                 pixcnt+=white;
  460.                 white=0;
  461.                 putblack(3);
  462.                 pixcnt+=3;
  463.                 }
  464.             else
  465.                 white+=3;
  466.             white+=4;
  467.             }
  468.         putwhite(1728-pixcnt);
  469.         puteol();
  470.         }
  471.     for(row=0;row<3;row++)
  472.         {
  473.         pixcnt=0;
  474.         white=64;
  475.         for(i=0,ssptr=fedstr;i<80;++i,++ssptr)
  476.             {
  477.             if(segmaps[*ssptr]&64)
  478.                 {
  479.                 putwhite(white);
  480.                 pixcnt+=white;
  481.                 white=0;
  482.                 putblack(16);
  483.                 pixcnt+=16;
  484.                 }
  485.             else
  486.                 {
  487.                 if(segmaps[*ssptr]&16)
  488.                     {
  489.                     putwhite(white);
  490.                     pixcnt+=white;
  491.                     white=0;
  492.                     putblack(3);
  493.                     pixcnt+=3;
  494.                     }
  495.                 else
  496.                     white+=3;
  497.                 white+=10;
  498.                 if(segmaps[*ssptr]&32)
  499.                     {
  500.                     putwhite(white);
  501.                     pixcnt+=white;
  502.                     white=0;
  503.                     putblack(3);
  504.                     pixcnt+=3;
  505.                     }
  506.                 else
  507.                     white+=3;
  508.                 }
  509.             white+=4;
  510.             }
  511.         putwhite(1728-pixcnt);
  512.         puteol();
  513.         }
  514.     putwhite(1728);
  515.     puteol();
  516.     putwhite(1728);
  517.     puteol();
  518.     putwhite(1728);
  519.     puteol();
  520.     putwhite(0);
  521.     putblack(1728);
  522.     putwhite(0);
  523.     /* We only get the black with this or extra EOL; goD knows why! */
  524.     }
  525.  
  526. sendchar(c)
  527.     unsigned char c;
  528.     {
  529.     while(!(inp(basereg+STATREG)&TXMTMASK))
  530.         if(kbhit())
  531.             getch();
  532.     outp(basereg, c);
  533.     }
  534.  
  535. int follow;
  536.  
  537. quit()
  538.     {
  539.     cleanup(0);
  540.     exit(99);
  541.     }
  542.  
  543. sendstr(str)
  544.     char *str;
  545.     {
  546.     int i;
  547.     for(i=0;str[i]!='\0';++i)
  548.         sendchar(str[i]);
  549.     }
  550.  
  551. #define FBUFSIZ 4096
  552.  
  553. unsigned char fbuf[FBUFSIZ];
  554. int fd, fbufi, fbufn;
  555.  
  556. unsigned char getbyte()
  557.     {
  558.     if(fbufi>=fbufn)
  559.         if((fbufn=read(fd, fbuf, FBUFSIZ))<=0)
  560.             {
  561.             printf("Premature end of file.\n");
  562.             cleanup(0);
  563.             exit(101);
  564.             }
  565.         else
  566.             fbufi=0;
  567.     return(fbuf[fbufi++]);
  568.     }
  569.  
  570. int scanok(seconds)
  571.     int seconds;
  572.     {
  573.     static char *okstr="\nOK\r\n";
  574.     static char *fhngstr="\n+FHNG";
  575.     long timestamp;
  576.     int i, j;
  577.     timestamp=time(NULL);
  578.     i=j=0;
  579.     while(1)
  580.         {
  581.         while(follow==index)
  582.             {
  583.             if(kbhit())
  584.                 getch();
  585.             if((time(NULL)-timestamp)>seconds)
  586.                 return(0);
  587.             }
  588.         putch(buf[follow]);
  589.         if(okstr[i]==buf[follow])
  590.                 {
  591.                 i++;
  592.                 if(okstr[i]=='\0')
  593.                     {
  594.                     follow++;
  595.                     follow%=TBUFSIZ;
  596.                     return(1);
  597.                     }
  598.                 }
  599.             else
  600.                 i=0;
  601.         if(fhngstr[j]==buf[follow])
  602.                 {
  603.                 j++;
  604.                 if(fhngstr[i]=='\0')
  605.                     {
  606.                     follow++;
  607.                     follow%=TBUFSIZ;
  608.                     do
  609.                         {
  610.                         follow%=TBUFSIZ;
  611.                         while(follow==index)
  612.                             {
  613.                             if(kbhit())
  614.                                 getch();
  615.                             if((time(NULL)-timestamp)>seconds)
  616.                                 return(0);
  617.                             }
  618.                         putch(buf[follow]);
  619.                         }
  620.                     while(buf[follow++]!='\n');
  621.                     follow%=TBUFSIZ;
  622.                     return(0);
  623.                     }
  624.                 }
  625.             else
  626.                 j=0;
  627.         follow++;
  628.         follow%=TBUFSIZ;
  629.         }
  630.     }
  631.  
  632. int scanconnect(seconds)
  633.     int seconds;
  634.     {
  635.     static char *connectstr="\nCONNECT\r\n";
  636.     static char *fhngstr="\n+FHNG";
  637.     long timestamp;
  638.     int i, j;
  639.     timestamp=time(NULL);
  640.     i=j=0;
  641.     while(1)
  642.         {
  643.         while(follow==index)
  644.             {
  645.             if(kbhit())
  646.                 getch();
  647.             if((time(NULL)-timestamp)>seconds)
  648.                 return(0);
  649.             }
  650.         putch(buf[follow]);
  651.         if(connectstr[i]==buf[follow])
  652.                 {
  653.                 i++;
  654.                 if(connectstr[i]=='\0')
  655.                     {
  656.                     follow++;
  657.                     follow%=TBUFSIZ;
  658.                     return(1);
  659.                     }
  660.                 }
  661.             else
  662.                 i=0;
  663.         if(fhngstr[j]==buf[follow])
  664.                 {
  665.                 j++;
  666.                 if(fhngstr[i]=='\0')
  667.                     {
  668.                     follow++;
  669.                     follow%=TBUFSIZ;
  670.                     do
  671.                         {
  672.                         follow%=TBUFSIZ;
  673.                         while(follow==index)
  674.                             {
  675.                             if(kbhit())
  676.                                 getch();
  677.                             if((time(NULL)-timestamp)>seconds)
  678.                                 return(0);
  679.                             }
  680.                         putch(buf[follow]);
  681.                         }
  682.                     while(buf[follow++]!='\n');
  683.                     follow%=TBUFSIZ;
  684.                     return(0);
  685.                     }
  686.                 }
  687.             else
  688.                 j=0;
  689.         follow++;
  690.         follow%=TBUFSIZ;
  691.         }
  692.     }
  693.  
  694. int scanfhng0(seconds)
  695.     int seconds;
  696.     {
  697.     static char *fhng0str="\n+FHNG: 0\r\n";
  698.     static char *fhngstr="\n+FHNG: #!";
  699.     long timestamp;
  700.     int i, j;
  701.     timestamp=time(NULL);
  702.     i=j=0;
  703.     while(1)
  704.         {
  705.         while(follow==index)
  706.             {
  707.             if(kbhit())
  708.                 getch();
  709.             if((time(NULL)-timestamp)>seconds)
  710.                 return(0);
  711.             }
  712.         putch(buf[follow]);
  713.         if(fhng0str[i]==buf[follow])
  714.                 {
  715.                 i++;
  716.                 if(fhng0str[i]=='\0')
  717.                     {
  718.                     follow++;
  719.                     follow%=TBUFSIZ;
  720.                     return(1);
  721.                     }
  722.                 }
  723.             else
  724.                 i=0;
  725.         if((fhngstr[j]==buf[follow])||((fhngstr[i]=='#')&&(buf[follow]!='0'))||((fhngstr[i]=='!')&&(buf[follow]!='\r')))
  726.                 {
  727.                 j++;
  728.                 if(fhngstr[i]=='\0')
  729.                     {
  730.                     follow++;
  731.                     follow%=TBUFSIZ;
  732.                     do
  733.                         {
  734.                         follow%=TBUFSIZ;
  735.                         while(follow==index)
  736.                             {
  737.                             if(kbhit())
  738.                                 getch();
  739.                             if((time(NULL)-timestamp)>seconds)
  740.                                 return(0);
  741.                             }
  742.                         putch(buf[follow]);
  743.                         }
  744.                     while(buf[follow++]!='\n');
  745.                     follow%=TBUFSIZ;
  746.                     return(0);
  747.                     }
  748.                 }
  749.             else
  750.                 j=0;
  751.         follow++;
  752.         follow%=TBUFSIZ;
  753.         }
  754.     }
  755.  
  756. main(argc, argv)
  757.     int argc;
  758.     char **argv;
  759.     {
  760.     int xflag, dleflag, i, page;
  761.     FILE *cfgfd;
  762.     unsigned char c, *fromstr, timestr[32], *ssptr, *tsptr;
  763.     time_t utime;
  764.     struct tm *goodies;
  765.     if(argc!=4)
  766.         {
  767.         printf("USAGE: sndfax <comnum> <speed> <file>\n");
  768.         exit(98);
  769.         }
  770.     for(i=0;i<80;i++)
  771.         fedstr[i]=11;
  772.     if((fromstr=getenv("PCCPFROM"))==NULL)
  773.         {
  774.         printf("WARNING: USA Federal regulations require fax sender identification.\n");
  775.         printf("Unable to find environment variable PCCPFROM; see manual. Sending anyway.\n");
  776.         }
  777.     for(ssptr=fromstr,tsptr=fedstr,i=0;(*ssptr)&&((*ssptr)!='\n')&&(i<40);ssptr++,tsptr++)
  778.         if(((*ssptr)>='0')&&((*ssptr)<='9'))
  779.             (*tsptr)=(*ssptr)-'0';
  780.         else if((*ssptr)=='-')
  781.             (*tsptr)=10;
  782.     time(&utime);
  783.     goodies=localtime(&utime);
  784.     sprintf(timestr, "%d-%02d-%02d  %02d%02d",
  785.         (goodies->tm_year>70)?(goodies->tm_year+1900):(goodies->tm_year+2000),
  786.         (goodies->tm_mon)+1, goodies->tm_mday,
  787.         goodies->tm_hour, goodies->tm_min);
  788.     for(ssptr=timestr,tsptr=&fedstr[45];*ssptr;ssptr++,tsptr++)
  789.         if(((*ssptr)>='0')&&((*ssptr)<='9'))
  790.             (*tsptr)=(*ssptr)-'0';
  791.         else if((*ssptr)=='-')
  792.             (*tsptr)=10;
  793.     if((fd=open(argv[3], O_RDONLY|O_BINARY))==-1)
  794.         {
  795.         printf("Error opening presumed SFX file %s for read.\n", argv[3]);
  796.         exit(97);
  797.         }
  798.     comnum=atoi(argv[1])-1;
  799.     speed=atoi(argv[2]);
  800.     databits='8';
  801.     parity='n';
  802.     stopbits='1';
  803.     setport();
  804.     readset();
  805.     follow=index=0;
  806.     setup();
  807.     signal(SIGINT, quit);
  808.     page=0;
  809.     fbufi=fbufn=0;
  810.     while(1)
  811.         {
  812.         makeheader(++page);
  813.         sendstr("AT+FDT\r");
  814.         if(!scanconnect(60))
  815.             {
  816.             cleanup(0);
  817.             printf("Failed to get CONNECT message.\n");
  818.             close(fd);
  819.             exit(1);
  820.             break;
  821.             }
  822.         while(1)
  823.             {
  824.             while(follow==index)
  825.                 if(kbhit())
  826.                     getch();
  827.             if(buf[follow++]==0x11)
  828.                 {
  829.                 follow%=TBUFSIZ;
  830.                 break;
  831.                 }
  832.             follow%=TBUFSIZ;
  833.             }
  834.         for(i=0;i<sfxbufi;i++)
  835.             {
  836.             for(xflag=0;xflag|(follow!=index);)
  837.                 if(follow!=index)
  838.                     {
  839.                     c=buf[follow++];
  840.                     if(follow>=TBUFSIZ)
  841.                         follow=0;
  842.                     if(c==0x13)
  843.                         xflag=1;
  844.                     else if(c==0x11)
  845.                         xflag=0;
  846.                     }
  847.             sendchar(sfxbuf[i]);
  848.             if(sfxbuf[i]==0x10)
  849.                 sendchar(0x10); /* Count on buffer slack */
  850.             }
  851.         dleflag=0;
  852.         while(1)
  853.             {
  854.             for(xflag=0;xflag|(follow!=index);)
  855.                 if(follow!=index)
  856.                     {
  857.                     c=buf[follow++];
  858.                     if(follow>=TBUFSIZ)
  859.                         follow=0;
  860.                     if(c==0x13)
  861.                         xflag=1;
  862.                     else if(c==0x11)
  863.                         xflag=0;
  864.                     }
  865.             c=getbyte();
  866.             if(dleflag)
  867.                 {
  868.                 dleflag=0;
  869.                 if(c==0x03)
  870.                     {
  871.                     sendchar(c);
  872.                     break;
  873.                     }
  874.                 else if(c==0x04)
  875.                     {
  876.                     sendchar(0x03);
  877.                     if(!scanok(60))
  878.                         {
  879.                         printf("Failed to get OK after last page image data.\n");
  880.                         cleanup(0);
  881.                         exit(2);
  882.                         }
  883.                     sendstr("AT+FET=2\r");
  884.                     if(!scanfhng0(60))
  885.                         {
  886.                         printf("Failed to get good hangup code.\n");
  887.                         cleanup(0);
  888.                         exit(3);
  889.                         }
  890.                     cleanup(0);
  891.                     exit(0);
  892.                     }
  893.                 else
  894.                     sendchar(c);
  895.                 }
  896.             else
  897.                 {
  898.                 if(c==0x10)
  899.                     dleflag=1;
  900.                 sendchar(c);
  901.                 }
  902.             }
  903.         if(!scanok(60))
  904.             {
  905.             printf("Failed to get OK after page image data.\n");
  906.             cleanup(0);
  907.             exit(7);
  908.             }
  909.         sendstr("AT+FET=0\r");
  910.         if(!scanok(60))
  911.             {
  912.             printf("Failed to get proper interpage handshake.\n");
  913.             cleanup(0);
  914.             exit(8);
  915.             }
  916.         }
  917.     printf("Something's wrong with the code; we should never have gotten here!\n");
  918.     cleanup(0);
  919.     exit(111);
  920.     }
  921.