![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devdk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to devdk.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "io.h"
7: #include "../port/error.h"
8:
9: #define DPRINT if(0) print
10:
11: #define NOW (MACHP(0)->ticks)
12:
13: typedef struct Dkmsg Dkmsg;
14: typedef struct Line Line;
15: typedef struct Dk Dk;
16:
17: enum {
18: Maxdk = 4,
19: };
20:
21: /*
22: * types of possible dkcalls
23: */
24: enum {
25: Dial,
26: Announce,
27: Redial
28: };
29:
30: /*
31: * format of messages to/from the datakit controller on the common
32: * signalling line
33: */
34: struct Dkmsg {
35: uchar type;
36: uchar srv;
37: uchar param0l;
38: uchar param0h;
39: uchar param1l;
40: uchar param1h;
41: uchar param2l;
42: uchar param2h;
43: uchar param3l;
44: uchar param3h;
45: uchar param4l;
46: uchar param4h;
47: };
48:
49: /*
50: * message codes (T_xxx == dialin.type, D_xxx == dialin.srv)
51: */
52: #define T_SRV 1 /* service request */
53: #define D_SERV 1 /* (host to dkmux) announce a service */
54: #define D_DIAL 2 /* (host to dkmux) connect to a service */
55: #define D_XINIT 7 /* (dkmux to host) line has been spliced */
56: #define T_REPLY 2 /* reply to T_SRV/D_SERV or T_SRV/D_DIAL */
57: #define D_OK 1 /* not used */
58: #define D_OPEN 2 /* (dkmux to host) connection established */
59: #define D_FAIL 3 /* (dkmux to host) connection failed */
60: #define T_CHG 3 /* change the status of a connection */
61: #define D_CLOSE 1 /* close the connection */
62: #define D_ISCLOSED 2 /* (dkmux to host) confirm a close */
63: #define D_CLOSEALL 3 /* (dkmux to host) close all connections */
64: #define D_REDIAL 6 /* (host to dkmux) redial a call */
65: #define T_ALIVE 4 /* (host to dkmux) keep alive message */
66: #define D_CONTINUE 0 /* host has not died since last msg */
67: #define D_RESTART 1 /* host has restarted */
68: #define D_MAXCHAN 2 /* request maximum line number */
69: #define T_RESTART 8 /* (dkmux to host) datakit restarted */
70:
71: /*
72: * macros for cracking/forming the window negotiation parameter
73: */
74: #define MIN(x,y) (x < y ? x : y)
75: #define W_WINDOW(o,d,t) ((o<<8) | (d<<4) | t | 0100000)
76: #define W_VALID(x) ((x) & 0100000)
77: #define W_ORIG(x) (((x)>>8) & 017)
78: #define W_DEST(x) (((x)>>4) & 017)
79: #define W_TRAF(x) ((x) & 017)
80: #define W_DESTMAX(x,y) (W_WINDOW(W_ORIG(x),MIN(W_DEST(x),y),W_TRAF(x)))
81: #define W_LIMIT(x,y) (W_WINDOW(MIN(W_ORIG(x),y),MIN(W_DEST(x),y),W_TRAF(x)))
82: #define W_VALUE(x) (1<<((x)+4))
83:
84: struct Line {
85: QLock;
86: Netprot; /* stat info */
87: int lineno;
88: Rendez r; /* wait here for dial */
89: int state; /* dial state */
90: int err; /* dialing error (if non zero) */
91: int window; /* negotiated window */
92: int timestamp; /* timestamp of last call received on this line */
93: int calltolive; /* multiple of 15 seconds for dialing state to last */
94: Queue *rq;
95: char addr[64];
96: char raddr[64];
97: char ruser[32];
98: Dk *dp; /* interface contianing this line */
99: };
100:
101: /*
102: * a dkmux dk. one exists for every stream that a
103: * dkmux line discipline is pushed onto.
104: */
105: struct Dk
106: {
107: QLock netlock;
108: Network net; /* stat info */
109: Line **linep; /* array of line structures */
110:
111: QLock csclock;
112: Chan *csc;
113:
114: char name[64]; /* dk name */
115: Queue *wq; /* dk output queue */
116: int ncsc; /* csc line number */
117: int lines; /* number of lines */
118: int restart;
119: int urpwindow;
120: Rendez timer;
121: int closeall; /* set when we receive a closeall message */
122: Rendez closeallr; /* wait here for a closeall */
123: };
124: Lock dklock;
125: Dk *dk[Maxdk];
126:
127: /*
128: * conversation states (for Line.state)
129: */
130: typedef enum {
131: Lclosed=0,
132: Lopened, /* opened but no call out */
133: Lconnected, /* opened and a call set up on htis line */
134: Lrclose, /* remote end has closed down */
135: Llclose, /* local end has closed down */
136: Ldialing, /* dialing a new call */
137: Llistening, /* this line listening for calls */
138: Lackwait, /* incoming call waiting for ack/nak */
139: Laccepting, /* waiting for user to accept or reject the call */
140: } Lstate;
141: char *dkstate[] =
142: {
143: [Lclosed] "Closed",
144: [Lopened] "Opened",
145: [Lconnected] "Established",
146: [Lrclose] "Rclose",
147: [Llclose] "Lclose",
148: [Ldialing] "Dialing",
149: [Llistening] "Listen",
150: [Lackwait] "Ackwait",
151: [Laccepting] "Accepting",
152: };
153:
154: /*
155: * map datakit error to errno
156: */
157: enum {
158: DKok,
159: DKbusy,
160: DKnetotl,
161: DKdestotl,
162: DKbadnet,
163: DKnetbusy,
164: DKinuse,
165: DKreject,
166: };
167: char* dkerr[]={
168: [DKok] "",
169: [DKbusy] "devdk: destination busy",
170: [DKnetotl] "devdk: network not answering",
171: [DKdestotl] "devdk: destination not answering",
172: [DKbadnet] "devdk: unknown address",
173: [DKnetbusy] "devdk: network busy",
174: [DKinuse] "devdk: service in use",
175: [DKreject] "devdk: connection refused",
176: };
177: #define DKERRS sizeof(dkerr)/sizeof(char*)
178:
179: /*
180: * imported
181: */
182: extern Qinfo urpinfo;
183:
184: /*
185: * predeclared
186: */
187: Chan* dkattach(char*);
188: static void dkmuxconfig(Queue*, Block*);
189: static Chan* dkopenline(Dk*, int);
190: static Chan* dkopencsc(Dk*);
191: static int dkmesg(Chan*, int, int, int, int);
192: static void dkcsckproc(void*);
193: static void dkanswer(Chan*, int, int);
194: static void dkwindow(Chan*);
195: static void dkcall(int, Chan*, char*, char*, char*);
196: static void dktimer(void*);
197: static void dkchgmesg(Chan*, Dk*, Dkmsg*, int);
198: static void dkreplymesg(Dk*, Dkmsg*, int);
199: Chan* dkopen(Chan*, int);
200: static void dkhangup(Line*);
201:
202: /*
203: * for standard network interface (net.c)
204: */
205: static int dkcloneline(Chan*);
206: static int dklisten(Chan*);
207: static void dkfilladdr(Chan*, char*, int);
208: static void dkfillraddr(Chan*, char*, int);
209: static void dkfillruser(Chan*, char*, int);
210: static void dkfillstatus(Chan*, char*, int);
211:
212: extern Qinfo dkinfo;
213:
214: /*
215: * the datakit multiplexor stream module definition
216: */
217: static Streamopen dkmuxopen;
218: static Streamput dkmuxoput;
219: static Streamput dkmuxiput;
220: Qinfo dkmuxinfo =
221: {
222: dkmuxiput,
223: dkmuxoput,
224: dkmuxopen,
225: 0,
226: "dkmux"
227: };
228:
229: /*
230: * allocate a line if it doesn't exist
231: */
232: static Line*
233: linealloc(Dk *dp, int lineno, int dolock)
234: {
235: Line *lp;
236:
237: if(dolock)
238: qlock(&dp->netlock);
239: if(lineno > dp->lines)
240: panic("linealloc");
241: lp = dp->linep[lineno];
242: if(lp == 0){
243: lp = smalloc(sizeof(Line));
244: lp->lineno = lineno;
245: netadd(&dp->net, lp, lineno);
246: dp->linep[lineno] = lp;
247: }
248: if(dolock)
249: qunlock(&dp->netlock);
250: return lp;
251: }
252:
253: /*
254: * a new dkmux. hold the stream in place so it can never be closed down.
255: */
256: static void
257: dkmuxopen(Queue *q, Stream *s)
258: {
259: RD(q)->ptr = 0;
260: WR(q)->ptr = 0;
261:
262: naildownstream(s);
263: }
264:
265: /*
266: * handle configuration
267: */
268: static void
269: dkmuxoput(Queue *q, Block *bp)
270: {
271: if(bp->type != M_DATA){
272: if(streamparse("config", bp))
273: dkmuxconfig(q, bp);
274: else
275: PUTNEXT(q, bp);
276: return;
277: }
278: PUTNEXT(q, bp);
279: }
280:
281: /*
282: * gather a message and send it up the appropriate stream
283: *
284: * The first two bytes of each message contains the channel
285: * number, low order byte first.
286: *
287: * Simplifying assumption: one put == one message && the channel number
288: * is in the first block. If this isn't true, demultiplexing will not
289: * work.
290: */
291: static void
292: dkmuxiput(Queue *q, Block *bp)
293: {
294: Dk *dp;
295: Line *lp;
296: int line;
297:
298: /*
299: * not configured yet
300: */
301: if(q->other->ptr == 0){
302: freeb(bp);
303: return;
304: }
305:
306: dp = (Dk *)q->ptr;
307: if(bp->type != M_DATA){
308: PUTNEXT(q, bp);
309: return;
310: }
311:
312: line = bp->rptr[0] | (bp->rptr[1]<<8);
313: bp->rptr += 2;
314: if(line<0 || line>=dp->lines){
315: DPRINT("dkmuxiput bad line %d\n", line);
316: freeb(bp);
317: return;
318: }
319:
320: lp = linealloc(dp, line, 1);
321: if(lp && canqlock(lp)){
322: if(lp->rq)
323: PUTNEXT(lp->rq, bp);
324: else{
325: DPRINT("dkmuxiput unopened line %d\n", line);
326: freeb(bp);
327: }
328: qunlock(lp);
329: } else {
330: DPRINT("dkmuxiput unopened line %d\n", line);
331: freeb(bp);
332: }
333: }
334:
335: /*
336: * the datakit line stream module definition
337: */
338: static Streamopen dkstopen;
339: static Streamclose dkstclose;
340: static Streamput dkoput, dkiput;
341: Qinfo dkinfo =
342: {
343: dkiput,
344: dkoput,
345: dkstopen,
346: dkstclose,
347: "dk"
348: };
349:
350: /*
351: * open and save a pointer to the conversation
352: */
353: static void
354: dkstopen(Queue *q, Stream *s)
355: {
356: Dk *dp;
357: Line *lp;
358:
359: dp = dk[s->dev];
360: q->other->ptr = q->ptr = lp = dp->linep[s->id];
361: lp->dp = dp;
362: lp->rq = q;
363: if(lp->state==Lclosed)
364: lp->state = Lopened;
365: }
366:
367: /*
368: * close down a datakit conversation
369: */
370: static void
371: dkstclose(Queue *q)
372: {
373: Dk *dp;
374: Line *lp;
375: Chan *c;
376:
377: lp = (Line *)q->ptr;
378: dp = lp->dp;
379:
380: /*
381: * if we never got going, we're done
382: */
383: if(lp->rq == 0){
384: lp->state = Lclosed;
385: return;
386: }
387:
388: /*
389: * these states don't need the datakit
390: */
391: switch(lp->state){
392: case Lclosed:
393: case Llclose:
394: case Lopened:
395: lp->state = Lclosed;
396: goto out;
397: }
398:
399: c = 0;
400: if(waserror()){
401: lp->state = Lclosed;
402: if(c)
403: close(c);
404: goto out;
405: }
406: c = dkopencsc(dp);
407:
408: /*
409: * shake hands with dk
410: */
411: switch(lp->state){
412: case Lrclose:
413: dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
414: lp->state = Lclosed;
415: break;
416:
417: case Lackwait:
418: dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
419: lp->state = Llclose;
420: break;
421:
422: case Llistening:
423: dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
424: lp->state = Llclose;
425: break;
426:
427: case Lconnected:
428: dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
429: lp->state = Llclose;
430: break;
431: }
432: poperror();
433: close(c);
434:
435: out:
436: qlock(lp);
437: lp->rq = 0;
438: qunlock(lp);
439:
440: netdisown(lp);
441: lp->window = 0;
442: }
443:
444: /*
445: * this is only called by hangup
446: */
447: static void
448: dkiput(Queue *q, Block *bp)
449: {
450: PUTNEXT(q, bp);
451: }
452:
453: /*
454: * we assume that each put is a message.
455: *
456: * add a 2 byte channel number to the start of each message,
457: * low order byte first. Make sure the first block contains
458: * both the 2 channel bytes and the control byte.
459: */
460: static void
461: dkoput(Queue *q, Block *bp)
462: {
463: Line *lp;
464: Dk *dp;
465: int line;
466:
467: if(bp->type != M_DATA){
468: freeb(bp);
469: error(Ebadarg);
470: }
471:
472: lp = (Line *)q->ptr;
473: dp = lp->dp;
474: line = lp->lineno;
475:
476: bp = padb(bp, 2);
477: bp->rptr[0] = line;
478: bp->rptr[1] = line>>8;
479:
480: FLOWCTL(dp->wq, bp);
481: }
482:
483: /*
484: * configure a datakit multiplexor. this takes 5 arguments separated
485: * by spaces:
486: * the line number of the common signalling channel (must be > 0)
487: * the number of lines in the device (optional)
488: * the word `restart' or `norestart' (optional/default==restart)
489: * the name of the dk (default==dk)
490: * the urp window size (default==2048)
491: *
492: * we can configure only once
493: */
494: static int
495: haveca(void *arg)
496: {
497: Dk *dp;
498:
499: dp = arg;
500: return dp->closeall;
501: }
502: static void
503: dkmuxconfig(Queue *q, Block *bp)
504: {
505: Dk *dp;
506: char *fields[5];
507: int n;
508: char buf[64];
509: char name[NAMELEN];
510: int lines;
511: int ncsc;
512: int restart;
513: int window;
514:
515: if(WR(q)->ptr){
516: freeb(bp);
517: error(Egreg);
518: }
519:
520: /*
521: * defaults
522: */
523: ncsc = 1;
524: restart = 1;
525: lines = 16;
526: window = 2048;
527: strcpy(name, "dk");
528:
529: /*
530: * parse
531: */
532: n = getfields((char *)bp->rptr, fields, 5, " ");
533: switch(n){
534: case 5:
535: window = strtoul(fields[4], 0, 0);
536: if(window < 16)
537: window = 1<<(window+4);
538: case 4:
539: strncpy(name, fields[3], sizeof(name));
540: name[sizeof(name)-1] = 0;
541: case 3:
542: if(strcmp(fields[2], "restart")!=0)
543: restart = 0;
544: case 2:
545: lines = strtoul(fields[1], 0, 0);
546: case 1:
547: ncsc = strtoul(fields[0], 0, 0);
548: break;
549: default:
550: freeb(bp);
551: error(Ebadarg);
552: }
553: freeb(bp);
554: if(ncsc <= 0 || lines <= ncsc)
555: error(Ebadarg);
556:
557: /*
558: * find a free dk slot. it name is already configured
559: * or no slots are left, error.
560: */
561: lock(&dklock);
562: if(waserror()){
563: unlock(&dklock);
564: nexterror();
565: }
566: for(n = 0; n < Maxdk; n++){
567: dp = dk[n];
568: if(dp == 0)
569: break;
570: if(strcmp(name, dp->name) == 0)
571: error(Einuse);
572: }
573: if(n == Maxdk)
574: error(Enoifc);
575:
576: /*
577: * allocate both a dk structure and an array of pointers to line
578: * structures
579: */
580: dp = smalloc(sizeof(Dk));
581: dp->ncsc = ncsc;
582: dp->lines = lines;
583: dp->linep = smalloc(sizeof(Line*) * dp->lines);
584: strcpy(dp->name, name);
585: dp->net.name = dp->name;
586: dp->net.nconv = dp->lines;
587: dp->net.devp = &dkinfo;
588: dp->net.protop = &urpinfo;
589: dp->net.listen = dklisten;
590: dp->net.clone = dkcloneline;
591: dp->net.ninfo = 5;
592: dp->net.info[0].name = "local";
593: dp->net.info[0].fill = dkfilladdr;
594: dp->net.info[1].name = "remote";
595: dp->net.info[1].fill = dkfillraddr;
596: dp->net.info[2].name = "ruser";
597: dp->net.info[2].fill = dkfillruser;
598: dp->net.info[3].name = "urpstats";
599: dp->net.info[3].fill = urpfillstats;
600: dp->net.info[4].name = "status";
601: dp->net.info[4].fill = dkfillstatus;
602: dp->restart = restart;
603: dp->urpwindow = window;
604: dp->wq = WR(q);
605: q->ptr = q->other->ptr = dp;
606: dk[n] = dp;
607: unlock(&dklock);
608: poperror();
609:
610: /*
611: * open csc here so that boot, dktimer, and dkcsckproc aren't
612: * all fighting for it at once.
613: */
614: dkopencsc(dp);
615:
616: /*
617: * start a process to listen to csc messages
618: */
619: sprint(buf, "csc.%s.%d", dp->name, dp->ncsc);
620: kproc(buf, dkcsckproc, dp);
621:
622: /*
623: * tell datakit we've rebooted. It should close all channels.
624: * do this here to get it done before trying to open a channel.
625: */
626: if(dp->restart) {
627: DPRINT("dktimer: restart %s\n", dp->name);
628: dp->closeall = 0;
629: dkmesg(dp->csc, T_ALIVE, D_RESTART, 0, 0);
630: }
631: tsleep(&dp->closeallr, haveca, dp, 15000);
632:
633: /*
634: * start a keepalive process
635: */
636: sprint(buf, "timer.%s.%d", dp->name, dp->ncsc);
637: kproc(buf, dktimer, dp);
638: }
639:
640: void
641: dkreset(void)
642: {
643: newqinfo(&dkmuxinfo);
644: }
645:
646: void
647: dkinit(void)
648: {
649: }
650:
651: Chan*
652: dkattach(char *spec)
653: {
654: Chan *c;
655: Dk *dp;
656: int dev;
657:
658: /*
659: * find a multiplexor with the same name (default dk)
660: */
661: if(*spec == 0)
662: spec = "dk";
663: for(dev = 0; dev < Maxdk; dev++){
664: dp = dk[dev];
665: if(dp && strcmp(dp->name, spec) == 0)
666: break;
667: }
668: if(dev == Maxdk)
669: error(Enoifc);
670:
671: /*
672: * return the new channel
673: */
674: c = devattach('k', spec);
675: c->dev = dev;
676: return c;
677: }
678:
679: Chan*
680: dkclone(Chan *c, Chan *nc)
681: {
682: return devclone(c, nc);
683: }
684:
685: int
686: dkwalk(Chan *c, char *name)
687: {
688: return netwalk(c, name, &dk[c->dev]->net);
689: }
690:
691: void
692: dkstat(Chan *c, char *dp)
693: {
694: netstat(c, dp, &dk[c->dev]->net);
695: }
696:
697: Chan*
698: dkopen(Chan *c, int omode)
699: {
700: Dk *dp;
701:
702: dp = dk[c->dev];
703: linealloc(dp, STREAMID(c->qid.path), 1);
704: return netopen(c, omode, &dp->net);
705: }
706:
707: void
708: dkcreate(Chan *c, char *name, int omode, ulong perm)
709: {
710: USED(c);
711: USED(name);
712: USED(omode);
713: USED(perm);
714: error(Eperm);
715: }
716:
717: void
718: dkclose(Chan *c)
719: {
720: if(c->stream)
721: streamclose(c);
722: }
723:
724: long
725: dkread(Chan *c, void *a, long n, ulong offset)
726: {
727: return netread(c, a, n, offset, &dk[c->dev]->net);
728: }
729:
730: long
731: dkwrite(Chan *c, void *a, long n, ulong offset)
732: {
733: int t;
734: char buf[256];
735: char *field[5];
736: int m;
737:
738: USED(offset);
739: t = STREAMTYPE(c->qid.path);
740:
741: /*
742: * get data dispatched as quickly as possible
743: */
744: if(t == Sdataqid)
745: return streamwrite(c, a, n, 0);
746:
747: /*
748: * easier to do here than in dkoput
749: */
750: if(t == Sctlqid){
751: if(n > sizeof buf - 1)
752: n = sizeof buf - 1;
753: strncpy(buf, a, n);
754: buf[n] = '\0';
755: m = getfields(buf, field, 5, " ");
756: if(strncmp(field[0], "connect", 7)==0){
757: if(m < 2)
758: error(Ebadarg);
759: dkcall(Dial, c, field[1], 0, 0);
760: } else if(strncmp(field[0], "announce", 8)==0){
761: if(m < 2)
762: error(Ebadarg);
763: dkcall(Announce, c, field[1], 0, 0);
764: } else if(strncmp(field[0], "redial", 6)==0){
765: if(m < 4)
766: error(Ebadarg);
767: dkcall(Redial, c, field[1], field[2], field[3]);
768: } else if(strncmp(field[0], "accept", 6)==0){
769: if(m < 2)
770: error(Ebadarg);
771: dkanswer(c, strtoul(field[1], 0, 0), 0);
772: } else if(strncmp(field[0], "reject", 6)==0){
773: if(m < 3)
774: error(Ebadarg);
775: for(m = 0; m < DKERRS-1; m++)
776: if(strcmp(field[2], dkerr[m]) == 0)
777: break;
778: dkanswer(c, strtoul(field[1], 0, 0), m);
779: } else
780: return streamwrite(c, a, n, 0);
781: return n;
782: }
783:
784: error(Eperm);
785: return -1; /* never reached */
786: }
787:
788: void
789: dkremove(Chan *c)
790: {
791: USED(c);
792: error(Eperm);
793: }
794:
795: void
796: dkwstat(Chan *c, char *dp)
797: {
798: netwstat(c, dp, &dk[c->dev]->net);
799: }
800:
801: /*
802: * return the number of an unused line (reserve it)
803: */
804: static int
805: dkcloneline(Chan *c)
806: {
807: Line *lp;
808: Dk *dp;
809: int line;
810:
811: dp = dk[c->dev];
812: /*
813: * get an unused device and open its control file
814: */
815: qlock(&dp->netlock);
816: for(line = dp->ncsc+1; line < dp->lines; line++){
817: lp = dp->linep[line];
818: if(lp == 0 || lp->state == Lclosed){
819: lp = linealloc(dp, line, 0);
820: lp->state = Lopened;
821:
822: /* current user becomes owner */
823: netown(lp, u->p->user, 0);
824:
825: qunlock(&dp->netlock);
826: return lp->lineno;
827: }
828: }
829: qunlock(&dp->netlock);
830: error(Enodev);
831: return -1; /* never reached */
832: }
833:
834: static Chan*
835: dkopenline(Dk *dp, int line)
836: {
837: Chan *c;
838:
839: c = 0;
840: if(waserror()){
841: if(c)
842: close(c);
843: nexterror();
844: }
845: c = dkattach(dp->name);
846: c->qid.path = STREAMQID(line, Sdataqid);
847: dkopen(c, ORDWR);
848: poperror();
849:
850: return c;
851: }
852:
853: /*
854: * open the common signalling channel (dp->csc's reference count never goes below 1)
855: */
856: static Chan*
857: dkopencsc(Dk *dp)
858: {
859: qlock(&dp->csclock);
860: if(dp->csc == 0)
861: dp->csc = dkopenline(dp, dp->ncsc);
862: incref(dp->csc);
863: qunlock(&dp->csclock);
864: return dp->csc;
865: }
866:
867: /*
868: * return the contents of the info files
869: */
870: void
871: dkfilladdr(Chan *c, char *buf, int len)
872: {
873: if(len < sizeof(dk[0]->linep[0]->addr)+2)
874: error(Ebadarg);
875: sprint(buf, "%s\n", dk[c->dev]->linep[STREAMID(c->qid.path)]->addr);
876: }
877: void
878: dkfillraddr(Chan *c, char *buf, int len)
879: {
880: if(len < sizeof(dk[0]->linep[0]->raddr)+2)
881: error(Ebadarg);
882: sprint(buf, "%s\n", dk[c->dev]->linep[STREAMID(c->qid.path)]->raddr);
883: }
884: void
885: dkfillruser(Chan *c, char *buf, int len)
886: {
887: if(len < sizeof(dk[0]->linep[0]->ruser)+2)
888: error(Ebadarg);
889: sprint(buf, "%s\n", dk[c->dev]->linep[STREAMID(c->qid.path)]->ruser);
890: }
891: void
892: dkfillstatus(Chan *c, char *buf, int len)
893: {
894: Dk *dp;
895: Line *lp;
896: int line;
897: char lbuf[65];
898:
899: line = STREAMID(c->qid.path);
900: dp = dk[c->dev];
901: lp = linealloc(dp, line, 1);
902: sprint(lbuf, "%s/%d %d %s window %d\n", dp->name, line,
903: lp->state != Lclosed ? 1 : 0, dkstate[lp->state], lp->window);
904: strncpy(buf, lbuf, len);
905: }
906:
907: /*
908: * send a message to the datakit on the common signaling line
909: */
910: static int
911: dkmesg(Chan *c, int type, int srv, int p0, int p1)
912: {
913: Dkmsg d;
914:
915: if(waserror()){
916: print("dkmesg: error\n");
917: return -1;
918: }
919: d.type = type;
920: d.srv = srv;
921: d.param0l = p0;
922: d.param0h = p0>>8;
923: d.param1l = p1;
924: d.param1h = p1>>8;
925: d.param2l = 0;
926: d.param2h = 0;
927: d.param3l = 0;
928: d.param3h = 0;
929: d.param4l = 0;
930: d.param4h = 0;
931: streamwrite(c, (char *)&d, sizeof(Dkmsg), 1);
932: poperror();
933: return 0;
934: }
935:
936: /*
937: * call out on a datakit
938: */
939: static int
940: calldone(void *a)
941: {
942: Line *lp;
943:
944: lp = (Line *)a;
945: return lp->state != Ldialing;
946: }
947: static void
948: dkcall(int type, Chan *c, char *addr, char *nuser, char *machine)
949: {
950: char dialstr[66];
951: int line, win;
952: char dialtone;
953: int t_val, d_val;
954: Dk *dp;
955: Line *lp;
956: Chan *dc;
957: Chan *csc;
958: char *bang, *dot;
959:
960: line = STREAMID(c->qid.path);
961: dp = dk[c->dev];
962: lp = linealloc(dp, line, 1);
963:
964: /*
965: * only dial on virgin lines
966: */
967: if(lp->state != Lopened)
968: error(Ebadarg);
969:
970: DPRINT("dkcall(line=%d, type=%d, dest=%s)\n", line, type, addr);
971:
972: /*
973: * build dial string
974: * - guard against new lines
975: * - change ! into . to delimit service
976: */
977: if(strchr(addr, '\n'))
978: error(Ebadarg);
979: if(strlen(addr)+strlen(u->p->user)+2 >= sizeof(dialstr))
980: error(Ebadarg);
981: strcpy(dialstr, addr);
982: bang = strchr(dialstr, '!');
983: if(bang){
984: dot = strchr(dialstr, '.');
985: if(dot==0 || dot > bang)
986: *bang = '.';
987: }
988: switch(type){
989: case Dial:
990: t_val = T_SRV;
991: d_val = D_DIAL;
992: strcat(dialstr, "\n");
993: strcat(dialstr, u->p->user);
994: strcat(dialstr, "\n");
995: break;
996: case Announce:
997: t_val = T_SRV;
998: d_val = D_SERV;
999: break;
1000: case Redial:
1001: t_val = T_CHG;
1002: d_val = D_REDIAL;
1003: strcat(dialstr, "\n");
1004: strcat(dialstr, nuser);
1005: strcat(dialstr, "\n");
1006: strcat(dialstr, machine);
1007: strcat(dialstr, "\n");
1008: break;
1009: default:
1010: t_val = 0;
1011: d_val = 0;
1012: panic("bad dial type");
1013: }
1014:
1015: /*
1016: * open the data file
1017: */
1018: dc = dkopenline(dp, line);
1019: if(waserror()){
1020: close(dc);
1021: nexterror();
1022: }
1023: lp->calltolive = 4;
1024: lp->state = Ldialing;
1025:
1026: /*
1027: * tell the controller we want to make a call
1028: */
1029: DPRINT("dialout\n");
1030: csc = dkopencsc(dp);
1031: if(waserror()){
1032: close(csc);
1033: nexterror();
1034: }
1035: for(win = 0; ; win++)
1036: if(W_VALUE(win) >= dp->urpwindow || win == 15)
1037: break;
1038: dkmesg(csc, t_val, d_val, line, W_WINDOW(win, win, 2));
1039: poperror();
1040: close(csc);
1041:
1042: /*
1043: * if redial, wait for a dial tone (otherwise we might send
1044: * the dialstr to the previous other end and not the controller)
1045: */
1046: if(type==Redial){
1047: if(streamread(dc, &dialtone, 1L) != 1L){
1048: lp->state = Lconnected;
1049: error(Ebadarg);
1050: }
1051: }
1052:
1053: /*
1054: * make the call
1055: */
1056: DPRINT("dialstr %s\n", dialstr);
1057: streamwrite(dc, dialstr, (long)strlen(dialstr), 1);
1058: close(dc);
1059: poperror();
1060:
1061: /*
1062: * redial's never get a reply, assume it worked
1063: */
1064: if(type == Redial) {
1065: lp->state = Lconnected;
1066: return;
1067: }
1068:
1069: /*
1070: * wait for a reply
1071: */
1072: DPRINT("reply wait\n");
1073: sleep(&lp->r, calldone, lp);
1074:
1075: /*
1076: * if there was an error, translate it to a plan 9
1077: * errno and report it to the user.
1078: */
1079: DPRINT("got reply %d\n", lp->state);
1080: if(lp->state != Lconnected) {
1081: if(lp->err >= DKERRS)
1082: error(dkerr[0]);
1083: else
1084: error(dkerr[lp->err]);
1085: }
1086:
1087: /*
1088: * change state if serving
1089: */
1090: if(type == D_SERV){
1091: lp->state = Llistening;
1092: }
1093: DPRINT("connected!\n");
1094:
1095: /*
1096: * decode the window size
1097: */
1098: if (W_VALID(lp->window)){
1099: /*
1100: * a 1127 window negotiation
1101: */
1102: lp->window = W_VALUE(W_DEST(lp->window));
1103: } else if(lp->window>2 && lp->window<31){
1104: /*
1105: * a generic window negotiation
1106: */
1107: lp->window = 1<<lp->window;
1108: } else
1109: lp->window = 0;
1110:
1111: /*
1112: * tag the connection
1113: */
1114: strncpy(lp->addr, addr, sizeof(lp->addr)-1);
1115: strncpy(lp->raddr, addr, sizeof(lp->raddr)-1);
1116:
1117: /*
1118: * reset the protocol
1119: */
1120: dkwindow(c);
1121: }
1122:
1123: /*
1124: * listen for a call, reflavor the
1125: */
1126: static int
1127: dklisten(Chan *c)
1128: {
1129: char dialstr[512];
1130: char *line[12];
1131: char *field[8];
1132: Line *lp;
1133: Dk *dp;
1134: int n, lineno, ts, window;
1135: int from;
1136: Chan *dc;
1137: static int dts;
1138: char *cp;
1139:
1140: dp = dk[c->dev];
1141: from = STREAMID(c->qid.path);
1142:
1143: /*
1144: * open the data file
1145: */
1146: dc = dkopenline(dp, STREAMID(c->qid.path));
1147: if(waserror()){
1148: close(dc);
1149: nexterror();
1150: }
1151:
1152: /*
1153: * wait for a call in
1154: */
1155: for(;;){
1156: /*
1157: * read the dialstring and null terminate it
1158: */
1159: n = streamread(dc, dialstr, sizeof(dialstr)-1);
1160: DPRINT("returns %d\n", n);
1161: if(n <= 0)
1162: error(Eio);
1163: dialstr[n] = 0;
1164: DPRINT("dialstr = %s\n", dialstr);
1165:
1166: /*
1167: * break the dial string into lines
1168: */
1169: n = getfields(dialstr, line, 12, "\n");
1170: if (n < 2) {
1171: DPRINT("bad dialstr from dk (1 line)\n");
1172: error(Eio);
1173: }
1174:
1175: /*
1176: * line 0 is `line.tstamp.traffic[.urpparms.window]'
1177: */
1178: window = 0;
1179: switch(getfields(line[0], field, 5, ".")){
1180: case 5:
1181: /*
1182: * generic way of passing window
1183: */
1184: window = strtoul(field[4], 0, 0);
1185: if(window > 0 && window <31)
1186: window = 1<<window;
1187: else
1188: window = 0;
1189: /*
1190: * intentional fall through
1191: */
1192: case 3:
1193: /*
1194: * 1127 way of passing window
1195: */
1196: if(window == 0){
1197: window = strtoul(field[2], 0, 0);
1198: if(W_VALID(window))
1199: window = W_VALUE(W_ORIG(window));
1200: else
1201: window = 0;
1202: }
1203: break;
1204: default:
1205: print("bad message from dk(bad first line)\n");
1206: continue;
1207: }
1208: lineno = strtoul(field[0], 0, 0);
1209: if(lineno >= dp->lines){
1210: print("dklisten: illegal line %d\n", lineno);
1211: continue;
1212: }
1213: lp = linealloc(dp, lineno, 1);
1214: ts = strtoul(field[1], 0, 0);
1215:
1216: /*
1217: * this could be a duplicate request
1218: */
1219: if(ts == lp->timestamp){
1220: if((dts++ % 1000) == 0)
1221: print("dklisten: repeat timestamp %d\n", lineno);
1222: if(lp->state != Lconnected)
1223: dkanswer(c, lineno, DKbusy);
1224: continue;
1225: }
1226:
1227: /*
1228: * take care of glare (datakit picked an inuse channel
1229: * for the call to come in on).
1230: */
1231: if(!canqlock(lp)){
1232: DPRINT("DKbusy1\n");
1233: dkanswer(c, lineno, DKbusy);
1234: continue;
1235: } else {
1236: if(lp->state != Lclosed){
1237: qunlock(lp);
1238: DPRINT("DKbusy2 %ux\n", lp->state);
1239: dkanswer(c, lineno, DKbusy);
1240: continue;
1241: }
1242: }
1243: lp->window = window;
1244:
1245: /*
1246: * Line 1 is `my-dk-name.service[.more-things]'.
1247: * Special characters are escaped by '\'s. Convert to
1248: * a plan 9 address, i.e. system!service.
1249: */
1250: strncpy(lp->addr, line[1], sizeof(lp->addr)-1);
1251: if(cp = strchr(lp->addr, '.')){
1252: *cp = '!';
1253: if(cp = strchr(cp, '.'))
1254: *cp = 0;
1255: }
1256:
1257: /*
1258: * the rest is variable length
1259: */
1260: switch(n) {
1261: case 2:
1262: /* no more lines */
1263: lp->ruser[0] = 0;
1264: lp->raddr[0] = 0;
1265: break;
1266: case 3:
1267: /* line 2 is `source.user.param1.param2' */
1268: getfields(line[2], field, 3, ".");
1269: strncpy(lp->raddr, field[0], sizeof(lp->raddr)-1);
1270: strncpy(lp->ruser, field[1], sizeof(lp->ruser)-1);
1271: break;
1272: case 4:
1273: /* line 2 is `user.param1.param2' */
1274: getfields(line[2], field, 2, ".");
1275: strncpy(lp->ruser, field[0], sizeof(lp->ruser)-1);
1276:
1277: /* line 3 is `source.node.mod.line' */
1278: strncpy(lp->raddr, line[3], sizeof(lp->raddr)-1);
1279: break;
1280: default:
1281: print("bad message from dk(>4 line)\n");
1282: qunlock(lp);
1283: error(Ebadarg);
1284: }
1285:
1286: DPRINT("src(%s)user(%s)dest(%s)w(%d)\n", lp->raddr, lp->ruser,
1287: lp->addr, W_TRAF(lp->window));
1288:
1289: lp->timestamp = ts;
1290: lp->state = Lconnected;
1291:
1292: /* listener becomes owner */
1293: netown(lp, dp->linep[from]->owner, 0);
1294:
1295: qunlock(lp);
1296: close(dc);
1297: poperror();
1298: DPRINT("dklisten returns %d\n", lineno);
1299: return lineno;
1300: }
1301: panic("dklisten terminates strangely\n");
1302: return -1; /* never reached */
1303: }
1304:
1305: /*
1306: * answer a call
1307: */
1308: static void
1309: dkanswer(Chan *c, int line, int code)
1310: {
1311: char reply[64];
1312: Chan *dc;
1313: Line *lp;
1314: Dk *dp;
1315:
1316: dp = dk[c->dev];
1317: lp = linealloc(dp, line, 1);
1318:
1319: /*
1320: * open the data file (c is a control file)
1321: */
1322: dc = dkattach(dp->name);
1323: if(waserror()){
1324: close(dc);
1325: nexterror();
1326: }
1327: dc->qid.path = STREAMQID(STREAMID(c->qid.path), Sdataqid);
1328: dkopen(dc, ORDWR);
1329:
1330: /*
1331: * send the reply
1332: */
1333: sprint(reply, "%ud.%ud.%ud", line, lp->timestamp, code);
1334: DPRINT("dkanswer %s\n", reply);
1335: streamwrite(dc, reply, strlen(reply), 1);
1336: close(dc);
1337: poperror();
1338:
1339: /*
1340: * set window size
1341: */
1342: if(code == 0){
1343: if(waserror()){
1344: close(dc);
1345: nexterror();
1346: }
1347: sprint(reply, "init %d %d", lp->window, Streamhi);
1348: dc = dkopenline(dp, line);
1349: dc->qid.path = STREAMQID(line, Sctlqid);
1350: streamwrite(dc, reply, strlen(reply), 1);
1351: close(dc);
1352: poperror();
1353: }
1354: }
1355:
1356: /*
1357: * set the window size and reset the protocol
1358: */
1359: static void
1360: dkwindow(Chan *c)
1361: {
1362: char buf[64];
1363: Line *lp;
1364:
1365: lp = linealloc(dk[c->dev], STREAMID(c->qid.path), 1);
1366: if(lp->window == 0)
1367: lp->window = 64;
1368: sprint(buf, "init %d %d", lp->window, Streamhi);
1369: streamwrite(c, buf, strlen(buf), 1);
1370: }
1371:
1372: /*
1373: * hangup a datakit connection
1374: */
1375: static void
1376: dkhangup(Line *lp)
1377: {
1378: Block *bp;
1379:
1380: qlock(lp);
1381: if(lp->rq){
1382: bp = allocb(0);
1383: bp->type = M_HANGUP;
1384: PUTNEXT(lp->rq, bp);
1385: }
1386: qunlock(lp);
1387: }
1388:
1389: /*
1390: * A process which listens to all input on a csc line
1391: */
1392: static void
1393: dkcsckproc(void *a)
1394: {
1395: long n;
1396: Dk *dp;
1397: Dkmsg d;
1398: int line;
1399:
1400: dp = a;
1401:
1402: if(waserror()){
1403: close(dp->csc);
1404: return;
1405: }
1406: DPRINT("dkcsckproc: %d\n", dp->ncsc);
1407:
1408: /*
1409: * loop forever listening
1410: */
1411: for(;;){
1412: n = streamread(dp->csc, (char *)&d, (long)sizeof(d));
1413: if(n != sizeof(d)){
1414: if(n == 0)
1415: error(Ehungup);
1416: print("strange csc message %d\n", n);
1417: continue;
1418: }
1419: line = (d.param0h<<8) + d.param0l;
1420: DPRINT("t(%d)s(%d)l(%d)\n", d.type, d.srv, line);
1421: switch (d.type) {
1422:
1423: case T_CHG: /* controller wants to close a line */
1424: dkchgmesg(dp->csc, dp, &d, line);
1425: break;
1426:
1427: case T_REPLY: /* reply to a dial request */
1428: dkreplymesg(dp, &d, line);
1429: break;
1430:
1431: case T_SRV: /* ignore it, it's useless */
1432: /* print("dksrvmesg(%d)\n", line); /**/
1433: break;
1434:
1435: case T_RESTART: /* datakit reboot */
1436: if(line >=0 && line<dp->lines)
1437: dp->lines = line+1;
1438: break;
1439:
1440: default:
1441: print("unrecognized csc message %o.%o(%o)\n",
1442: d.type, d.srv, line);
1443: break;
1444: }
1445: }
1446: }
1447:
1448: /*
1449: * datakit requests or confirms closing a line
1450: */
1451: static void
1452: dkchgmesg(Chan *c, Dk *dp, Dkmsg *dialp, int line)
1453: {
1454: Line *lp;
1455:
1456: switch (dialp->srv) {
1457:
1458: case D_CLOSE: /* remote shutdown */
1459: if (line <= 0 || line >= dp->lines || (lp = dp->linep[line]) == 0) {
1460: /* tell controller this line is not in use */
1461: dkmesg(c, T_CHG, D_CLOSE, line, 0);
1462: return;
1463: }
1464: switch (lp->state) {
1465:
1466: case Ldialing:
1467: /* simulate a failed connection */
1468: dkreplymesg(dp, (Dkmsg *)0, line);
1469: lp->state = Lrclose;
1470: break;
1471:
1472: case Lrclose:
1473: case Lconnected:
1474: case Llistening:
1475: case Lackwait:
1476: dkhangup(lp);
1477: lp->state = Lrclose;
1478: break;
1479:
1480: case Lopened:
1481: dkmesg(c, T_CHG, D_CLOSE, line, 0);
1482: break;
1483:
1484: case Llclose:
1485: case Lclosed:
1486: dkhangup(lp);
1487: dkmesg(c, T_CHG, D_CLOSE, line, 0);
1488: lp->state = Lclosed;
1489: break;
1490: }
1491: break;
1492:
1493: case D_ISCLOSED: /* acknowledging a local shutdown */
1494: if (line <= 0 || line >= dp->lines || (lp = dp->linep[line]) == 0)
1495: return;
1496: switch (lp->state) {
1497: case Llclose:
1498: case Lclosed:
1499: lp->state = Lclosed;
1500: break;
1501:
1502: case Lrclose:
1503: case Lconnected:
1504: case Llistening:
1505: case Lackwait:
1506: break;
1507: }
1508: break;
1509:
1510: case D_CLOSEALL:
1511: /*
1512: * datakit wants us to close all lines
1513: */
1514: for(line = dp->ncsc+1; line < dp->lines; line++){
1515: lp = dp->linep[line];
1516: if(lp == 0)
1517: continue;
1518: switch (lp->state) {
1519:
1520: case Ldialing:
1521: /* simulate a failed connection */
1522: dkreplymesg(dp, (Dkmsg *)0, line);
1523: lp->state = Lrclose;
1524: break;
1525:
1526: case Lrclose:
1527: case Lconnected:
1528: case Llistening:
1529: case Lackwait:
1530: lp->state = Lrclose;
1531: dkhangup(lp);
1532: break;
1533:
1534: case Lopened:
1535: break;
1536:
1537: case Llclose:
1538: case Lclosed:
1539: lp->state = Lclosed;
1540: break;
1541: }
1542: }
1543: dp->closeall = 1;
1544: wakeup(&dp->closeallr);
1545: break;
1546:
1547: default:
1548: print("unrecognized T_CHG\n");
1549: }
1550: }
1551:
1552: /*
1553: * datakit replies to a dialout. capture reply code and traffic parameters
1554: */
1555: static void
1556: dkreplymesg(Dk *dp, Dkmsg *dialp, int line)
1557: {
1558: Line *lp;
1559:
1560: DPRINT("dkreplymesg(%d)\n", line);
1561:
1562: if(line < 0 || line >= dp->lines || (lp = dp->linep[line]) == 0)
1563: return;
1564:
1565: if(lp->state != Ldialing)
1566: return;
1567:
1568: if(dialp){
1569: /*
1570: * a reply from the dk
1571: */
1572: lp->state = (dialp->srv==D_OPEN) ? Lconnected : Lrclose;
1573: lp->err = (dialp->param1h<<8) + dialp->param1l;
1574: lp->window = lp->err;
1575: DPRINT("dkreplymesg: %d\n", lp->state);
1576: } else {
1577: /*
1578: * a local abort
1579: */
1580: lp->state = Lrclose;
1581: lp->err = 0;
1582: }
1583:
1584: if(lp->state==Lrclose){
1585: dkhangup(lp);
1586: }
1587: wakeup(&lp->r);
1588: }
1589:
1590: /*
1591: * send a I'm alive message every 7.5 seconds and remind the dk of
1592: * any closed channels it hasn't acknowledged.
1593: */
1594: static void
1595: dktimer(void *a)
1596: {
1597: int i;
1598: Dk *dp;
1599: Line *lp;
1600: Chan *c;
1601:
1602: dp = (Dk *)a;
1603: c = dkopencsc(dp);
1604:
1605: while(waserror());
1606:
1607: for(;;){
1608: /*
1609: * send keep alive
1610: */
1611: DPRINT("keep alive\n");
1612: dkmesg(c, T_ALIVE, D_CONTINUE, 0, 0);
1613:
1614: /*
1615: * remind controller of dead lines and
1616: * timeout calls that take to long
1617: */
1618: for (i=dp->ncsc+1; i<dp->lines; i++){
1619: lp = dp->linep[i];
1620: if(lp == 0)
1621: continue;
1622: switch(lp->state){
1623: case Llclose:
1624: dkmesg(c, T_CHG, D_CLOSE, i, 0);
1625: break;
1626:
1627: case Ldialing:
1628: if(lp->calltolive==0 || --lp->calltolive!=0)
1629: break;
1630: dkreplymesg(dp, (Dkmsg *)0, i);
1631: break;
1632: }
1633: }
1634: tsleep(&dp->timer, return0, 0, 7500);
1635: }
1636: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.