UNIX 7th Ed. - /usr/src/cmd/uucp/gio.c

   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: }

Defined functions

Defined variables

Defined macros