![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso_pcb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to iso_pcb.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 root 1: /***********************************************************
2: Copyright IBM Corporation 1987
3:
4: All Rights Reserved
5:
6: Permission to use, copy, modify, and distribute this software and its
7: documentation for any purpose and without fee is hereby granted,
8: provided that the above copyright notice appear in all copies and that
9: both that copyright notice and this permission notice appear in
10: supporting documentation, and that the name of IBM not be
11: used in advertising or publicity pertaining to distribution of the
12: software without specific, written prior permission.
13:
14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
20: SOFTWARE.
21:
22: ******************************************************************/
23:
24: /*
25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
26: */
27: /*
28: * $Header: iso_pcb.c,v 4.5 88/06/29 14:59:56 hagens Exp $
29: * $Source: /usr/argo/sys/netiso/RCS/iso_pcb.c,v $
30: * @(#)iso_pcb.c 7.7 (Berkeley) 4/16/90
31: *
32: * Iso address family net-layer(s) pcb stuff. NEH 1/29/87
33: */
34:
35: #ifndef lint
36: static char *rcsid = "$Header: iso_pcb.c,v 4.5 88/06/29 14:59:56 hagens Exp $";
37: #endif
38:
39: #ifdef ISO
40:
41: #include "param.h"
42: #include "systm.h"
43: #include "user.h"
44: #include "mbuf.h"
45: #include "socket.h"
46: #include "socketvar.h"
47: #include "argo_debug.h"
48: #include "iso.h"
49: #include "clnp.h"
50: #include "../netinet/in_systm.h"
51: #include "../net/if.h"
52: #include "../net/route.h"
53: #include "iso_pcb.h"
54: #include "iso_var.h"
55: #include "protosw.h"
56:
57: #define PCBNULL (struct isopcb *)0
58: struct iso_addr zeroiso_addr = {
59: 0
60: };
61:
62:
63: /*
64: * FUNCTION: iso_pcballoc
65: *
66: * PURPOSE: creates an isopcb structure in an mbuf,
67: * with socket (so), and
68: * puts it in the queue with head (head)
69: *
70: * RETURNS: 0 if OK, ENOBUFS if can't alloc the necessary mbuf
71: */
72: int
73: iso_pcballoc(so, head)
74: struct socket *so;
75: struct isopcb *head;
76: {
77: register struct isopcb *isop;
78:
79: IFDEBUG(D_ISO)
80: printf("iso_pcballoc(so 0x%x)\n", so);
81: ENDDEBUG
82: MALLOC(isop, struct isopcb *, sizeof(*isop), M_PCB, M_NOWAIT);
83: if (isop == NULL)
84: return ENOBUFS;
85: bzero((caddr_t)isop, sizeof(*isop));
86: isop->isop_head = head;
87: isop->isop_socket = so;
88: insque(isop, head);
89: so->so_pcb = (caddr_t)isop;
90: return 0;
91: }
92:
93: /*
94: * FUNCTION: iso_pcbbind
95: *
96: * PURPOSE: binds the address given in *(nam) to the socket
97: * specified by the isopcb in *(isop)
98: * If the given address is zero, it makes sure the
99: * address isn't already in use and if it's got a network
100: * portion, we look for an interface with that network
101: * address. If the address given is zero, we allocate
102: * a port and stuff it in the (nam) structure.
103: *
104: * RETURNS: errno E* or 0 if ok.
105: *
106: * SIDE EFFECTS: increments head->isop_lport if it allocates a port #
107: *
108: * NOTES:
109: */
110: #define satosiso(sa) ((struct sockaddr_iso *)(sa))
111: int
112: iso_pcbbind(isop, nam)
113: register struct isopcb *isop;
114: struct mbuf *nam;
115: {
116: register struct isopcb *head = isop->isop_head;
117: register struct sockaddr_iso *siso;
118: struct iso_ifaddr *ia;
119: union {
120: char data[2];
121: u_short s;
122: } suf;
123:
124: IFDEBUG(D_ISO)
125: printf("iso_pcbbind(isop 0x%x, nam 0x%x)\n", isop, nam);
126: ENDDEBUG
127: suf.s = 0;
128: if (iso_ifaddr == 0) /* any interfaces attached? */
129: return EADDRNOTAVAIL;
130: if (isop->isop_laddr) /* already bound */
131: return EADDRINUSE;
132: if(nam == (struct mbuf *)0) {
133: isop->isop_laddr = &isop->isop_sladdr;
134: isop->isop_sladdr.siso_len = sizeof(struct sockaddr_iso);
135: isop->isop_sladdr.siso_family = AF_ISO;
136: isop->isop_sladdr.siso_tlen = 2;
137: isop->isop_sladdr.siso_nlen = 0;
138: isop->isop_sladdr.siso_slen = 0;
139: isop->isop_sladdr.siso_plen = 0;
140: goto noname;
141: }
142: siso = mtod(nam, struct sockaddr_iso *);
143: IFDEBUG(D_ISO)
144: printf("iso_pcbbind(name len 0x%x)\n", nam->m_len);
145: printf("The address is %s\n", clnp_iso_addrp(&siso->siso_addr));
146: ENDDEBUG
147: /*
148: * We would like sort of length check but since some OSI addrs
149: * do not have fixed length, we can't really do much.
150: * The ONLY thing we can say is that an osi addr has to have
151: * at LEAST an afi and one more byte and had better fit into
152: * a struct iso_addr.
153: * However, in fact the size of the whole thing is a struct
154: * sockaddr_iso, so probably this is what we should check for.
155: */
156: if( (nam->m_len < 2) || (nam->m_len < siso->siso_len)) {
157: return ENAMETOOLONG;
158: }
159: if (siso->siso_tlen) {
160: register char *cp = TSEL(siso);
161: suf.data[0] = cp[0];
162: suf.data[1] = cp[1];
163: }
164: if (siso->siso_nlen) {
165: /* non-zero net addr- better match one of our interfaces */
166: IFDEBUG(D_ISO)
167: printf("iso_pcbbind: bind to NOT zeroisoaddr\n");
168: ENDDEBUG
169: for (ia = iso_ifaddr; ia; ia = ia->ia_next)
170: if (SAME_ISOADDR(siso, &ia->ia_addr))
171: break;
172: if (ia == 0)
173: return EADDRNOTAVAIL;
174: }
175: if (siso->siso_len <= sizeof (isop->isop_sladdr)) {
176: isop->isop_laddr = &isop->isop_sladdr;
177: } else {
178: if ((nam = m_copy(nam, 0, (int)M_COPYALL)) == 0)
179: return ENOBUFS;
180: isop->isop_laddr = mtod(nam, struct sockaddr_iso *);
181: }
182: bcopy((caddr_t)siso, (caddr_t)isop->isop_laddr, siso->siso_len);
183: if (suf.s || siso->siso_tlen != 2) {
184: if((suf.s < ISO_PORT_RESERVED) && (siso->siso_tlen <= 2) &&
185: (u.u_uid != 0))
186: return EACCES;
187: if ((isop->isop_socket->so_options & SO_REUSEADDR) == 0 &&
188: iso_pcblookup(head, 0, (caddr_t)0, isop->isop_laddr))
189: return EADDRINUSE;
190: } else {
191: register char *cp;
192: noname:
193: cp = TSEL(isop->isop_laddr);
194: IFDEBUG(D_ISO)
195: printf("iso_pcbbind noname\n");
196: ENDDEBUG
197: do {
198: if (head->isop_lport++ < ISO_PORT_RESERVED ||
199: head->isop_lport > ISO_PORT_USERRESERVED)
200: head->isop_lport = ISO_PORT_RESERVED;
201: suf.s = head->isop_lport;
202: cp[0] = suf.data[0];
203: cp[1] = suf.data[1];
204: } while (iso_pcblookup(head, 0, (caddr_t)0, isop->isop_laddr));
205: }
206: IFDEBUG(D_ISO)
207: printf("iso_pcbbind returns 0, suf 0x%x\n", suf);
208: ENDDEBUG
209: return 0;
210: }
211: /*
212: * FUNCTION: iso_pcbconnect
213: *
214: * PURPOSE: Make the isopcb (isop) look like it's connected.
215: * In other words, give it the peer address given in
216: * the mbuf * (nam). Make sure such a combination
217: * of local, peer addresses doesn't already exist
218: * for this protocol. Internet mentality prevails here,
219: * wherein a src,dst pair uniquely identifies a connection.
220: * Both net address and port must be specified in argument
221: * (nam).
222: * If we don't have a local address for this socket yet,
223: * we pick one by calling iso_pcbbind().
224: *
225: * RETURNS: errno E* or 0 if ok.
226: *
227: * SIDE EFFECTS: Looks up a route, which may cause one to be left
228: * in the isopcb.
229: *
230: * NOTES:
231: */
232: int
233: iso_pcbconnect(isop, nam)
234: register struct isopcb *isop;
235: struct mbuf *nam;
236: {
237: register struct sockaddr_iso *siso = mtod(nam, struct sockaddr_iso *);
238: int local_zero, error = 0;
239: struct iso_ifaddr *ia;
240:
241: IFDEBUG(D_ISO)
242: printf("iso_pcbconnect(isop 0x%x sock 0x%x nam 0x%x",
243: isop, isop->isop_socket, nam);
244: printf("nam->m_len 0x%x), addr:\n", nam->m_len);
245: dump_isoaddr(siso);
246: ENDDEBUG
247: if (nam->m_len < siso->siso_len)
248: return EINVAL;
249: if (siso->siso_family != AF_ISO)
250: return EAFNOSUPPORT;
251: if (siso->siso_nlen == 0) {
252: if (ia = iso_ifaddr) {
253: int nlen = ia->ia_addr.siso_nlen;
254: ovbcopy(TSEL(siso), nlen + TSEL(siso),
255: siso->siso_plen + siso->siso_tlen + siso->siso_slen);
256: bcopy((caddr_t)&ia->ia_addr.siso_addr,
257: (caddr_t)&siso->siso_addr, nlen + 1);
258: /* includes siso->siso_nlen = nlen; */
259: } else
260: return EADDRNOTAVAIL;
261: }
262: /*
263: * Local zero means either not bound, or bound to a TSEL, but no
264: * particular local interface. So, if we want to send somebody
265: * we need to choose a return address.
266: */
267: local_zero =
268: ((isop->isop_laddr == 0) || (isop->isop_laddr->siso_nlen == 0));
269: if (local_zero) {
270: int flags;
271:
272: IFDEBUG(D_ISO)
273: printf("iso_pcbconnect localzero 1\n");
274: ENDDEBUG
275: /*
276: * If route is known or can be allocated now,
277: * our src addr is taken from the i/f, else punt.
278: */
279: flags = isop->isop_socket->so_options & SO_DONTROUTE;
280: if (error = clnp_route(&siso->siso_addr, &isop->isop_route, flags,
281: (struct sockaddr **)0, &ia))
282: return error;
283: IFDEBUG(D_ISO)
284: printf("iso_pcbconnect localzero 2, ro->ro_rt 0x%x",
285: isop->isop_route.ro_rt);
286: printf(" ia 0x%x\n", ia);
287: ENDDEBUG
288: }
289: IFDEBUG(D_ISO)
290: printf("in iso_pcbconnect before lookup isop 0x%x isop->sock 0x%x\n",
291: isop, isop->isop_socket);
292: ENDDEBUG
293: if (local_zero) {
294: int nlen, tlen, totlen; caddr_t oldtsel, newtsel;
295: siso = isop->isop_laddr;
296: if (siso == 0 || siso->siso_tlen == 0)
297: (void)iso_pcbbind(isop, (struct mbuf *)0);
298: /*
299: * Here we have problem of squezeing in a definite network address
300: * into an existing sockaddr_iso, which in fact may not have room
301: * for it. This gets messy.
302: */
303: siso = isop->isop_laddr;
304: oldtsel = TSEL(siso);
305: tlen = siso->siso_tlen;
306: nlen = ia->ia_addr.siso_nlen;
307: totlen = tlen + nlen + _offsetof(struct sockaddr_iso, siso_data[0]);
308: if ((siso == &isop->isop_sladdr) &&
309: (totlen > sizeof(isop->isop_sladdr))) {
310: struct mbuf *m = m_get(MT_SONAME, M_DONTWAIT);
311: if (m == 0)
312: return ENOBUFS;
313: m->m_len = totlen;
314: isop->isop_laddr = siso = mtod(m, struct sockaddr_iso *);
315: }
316: siso->siso_nlen = ia->ia_addr.siso_nlen;
317: newtsel = TSEL(siso);
318: ovbcopy(oldtsel, newtsel, tlen);
319: bcopy(ia->ia_addr.siso_data, siso->siso_data, nlen);
320: siso->siso_tlen = tlen;
321: siso->siso_family = AF_ISO;
322: siso->siso_len = totlen;
323: siso = mtod(nam, struct sockaddr_iso *);
324: }
325: IFDEBUG(D_ISO)
326: printf("in iso_pcbconnect before bcopy isop 0x%x isop->sock 0x%x\n",
327: isop, isop->isop_socket);
328: ENDDEBUG
329: /*
330: * If we had to allocate space to a previous big foreign address,
331: * and for some reason we didn't free it, we reuse it knowing
332: * that is going to be big enough, as sockaddrs are delivered in
333: * 128 byte mbufs.
334: * If the foreign address is small enough, we use default space;
335: * otherwise, we grab an mbuf to copy into.
336: */
337: if (isop->isop_faddr == 0 || isop->isop_faddr == &isop->isop_sfaddr) {
338: if (siso->siso_len <= sizeof(isop->isop_sfaddr))
339: isop->isop_faddr = &isop->isop_sfaddr;
340: else {
341: struct mbuf *m = m_get(MT_SONAME, M_DONTWAIT);
342: if (m == 0)
343: return ENOBUFS;
344: isop->isop_faddr = mtod(m, struct sockaddr_iso *);
345: }
346: }
347: bcopy((caddr_t)siso, (caddr_t)isop->isop_faddr, siso->siso_len);
348: IFDEBUG(D_ISO)
349: printf("in iso_pcbconnect after bcopy isop 0x%x isop->sock 0x%x\n",
350: isop, isop->isop_socket);
351: printf("iso_pcbconnect connected to addr:\n");
352: dump_isoaddr(isop->isop_faddr);
353: printf("iso_pcbconnect end: src addr:\n");
354: dump_isoaddr(isop->isop_laddr);
355: ENDDEBUG
356: return 0;
357: }
358:
359: /*
360: * FUNCTION: iso_pcbdisconnect()
361: *
362: * PURPOSE: washes away the peer address info so the socket
363: * appears to be disconnected.
364: * If there's no file descriptor associated with the socket
365: * it detaches the pcb.
366: *
367: * RETURNS: Nada.
368: *
369: * SIDE EFFECTS: May detach the pcb.
370: *
371: * NOTES:
372: */
373: void
374: iso_pcbdisconnect(isop)
375: struct isopcb *isop;
376: {
377: void iso_pcbdetach();
378: register struct sockaddr_iso *siso;
379:
380: IFDEBUG(D_ISO)
381: printf("iso_pcbdisconnect(isop 0x%x)\n", isop);
382: ENDDEBUG
383: /*
384: * Preserver binding infnormation if already bound.
385: */
386: if ((siso = isop->isop_laddr) && siso->siso_nlen && siso->siso_tlen) {
387: caddr_t otsel = TSEL(siso);
388: siso->siso_nlen = 0;
389: ovbcopy(otsel, TSEL(siso), siso->siso_tlen);
390: }
391: if (isop->isop_faddr && isop->isop_faddr != &isop->isop_sfaddr)
392: m_freem(dtom(isop->isop_faddr));
393: isop->isop_faddr = 0;
394: if (isop->isop_socket->so_state & SS_NOFDREF)
395: iso_pcbdetach(isop);
396: }
397:
398: /*
399: * FUNCTION: iso_pcbdetach
400: *
401: * PURPOSE: detach the pcb at *(isop) from it's socket and free
402: * the mbufs associated with the pcb..
403: * Dequeues (isop) from its head.
404: *
405: * RETURNS: Nada.
406: *
407: * SIDE EFFECTS:
408: *
409: * NOTES:
410: */
411: void
412: iso_pcbdetach(isop)
413: struct isopcb *isop;
414: {
415: struct socket *so = isop->isop_socket;
416:
417: IFDEBUG(D_ISO)
418: printf("iso_pcbdetach(isop 0x%x socket 0x%x so 0x%x)\n",
419: isop, isop->isop_socket, so);
420: ENDDEBUG
421: if (so ) { /* in the x.25 domain, we sometimes have no socket */
422: so->so_pcb = 0;
423: sofree(so);
424: }
425: IFDEBUG(D_ISO)
426: printf("iso_pcbdetach 2 \n");
427: ENDDEBUG
428: if (isop->isop_options)
429: (void)m_free(isop->isop_options);
430: IFDEBUG(D_ISO)
431: printf("iso_pcbdetach 3 \n");
432: ENDDEBUG
433: if (isop->isop_route.ro_rt)
434: rtfree(isop->isop_route.ro_rt);
435: IFDEBUG(D_ISO)
436: printf("iso_pcbdetach 3.1\n");
437: ENDDEBUG
438: if (isop->isop_clnpcache != NULL) {
439: struct clnp_cache *clcp =
440: mtod(isop->isop_clnpcache, struct clnp_cache *);
441: IFDEBUG(D_ISO)
442: printf("iso_pcbdetach 3.2: clcp 0x%x freeing clc_hdr x%x\n",
443: clcp, clcp->clc_hdr);
444: ENDDEBUG
445: if (clcp->clc_hdr != NULL)
446: m_free(clcp->clc_hdr);
447: IFDEBUG(D_ISO)
448: printf("iso_pcbdetach 3.3: freeing cache x%x\n",
449: isop->isop_clnpcache);
450: ENDDEBUG
451: m_free(isop->isop_clnpcache);
452: }
453: IFDEBUG(D_ISO)
454: printf("iso_pcbdetach 4 \n");
455: ENDDEBUG
456: remque(isop);
457: IFDEBUG(D_ISO)
458: printf("iso_pcbdetach 5 \n");
459: ENDDEBUG
460: if (isop->isop_laddr && (isop->isop_laddr != &isop->isop_sladdr))
461: m_freem(dtom(isop->isop_laddr));
462: free((caddr_t)isop, M_PCB);
463: }
464:
465:
466: /*
467: * FUNCTION: iso_pcbnotify
468: *
469: * PURPOSE: notify all connections in this protocol's queue (head)
470: * that have peer address (dst) of the problem (errno)
471: * by calling (notify) on the connections' isopcbs.
472: *
473: * RETURNS: Rien.
474: *
475: * SIDE EFFECTS:
476: *
477: * NOTES: (notify) is called at splimp!
478: */
479: void
480: iso_pcbnotify(head, siso, errno, notify)
481: struct isopcb *head;
482: register struct sockaddr_iso *siso;
483: int errno, (*notify)();
484: {
485: register struct isopcb *isop;
486: int s = splimp();
487:
488: IFDEBUG(D_ISO)
489: printf("iso_pcbnotify(head 0x%x, notify 0x%x) dst:\n", head, notify);
490: ENDDEBUG
491: for (isop = head->isop_next; isop != head; isop = isop->isop_next) {
492: if (isop->isop_socket == 0 || isop->isop_faddr == 0 ||
493: !SAME_ISOADDR(siso, isop->isop_faddr)) {
494: IFDEBUG(D_ISO)
495: printf("iso_pcbnotify: CONTINUE isop 0x%x, sock 0x%x\n" ,
496: isop, isop->isop_socket);
497: printf("addrmatch cmp'd with (0x%x):\n", isop->isop_faddr);
498: dump_isoaddr(isop->isop_faddr);
499: ENDDEBUG
500: continue;
501: }
502: if (errno)
503: isop->isop_socket->so_error = errno;
504: if (notify)
505: (*notify)(isop);
506: }
507: splx(s);
508: IFDEBUG(D_ISO)
509: printf("END OF iso_pcbnotify\n" );
510: ENDDEBUG
511: }
512:
513:
514: /*
515: * FUNCTION: iso_pcblookup
516: *
517: * PURPOSE: looks for a given combination of (faddr), (fport),
518: * (lport), (laddr) in the queue named by (head).
519: * Argument (flags) is ignored.
520: *
521: * RETURNS: ptr to the isopcb if it finds a connection matching
522: * these arguments, o.w. returns zero.
523: *
524: * SIDE EFFECTS:
525: *
526: * NOTES:
527: */
528: struct isopcb *
529: iso_pcblookup(head, fportlen, fport, laddr)
530: struct isopcb *head;
531: register struct sockaddr_iso *laddr;
532: caddr_t fport;
533: int fportlen;
534: {
535: register struct isopcb *isop;
536: register caddr_t lp = TSEL(laddr);
537: unsigned int llen = laddr->siso_tlen;
538:
539: IFDEBUG(D_ISO)
540: printf("iso_pcblookup(head 0x%x laddr 0x%x fport 0x%x)\n",
541: head, laddr, fport);
542: ENDDEBUG
543: for (isop = head->isop_next; isop != head; isop = isop->isop_next) {
544: if (isop->isop_laddr == 0 || isop->isop_laddr == laddr)
545: continue;
546: if (isop->isop_laddr->siso_tlen != llen)
547: continue;
548: if (bcmp(lp, TSEL(isop->isop_laddr), llen))
549: continue;
550: if (fportlen && isop->isop_faddr &&
551: bcmp(fport, TSEL(isop->isop_faddr), (unsigned)fportlen))
552: continue;
553: /* PHASE2
554: * addrmatch1 should be iso_addrmatch(a, b, mask)
555: * where mask is taken from isop->isop_laddrmask (new field)
556: * isop_lnetmask will also be available in isop
557: if (laddr != &zeroiso_addr &&
558: !iso_addrmatch1(laddr, &(isop->isop_laddr.siso_addr)))
559: continue;
560: */
561: if (laddr->siso_nlen && (!SAME_ISOADDR(laddr, isop->isop_laddr)))
562: continue;
563: return (isop);
564: }
565: return (struct isopcb *)0;
566: }
567: #endif ISO
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.