![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / uucp|
Return to dio.c CVS log | Up to [Research Unix] / researchv8dc / cmd / uucp |
1.1 root 1: /* %W%
2: */
3: #include "uucp.h"
4: VERSION(%W%);
5:
6: #ifdef DATAKIT
7: #include <dk.h>
8:
9: #define XBUFSIZ 1024
10: time_t time();
11: static jmp_buf Dfailbuf;
12:
13: /*
14: * Datakit protocol
15: */
16: static dalarm() {longjmp(Dfailbuf);}
17: static int (*dsig)();
18: #ifndef V8
19: static short dkrmode[3] = { DKR_BLOCK, 0, 0 };
20: static short dkeof[3] = { 106, 0, 0 }; /* End of File signal */
21: #endif
22:
23: /*
24: * turn on protocol
25: */
26: dturnon()
27: {
28:
29: dsig=signal(SIGALRM, dalarm);
30: #ifndef V8
31: if(ioctl(Ofn, DIOCRMODE, dkrmode) < 0) {
32: int ret; extern int errno;
33: ret=ioctl(Ofn, DIOCRMODE, dkrmode);
34: DEBUG(4, "dturnon: ret=%d, ", ret);
35: DEBUG(4, "Ofn=%d, ", Ofn);
36: DEBUG(4, "errno=%d\n", errno);
37: return(-1);
38: }
39: #endif !V8
40: return(0);
41: }
42: dturnoff()
43: {
44: (void) signal(SIGALRM, dsig);
45: return(0);
46: }
47:
48: /*
49: * write message across Datakit link
50: * type -> message type
51: * str -> message body (ascii string)
52: * fn -> Datakit file descriptor
53: * return
54: * SUCCESS -> message sent
55: * FAIL -> write failed
56: */
57: dwrmsg(type, str, fn)
58: register char *str;
59: int fn;
60: char type;
61: {
62: register char *s;
63: char bufr[XBUFSIZ];
64:
65: bufr[0] = type;
66: s = &bufr[1];
67: while (*str)
68: *s++ = *str++;
69: *s = '\0';
70: if (*(--s) == '\n')
71: *s = '\0';
72: return(write(fn, bufr, (unsigned) strlen(bufr) + 1) < 0 ? FAIL : SUCCESS);
73: }
74:
75: /*
76: * read message from Datakit link
77: * str -> message buffer
78: * fn -> Datakit file descriptor
79: * return
80: * FAIL -> send timed out
81: * SUCCESS -> ok message in str
82: */
83: drdmsg(str, fn)
84: register char *str;
85: {
86:
87: register int len;
88:
89: if(setjmp(Dfailbuf))
90: return(FAIL);
91:
92: (void) alarm(60);
93: for (;;) {
94: if( (len = read(fn, str, XBUFSIZ)) <= 0) {
95: (void) alarm(0);
96: return(FAIL);
97: }
98: str += len;
99: if (*(str - 1) == '\0')
100: break;
101: }
102: (void) alarm(0);
103: return(SUCCESS);
104: }
105:
106: /*
107: * read data from file fp1 and write
108: * on Datakit link
109: * fp1 -> file descriptor
110: * fn -> Datakit descriptor
111: * returns:
112: * FAIL ->failure in Datakit link
113: * SUCCESS -> ok
114: */
115: dwrdata(fp1, fn)
116: register FILE *fp1;
117: {
118: register int len, ret;
119: long bytes;
120: char bufr[XBUFSIZ];
121: char text[128];
122: time_t ticks;
123:
124: bytes = 0L;
125: (void) millitick(); /* set msec timer */
126: while ((len = fread(bufr, sizeof (char), XBUFSIZ, fp1)) > 0) {
127: bytes += len;
128: ret = write(fn, bufr, (unsigned) len);
129: if (ret != len) {
130: return(FAIL);
131: }
132: if (len != XBUFSIZ)
133: break;
134: }
135: #ifndef V8
136: ioctl(fn, DIOCXCTL, dkeof);
137: #endif
138: ret = write(fn, bufr, (unsigned) 0);
139: ticks = millitick();
140: (void) sprintf(text, "-> %ld / %ld.%.3d secs",
141: bytes, ticks / 1000, ticks % 1000);
142: DEBUG(4, "%s\n", text);
143: syslog(text);
144: return(SUCCESS);
145: }
146:
147: /*
148: * read data from Datakit link and
149: * write into file
150: * fp2 -> file descriptor
151: * fn -> Datakit descriptor
152: * returns:
153: * SUCCESS -> ok
154: * FAIL -> failure on Datakit link
155: */
156: drddata(fn, fp2)
157: register FILE *fp2;
158: {
159: register int len;
160: long bytes;
161: char text[128];
162: char bufr[XBUFSIZ];
163: time_t ticks;
164:
165: bytes = 0L;
166: (void) millitick(); /* set msec timer */
167: for (;;) {
168: len = drdblk(bufr, XBUFSIZ, fn);
169: if (len < 0) {
170: return(FAIL);
171: }
172: bytes += len;
173: fwrite(bufr, sizeof (char), len, fp2);
174: if (len < XBUFSIZ)
175: break;
176: }
177: ticks = millitick();
178: (void) sprintf(text, "<- %ld / %ld.%.3d secs",
179: bytes, ticks / 1000, ticks % 1000);
180: DEBUG(4, "%s\n", text);
181: syslog(text);
182: return(SUCCESS);
183: }
184:
185: /*
186: * read block from Datakit link
187: * reads are timed
188: * blk -> address of buffer
189: * len -> size to read
190: * fn -> Datakit descriptor
191: * returns:
192: * FAIL -> link error timeout on link
193: * i -> # of bytes read
194: */
195: drdblk(blk, len, fn)
196: register char *blk;
197: {
198: register int i, ret;
199:
200: if(setjmp(Dfailbuf))
201: return(FAIL);
202:
203: for (i = 0; i < len; i += ret) {
204: (void) alarm(60);
205: if ((ret = read(fn, blk, (unsigned) len - i)) < 0) {
206: (void) alarm(0);
207: return(FAIL);
208: }
209: blk += ret;
210: if (ret == 0) /* zero length block contains only EOF signal */
211: break;
212: }
213: (void) alarm(0);
214: return(i);
215: }
216: #endif DATAKIT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.