![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps2udp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2-lpp|
Return to ps2udp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2-lpp |
1.1 root 1: /* ps2udp.c - PPM: UDP backing */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/psap2-lpp/RCS/ps2udp.c,v 7.3 90/07/09 14:45:02 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/psap2-lpp/RCS/ps2udp.c,v 7.3 90/07/09 14:45:02 mrose Exp $
9: *
10: * Contributed by The Wollongong Group, Inc.
11: *
12: *
13: * $Log: ps2udp.c,v $
14: * Revision 7.3 90/07/09 14:45:02 mrose
15: * sync
16: *
17: * Revision 7.2 90/07/01 21:05:21 mrose
18: * pepsy
19: *
20: * Revision 7.1 89/12/19 16:17:48 mrose
21: * dgram
22: *
23: * Revision 7.0 89/11/23 22:15:51 mrose
24: * Release 6.0
25: *
26: */
27:
28: /*
29: * NOTICE
30: *
31: * Acquisition, use, and distribution of this module and related
32: * materials are subject to the restrictions of a license agreement.
33: * Consult the Preface in the User's Manual for the full terms of
34: * this agreement.
35: *
36: */
37:
38:
39: /* LINTLIBRARY */
40:
41: #include <errno.h>
42: #include <stdio.h>
43: #define LPP
44: #include "PS-types.h"
45: #include "ppkt.h"
46: #include "tsap.h"
47: #include "tailor.h"
48:
49: #include "dgram.h"
50: #include "internet.h"
51:
52:
53: extern int errno;
54:
55: /* */
56:
57: #define MAXTRIES 3 /* should be tailorable... */
58: #define WAITRIES 30 /* .. */
59:
60:
61: int udpopen (pb, calling, called, pi, async)
62: register struct psapblk *pb;
63: struct NSAPaddr *calling,
64: *called;
65: struct PSAPindication *pi;
66: int async;
67: {
68: int fd;
69: struct sockaddr_in lo_socket,
70: in_socket;
71: register struct sockaddr_in *lsock = &lo_socket,
72: *isock = &in_socket;
73: register struct hostent *hp;
74:
75: bzero ((char *) isock, sizeof *isock);
76:
77: if (called -> na_port == 0)
78: return psaplose (pi, PC_ADDRESS, NULLCP,
79: "UDP port of called address not specified");
80: else
81: isock -> sin_port = called -> na_port;
82:
83: if ((hp = gethostbystring (called -> na_domain)) == NULL)
84: return psaplose (pi, PC_ADDRESS, NULLCP, "%s: unknown host",
85: called -> na_domain);
86: #ifdef notanymore
87: (void) strncpy (called -> na_domain, hp -> h_name,
88: sizeof called -> na_domain);
89: #endif
90:
91: isock -> sin_family = hp -> h_addrtype;
92: inaddr_copy (hp, isock);
93:
94: #ifndef notanymore
95: (void) strcpy (called -> na_domain, inet_ntoa (isock -> sin_addr));
96: #endif
97:
98: bzero ((char *) lsock, sizeof *lsock);
99: if (calling && calling -> na_domain[0]) {
100: if ((hp = gethostbystring (calling -> na_domain)) == NULL)
101: return psaplose (pi, PC_ADDRESS, NULLCP, "%s: unknown host",
102: calling -> na_domain);
103:
104: if ((lsock -> sin_family = hp -> h_addrtype) != isock -> sin_family)
105: return psaplose (pi, PC_ADDRESS, NULLCP,
106: "address family mismatch");
107:
108: inaddr_copy (hp, lsock);
109: }
110: else
111: lsock -> sin_family = isock -> sin_family;
112:
113: if ((fd = start_udp_client (lsock, 0, 0, 0)) == NOTOK)
114: return psaplose (pi, PC_CONGEST, "socket", "unable to start");
115:
116: if (join_udp_server (fd, isock) == NOTOK) {
117: (void) psaplose (pi, PC_REFUSED, "connection", "unable to establish");
118: (void) close_udp_socket (fd);
119: return NOTOK;
120: }
121:
122: if ((pb -> pb_stream = ps_alloc (dg_open)) == NULLPS
123: || dg_setup (pb -> pb_stream, fd, MAXDGRAM, read_udp_socket,
124: write_udp_socket) == NOTOK) {
125: (void) psaplose (pi, PC_CONGEST, NULLCP, NULLCP);
126: (void) close_udp_socket (fd);
127: return NOTOK;
128: }
129:
130: PUservice (pb, fd);
131:
132: pb -> pb_tries = pb -> pb_maxtries;
133:
134: for (;;)
135: switch (udpretry (pb, PC_REFUSED, pi)) {
136: case NOTOK:
137: return NOTOK;
138:
139: case OK:
140: if (async)
141: return OK;
142: continue;
143:
144: case DONE:
145: default:
146: return DONE;
147: }
148: }
149:
150: /* */
151:
152: /* ARGSUSED */
153:
154: char *udpsave (fd, sin, cp1, cp2, td)
155: int fd;
156: struct sockaddr_in *sin;
157: char *cp1,
158: *cp2;
159: struct TSAPdisconnect *td;
160: {
161: static char buffer[BUFSIZ];
162:
163: (void) sprintf (buffer, "%c%d %s %s", PT_UDP, fd, cp1, cp2);
164:
165: return buffer;
166: }
167:
168:
169: int udprestore (pb, buffer, pi)
170: register struct psapblk *pb;
171: char *buffer;
172: struct PSAPindication *pi;
173: {
174: int fd;
175: char domain[NSAP_DOMAINLEN + 1];
176: register struct NSAPaddr *na;
177:
178: na = &pb -> pb_initiating;
179: na -> na_stack = NA_TCP;
180: na -> na_community = ts_comm_tcp_default;
181: na -> na_tset = NA_TSET_UDP;
182:
183: if (sscanf (buffer, "%d %s %s", &fd, na -> na_domain, domain) != 3
184: || fd < 0)
185: return psaplose (pi, PC_PARAMETER, NULLCP,
186: "bad initialization vector");
187:
188: PUservice (pb, fd);
189:
190: na = pb -> pb_responding.pa_addr.sa_addr.ta_addrs;
191: na -> na_stack = NA_TCP;
192: na -> na_community = ts_comm_tcp_default;
193: na -> na_tset = NA_TSET_UDP;
194: (void) strncpy (na -> na_domain, domain, sizeof na -> na_domain);
195:
196: if ((pb -> pb_stream = ps_alloc (dg_open)) == NULLPS
197: || dg_setup (pb -> pb_stream, pb -> pb_fd, MAXDGRAM,
198: read_udp_socket, write_udp_socket) == NOTOK)
199: return psaplose (pi, PC_CONGEST, NULLCP, NULLCP);
200:
201: return OK;
202: }
203:
204: /* */
205:
206: static int udpretry (pb, reason, pi)
207: register struct psapblk *pb;
208: int reason;
209: struct PSAPindication *pi;
210: {
211: int nfds;
212: fd_set ifds;
213: PS ps;
214:
215: PLOGP (psap2_log,PS_PDUs, pb -> pb_retry,
216: reason == PC_REFUSED ? "ConnectRequest-PDU" : "ReleaseRequest-PDU",
217: 0);
218:
219: if (pe2ps (ps = pb -> pb_stream, pb -> pb_retry) == NOTOK) {
220: (void) pslose (pi, ps -> ps_errno);
221: (void) close_udp_socket (pb -> pb_fd);
222: return (pb -> pb_fd = NOTOK);
223: }
224:
225: FD_ZERO (&ifds);
226:
227: nfds = pb -> pb_fd + 1;
228: FD_SET (pb -> pb_fd, &ifds);
229: if (select_udp_socket (nfds, &ifds, NULLFD, NULLFD, WAITRIES) < 1) {
230: if (--pb -> pb_tries > 0)
231: return OK;
232:
233: if (reason == PC_REFUSED) {
234: errno = ETIMEDOUT;
235: (void) ppktlose (pb, pi, PC_REFUSED, pb -> pb_reference,
236: "connection", "unable to establish");
237: }
238: else
239: (void) ppktlose (pb, pi, reason, pb -> pb_reference, NULLCP,
240: NULLCP);
241:
242: (void) close_udp_socket (pb -> pb_fd);
243: return (pb -> pb_fd = NOTOK);
244: }
245:
246: if (pb -> pb_response)
247: pe_free (pb -> pb_response);
248: if ((pb -> pb_response = ps2pe (ps = pb -> pb_stream)) == NULLPE) {
249: (void) pslose (pi, ps -> ps_errno);
250: (void) close_udp_socket (pb -> pb_fd);
251: return (pb -> pb_fd = NOTOK);
252: }
253:
254: return DONE;
255: }
256:
257: /* */
258:
259: static int udpcheck (pb, pi)
260: register struct psapblk *pb;
261: struct PSAPindication *pi;
262: {
263: int nfds;
264: fd_set ifds;
265:
266: FD_ZERO (&ifds);
267:
268: nfds = pb -> pb_fd + 1;
269: FD_SET (pb -> pb_fd, &ifds);
270: if (select_udp_socket (nfds, &ifds, NULLFD, NULLFD, OK) < 1)
271: return psaplose (pi, PC_TIMER, NULLCP, NULLCP);
272:
273: return psaplose (pi, PC_WAITING, NULLCP, NULLCP);
274: }
275:
276: /* */
277:
278: #define udpclose close_udp_socket
279: #define udpselect select_udp_socket
280:
281:
282: static int PUservice (pb, fd)
283: register struct psapblk *pb;
284: int fd;
285: {
286: pb -> pb_fd = fd;
287:
288: pb -> pb_reliability = LOW_QUALITY;
289: pb -> pb_maxtries = MAXTRIES;
290:
291: pb -> pb_retryfnx = udpretry;
292: pb -> pb_closefnx = udpclose;
293: pb -> pb_selectfnx = udpselect;
294: pb -> pb_checkfnx = udpcheck;
295: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.