home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / uucp / gio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-01-10  |  2.8 KB  |  203 lines
  1. #define USER 1
  2. #include <sys/pk.p>
  3. #include <sys/param.h>
  4. #include <sys/pk.h>
  5. #include <sys/buf.h>
  6. #include <setjmp.h>
  7. #include "uucp.h"
  8.  
  9.  
  10. jmp_buf Failbuf;
  11.  
  12. struct pack *Pk;
  13.  
  14. pkfail()
  15. {
  16.     longjmp(Failbuf, 1);
  17. }
  18.  
  19. gturnon()
  20. {
  21.     int ret;
  22.     struct pack *pkopen();
  23.     if (setjmp(Failbuf))
  24.         return(FAIL);
  25.     if (Pkdrvon) {
  26.         ret = pkon(Ofn, PACKSIZE);
  27.         DEBUG(4, "pkon - %d ", ret);
  28.         DEBUG(4, "Ofn - %d\n", Ofn);
  29.         if (ret <= 0)
  30.             return(FAIL);
  31.     }
  32.     else {
  33.         if (Debug > 4)
  34.             pkdebug = 1;
  35.         Pk = pkopen(Ifn, Ofn);
  36.         if ((int) Pk == NULL)
  37.             return(FAIL);
  38.     }
  39.     return(0);
  40. }
  41.  
  42.  
  43. gturnoff()
  44. {
  45.     if(setjmp(Failbuf))
  46.         return(FAIL);
  47.     if (Pkdrvon)
  48.         pkoff(Ofn);
  49.     else
  50.         pkclose(Pk);
  51.     return(0);
  52. }
  53.  
  54.  
  55. gwrmsg(type, str, fn)
  56. char type, *str;
  57. int fn;
  58. {
  59.     char bufr[BUFSIZ], *s;
  60.     int len, i, ret;
  61.  
  62.     if(setjmp(Failbuf))
  63.         return(FAIL);
  64.     bufr[0] = type;
  65.     s = &bufr[1];
  66.     while (*str)
  67.         *s++ = *str++;
  68.     *s = '\0';
  69.     if (*(--s) == '\n')
  70.         *s = '\0';
  71.     len = strlen(bufr) + 1;
  72.     if ((i = len % PACKSIZE)) {
  73.         len = len + PACKSIZE - i;
  74.         bufr[len - 1] = '\0';
  75.     }
  76.     ret = gwrblk(bufr, len, fn);
  77.     return(0);
  78. }
  79.  
  80.  
  81. grdmsg(str, fn)
  82. char *str;
  83. int fn;
  84. {
  85.     unsigned len;
  86.  
  87.     if(setjmp(Failbuf))
  88.         return(FAIL);
  89.     for (;;) {
  90.         if (Pkdrvon)
  91.             len = read(fn, str, PACKSIZE);
  92.         else
  93.             len = pkread(Pk, str, PACKSIZE);
  94.         str += len;
  95.         if (*(str - 1) == '\0')
  96.             break;
  97.     }
  98.     return(0);
  99. }
  100.  
  101.  
  102. gwrdata(fp1, fn)
  103. FILE *fp1;
  104. int fn;
  105. {
  106.     char bufr[BUFSIZ];
  107.     int len;
  108.     int ret;
  109.     time_t t1, t2;
  110.     long bytes;
  111.     char text[BUFSIZ];
  112.  
  113.     if(setjmp(Failbuf))
  114.         return(FAIL);
  115.     bytes = 0L;
  116.     time(&t1);
  117.     while ((len = fread(bufr, sizeof (char), BUFSIZ, fp1)) > 0) {
  118.         bytes += len;
  119.         ret = gwrblk(bufr, len, fn);
  120.         if (ret != len) {
  121.             return(FAIL);
  122.         }
  123.         if (len != BUFSIZ)
  124.             break;
  125.     }
  126.     ret = gwrblk(bufr, 0, fn);
  127.     time(&t2);
  128.     sprintf(text, "sent data %D bytes %D secs", bytes, t2 - t1);
  129.     DEBUG(1, "%s\n", text);
  130.     syslog(text);
  131.     sysacct(bytes, t2 - t1);
  132.     return(0);
  133. }
  134.  
  135.  
  136. grddata(fn, fp2)
  137. FILE *fp2;
  138. int fn;
  139. {
  140.     int len;
  141.     char bufr[BUFSIZ];
  142.     time_t t1, t2;
  143.     long bytes;
  144.     char text[BUFSIZ];
  145.  
  146.     if(setjmp(Failbuf))
  147.         return(FAIL);
  148.     bytes = 0L;
  149.     time(&t1);
  150.     for (;;) {
  151.         len = grdblk(bufr, BUFSIZ, fn);
  152.         if (len < 0) {
  153.             return(FAIL);
  154.         }
  155.         bytes += len;
  156.         fwrite(bufr, sizeof (char), len, fp2);
  157.         if (len < BUFSIZ)
  158.             break;
  159.     }
  160.     time(&t2);
  161.     sprintf(text, "received data %D bytes %D secs", bytes, t2 - t1);
  162.     DEBUG(1, "%s\n", text);
  163.     syslog(text);
  164.     sysacct(bytes, t2 - t1);
  165.     return(0);
  166. }
  167.  
  168.  
  169. grdblk(blk, len,  fn)
  170. int fn, len;
  171. char *blk;
  172. {
  173.     int i, ret;
  174.  
  175.     for (i = 0; i < len; i += ret) {
  176.         if (Pkdrvon)
  177.             ret = read(fn, blk, len - i);
  178.         else
  179.             ret = pkread(Pk, blk, len - i);
  180.         if (ret < 0)
  181.             return(FAIL);
  182.         blk += ret;
  183.         if (ret == 0)
  184.             return(i);
  185.     }
  186.     return(i);
  187. }
  188.  
  189.  
  190. gwrblk(blk, len, fn)
  191. char *blk;
  192. unsigned len;
  193. int fn;
  194. {
  195.     int ret;
  196.  
  197.     if (Pkdrvon)
  198.         ret = write(fn, blk, len);
  199.     else
  200.         ret = pkwrite(Pk, blk, len);
  201.     return(ret);
  202. }
  203.