![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dial.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / ipc / mgrs / ndkmgr|
Return to dial.c CVS log | Up to [Research Unix] / researchv10no / ipc / mgrs / ndkmgr |
1.1 root 1: #include <sys/types.h>
2: #include <sys/stat.h>
3: #include <sys/filio.h>
4: #include "dk.h"
5: #include <stdio.h>
6: #include <signal.h>
7: #include <errno.h>
8: #include <ipc.h>
9: #include <libc.h>
10: #include "defs.h"
11: #include <dkwindow.h>
12: #include <sys/dkio.h>
13:
14: /* imported */
15: extern int uxp_ld;
16: extern int dkp_ld;
17: extern int errno;
18: extern int unit;
19:
20: enum { dial, announce, redial };
21:
22:
23: static int
24: gettraffic(ip)
25: ipcinfo *ip;
26: {
27: char *dp;
28:
29: /* get type of request and properties */
30: for(dp = ip->param; *dp; dp++) {
31: for(;*dp && *dp==' '; dp++);
32: if (strncmp(dp, "heavy", 5)==0 && (dp[5]=='\0'||dp[5]==' '))
33: return 2;
34: for(;*dp && *dp!=' '; dp++);
35: }
36: return 0;
37: }
38:
39: int
40: net_dial(ip)
41: ipcinfo *ip;
42: {
43: int fd;
44: int ctlfd;
45: int traffic;
46: int chan;
47:
48: traffic = gettraffic(ip);
49: fd = dkchan(&traffic, unit, &chan, &ctlfd);
50: if (fd < 0)
51: return ABORT(EBUSY, "out of output channels", NULLINFO);
52: return dkdial(fd, ctlfd, ip, traffic, chan, dial);
53: }
54:
55: int
56: net_announce(ip)
57: ipcinfo *ip;
58: {
59: int fd;
60: int ctlfd;
61: int traffic;
62: int chan;
63:
64: /*
65: * hack: assertively set unit
66: * when announcing, use traffic type to decide on interface to use.
67: * otherwise, we could announce on the wrong interface.
68: * bug: dkchan tries the other interface, so could still
69: * end up on the wrong one if the right one is full
70: */
71: traffic = gettraffic(ip);
72: if (unit == 'b') {
73: switch(traffic){
74: case 0:
75: unit = '0';
76: break;
77: case 2:
78: unit = '2';
79: break;
80: }
81: }
82: fd = dkchan(&traffic, unit, &chan, &ctlfd);
83: if (fd < 0)
84: return ABORT(EBUSY, "out of output channels", NULLINFO);
85: return dkdial(fd, ctlfd, ip, traffic, chan, announce);
86: }
87:
88: int
89: net_redial(ip)
90: ipcinfo *ip;
91: {
92: int traffic;
93: int chan;
94: int ctlfd;
95:
96: /*
97: * find unit, traffic, and channel
98: */
99: if(dkid(ip->cfd, unit, &traffic, &chan, &ctlfd)<0)
100: return -1;
101: return dkdial(ip->cfd, ctlfd, ip, traffic, chan, redial);
102: }
103:
104: int
105: dkdial(fd, listener, ip, traffic, chan, operation)
106: ipcinfo *ip;
107: {
108: int i;
109: struct dialout d;
110: char dialstr[128];
111: char dialtone[2];
112: register char *dp, *cp;
113: struct dialout reply;
114: int al_catch();
115: long window;
116: char ws[8];
117:
118: /*
119: * restart URP on the channel
120: */
121: signal(SIGALRM, al_catch);
122: dkproto(fd, dkp_ld);
123: ioctl(fd, FIOPUSHLD, &uxp_ld);
124:
125: /* set up the parameter block for the initial request */
126: switch(operation){
127: case dial:
128: d.type = T_SRV;
129: d.srv = D_DIAL;
130: break;
131: case announce:
132: d.type = T_SRV;
133: d.srv = D_SERV;
134: break;
135: case redial:
136: d.type = T_CHG;
137: d.srv = D_REDIAL;
138: break;
139: }
140: d.param0l = chan;
141: d.param0h = chan>>8;
142: d.param1l = traffic;
143: d.param1h = traffic>>8;
144: d.param2l = 0;
145: d.param2h = 0;
146: d.param3l = 0;
147: d.param3h = 0;
148: d.param4l = ip->uid;
149: d.param4h = ip->uid>>8;
150:
151: /*
152: * Make dial string.
153: * Convert first two '!'s to '.'s to comply with generic's form
154: * of destination.service[.more-things]. Escape any '.'s in the
155: * service part with '\'s.
156: */
157: for(i=0, cp=ip->name, dp=dialstr; *cp; cp++)
158: if (i<2 && *cp=='!'){
159: *dp++ = '.';
160: i++;
161: } else if (i==1 && *cp=='.') {
162: *dp++ = '\\';
163: *dp++ = '.';
164: } else if (*cp=='\n') {
165: close(fd);
166: return ABORT(EACCES, "illegal dial string", NULLINFO);
167: } else
168: *dp++ = *cp;
169: *dp = '\0';
170: switch(operation){
171: case dial:
172: strcat(dialstr, "\n");
173: strcat(dialstr, ip->user);
174: break;
175: case redial:
176: strcat(dialstr, "\n");
177: strcat(dialstr, ip->user);
178: strcat(dialstr, "\n");
179: strcat(dialstr, ip->machine);
180: break;
181: }
182:
183: /*
184: * send request on common signalling channel
185: */
186: alarm(15);
187: i = write(listener, (char *)&d, sizeof(d));
188: close(listener);
189: if (i != sizeof(d)) {
190: alarm(0);
191: close(fd);
192: ip->cfd = -1;
193: return ABORT(EIO, "can't dial out on dk", NULLINFO);
194: }
195:
196: /*
197: * wait for dial tone (REDIAL only)
198: */
199: if(operation==redial && (read(fd, dialtone, 1)!=1 || *dialtone!='O')) {
200: alarm(0);
201: close(fd);
202: ip->cfd = -1;
203: return ABORT(EIO, "no dialtone on dk", NULLINFO);
204: }
205:
206: /*
207: * dial out
208: */
209: alarm(60);
210: ioctl(fd, DIOCSTOP, 0); /* hold back user data */
211: write(fd, dialstr, strlen(dialstr));
212: if(operation==redial){
213: alarm(0);
214: return fd;
215: }
216:
217: /*
218: * get reply back (REDIAL never gets here)
219: */
220: i = read(fd, (char *)&reply, sizeof reply);
221: alarm(0);
222: if (i <= 0) {
223: close(fd);
224: return ABORT(EIO,"remote system doesn't respond",
225: (ipcinfo *)NULL);
226: }
227:
228: /*
229: * successful reply, analyze it
230: */
231: i = (reply.param1h<<8) | reply.param1l;
232: if (reply.srv!=D_OPEN) {
233: close(fd);
234: dktouerr(i&0x7f);
235: return -1;
236: }
237: if (W_VALID(i)){
238: /*
239: * a 1127 window negotiation
240: */
241: window = W_VALUE(W_DEST(i));
242: } else if(i>2 && i<31){
243: /*
244: * a generic window negotiation
245: */
246: window = 1<<i;
247: } else
248: window = 0;
249: logevent("out window(%d)\n", window);
250: dkproto(fd, dkp_ld);
251: ioctl(fd, FIOPOPLD, 0); /* dump rdk */
252: setwins(fd, window);
253: ip->myname = "";
254: ip->machine = "";
255: return fd;
256: }
257:
258: al_catch()
259: {
260: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.