1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30
31 #pragma ident "%Z%%M% %I% %E% SMI"
32
33 #include "uucp.h"
34
35 #include "pk.h"
36 #include <sys/buf.h>
37
38 extern void pkfail(), pkzero(), pkoutput(), pkreset(), pkcntl(), pkgetpack();
39 extern int pksack();
40 static void pkdata();
41 static int pkcget();
42 static void xlatestate(struct pack *, int);
43 void xlatecntl(int, int);
44
45 /*
46 * Code added to allow translation of states from numbers to
47 * letters, to be done in such a way as to be meaningful to
48 * John Q. Public
49 */
50 struct {
51 int state;
52 char *msg;
53 } st_trans[] = {
54 DEAD, "Dead!",
55 INITa, "INIT code a",
56 INITb, "INIT code b",
57 LIVE, "O.K.",
58 RXMIT, "Rcv/Xmit",
59 RREJ, "RREJ?",
60 PDEBUG, "PDEBUG?",
61 DRAINO, "Draino...",
62 WAITO, "Waiting",
63 DOWN, "Link down",
64 RCLOSE, "RCLOSE?",
65 BADFRAME, "Bad frame",
66 -1, "End of the line",
67 };
68
69 extern char _Protocol[]; /* Protocol string with (options) */
70
71 #define PKMAXSTMSG 40
72 int Connodata = 0; /* Continuous Non Valid Data Count */
73 int Ntimeout = 0;
74 #define CONNODATA 20 /* Max Continuous Non Valid Data Count */
75 #define NTIMEOUT 50 /* This is not currently used, but maybe future */
76
77 extern jmp_buf Getjbuf;
78
79 /*
80 * start initial synchronization.
81 */
82 struct pack *
pkopen(ifn,ofn)83 pkopen(ifn, ofn)
84 int ifn, ofn;
85 {
86 struct pack *pk;
87 char **bp;
88 int i;
89 int windows = WINDOWS;
90 extern int xpacksize, packsize;
91
92 if ((pk = (struct pack *) calloc(1, sizeof (struct pack))) == NULL)
93 return(NULL);
94 pk->p_ifn = ifn;
95 pk->p_ofn = ofn;
96 DEBUG(7, "Setting up protocol parameters '%s'\n", _Protocol);
97 if ( _Protocol[1] == '(' ) {
98 if (sscanf(_Protocol, "%*c(%d,%d)", &windows, &packsize) == 0)
99 sscanf(_Protocol, "%*c(,%d)", &packsize);
100 windows = ( windows < MINWINDOWS ? WINDOWS :
101 ( windows > MAXWINDOWS ? WINDOWS : windows ) );
102 packsize = ( packsize < MINPACKSIZE ? PACKSIZE :
103 ( packsize > MAXPACKSIZE ? PACKSIZE : packsize ) );
104 }
105 if ( (_Protocol[0] == 'g') && (packsize > OLDPACKSIZE) ) {
106 /*
107 * We reset to OLDPACKSIZE to maintain compatibility
108 * with old limited implementations. Maybe we should
109 * just warn the administrator and continue?
110 */
111 packsize = OLDPACKSIZE;
112 }
113 pk->p_xsize = pk->p_rsize = xpacksize = packsize;
114 pk->p_rwindow = pk->p_swindow = windows;
115
116 /*
117 * allocate input window
118 */
119 for (i = 0; i < pk->p_rwindow; i++) {
120 if ((bp = (char **) malloc((unsigned) pk->p_xsize)) == NULL)
121 break;
122 *bp = (char *) pk->p_ipool;
123 pk->p_ipool = bp;
124 }
125 if (i == 0)
126 return(NULL);
127 pk->p_rwindow = i;
128
129 /*
130 * start synchronization
131 */
132 pk->p_msg = pk->p_rmsg = M_INITA;
133 pkoutput(pk);
134
135 for (i = 0; i < PKMAXSTMSG; i++) {
136 pkgetpack(pk);
137 if ((pk->p_state & LIVE) != 0)
138 break;
139 }
140 if (i >= PKMAXSTMSG)
141 return(NULL);
142
143 pkreset(pk);
144 return(pk);
145 }
146
147 /*
148 * input framing and block checking.
149 * frame layout for most devices is:
150 *
151 * S|K|X|Y|C|Z| ... data ... |
152 *
153 * where S == initial synch byte
154 * K == encoded frame size (indexes pksizes[])
155 * X, Y == block check bytes
156 * C == control byte
157 * Z == XOR of header (K^X^Y^C)
158 * data == 0 or more data bytes
159 *
160 */
161 #define GETRIES 10
162
163 /*
164 * Byte collection.
165 */
166 void
pkgetpack(ipk)167 pkgetpack(ipk)
168 struct pack *ipk;
169 {
170 char *p;
171 struct pack *pk;
172 struct header *h;
173 unsigned short sum;
174 int k, tries, ifn, noise;
175 char **bp, hdchk;
176
177 pk = ipk;
178 /*
179 * If we are known to be DOWN, or if we've received too many garbage
180 * packets or timeouts, give up without a fight.
181 */
182 if ((pk->p_state & DOWN) || Connodata > CONNODATA || Ntimeout > NTIMEOUT)
183 pkfail();
184 ifn = pk->p_ifn;
185 h = &pk->p_ihbuf;
186
187 /*
188 * Attempt no more than GETRIES times to read a packet. The only valid
189 * exit from this loop is a return. Break forces a failure.
190 */
191 for (tries = 0; tries < GETRIES; tries++) {
192 /*
193 * Read header.
194 * First look for SYN. If more than 3 * packetsize characters
195 * go by w/o a SYN, request a retransmit.
196 */
197 p = (caddr_t) h;
198 noise = 0;
199 for ( ; ; ) {
200 if (pkcget(ifn, p, HDRSIZ) != SUCCESS) {
201 DEBUG(7,
202 "Alarm while looking for SYN -- request RXMIT\n%s", "");
203 goto retransmit;
204 }
205 if (*p == SYN)
206 break; /* got it */
207 else {
208 char *pp, *pend;
209
210 DEBUG(7, "first char not SYN (%x)\n", *p&0xff);
211 if ((pp = memchr(p, SYN, HDRSIZ)) != NULL) {
212 pend = p + HDRSIZ;
213 while (pp < pend)
214 *p++ = *pp++;
215 /* Now look for remainder of header */
216 if (pkcget(ifn, p, pend - p) !=
217 SUCCESS) {
218 DEBUG(7,
219 "Alarm while looking for header -- request RXMIT\n%s", "");
220 goto retransmit;
221 }
222 p = (caddr_t) h;
223 break; /* got entire header */
224 }
225 }
226 if ((noise += HDRSIZ) > 3 * pk->p_rsize) {
227 DEBUG(7,
228 "No SYN in %d characters -- request RXMIT\n", noise);
229 goto retransmit;
230 }
231 }
232 /* Validate the header */
233 Connodata++;
234 hdchk = p[1] ^ p[2] ^ p[3] ^ p[4];
235 sum = ((unsigned) p[2] & 0377) | ((unsigned) p[3] << 8);
236 h->sum = sum;
237 k = h->ksize;
238 if (hdchk != h->ccntl) {
239 /* bad header */
240 DEBUG(7, "bad header checksum\n%s", "");
241 return;
242 }
243
244 if (k == 9) { /* control packet */
245 if (((h->sum + h->cntl) & 0xffff) == CHECK) {
246 pkcntl(h->cntl, pk);
247 xlatestate(pk, 7);
248 } else {
249 /* bad header */
250 DEBUG(7, "bad header (k == 9) 0%o\n", h->cntl&0xff);
251 pk->p_state |= BADFRAME;
252 }
253 return;
254 }
255 /* data packet */
256 if (k && pksizes[k] != pk->p_rsize)
257 return;
258 pk->p_rpr = h->cntl & MOD8;
259 pksack(pk);
260 if ((bp = pk->p_ipool) == NULL) {
261 DEBUG(7, "bp NULL\n%s", "");
262 return;
263 }
264 pk->p_ipool = (char **) *bp;
265 /* Header checks out, go for data */
266 if (pkcget(pk->p_ifn, (char *) bp, pk->p_rsize) == SUCCESS) {
267 pkdata(h->cntl, h->sum, pk, bp);
268 Ntimeout = 0;
269 return;
270 }
271 DEBUG(7, "Alarm while reading data -- request RXMIT\n%s", "");
272 retransmit:
273 /*
274 * Transmission error or excessive noise. Send a RXMIT
275 * and try again.
276 */
277 /*
278 Retries++;
279 */
280 pk->p_msg |= pk->p_rmsg;
281 if (pk->p_msg == 0)
282 pk->p_msg |= M_RR;
283 if ((pk->p_state & LIVE) == LIVE)
284 pk->p_state |= RXMIT;
285 pkoutput(pk);
286 }
287 DEBUG(7, "pkgetpack failed after %d tries\n", tries);
288 pkfail();
289 }
290
291 /*
292 * Translate pk->p_state into something printable.
293 */
294 static void
xlatestate(pk,dbglvl)295 xlatestate(pk, dbglvl)
296 struct pack *pk;
297 int dbglvl;
298 {
299 int i;
300 char delimc = ' ', msgline[80], *buf = msgline;
301
302 if (Debug < dbglvl)
303 return;
304 sprintf(buf, "state -");
305 buf += strlen(buf);
306 for(i = 0; st_trans[i].state != -1; i++) {
307 if (pk->p_state&st_trans[i].state){
308 sprintf(buf, "%c[%s]", delimc, st_trans[i].msg);
309 buf += strlen(buf);
310 delimc = '&';
311 }
312 }
313 sprintf(buf, " (0%o)\n", pk->p_state);
314 DEBUG(dbglvl, "%s", msgline);
315 return;
316 }
317
318 static void
pkdata(c,sum,pk,bp)319 pkdata(c, sum, pk, bp)
320 struct pack *pk;
321 unsigned short sum;
322 char c;
323 char **bp;
324 {
325 int x;
326 int t;
327 char m;
328
329 if (pk->p_state & DRAINO || !(pk->p_state & LIVE)) {
330 pk->p_msg |= pk->p_rmsg;
331 pkoutput(pk);
332 goto drop;
333 }
334 t = next[pk->p_pr];
335 for(x=pk->p_pr; x!=t; x = (x-1)&7) {
336 if (pk->p_is[x] == 0)
337 goto slot;
338 }
339 drop:
340 *bp = (char *)pk->p_ipool;
341 pk->p_ipool = bp;
342 return;
343
344 slot:
345 m = mask[x];
346 pk->p_imap |= m;
347 pk->p_is[x] = c;
348 pk->p_isum[x] = sum;
349 pk->p_ib[x] = (char *)bp;
350 }
351
352 /*
353 * Start transmission on output device associated with pk.
354 * For asynch devices (t_line==1) framing is
355 * imposed. For devices with framing and crc
356 * in the driver (t_line==2) the transfer is
357 * passed on to the driver.
358 */
359 void
pkxstart(pk,cntl,x)360 pkxstart(pk, cntl, x)
361 struct pack *pk;
362 int x;
363 char cntl;
364 {
365 char *p;
366 short checkword;
367 char hdchk;
368
369 p = (caddr_t) &pk->p_ohbuf;
370 *p++ = SYN;
371 if (x < 0) {
372 *p++ = hdchk = 9;
373 checkword = cntl;
374 } else {
375 *p++ = hdchk = pk->p_lpsize;
376 checkword = pk->p_osum[x] ^ (unsigned)(cntl & 0377);
377 }
378 checkword = CHECK - checkword;
379 *p = checkword;
380 hdchk ^= *p++;
381 *p = checkword>>8;
382 hdchk ^= *p++;
383 *p = cntl;
384 hdchk ^= *p++;
385 *p = hdchk;
386
387 /*
388 * writes
389 */
390 if (Debug >= 9)
391 xlatecntl(1, cntl);
392
393 p = (caddr_t) & pk->p_ohbuf;
394 if (x < 0) {
395 if ((*Write)(pk->p_ofn, p, HDRSIZ) != HDRSIZ) {
396 DEBUG(4, "pkxstart, write failed, %s\n",
397 strerror(errno));
398 logent(strerror(errno), "PKXSTART WRITE");
399 pkfail();
400 /* NOT REACHED */
401 }
402 } else {
403 char buf[MAXPACKSIZE + HDRSIZ];
404
405 memcpy(buf, p, HDRSIZ);
406 memcpy(buf+HDRSIZ, pk->p_ob[x], pk->p_xsize);
407 if ((*Write)(pk->p_ofn, buf, pk->p_xsize + HDRSIZ) !=
408 pk->p_xsize + HDRSIZ) {
409 DEBUG(4, "pkxstart, write failed, %s\n",
410 strerror(errno));
411 logent(strerror(errno), "PKXSTART WRITE");
412 pkfail();
413 /* NOT REACHED */
414 }
415 Connodata = 0;
416 }
417 if (pk->p_msg)
418 pkoutput(pk);
419 }
420
421 /*
422 * get n characters from input
423 * b -> buffer for characters
424 * fn -> file descriptor
425 * n -> requested number of characters
426 * return:
427 * SUCCESS -> n chars successfully read
428 * FAIL -> o.w.
429 */
430
431 static int
pkcget(fn,b,n)432 pkcget(fn, b, n)
433 int n;
434 char *b;
435 int fn;
436 {
437 int ret;
438 #ifdef PKSPEEDUP
439 extern int linebaudrate;
440 int donap = (linebaudrate > 0 && linebaudrate < 4800);
441 #endif /* PKSPEEDUP */
442
443 if (n == 0)
444 return(SUCCESS);
445 if (setjmp(Getjbuf)) {
446 Ntimeout++;
447 DEBUG(4, "pkcget: alarm %d\n", Ntimeout);
448 return(FAIL);
449 }
450
451 (void) alarm( (unsigned) ( 10 + (n >> 7)) );
452
453 for (;;) {
454 ret = (*Read)(fn, b, n);
455 (void) alarm(0);
456 if (ret == 0) {
457 DEBUG(4, "pkcget, read failed, EOF\n", 0);
458 /*
459 * Device has decided that the connection has no
460 * more data to send. Any further tries are futile...
461 * (The only other way to get a zero return value
462 * is to read a zero length message from a STREAM.
463 * However, uucp *never* sends zero length messages
464 * over any sort of channel...)
465 */
466 pkfail();
467 /* NOT REACHED */
468 }
469 if (ret < 0) {
470 DEBUG(4, "pkcget, read failed, %s\n",
471 strerror(errno));
472 logent(strerror(errno), "PKCGET READ");
473 pkfail();
474 /* NOT REACHED */
475 }
476 if ((n -= ret) <= 0)
477 break;
478 #ifdef PKSPEEDUP
479 if (donap) {
480 #if defined(BSD4_2) || defined(ATTSVR4)
481 /* wait for more chars to come in */
482 nap((n * HZ * 10) / linebaudrate); /* n char times */
483 #else
484 sleep(1);
485 #endif
486 }
487 #endif /* PKSPEEDUP */
488 b += ret;
489 (void) alarm( (unsigned) ( 10 + (n >> 7)) );
490 }
491 (void) alarm(0);
492 return(SUCCESS);
493 }
494
495 /*
496 * role == 0: receive
497 * role == 1: send
498 */
499 void
xlatecntl(role,cntl)500 xlatecntl(role, cntl)
501 int role;
502 int cntl;
503 {
504 static char *cntltype[4] = {"CNTL, ", "ALT, ", "DATA, ", "SHORT, "};
505 static char *cntlxxx[8] = {"ZERO, ", "CLOSE, ", "RJ, ", "SRJ, ",
506 "RR, ", "INITC, ", "INITB, ", "INITA, "};
507 char dbgbuf[128];
508 char *ptr;
509
510 ptr = dbgbuf;
511 strcpy(ptr, role ? "send " : "recv ");
512 ptr += strlen(ptr);
513
514 strcpy(ptr, cntltype[(cntl&0300)>>6]);
515 ptr += strlen(ptr);
516
517 if (cntl&0300) {
518 /* data packet */
519 if (role)
520 sprintf(ptr, "loc %o, rem %o\n", (cntl & 070) >> 3, cntl & 7);
521 else
522 sprintf(ptr, "loc %o, rem %o\n", cntl & 7, (cntl & 070) >> 3);
523 } else {
524 /* control packet */
525 strcpy(ptr, cntlxxx[(cntl&070)>>3]);
526 ptr += strlen(ptr);
527 sprintf(ptr, "val %o\n", cntl & 7);
528 }
529
530 DEBUG(1, dbgbuf, 0);
531 }
532