?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MFC r1.3 r1.13 r1.8 (HEAD):
[dragonfly.git] / sys / netproto / atm / atm_socket.c
blobeb84bcb163e44aa407c16c4d4d2e97319bd7d066
1 /*
2 *
3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
6 *
7 *
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
12 *
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
20 *
21 * Copyright 1994-1998 Network Computing Services, Inc.
22 *
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
25 *
26 * @(#) $FreeBSD: src/sys/netatm/atm_socket.c,v 1.4 1999/08/28 00:48:37 peter Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/atm_socket.c,v 1.12 2008/06/21 12:30:19 aggelos Exp $
28 */
29
30 /*
31 * Core ATM Services
32 * -----------------
33 *
34 * ATM common socket protocol processing
35 *
36 */
37
38 #include "kern_include.h"
39
40 /*
41 * Local functions
42 */
43
44
45 /*
46 * Local variables
47 */
48 static struct sp_info atm_pcb_pool = {
49 "atm pcb pool", /* si_name */
50 sizeof(Atm_pcb), /* si_blksiz */
51 10, /* si_blkcnt */
52 100 /* si_maxallow */
53 };
54
55 static struct t_atm_cause atm_sock_cause = {
56 T_ATM_ITU_CODING,
57 T_ATM_LOC_USER,
58 T_ATM_CAUSE_UNSPECIFIED_NORMAL,
59 {0, 0, 0, 0}
60 };
61
62
63 /*
64 * Allocate resources for a new ATM socket
65 *
66 * Called at splnet.
67 *
68 * Arguments:
69 * so pointer to socket
70 * send socket send buffer maximum
71 * recv socket receive buffer maximum
72 *
73 * Returns:
74 * 0 attach successful
75 * errno attach failed - reason indicated
76 *
77 */
78 int
79 atm_sock_attach(struct socket *so, u_long send, u_long recv, struct rlimit *rl)
80 {
81 Atm_pcb *atp = sotoatmpcb(so);
82 int err;
83
84 /*
85 * Make sure initialization has happened
86 */
87 if (!atm_init)
88 atm_initialize();
89
90 /*
91 * Make sure we're not already attached
92 */
93 if (atp)
94 return (EISCONN);
95
96 /*
97 * Reserve socket buffer space, if not already done
98 */
99 if ((so->so_snd.ssb_hiwat == 0) || (so->so_rcv.ssb_hiwat == 0)) {
100 err = soreserve(so, send, recv, rl);
101 if (err)
102 return (err);
103 }
104
105 /*
106 * Allocate and initialize our control block
107 */
108 atp = (Atm_pcb *)atm_allocate(&atm_pcb_pool);
109 if (atp == NULL)
110 return (ENOMEM);
111
112 atp->atp_socket = so;
113 so->so_pcb = (caddr_t)atp;
114 return (0);
115 }
116
117
118 /*
119 * Detach from socket and free resources
120 *
121 * Called at splnet.
122 *
123 * Arguments:
124 * so pointer to socket
125 *
126 * Returns:
127 * 0 detach successful
128 * errno detach failed - reason indicated
129 *
130 */
131 int
132 atm_sock_detach(struct socket *so)
133 {
134 Atm_pcb *atp = sotoatmpcb(so);
135
136 /*
137 * Make sure we're still attached
138 */
139 if (atp == NULL)
140 return (ENOTCONN);
141
142 /*
143 * Terminate any (possibly pending) connection
144 */
145 if (atp->atp_conn) {
146 atm_sock_disconnect(so);
147 }
148
149 /*
150 * Break links and free control blocks
151 */
152 so->so_pcb = NULL;
153 sofree(so);
154
155 atm_free((caddr_t)atp);
156
157 return (0);
158 }
159
160
161 /*
162 * Bind local address to socket
163 *
164 * Called at splnet.
165 *
166 * Arguments:
167 * so pointer to socket
168 * addr pointer to protocol address
169 *
170 * Returns:
171 * 0 request processed
172 * errno error processing request - reason indicated
173 *
174 */
175 int
176 atm_sock_bind(struct socket *so, struct sockaddr *addr)
177 {
178 Atm_pcb *atp = sotoatmpcb(so);
179 Atm_attributes attr;
180 struct sockaddr_atm *satm;
181 struct t_atm_sap_addr *sapadr;
182 struct t_atm_sap_layer2 *sapl2;
183 struct t_atm_sap_layer3 *sapl3;
184 struct t_atm_sap_appl *sapapl;
185
186 /*
187 * Make sure we're still attached
188 */
189 if (atp == NULL)
190 return (ENOTCONN);
191
192 /*
193 * Can't change local address once we've started connection process
194 */
195 if (atp->atp_conn != NULL)
196 return (EADDRNOTAVAIL);
197
198 /*
199 * Validate requested local address
200 */
201 satm = (struct sockaddr_atm *)addr;
202 if (satm->satm_family != AF_ATM)
203 return (EAFNOSUPPORT);
204
205 sapadr = &satm->satm_addr.t_atm_sap_addr;
206 if (sapadr->SVE_tag_addr == T_ATM_PRESENT) {
207 if (sapadr->address_format == T_ATM_ENDSYS_ADDR) {
208 if (sapadr->SVE_tag_selector != T_ATM_PRESENT)
209 return (EINVAL);
210 } else if (sapadr->address_format == T_ATM_E164_ADDR) {
211 if (sapadr->SVE_tag_selector != T_ATM_ABSENT)
212 return (EINVAL);
213 } else
214 return (EINVAL);
215 } else if ((sapadr->SVE_tag_addr != T_ATM_ABSENT) &&
216 (sapadr->SVE_tag_addr != T_ATM_ANY))
217 return (EINVAL);
218 if (sapadr->address_length > ATM_ADDR_LEN)
219 return (EINVAL);
220
221 sapl2 = &satm->satm_addr.t_atm_sap_layer2;
222 if (sapl2->SVE_tag == T_ATM_PRESENT) {
223 if ((sapl2->ID_type != T_ATM_SIMPLE_ID) &&
224 (sapl2->ID_type != T_ATM_USER_ID))
225 return (EINVAL);
226 } else if ((sapl2->SVE_tag != T_ATM_ABSENT) &&
227 (sapl2->SVE_tag != T_ATM_ANY))
228 return (EINVAL);
229
230 sapl3 = &satm->satm_addr.t_atm_sap_layer3;
231 if (sapl3->SVE_tag == T_ATM_PRESENT) {
232 if ((sapl3->ID_type != T_ATM_SIMPLE_ID) &&
233 (sapl3->ID_type != T_ATM_IPI_ID) &&
234 (sapl3->ID_type != T_ATM_SNAP_ID) &&
235 (sapl3->ID_type != T_ATM_USER_ID))
236 return (EINVAL);
237 } else if ((sapl3->SVE_tag != T_ATM_ABSENT) &&
238 (sapl3->SVE_tag != T_ATM_ANY))
239 return (EINVAL);
240
241 sapapl = &satm->satm_addr.t_atm_sap_appl;
242 if (sapapl->SVE_tag == T_ATM_PRESENT) {
243 if ((sapapl->ID_type != T_ATM_ISO_APP_ID) &&
244 (sapapl->ID_type != T_ATM_USER_APP_ID) &&
245 (sapapl->ID_type != T_ATM_VENDOR_APP_ID))
246 return (EINVAL);
247 } else if ((sapapl->SVE_tag != T_ATM_ABSENT) &&
248 (sapapl->SVE_tag != T_ATM_ANY))
249 return (EINVAL);
250
251 /*
252 * Create temporary attributes list so that we can check out the
253 * new bind parameters before we modify the socket's values;
254 */
255 attr = atp->atp_attr;
256 attr.called.tag = sapadr->SVE_tag_addr;
257 KM_COPY(&sapadr->address_format, &attr.called.addr, sizeof(Atm_addr));
258
259 attr.blli.tag_l2 = sapl2->SVE_tag;
260 if (sapl2->SVE_tag == T_ATM_PRESENT) {
261 attr.blli.v.layer_2_protocol.ID_type = sapl2->ID_type;
262 KM_COPY(&sapl2->ID, &attr.blli.v.layer_2_protocol.ID,
263 sizeof(attr.blli.v.layer_2_protocol.ID));
264 }
265
266 attr.blli.tag_l3 = sapl3->SVE_tag;
267 if (sapl3->SVE_tag == T_ATM_PRESENT) {
268 attr.blli.v.layer_3_protocol.ID_type = sapl3->ID_type;
269 KM_COPY(&sapl3->ID, &attr.blli.v.layer_3_protocol.ID,
270 sizeof(attr.blli.v.layer_3_protocol.ID));
271 }
272
273 attr.bhli.tag = sapapl->SVE_tag;
274 if (sapapl->SVE_tag == T_ATM_PRESENT) {
275 attr.bhli.v.ID_type = sapapl->ID_type;
276 KM_COPY(&sapapl->ID, &attr.bhli.v.ID,
277 sizeof(attr.bhli.v.ID));
278 }
279
280 /*
281 * Make sure we have unique listening attributes
282 */
283 if (atm_cm_match(&attr, NULL) != NULL)
284 return (EADDRINUSE);
285
286 /*
287 * Looks good, save new attributes
288 */
289 atp->atp_attr = attr;
290
291 return (0);
292 }
293
294
295 /*
296 * Listen for incoming connections
297 *
298 * Called at splnet.
299 *
300 * Arguments:
301 * so pointer to socket
302 * epp pointer to endpoint definition structure
303 *
304 * Returns:
305 * 0 request processed
306 * errno error processing request - reason indicated
307 *
308 */
309 int
310 atm_sock_listen(struct socket *so, Atm_endpoint *epp)
311 {
312 Atm_pcb *atp = sotoatmpcb(so);
313
314 /*
315 * Make sure we're still attached
316 */
317 if (atp == NULL)
318 return (ENOTCONN);
319
320 /*
321 * Start listening for incoming calls
322 */
323 return (atm_cm_listen(epp, atp, &atp->atp_attr, &atp->atp_conn));
324 }
325
326
327 /*
328 * Connect socket to peer
329 *
330 * Called at splnet.
331 *
332 * Arguments:
333 * so pointer to socket
334 * addr pointer to protocol address
335 * epp pointer to endpoint definition structure
336 *
337 * Returns:
338 * 0 request processed
339 * errno error processing request - reason indicated
340 *
341 */
342 int
343 atm_sock_connect(struct socket *so, struct sockaddr *addr, Atm_endpoint *epp)
344 {
345 Atm_pcb *atp = sotoatmpcb(so);
346 struct sockaddr_atm *satm;
347 struct t_atm_sap_addr *sapadr;
348 struct t_atm_sap_layer2 *sapl2;
349 struct t_atm_sap_layer3 *sapl3;
350 struct t_atm_sap_appl *sapapl;
351 int err;
352
353 /*
354 * Make sure we're still attached
355 */
356 if (atp == NULL)
357 return (ENOTCONN);
358
359 /*
360 * Validate requested peer address
361 */
362 satm = (struct sockaddr_atm *)addr;
363 if (satm->satm_family != AF_ATM)
364 return (EAFNOSUPPORT);
365
366 sapadr = &satm->satm_addr.t_atm_sap_addr;
367 if (sapadr->SVE_tag_addr != T_ATM_PRESENT)
368 return (EINVAL);
369 if (sapadr->address_format == T_ATM_ENDSYS_ADDR) {
370 if (sapadr->SVE_tag_selector != T_ATM_PRESENT)
371 return (EINVAL);
372 } else if (sapadr->address_format == T_ATM_E164_ADDR) {
373 if (sapadr->SVE_tag_selector != T_ATM_ABSENT)
374 return (EINVAL);
375 } else if (sapadr->address_format == T_ATM_PVC_ADDR) {
376 if (sapadr->SVE_tag_selector != T_ATM_ABSENT)
377 return (EINVAL);
378 } else
379 return (EINVAL);
380 if (sapadr->address_length > ATM_ADDR_LEN)
381 return (EINVAL);
382
383 sapl2 = &satm->satm_addr.t_atm_sap_layer2;
384 if (sapl2->SVE_tag == T_ATM_PRESENT) {
385 if ((sapl2->ID_type != T_ATM_SIMPLE_ID) &&
386 (sapl2->ID_type != T_ATM_USER_ID))
387 return (EINVAL);
388 } else if (sapl2->SVE_tag != T_ATM_ABSENT)
389 return (EINVAL);
390
391 sapl3 = &satm->satm_addr.t_atm_sap_layer3;
392 if (sapl3->SVE_tag == T_ATM_PRESENT) {
393 if ((sapl3->ID_type != T_ATM_SIMPLE_ID) &&
394 (sapl3->ID_type != T_ATM_IPI_ID) &&
395 (sapl3->ID_type != T_ATM_SNAP_ID) &&
396 (sapl3->ID_type != T_ATM_USER_ID))
397 return (EINVAL);
398 } else if (sapl3->SVE_tag != T_ATM_ABSENT)
399 return (EINVAL);
400
401 sapapl = &satm->satm_addr.t_atm_sap_appl;
402 if (sapapl->SVE_tag == T_ATM_PRESENT) {
403 if ((sapapl->ID_type != T_ATM_ISO_APP_ID) &&
404 (sapapl->ID_type != T_ATM_USER_APP_ID) &&
405 (sapapl->ID_type != T_ATM_VENDOR_APP_ID))
406 return (EINVAL);
407 } else if (sapapl->SVE_tag != T_ATM_ABSENT)
408 return (EINVAL);
409
410 /*
411 * Select an outgoing network interface
412 */
413 if (atp->atp_attr.nif == NULL) {
414 struct atm_pif *pip;
415
416 for (pip = atm_interface_head; pip != NULL;
417 pip = pip->pif_next) {
418 if (pip->pif_nif != NULL) {
419 atp->atp_attr.nif = pip->pif_nif;
420 break;
421 }
422 }
423 if (atp->atp_attr.nif == NULL)
424 return (ENXIO);
425 }
426
427 /*
428 * Set supplied connection attributes
429 */
430 atp->atp_attr.called.tag = T_ATM_PRESENT;
431 KM_COPY(&sapadr->address_format, &atp->atp_attr.called.addr,
432 sizeof(Atm_addr));
433
434 atp->atp_attr.blli.tag_l2 = sapl2->SVE_tag;
435 if (sapl2->SVE_tag == T_ATM_PRESENT) {
436 atp->atp_attr.blli.v.layer_2_protocol.ID_type = sapl2->ID_type;
437 KM_COPY(&sapl2->ID, &atp->atp_attr.blli.v.layer_2_protocol.ID,
438 sizeof(atp->atp_attr.blli.v.layer_2_protocol.ID));
439 }
440
441 atp->atp_attr.blli.tag_l3 = sapl3->SVE_tag;
442 if (sapl3->SVE_tag == T_ATM_PRESENT) {
443 atp->atp_attr.blli.v.layer_3_protocol.ID_type = sapl3->ID_type;
444 KM_COPY(&sapl3->ID, &atp->atp_attr.blli.v.layer_3_protocol.ID,
445 sizeof(atp->atp_attr.blli.v.layer_3_protocol.ID));
446 }
447
448 atp->atp_attr.bhli.tag = sapapl->SVE_tag;
449 if (sapapl->SVE_tag == T_ATM_PRESENT) {
450 atp->atp_attr.bhli.v.ID_type = sapapl->ID_type;
451 KM_COPY(&sapapl->ID, &atp->atp_attr.bhli.v.ID,
452 sizeof(atp->atp_attr.bhli.v.ID));
453 }
454
455 /*
456 * We're finally ready to initiate the ATM connection
457 */
458 soisconnecting(so);
459 atm_sock_stat.as_connreq[atp->atp_type]++;
460 err = atm_cm_connect(epp, atp, &atp->atp_attr, &atp->atp_conn);
461 if (err == 0) {
462 /*
463 * Connection is setup
464 */
465 atm_sock_stat.as_conncomp[atp->atp_type]++;
466 soisconnected(so);
467
468 } else if (err == EINPROGRESS) {
469 /*
470 * We've got to wait for a connected event
471 */
472 err = 0;
473
474 } else {
475 /*
476 * Call failed...
477 */
478 atm_sock_stat.as_connfail[atp->atp_type]++;
479 soisdisconnected(so);
480 }
481
482 return (err);
483 }
484
485
486 /*
487 * Disconnect connected socket
488 *
489 * Called at splnet.
490 *
491 * Arguments:
492 * so pointer to socket
493 *
494 * Returns:
495 * 0 request processed
496 * errno error processing request - reason indicated
497 *
498 */
499 int
500 atm_sock_disconnect(struct socket *so)
501 {
502 Atm_pcb *atp = sotoatmpcb(so);
503 struct t_atm_cause *cause;
504 int err;
505
506 /*
507 * Make sure we're still attached
508 */
509 if (atp == NULL)
510 return (ENOTCONN);
511
512 /*
513 * Release the ATM connection
514 */
515 if (atp->atp_conn) {
516 if (atp->atp_attr.cause.tag == T_ATM_PRESENT)
517 cause = &atp->atp_attr.cause.v;
518 else
519 cause = &atm_sock_cause;
520 err = atm_cm_release(atp->atp_conn, cause);
521 if (err)
522 log(LOG_ERR, "atm_sock_disconnect: release fail (%d)\n",
523 err);
524 atm_sock_stat.as_connrel[atp->atp_type]++;
525 atp->atp_conn = NULL;
526 }
527
528 soisdisconnected(so);
529
530 return (0);
531 }
532
533
534 /*
535 * Retrieve local socket address
536 *
537 * Called at splnet.
538 *
539 * Arguments:
540 * so pointer to socket
541 * addr pointer to pointer to contain protocol address
542 *
543 * Returns:
544 * 0 request processed
545 * errno error processing request - reason indicated
546 *
547 */
548 int
549 atm_sock_sockaddr(struct socket *so, struct sockaddr **addr)
550 {
551 struct sockaddr_atm *satm;
552 struct t_atm_sap_addr *saddr;
553 Atm_pcb *atp = sotoatmpcb(so);
554
555 /*
556 * Return local interface address, if known
557 */
558 satm = KM_ALLOC(sizeof *satm, M_SONAME, M_WAITOK);
559
560 KM_ZERO(satm, sizeof(*satm));
561 satm->satm_family = AF_ATM;
562 satm->satm_len = sizeof(*satm);
563
564 saddr = &satm->satm_addr.t_atm_sap_addr;
565 if (atp->atp_attr.nif && atp->atp_attr.nif->nif_pif->pif_siginst) {
566 saddr->SVE_tag_addr = T_ATM_PRESENT;
567 ATM_ADDR_SEL_COPY(
568 &atp->atp_attr.nif->nif_pif->pif_siginst->si_addr,
569 atp->atp_attr.nif->nif_sel, saddr);
570 if (saddr->address_format == T_ATM_ENDSYS_ADDR)
571 saddr->SVE_tag_selector = T_ATM_PRESENT;
572 else
573 saddr->SVE_tag_selector = T_ATM_ABSENT;
574 } else {
575 saddr->SVE_tag_addr = T_ATM_ABSENT;
576 saddr->SVE_tag_selector = T_ATM_ABSENT;
577 saddr->address_format = T_ATM_ABSENT;
578 }
579 satm->satm_addr.t_atm_sap_layer2.SVE_tag = T_ATM_ABSENT;
580 satm->satm_addr.t_atm_sap_layer3.SVE_tag = T_ATM_ABSENT;
581 satm->satm_addr.t_atm_sap_appl.SVE_tag = T_ATM_ABSENT;
582
583 *addr = (struct sockaddr *)satm;
584 return (0);
585 }
586
587
588 /*
589 * Retrieve peer socket address
590 *
591 * Called at splnet.
592 *
593 * Arguments:
594 * so pointer to socket
595 * addr pointer to pointer to contain protocol address
596 *
597 * Returns:
598 * 0 request processed
599 * errno error processing request - reason indicated
600 *
601 */
602 int
603 atm_sock_peeraddr(struct socket *so, struct sockaddr **addr)
604 {
605 struct sockaddr_atm *satm;
606 struct t_atm_sap_addr *saddr;
607 Atm_pcb *atp = sotoatmpcb(so);
608 Atm_connvc *cvp;
609
610 /*
611 * Return remote address, if known
612 */
613 satm = KM_ALLOC(sizeof *satm, M_SONAME, M_WAITOK);
614
615 KM_ZERO(satm, sizeof(*satm));
616 satm->satm_family = AF_ATM;
617 satm->satm_len = sizeof(*satm);
618
619 saddr = &satm->satm_addr.t_atm_sap_addr;
620 if (so->so_state & SS_ISCONNECTED) {
621 cvp = atp->atp_conn->co_connvc;
622 saddr->SVE_tag_addr = T_ATM_PRESENT;
623 if (cvp->cvc_flags & CVCF_CALLER) {
624 ATM_ADDR_COPY(&cvp->cvc_attr.called.addr, saddr);
625 } else {
626 if (cvp->cvc_attr.calling.tag == T_ATM_PRESENT) {
627 ATM_ADDR_COPY(&cvp->cvc_attr.calling.addr,
628 saddr);
629 } else {
630 saddr->SVE_tag_addr = T_ATM_ABSENT;
631 saddr->address_format = T_ATM_ABSENT;
632 }
633 }
634 if (saddr->address_format == T_ATM_ENDSYS_ADDR)
635 saddr->SVE_tag_selector = T_ATM_PRESENT;
636 else
637 saddr->SVE_tag_selector = T_ATM_ABSENT;
638 } else {
639 saddr->SVE_tag_addr = T_ATM_ABSENT;
640 saddr->SVE_tag_selector = T_ATM_ABSENT;
641 saddr->address_format = T_ATM_ABSENT;
642 }
643 satm->satm_addr.t_atm_sap_layer2.SVE_tag = T_ATM_ABSENT;
644 satm->satm_addr.t_atm_sap_layer3.SVE_tag = T_ATM_ABSENT;
645 satm->satm_addr.t_atm_sap_appl.SVE_tag = T_ATM_ABSENT;
646
647 *addr = (struct sockaddr *)satm;
648 return (0);
649 }
650
651
652 /*
653 * Common setsockopt processing
654 *
655 * Called at splnet.
656 *
657 * Arguments:
658 * so pointer to socket
659 * sopt pointer to socket option info
660 * atp pointer to ATM PCB
661 *
662 * Returns:
663 * 0 request processed
664 * errno error processing request - reason indicated
665 *
666 */
667 int
668 atm_sock_setopt(struct socket *so, struct sockopt *sopt, Atm_pcb *atp)
669 {
670 int err = 0;
671 union {
672 struct t_atm_aal5 aal5;
673 struct t_atm_traffic trf;
674 struct t_atm_bearer brr;
675 struct t_atm_bhli bhl;
676 struct t_atm_blli bll;
677 Atm_addr addr;
678 struct t_atm_cause cau;
679 struct t_atm_qos qos;
680 struct t_atm_transit trn;
681 struct t_atm_net_intf nif;
682 struct t_atm_llc llc;
683 struct t_atm_app_name appn;
684 } p;
685
686 #define MAXVAL(bits) ((1 << bits) - 1)
687 #define MAXMASK(bits) (~MAXVAL(bits))
688
689 switch (sopt->sopt_name) {
690
691 case T_ATM_AAL5:
692 err = soopt_to_kbuf(sopt, &p.aal5, sizeof p.aal5, sizeof p.aal5);
693 if (err)
694 break;
695 if ((p.aal5.forward_max_SDU_size != T_ATM_ABSENT) &&
696 (p.aal5.forward_max_SDU_size & MAXMASK(16)))
697 return (EINVAL);
698 if ((p.aal5.backward_max_SDU_size != T_ATM_ABSENT) &&
699 (p.aal5.backward_max_SDU_size & MAXMASK(16)))
700 return (EINVAL);
701 if ((p.aal5.SSCS_type != T_ATM_ABSENT) &&
702 (p.aal5.SSCS_type != T_ATM_NULL) &&
703 (p.aal5.SSCS_type != T_ATM_SSCS_SSCOP_REL) &&
704 (p.aal5.SSCS_type != T_ATM_SSCS_SSCOP_UNREL) &&
705 (p.aal5.SSCS_type != T_ATM_SSCS_FR))
706 return (EINVAL);
707
708 if ((p.aal5.forward_max_SDU_size == T_ATM_ABSENT) &&
709 (p.aal5.backward_max_SDU_size == T_ATM_ABSENT) &&
710 (p.aal5.SSCS_type == T_ATM_ABSENT))
711 atp->atp_attr.aal.tag = T_ATM_ABSENT;
712 else {
713 atp->atp_attr.aal.tag = T_ATM_PRESENT;
714 atp->atp_attr.aal.type = ATM_AAL5;
715 atp->atp_attr.aal.v.aal5 = p.aal5;
716 }
717 break;
718
719 case T_ATM_TRAFFIC:
720 err = soopt_to_kbuf(sopt, &p.trf, sizeof p.trf, sizeof p.trf);
721 if (err)
722 break;
723 if ((p.trf.forward.PCR_high_priority != T_ATM_ABSENT) &&
724 (p.trf.forward.PCR_high_priority & MAXMASK(24)))
725 return (EINVAL);
726 if (p.trf.forward.PCR_all_traffic & MAXMASK(24))
727 return (EINVAL);
728 if ((p.trf.forward.SCR_high_priority != T_ATM_ABSENT) &&
729 (p.trf.forward.SCR_high_priority & MAXMASK(24)))
730 return (EINVAL);
731 if ((p.trf.forward.SCR_all_traffic != T_ATM_ABSENT) &&
732 (p.trf.forward.SCR_all_traffic & MAXMASK(24)))
733 return (EINVAL);
734 if ((p.trf.forward.MBS_high_priority != T_ATM_ABSENT) &&
735 (p.trf.forward.MBS_high_priority & MAXMASK(24)))
736 return (EINVAL);
737 if ((p.trf.forward.MBS_all_traffic != T_ATM_ABSENT) &&
738 (p.trf.forward.MBS_all_traffic & MAXMASK(24)))
739 return (EINVAL);
740 if ((p.trf.forward.tagging != T_YES) &&
741 (p.trf.forward.tagging != T_NO))
742 return (EINVAL);
743
744 if ((p.trf.backward.PCR_high_priority != T_ATM_ABSENT) &&
745 (p.trf.backward.PCR_high_priority & MAXMASK(24)))
746 return (EINVAL);
747 if (p.trf.backward.PCR_all_traffic & MAXMASK(24))
748 return (EINVAL);
749 if ((p.trf.backward.SCR_high_priority != T_ATM_ABSENT) &&
750 (p.trf.backward.SCR_high_priority & MAXMASK(24)))
751 return (EINVAL);
752 if ((p.trf.backward.SCR_all_traffic != T_ATM_ABSENT) &&
753 (p.trf.backward.SCR_all_traffic & MAXMASK(24)))
754 return (EINVAL);
755 if ((p.trf.backward.MBS_high_priority != T_ATM_ABSENT) &&
756 (p.trf.backward.MBS_high_priority & MAXMASK(24)))
757 return (EINVAL);
758 if ((p.trf.backward.MBS_all_traffic != T_ATM_ABSENT) &&
759 (p.trf.backward.MBS_all_traffic & MAXMASK(24)))
760 return (EINVAL);
761 if ((p.trf.backward.tagging != T_YES) &&
762 (p.trf.backward.tagging != T_NO))
763 return (EINVAL);
764 if ((p.trf.best_effort != T_YES) &&
765 (p.trf.best_effort != T_NO))
766 return (EINVAL);
767
768 atp->atp_attr.traffic.tag = T_ATM_PRESENT;
769 atp->atp_attr.traffic.v = p.trf;
770 break;
771
772 case T_ATM_BEARER_CAP:
773 err = soopt_to_kbuf(sopt, &p.brr, sizeof p.brr, sizeof p.brr);
774 if (err)
775 break;
776 if ((p.brr.bearer_class != T_ATM_CLASS_A) &&
777 (p.brr.bearer_class != T_ATM_CLASS_C) &&
778 (p.brr.bearer_class != T_ATM_CLASS_X))
779 return (EINVAL);
780 if ((p.brr.traffic_type != T_ATM_NULL) &&
781 (p.brr.traffic_type != T_ATM_CBR) &&
782 (p.brr.traffic_type != T_ATM_VBR))
783 return (EINVAL);
784 if ((p.brr.timing_requirements != T_ATM_NULL) &&
785 (p.brr.timing_requirements != T_ATM_END_TO_END) &&
786 (p.brr.timing_requirements != T_ATM_NO_END_TO_END))
787 return (EINVAL);
788 if ((p.brr.clipping_susceptibility != T_NO) &&
789 (p.brr.clipping_susceptibility != T_YES))
790 return (EINVAL);
791 if ((p.brr.connection_configuration != T_ATM_1_TO_1) &&
792 (p.brr.connection_configuration != T_ATM_1_TO_MANY))
793 return (EINVAL);
794
795 atp->atp_attr.bearer.tag = T_ATM_PRESENT;
796 atp->atp_attr.bearer.v = p.brr;
797 break;
798
799 case T_ATM_BHLI:
800 err = soopt_to_kbuf(sopt, &p.bhl, sizeof p.bhl, sizeof p.bhl);
801 if (err)
802 break;
803 if ((p.bhl.ID_type != T_ATM_ABSENT) &&
804 (p.bhl.ID_type != T_ATM_ISO_APP_ID) &&
805 (p.bhl.ID_type != T_ATM_USER_APP_ID) &&
806 (p.bhl.ID_type != T_ATM_VENDOR_APP_ID))
807 return (EINVAL);
808
809 if (p.bhl.ID_type == T_ATM_ABSENT)
810 atp->atp_attr.bhli.tag = T_ATM_ABSENT;
811 else {
812 atp->atp_attr.bhli.tag = T_ATM_PRESENT;
813 atp->atp_attr.bhli.v = p.bhl;
814 }
815 break;
816
817 case T_ATM_BLLI:
818 err = soopt_to_kbuf(sopt, &p.bll, sizeof p.bll, sizeof p.bll);
819 if (err)
820 break;
821 if ((p.bll.layer_2_protocol.ID_type != T_ATM_ABSENT) &&
822 (p.bll.layer_2_protocol.ID_type != T_ATM_SIMPLE_ID) &&
823 (p.bll.layer_2_protocol.ID_type != T_ATM_USER_ID))
824 return (EINVAL);
825 if ((p.bll.layer_2_protocol.mode != T_ATM_ABSENT) &&
826 (p.bll.layer_2_protocol.mode != T_ATM_BLLI_NORMAL_MODE) &&
827 (p.bll.layer_2_protocol.mode != T_ATM_BLLI_EXTENDED_MODE))
828 return (EINVAL);
829 if ((p.bll.layer_2_protocol.window_size != T_ATM_ABSENT) &&
830 (p.bll.layer_2_protocol.window_size < 1))
831 return (EINVAL);
832
833 if ((p.bll.layer_3_protocol.ID_type != T_ATM_ABSENT) &&
834 (p.bll.layer_3_protocol.ID_type != T_ATM_SIMPLE_ID) &&
835 (p.bll.layer_3_protocol.ID_type != T_ATM_IPI_ID) &&
836 (p.bll.layer_3_protocol.ID_type != T_ATM_SNAP_ID) &&
837 (p.bll.layer_3_protocol.ID_type != T_ATM_USER_ID))
838 return (EINVAL);
839 if ((p.bll.layer_3_protocol.mode != T_ATM_ABSENT) &&
840 (p.bll.layer_3_protocol.mode != T_ATM_BLLI_NORMAL_MODE) &&
841 (p.bll.layer_3_protocol.mode != T_ATM_BLLI_EXTENDED_MODE))
842 return (EINVAL);
843 if ((p.bll.layer_3_protocol.packet_size != T_ATM_ABSENT) &&
844 (p.bll.layer_3_protocol.packet_size & MAXMASK(4)))
845 return (EINVAL);
846 if ((p.bll.layer_3_protocol.window_size != T_ATM_ABSENT) &&
847 (p.bll.layer_3_protocol.window_size < 1))
848 return (EINVAL);
849
850 if (p.bll.layer_2_protocol.ID_type == T_ATM_ABSENT)
851 atp->atp_attr.blli.tag_l2 = T_ATM_ABSENT;
852 else
853 atp->atp_attr.blli.tag_l2 = T_ATM_PRESENT;
854
855 if (p.bll.layer_3_protocol.ID_type == T_ATM_ABSENT)
856 atp->atp_attr.blli.tag_l3 = T_ATM_ABSENT;
857 else
858 atp->atp_attr.blli.tag_l3 = T_ATM_PRESENT;
859
860 if ((atp->atp_attr.blli.tag_l2 == T_ATM_PRESENT) ||
861 (atp->atp_attr.blli.tag_l3 == T_ATM_PRESENT))
862 atp->atp_attr.blli.v = p.bll;
863 break;
864
865 case T_ATM_DEST_ADDR:
866 err = soopt_to_kbuf(sopt, &p.addr, sizeof p.addr, sizeof p.addr);
867 if (err)
868 break;
869 if ((p.addr.address_format != T_ATM_ENDSYS_ADDR) &&
870 (p.addr.address_format != T_ATM_E164_ADDR))
871 return (EINVAL);
872 if (p.addr.address_length > ATM_ADDR_LEN)
873 return (EINVAL);
874
875 atp->atp_attr.called.tag = T_ATM_PRESENT;
876 atp->atp_attr.called.addr = p.addr;
877 break;
878
879 case T_ATM_DEST_SUB:
880 err = soopt_to_kbuf(sopt, &p.addr, sizeof p.addr, sizeof p.addr);
881 if (err)
882 break;
883 if ((p.addr.address_format != T_ATM_ABSENT) &&
884 (p.addr.address_format != T_ATM_NSAP_ADDR))
885 return (EINVAL);
886 if (p.addr.address_length > ATM_ADDR_LEN)
887 return (EINVAL);
888
889 /* T_ATM_DEST_ADDR controls tag */
890 atp->atp_attr.called.subaddr = p.addr;
891 break;
892
893 case T_ATM_ORIG_ADDR:
894 return (EACCES);
895
896 case T_ATM_ORIG_SUB:
897 return (EACCES);
898
899 case T_ATM_CALLER_ID:
900 return (EACCES);
901
902 case T_ATM_CAUSE:
903 err = soopt_to_kbuf(sopt, &p.cau, sizeof p.cau, sizeof p.cau);
904 if (err)
905 break;
906 if ((p.cau.coding_standard != T_ATM_ABSENT) &&
907 (p.cau.coding_standard != T_ATM_ITU_CODING) &&
908 (p.cau.coding_standard != T_ATM_NETWORK_CODING))
909 return (EINVAL);
910 if ((p.cau.location != T_ATM_LOC_USER) &&
911 (p.cau.location != T_ATM_LOC_LOCAL_PRIVATE_NET) &&
912 (p.cau.location != T_ATM_LOC_LOCAL_PUBLIC_NET) &&
913 (p.cau.location != T_ATM_LOC_TRANSIT_NET) &&
914 (p.cau.location != T_ATM_LOC_REMOTE_PUBLIC_NET) &&
915 (p.cau.location != T_ATM_LOC_REMOTE_PRIVATE_NET) &&
916 (p.cau.location != T_ATM_LOC_INTERNATIONAL_NET) &&
917 (p.cau.location != T_ATM_LOC_BEYOND_INTERWORKING))
918 return (EINVAL);
919
920 if (p.cau.coding_standard == T_ATM_ABSENT)
921 atp->atp_attr.cause.tag = T_ATM_ABSENT;
922 else {
923 atp->atp_attr.cause.tag = T_ATM_PRESENT;
924 atp->atp_attr.cause.v = p.cau;
925 }
926 break;
927
928 case T_ATM_QOS:
929 err = soopt_to_kbuf(sopt, &p.qos, sizeof p.qos, sizeof p.qos);
930 if (err)
931 break;
932 if ((p.qos.coding_standard != T_ATM_ABSENT) &&
933 (p.qos.coding_standard != T_ATM_ITU_CODING) &&
934 (p.qos.coding_standard != T_ATM_NETWORK_CODING))
935 return (EINVAL);
936 if ((p.qos.forward.qos_class != T_ATM_QOS_CLASS_0) &&
937 (p.qos.forward.qos_class != T_ATM_QOS_CLASS_1) &&
938 (p.qos.forward.qos_class != T_ATM_QOS_CLASS_2) &&
939 (p.qos.forward.qos_class != T_ATM_QOS_CLASS_3) &&
940 (p.qos.forward.qos_class != T_ATM_QOS_CLASS_4))
941 return (EINVAL);
942 if ((p.qos.backward.qos_class != T_ATM_QOS_CLASS_0) &&
943 (p.qos.backward.qos_class != T_ATM_QOS_CLASS_1) &&
944 (p.qos.backward.qos_class != T_ATM_QOS_CLASS_2) &&
945 (p.qos.backward.qos_class != T_ATM_QOS_CLASS_3) &&
946 (p.qos.backward.qos_class != T_ATM_QOS_CLASS_4))
947 return (EINVAL);
948
949 if (p.qos.coding_standard == T_ATM_ABSENT)
950 atp->atp_attr.qos.tag = T_ATM_ABSENT;
951 else {
952 atp->atp_attr.qos.tag = T_ATM_PRESENT;
953 atp->atp_attr.qos.v = p.qos;
954 }
955 break;
956
957 case T_ATM_TRANSIT:
958 err = soopt_to_kbuf(sopt, &p.trn, sizeof p.trn, sizeof p.trn);
959 if (err)
960 break;
961 if (p.trn.length > T_ATM_MAX_NET_ID)
962 return (EINVAL);
963
964 if (p.trn.length == 0)
965 atp->atp_attr.transit.tag = T_ATM_ABSENT;
966 else {
967 atp->atp_attr.transit.tag = T_ATM_PRESENT;
968 atp->atp_attr.transit.v = p.trn;
969 }
970 break;
971
972 case T_ATM_ADD_LEAF:
973 return (EPROTONOSUPPORT); /* XXX */
974
975 case T_ATM_DROP_LEAF:
976 return (EPROTONOSUPPORT); /* XXX */
977
978 case T_ATM_NET_INTF:
979 err = soopt_to_kbuf(sopt, &p.nif, sizeof p.nif, sizeof p.nif);
980 if (err)
981 break;
982
983 atp->atp_attr.nif = atm_nifname(p.nif.net_intf);
984 if (atp->atp_attr.nif == NULL)
985 return (ENXIO);
986 break;
987
988 case T_ATM_LLC:
989 err = soopt_to_kbuf(sopt, &p.llc, sizeof p.llc, sizeof p.llc);
990 if (err)
991 break;
992 if ((p.llc.llc_len < T_ATM_LLC_MIN_LEN) ||
993 (p.llc.llc_len > T_ATM_LLC_MAX_LEN))
994 return (EINVAL);
995
996 atp->atp_attr.llc.tag = T_ATM_PRESENT;
997 atp->atp_attr.llc.v = p.llc;
998 break;
999
1000 case T_ATM_APP_NAME:
1001 err = soopt_to_kbuf(sopt, &p.appn, sizeof p.appn, sizeof p.appn);
1002 if (err)
1003 break;
1004
1005 strncpy(atp->atp_name, p.appn.app_name, T_ATM_APP_NAME_LEN);
1006 break;
1007
1008 default:
1009 return (ENOPROTOOPT);
1010 }
1011
1012 return (err);
1013 }
1014
1015
1016 /*
1017 * Common getsockopt processing
1018 *
1019 * Called at splnet.
1020 *
1021 * Arguments:
1022 * so pointer to socket
1023 * sopt pointer to socket option info
1024 * atp pointer to ATM PCB
1025 *
1026 * Returns:
1027 * 0 request processed
1028 * errno error processing request - reason indicated
1029 *
1030 */
1031 int
1032 atm_sock_getopt(struct socket *so, struct sockopt *sopt, Atm_pcb *atp)
1033 {
1034 Atm_attributes *ap;
1035
1036 /*
1037 * If socket is connected, return attributes for the VCC in use,
1038 * otherwise just return what the user has setup so far.
1039 */
1040 if (so->so_state & SS_ISCONNECTED)
1041 ap = &atp->atp_conn->co_connvc->cvc_attr;
1042 else
1043 ap = &atp->atp_attr;
1044
1045 switch (sopt->sopt_name) {
1046
1047 case T_ATM_AAL5:
1048 if ((ap->aal.tag == T_ATM_PRESENT) &&
1049 (ap->aal.type == ATM_AAL5)) {
1050 soopt_from_kbuf(sopt, &ap->aal.v.aal5,
1051 sizeof ap->aal.v.aal5);
1052 return 0;
1053 } else {
1054 return (ENOENT);
1055 }
1056 break;
1057
1058 case T_ATM_TRAFFIC:
1059 if (ap->traffic.tag == T_ATM_PRESENT) {
1060 soopt_from_kbuf(sopt, &ap->traffic.v,
1061 sizeof ap->traffic.v);
1062 return 0;
1063 } else {
1064 return (ENOENT);
1065 }
1066 break;
1067
1068 case T_ATM_BEARER_CAP:
1069 if (ap->bearer.tag == T_ATM_PRESENT) {
1070 soopt_from_kbuf(sopt, &ap->bearer.v,
1071 sizeof ap->bearer.v);
1072 return 0;
1073 } else {
1074 return (ENOENT);
1075 }
1076 break;
1077
1078 case T_ATM_BHLI:
1079 if (ap->bhli.tag == T_ATM_PRESENT) {
1080 soopt_from_kbuf(sopt, &ap->bhli.v,
1081 sizeof ap->bhli.v);
1082 return 0;
1083 } else {
1084 return (ENOENT);
1085 }
1086 break;
1087
1088 case T_ATM_BLLI:
1089 if ((ap->blli.tag_l2 == T_ATM_PRESENT) ||
1090 (ap->blli.tag_l3 == T_ATM_PRESENT)) {
1091 soopt_from_kbuf(sopt, &ap->blli.v,
1092 sizeof ap->blli.v);
1093 return 0;
1094 } else {
1095 return (ENOENT);
1096 }
1097 break;
1098
1099 case T_ATM_DEST_ADDR:
1100 if (ap->called.tag == T_ATM_PRESENT) {
1101 soopt_from_kbuf(sopt, &ap->called.addr,
1102 sizeof ap->called.addr);
1103 return 0;
1104 } else {
1105 return (ENOENT);
1106 }
1107 break;
1108
1109 case T_ATM_DEST_SUB:
1110 if (ap->called.tag == T_ATM_PRESENT) {
1111 soopt_from_kbuf(sopt, &ap->called.subaddr,
1112 sizeof ap->called.subaddr);
1113 return 0;
1114 } else {
1115 return (ENOENT);
1116 }
1117 break;
1118
1119 case T_ATM_ORIG_ADDR:
1120 if (ap->calling.tag == T_ATM_PRESENT) {
1121 soopt_from_kbuf(sopt, &ap->calling.addr,
1122 sizeof ap->calling.addr);
1123 return 0;
1124 } else {
1125 return (ENOENT);
1126 }
1127 break;
1128
1129 case T_ATM_ORIG_SUB:
1130 if (ap->calling.tag == T_ATM_PRESENT) {
1131 soopt_from_kbuf(sopt, &ap->calling.subaddr,
1132 sizeof ap->calling.subaddr);
1133 return 0;
1134 } else {
1135 return (ENOENT);
1136 }
1137 break;
1138
1139 case T_ATM_CALLER_ID:
1140 if (ap->calling.tag == T_ATM_PRESENT) {
1141 soopt_from_kbuf(sopt, &ap->calling.cid,
1142 sizeof ap->calling.cid);
1143 return 0;
1144 } else {
1145 return (ENOENT);
1146 }
1147 break;
1148
1149 case T_ATM_CAUSE:
1150 if (ap->cause.tag == T_ATM_PRESENT) {
1151 soopt_from_kbuf(sopt, &ap->cause.v,
1152 sizeof ap->cause.v);
1153 return 0;
1154 } else {
1155 return (ENOENT);
1156 }
1157 break;
1158
1159 case T_ATM_QOS:
1160 if (ap->qos.tag == T_ATM_PRESENT) {
1161 soopt_from_kbuf(sopt, &ap->qos.v,
1162 sizeof ap->qos.v);
1163 return 0;
1164 } else {
1165 return (ENOENT);
1166 }
1167 break;
1168
1169 case T_ATM_TRANSIT:
1170 if (ap->transit.tag == T_ATM_PRESENT) {
1171 soopt_from_kbuf(sopt, &ap->transit.v,
1172 sizeof ap->transit.v);
1173 return 0;
1174 } else {
1175 return (ENOENT);
1176 }
1177 break;
1178
1179 case T_ATM_LEAF_IND:
1180 return (EPROTONOSUPPORT); /* XXX */
1181
1182 case T_ATM_NET_INTF:
1183 if (ap->nif) {
1184 struct t_atm_net_intf netif;
1185 struct ifnet *ifp;
1186
1187 ifp = &ap->nif->nif_if;
1188 ksnprintf(netif.net_intf, sizeof(netif.net_intf),
1189 "%s", ifp->if_xname);
1190 soopt_from_kbuf(sopt, &netif,
1191 sizeof netif);
1192 return 0;
1193 } else {
1194 return (ENOENT);
1195 }
1196 break;
1197
1198 case T_ATM_LLC:
1199 if (ap->llc.tag == T_ATM_PRESENT) {
1200 soopt_from_kbuf(sopt, &ap->llc.v,
1201 sizeof ap->llc.v);
1202 return 0;
1203 } else {
1204 return (ENOENT);
1205 }
1206 break;
1207
1208 default:
1209 return (ENOPROTOOPT);
1210 }
1211
1212 return (0);
1213 }
1214
1215
1216 /*
1217 * Process Socket VCC Connected Notification
1218 *
1219 * Arguments:
1220 * toku owner's connection token (atm_pcb protocol block)
1221 *
1222 * Returns:
1223 * none
1224 *
1225 */
1226 void
1227 atm_sock_connected(void *toku)
1228 {
1229 Atm_pcb *atp = (Atm_pcb *)toku;
1230
1231 /*
1232 * Connection is setup
1233 */
1234 atm_sock_stat.as_conncomp[atp->atp_type]++;
1235 soisconnected(atp->atp_socket);
1236 }
1237
1238
1239 /*
1240 * Process Socket VCC Cleared Notification
1241 *
1242 * Arguments:
1243 * toku owner's connection token (atm_pcb protocol block)
1244 * cause pointer to cause code
1245 *
1246 * Returns:
1247 * none
1248 *
1249 */
1250 void
1251 atm_sock_cleared(void *toku, struct t_atm_cause *cause)
1252 {
1253 Atm_pcb *atp = (Atm_pcb *)toku;
1254 struct socket *so;
1255
1256 so = atp->atp_socket;
1257
1258 /*
1259 * Save call clearing cause
1260 */
1261 atp->atp_attr.cause.tag = T_ATM_PRESENT;
1262 atp->atp_attr.cause.v = *cause;
1263
1264 /*
1265 * Set user error code
1266 */
1267 if (so->so_state & SS_ISCONNECTED) {
1268 so->so_error = ECONNRESET;
1269 atm_sock_stat.as_connclr[atp->atp_type]++;
1270 } else {
1271 so->so_error = ECONNREFUSED;
1272 atm_sock_stat.as_connfail[atp->atp_type]++;
1273 }
1274
1275 /*
1276 * Connection is gone
1277 */
1278 atp->atp_conn = NULL;
1279 soisdisconnected(so);
1280
1281 /*
1282 * Cleanup failed incoming connection setup
1283 */
1284 if (so->so_state & SS_NOFDREF) {
1285 atm_sock_detach(so);
1286 }
1287 }
1288
DragonFly BSD