sys/netinet/sctp_asconf.c

   1 /*      $KAME: sctp_asconf.c,v 1.23 2004/08/17 06:28:01 t-momose Exp $  */
   2
   3 /*
   4  * Copyright (c) 2001, 2002, 2003, 2004 Cisco Systems, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the project nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY CISCO SYSTEMS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL CISCO SYSTEMS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31 #if !(defined(__OpenBSD__) || defined(__APPLE__))
  32 #include "opt_ipsec.h"
  33 #endif
  34 #if defined(__FreeBSD__)
  35 #include "opt_compat.h"
  36 #include "opt_inet6.h"
  37 #include "opt_inet.h"
  38 #endif
  39 #if defined(__NetBSD__)
  40 #include "opt_inet.h"
  41 #endif
  42
  43 #ifdef __APPLE__
  44 #include <sctp.h>
  45 #elif !defined(__OpenBSD__)
  46 #include "opt_sctp.h"
  47 #endif
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/malloc.h>
  52 #include <sys/mbuf.h>
  53 #include <sys/socket.h>
  54 #include <sys/socketvar.h>
  55 #include <sys/kernel.h>
  56 #include <sys/sysctl.h>
  57 #include <sys/thread2.h>
  58
  59 #include <net/if.h>
  60 #include <net/if_types.h>
  61 #include <net/route.h>
  62
  63 #include <netinet/in.h>
  64 #include <netinet/in_systm.h>
  65 #include <netinet/ip.h>
  66 #include <netinet/in_pcb.h>
  67 #include <netinet/in_var.h>
  68 #include <netinet/ip_var.h>
  69
  70 #ifdef INET6
  71 #include <netinet/ip6.h>
  72 #include <netinet6/ip6_var.h>
  73 #if defined(__FreeBSD__) || (__NetBSD__)
  74 #include <netinet6/in6_pcb.h>
  75 #elif defined(__OpenBSD__)
  76 #include <netinet/in_pcb.h>
  77 #endif
  78 #include <netinet/icmp6.h>
  79 #include <netinet6/nd6.h>
  80 #endif /* INET6 */
  81
  82 #include <netinet/in_pcb.h>
  83
  84 #include <netinet/sctp_var.h>
  85 #include <netinet/sctp_pcb.h>
  86 #include <netinet/sctp_header.h>
  87 #include <netinet/sctputil.h>
  88 #include <netinet/sctp_output.h>
  89 #include <netinet/sctp_asconf.h>
  90
  91 /*
  92  * debug flags:
  93  *   SCTP_DEBUG_ASCONF1: protocol info, general info and errors
  94  *   SCTP_DEBUG_ASCONF2: detailed info
  95  */
  96 #ifdef SCTP_DEBUG
  97 extern u_int32_t sctp_debug_on;
  98
  99 #if defined(SCTP_BASE_FREEBSD) || defined(__APPLE__)
 100 #define strlcpy strncpy
 101 #endif
 102 #endif /* SCTP_DEBUG */
 103
 104 /*
 105  * draft-ietf-tsvwg-addip-sctp
 106  *
 107  * Address management only currently supported
 108  * For the bound all case:
 109  *      the asoc local addr list is always a "DO NOT USE" list
 110  * For the subset bound case:
 111  *      If ASCONFs are allowed:
 112  *              the endpoint local addr list is the usable address list
 113  *              the asoc local addr list is the "DO NOT USE" list
 114  *      If ASCONFs are not allowed:
 115  *              the endpoint local addr list is the default usable list
 116  *              the asoc local addr list is the usable address list
 117  *
 118  * An ASCONF parameter queue exists per asoc which holds the pending
 119  * address operations.  Lists are updated upon receipt of ASCONF-ACK.
 120  *
 121  * Deleted addresses are always immediately removed from the lists as
 122  * they will (shortly) no longer exist in the kernel.  We send ASCONFs
 123  * as a courtesy, only if allowed.
 124  */
 125
 126 /*
 127  * ASCONF parameter processing
 128  * response_required: set if a reply is required (eg. SUCCESS_REPORT)
 129  * returns a mbuf to an "error" response parameter or NULL/"success" if ok
 130  * FIX: allocating this many mbufs on the fly is pretty inefficient...
 131  */
 132
 133 static struct mbuf *
 134 sctp_asconf_success_response(uint32_t id)
 135 {
 136         struct mbuf *m_reply = NULL;
 137         struct sctp_asconf_paramhdr *aph;
 138
 139         MGET(m_reply, MB_DONTWAIT, MT_DATA);
 140         if (m_reply == NULL) {
 141 #ifdef SCTP_DEBUG
 142                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 143                         kprintf("asconf_success_response: couldn't get mbuf!\n");
 144                 }
 145 #endif /* SCTP_DEBUG */
 146                 return NULL;
 147         }
 148         aph = mtod(m_reply, struct sctp_asconf_paramhdr *);
 149         aph->correlation_id = id;
 150         aph->ph.param_type = htons(SCTP_SUCCESS_REPORT);
 151         aph->ph.param_length = sizeof(struct sctp_asconf_paramhdr);
 152         m_reply->m_len = aph->ph.param_length;
 153         aph->ph.param_length = htons(aph->ph.param_length);
 154
 155         return m_reply;
 156 }
 157
 158 static struct mbuf *
 159 sctp_asconf_error_response(uint32_t id, uint16_t cause, uint8_t *error_tlv,
 160     uint16_t tlv_length)
 161 {
 162         struct mbuf *m_reply = NULL;
 163         struct sctp_asconf_paramhdr *aph;
 164         struct sctp_error_cause *error;
 165         uint8_t *tlv;
 166
 167         MGET(m_reply, MB_DONTWAIT, MT_DATA);
 168         if (m_reply == NULL) {
 169 #ifdef SCTP_DEBUG
 170                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 171                         kprintf("asconf_error_response: couldn't get mbuf!\n");
 172                 }
 173 #endif /* SCTP_DEBUG */
 174                 return NULL;
 175         }
 176         aph = mtod(m_reply, struct sctp_asconf_paramhdr *);
 177         error = (struct sctp_error_cause *)(aph + 1);
 178
 179         aph->correlation_id = id;
 180         aph->ph.param_type = htons(SCTP_ERROR_CAUSE_IND);
 181         error->code = htons(cause);
 182         error->length = tlv_length + sizeof(struct sctp_error_cause);
 183         aph->ph.param_length = error->length +
 184             sizeof(struct sctp_asconf_paramhdr);
 185
 186         if (aph->ph.param_length > MLEN) {
 187 #ifdef SCTP_DEBUG
 188                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 189                         kprintf("asconf_error_response: tlv_length (%xh) too big\n",
 190                             tlv_length);
 191                 }
 192 #endif /* SCTP_DEBUG */
 193                 sctp_m_freem(m_reply);  /* discard */
 194                 return NULL;
 195         }
 196
 197         if (error_tlv != NULL) {
 198                 tlv = (uint8_t *)(error + 1);
 199                 memcpy(tlv, error_tlv, tlv_length);
 200         }
 201
 202         m_reply->m_len = aph->ph.param_length;
 203         error->length = htons(error->length);
 204         aph->ph.param_length = htons(aph->ph.param_length);
 205
 206         return m_reply;
 207 }
 208
 209 static struct mbuf *
 210 sctp_process_asconf_add_ip(struct sctp_asconf_paramhdr *aph,
 211     struct sctp_tcb *stcb, int response_required)
 212 {
 213         struct mbuf *m_reply = NULL;
 214         struct sockaddr_storage sa_store;
 215         struct sctp_ipv4addr_param *v4addr;
 216         uint16_t param_type, param_length, aparam_length;
 217         struct sockaddr *sa;
 218         struct sockaddr_in *sin;
 219 #ifdef INET6
 220         struct sockaddr_in6 *sin6;
 221         struct sctp_ipv6addr_param *v6addr;
 222 #endif /* INET6 */
 223
 224         aparam_length = ntohs(aph->ph.param_length);
 225         v4addr = (struct sctp_ipv4addr_param *)(aph + 1);
 226 #ifdef INET6
 227         v6addr = (struct sctp_ipv6addr_param *)(aph + 1);
 228 #endif /* INET6 */
 229         param_type = ntohs(v4addr->ph.param_type);
 230         param_length = ntohs(v4addr->ph.param_length);
 231
 232         sa = (struct sockaddr *)&sa_store;
 233         switch (param_type) {
 234         case SCTP_IPV4_ADDRESS:
 235                 if (param_length != sizeof(struct sctp_ipv4addr_param)) {
 236                         /* invalid param size */
 237                         return NULL;
 238                 }
 239                 sin = (struct sockaddr_in *)&sa_store;
 240                 bzero(sin, sizeof(*sin));
 241                 sin->sin_family = AF_INET;
 242                 sin->sin_len = sizeof(struct sockaddr_in);
 243                 sin->sin_port = stcb->rport;
 244                 sin->sin_addr.s_addr = v4addr->addr;
 245 #ifdef SCTP_DEBUG
 246                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 247                         kprintf("process_asconf_add_ip: adding ");
 248                         sctp_print_address(sa);
 249                 }
 250 #endif /* SCTP_DEBUG */
 251                 break;
 252         case SCTP_IPV6_ADDRESS:
 253 #ifdef INET6
 254                 if (param_length != sizeof(struct sctp_ipv6addr_param)) {
 255                         /* invalid param size */
 256                         return NULL;
 257                 }
 258                 sin6 = (struct sockaddr_in6 *)&sa_store;
 259                 bzero(sin6, sizeof(*sin6));
 260                 sin6->sin6_family = AF_INET6;
 261                 sin6->sin6_len = sizeof(struct sockaddr_in6);
 262                 sin6->sin6_port = stcb->rport;
 263                 memcpy((caddr_t)&sin6->sin6_addr, v6addr->addr,
 264                     sizeof(struct in6_addr));
 265 #ifdef SCTP_DEBUG
 266                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 267                         kprintf("process_asconf_add_ip: adding ");
 268                         sctp_print_address(sa);
 269                 }
 270 #endif /* SCTP_DEBUG */
 271 #else
 272                 /* IPv6 not enabled! */
 273                 /* FIX ME: currently sends back an invalid param error */
 274                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 275                     SCTP_ERROR_INVALID_PARAM, (uint8_t *)aph, aparam_length);
 276 #ifdef SCTP_DEBUG
 277                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 278                         kprintf("process_asconf_add_ip: v6 disabled- skipping ");
 279                         sctp_print_address(sa);
 280                 }
 281 #endif /* SCTP_DEBUG */
 282                 return m_reply;
 283 #endif /* INET6 */
 284                 break;
 285         default:
 286                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 287                     SCTP_ERROR_UNRESOLVABLE_ADDR, (uint8_t *)aph,
 288                     aparam_length);
 289                 return m_reply;
 290         } /* end switch */
 291
 292         /* add the address */
 293         if (sctp_add_remote_addr(stcb, sa, 0, 6) != 0) {
 294 #ifdef SCTP_DEBUG
 295                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 296                         kprintf("process_asconf_add_ip: error adding address\n");
 297                 }
 298 #endif /* SCTP_DEBUG */
 299                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 300                     SCTP_ERROR_RESOURCE_SHORTAGE, (uint8_t *)aph,
 301                     aparam_length);
 302         } else {
 303                 /* notify upper layer */
 304                 sctp_ulp_notify(SCTP_NOTIFY_ASCONF_ADD_IP, stcb, 0, sa);
 305                 if (response_required) {
 306                         m_reply =
 307                             sctp_asconf_success_response(aph->correlation_id);
 308                 }
 309         }
 310
 311         return m_reply;
 312 }
 313
 314 static struct mbuf *
 315 sctp_process_asconf_delete_ip(struct mbuf *m, struct sctp_asconf_paramhdr *aph,
 316     struct sctp_tcb *stcb, int response_required)
 317 {
 318         struct mbuf *m_reply = NULL;
 319         struct sockaddr_storage sa_store, sa_source;
 320         struct sctp_ipv4addr_param *v4addr;
 321         uint16_t param_type, param_length, aparam_length;
 322         struct sockaddr *sa;
 323         struct sockaddr_in *sin;
 324         struct ip *iph;
 325         int result;
 326 #ifdef INET6
 327         struct sockaddr_in6 *sin6;
 328         struct sctp_ipv6addr_param *v6addr;
 329 #endif /* INET6 */
 330
 331         aparam_length = ntohs(aph->ph.param_length);
 332         v4addr = (struct sctp_ipv4addr_param *)(aph + 1);
 333 #ifdef INET6
 334         v6addr = (struct sctp_ipv6addr_param *)(aph + 1);
 335 #endif /* INET6 */
 336         param_type = ntohs(v4addr->ph.param_type);
 337         param_length = ntohs(v4addr->ph.param_length);
 338
 339         /* get the source IP address for deletion check */
 340         iph = mtod(m, struct ip *);
 341         if (iph->ip_v == IPVERSION) {
 342                 /* IPv4 source */
 343                 sin = (struct sockaddr_in *)&sa_source;
 344                 bzero(sin, sizeof(*sin));
 345                 sin->sin_family = AF_INET;
 346                 sin->sin_len = sizeof(struct sockaddr_in);
 347                 sin->sin_port = stcb->rport;
 348                 sin->sin_addr.s_addr = iph->ip_src.s_addr;
 349         }
 350 #ifdef INET6
 351         else if (iph->ip_v == (IPV6_VERSION >> 4)) {
 352                 /* IPv6 source */
 353                 struct ip6_hdr *ip6;
 354
 355                 sin6 = (struct sockaddr_in6 *)&sa_source;
 356                 bzero(sin6, sizeof(*sin6));
 357                 sin6->sin6_family = AF_INET6;
 358                 sin6->sin6_len = sizeof(struct sockaddr_in6);
 359                 sin6->sin6_port = stcb->rport;
 360                 ip6 = mtod(m, struct ip6_hdr *);
 361                 sin6->sin6_addr = ip6->ip6_src;
 362         }
 363 #endif /* INET6 */
 364         else
 365                 return NULL;
 366
 367         sa = (struct sockaddr *)&sa_store;
 368         switch (param_type) {
 369         case SCTP_IPV4_ADDRESS:
 370                 if (param_length != sizeof(struct sctp_ipv4addr_param)) {
 371                         /* invalid param size */
 372                         return NULL;
 373                 }
 374                 sin = (struct sockaddr_in *)&sa_store;
 375                 bzero(sin, sizeof(*sin));
 376                 sin->sin_family = AF_INET;
 377                 sin->sin_len = sizeof(struct sockaddr_in);
 378                 sin->sin_port = stcb->rport;
 379                 sin->sin_addr.s_addr = v4addr->addr;
 380 #ifdef SCTP_DEBUG
 381                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 382                         kprintf("process_asconf_delete_ip: deleting ");
 383                         sctp_print_address(sa);
 384                 }
 385 #endif /* SCTP_DEBUG */
 386                 break;
 387         case SCTP_IPV6_ADDRESS:
 388                 if (param_length != sizeof(struct sctp_ipv6addr_param)) {
 389                         /* invalid param size */
 390                         return NULL;
 391                 }
 392 #ifdef INET6
 393                 sin6 = (struct sockaddr_in6 *)&sa_store;
 394                 bzero(sin6, sizeof(*sin6));
 395                 sin6->sin6_family = AF_INET6;
 396                 sin6->sin6_len = sizeof(struct sockaddr_in6);
 397                 sin6->sin6_port = stcb->rport;
 398                 memcpy(&sin6->sin6_addr, v6addr->addr,
 399                     sizeof(struct in6_addr));
 400 #ifdef SCTP_DEBUG
 401                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 402                         kprintf("process_asconf_delete_ip: deleting ");
 403                         sctp_print_address(sa);
 404                 }
 405 #endif /* SCTP_DEBUG */
 406 #else
 407                 /* IPv6 not enabled!  No "action" needed; just ack it */
 408 #ifdef SCTP_DEBUG
 409                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 410                         kprintf("process_asconf_delete_ip: v6 disabled- ignoring: ");
 411                         sctp_print_address(sa);
 412                 }
 413 #endif /* SCTP_DEBUG */
 414                 /* just respond with a "success" ASCONF-ACK */
 415                 return NULL;
 416 #endif /* INET6 */
 417                 break;
 418         default:
 419                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 420                     SCTP_ERROR_UNRESOLVABLE_ADDR, (uint8_t *)aph,
 421                     aparam_length);
 422                 return m_reply;
 423         } /* end switch */
 424
 425         /* make sure the source address is not being deleted */
 426         if ((memcmp(sa, &sa_source, sizeof(struct sockaddr_in)) == 0)
 427 #ifdef INET6
 428             || (memcmp(sa, &sa_source, sizeof(struct sockaddr_in6)) == 0)
 429 #endif /* INET6 */
 430                 ) {
 431                 /* trying to delete the source address! */
 432 #ifdef SCTP_DEBUG
 433                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 434                         kprintf("process_asconf_delete_ip: tried to delete source addr\n");
 435                 }
 436 #endif /* SCTP_DEBUG */
 437                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 438                     SCTP_ERROR_DELETE_SOURCE_ADDR, (uint8_t *)aph,
 439                     aparam_length);
 440                 return m_reply;
 441         }
 442
 443         /* delete the address */
 444         result = sctp_del_remote_addr(stcb, sa);
 445         /*
 446          * note if result == -2, the address doesn't exist in the asoc
 447          * but since it's being deleted anyways, we just ack the delete
 448          * -- but this probably means something has already gone awry
 449          */
 450         if (result == -1) {
 451                 /* only one address in the asoc */
 452 #ifdef SCTP_DEBUG
 453                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 454                         kprintf("process_asconf_delete_ip: tried to delete last IP addr!\n");
 455                 }
 456 #endif /* SCTP_DEBUG */
 457                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 458                     SCTP_ERROR_DELETE_LAST_ADDR, (uint8_t *)aph,
 459                     aparam_length);
 460         } else {
 461                 /* notify upper layer */
 462                 sctp_ulp_notify(SCTP_NOTIFY_ASCONF_DELETE_IP, stcb, 0, sa);
 463         }
 464
 465         if (response_required) {
 466                 m_reply = sctp_asconf_success_response(aph->correlation_id);
 467         }
 468         return m_reply;
 469 }
 470
 471 static struct mbuf *
 472 sctp_process_asconf_set_primary(struct sctp_asconf_paramhdr *aph,
 473     struct sctp_tcb *stcb, int response_required)
 474 {
 475         struct mbuf *m_reply = NULL;
 476         struct sockaddr_storage sa_store;
 477         struct sctp_ipv4addr_param *v4addr;
 478         uint16_t param_type, param_length, aparam_length;
 479         struct sockaddr *sa;
 480         struct sockaddr_in *sin;
 481 #ifdef INET6
 482         struct sockaddr_in6 *sin6;
 483         struct sctp_ipv6addr_param *v6addr;
 484 #endif /* INET6 */
 485
 486         aparam_length = ntohs(aph->ph.param_length);
 487         v4addr = (struct sctp_ipv4addr_param *)(aph + 1);
 488 #ifdef INET6
 489         v6addr = (struct sctp_ipv6addr_param *)(aph + 1);
 490 #endif /* INET6 */
 491         param_type = ntohs(v4addr->ph.param_type);
 492         param_length = ntohs(v4addr->ph.param_length);
 493
 494         sa = (struct sockaddr *)&sa_store;
 495         switch (param_type) {
 496         case SCTP_IPV4_ADDRESS:
 497                 if (param_length != sizeof(struct sctp_ipv4addr_param)) {
 498                         /* invalid param size */
 499                         return NULL;
 500                 }
 501                 sin = (struct sockaddr_in *)&sa_store;
 502                 bzero(sin, sizeof(*sin));
 503                 sin->sin_family = AF_INET;
 504                 sin->sin_len = sizeof(struct sockaddr_in);
 505                 sin->sin_addr.s_addr = v4addr->addr;
 506 #ifdef SCTP_DEBUG
 507                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 508                         kprintf("process_asconf_set_primary: ");
 509                         sctp_print_address(sa);
 510                 }
 511 #endif /* SCTP_DEBUG */
 512                 break;
 513         case SCTP_IPV6_ADDRESS:
 514                 if (param_length != sizeof(struct sctp_ipv6addr_param)) {
 515                         /* invalid param size */
 516                         return NULL;
 517                 }
 518 #ifdef INET6
 519                 sin6 = (struct sockaddr_in6 *)&sa_store;
 520                 bzero(sin6, sizeof(*sin6));
 521                 sin6->sin6_family = AF_INET6;
 522                 sin6->sin6_len = sizeof(struct sockaddr_in6);
 523                 memcpy((caddr_t)&sin6->sin6_addr, v6addr->addr,
 524                     sizeof(struct in6_addr));
 525 #ifdef SCTP_DEBUG
 526                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 527                         kprintf("process_asconf_set_primary: ");
 528                         sctp_print_address(sa);
 529                 }
 530 #endif /* SCTP_DEBUG */
 531 #else
 532                 /* IPv6 not enabled!  No "action" needed; just ack it */
 533 #ifdef SCTP_DEBUG
 534                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 535                         kprintf("process_asconf_set_primary: v6 disabled- ignoring: ");
 536                         sctp_print_address(sa);
 537                 }
 538 #endif /* SCTP_DEBUG */
 539                 /* just respond with a "success" ASCONF-ACK */
 540                 return NULL;
 541 #endif /* INET6 */
 542                 break;
 543         default:
 544                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 545                     SCTP_ERROR_UNRESOLVABLE_ADDR, (uint8_t *)aph,
 546                     aparam_length);
 547                 return m_reply;
 548         } /* end switch */
 549
 550         /* set the primary address */
 551         if (sctp_set_primary_addr(stcb, sa, NULL) == 0) {
 552 #ifdef SCTP_DEBUG
 553                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 554                         kprintf("process_asconf_set_primary: primary address set\n");
 555                 }
 556 #endif /* SCTP_DEBUG */
 557                 /* notify upper layer */
 558                 sctp_ulp_notify(SCTP_NOTIFY_ASCONF_SET_PRIMARY, stcb, 0, sa);
 559
 560                 if (response_required) {
 561                         m_reply = sctp_asconf_success_response(aph->correlation_id);
 562                 }
 563         } else {
 564                 /* couldn't set the requested primary address! */
 565 #ifdef SCTP_DEBUG
 566                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 567                         kprintf("process_asconf_set_primary: set primary failed!\n");
 568                 }
 569 #endif /* SCTP_DEBUG */
 570                 /* must have been an invalid address, so report */
 571                 m_reply = sctp_asconf_error_response(aph->correlation_id,
 572                     SCTP_ERROR_UNRESOLVABLE_ADDR, (uint8_t *)aph,
 573                     aparam_length);
 574         }
 575
 576         return m_reply;
 577 }
 578
 579 /*
 580  * handles an ASCONF chunk
 581  * if all parameters are processed ok, send a plain (empty) ASCONF-ACK
 582  */
 583 void
 584 sctp_handle_asconf(struct mbuf *m, unsigned int offset, struct sctp_asconf_chunk *cp,
 585     struct sctp_tcb *stcb, struct sctp_nets *net)
 586 {
 587         struct sctp_association *asoc;
 588         uint32_t serial_num;
 589         struct mbuf *m_ack, *m_result, *m_tail;
 590         struct sctp_asconf_ack_chunk *ack_cp;
 591         struct sctp_asconf_paramhdr *aph, *ack_aph;
 592         struct sctp_ipv6addr_param *p_addr;
 593         unsigned int asconf_limit;
 594         int error = 0;          /* did an error occur? */
 595         /* asconf param buffer */
 596         static u_int8_t aparam_buf[DEFAULT_PARAM_BUFFER];
 597
 598         /* verify minimum length */
 599         if (ntohs(cp->ch.chunk_length) < sizeof(struct sctp_asconf_chunk)) {
 600 #ifdef SCTP_DEBUG
 601                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 602                         kprintf("handle_asconf: chunk too small = %xh\n",
 603                             ntohs(cp->ch.chunk_length));
 604                 }
 605 #endif /* SCTP_DEBUG */
 606                 return;
 607         }
 608
 609         asoc = &stcb->asoc;
 610         serial_num = ntohl(cp->serial_number);
 611
 612         if (serial_num == asoc->asconf_seq_in) {
 613                 /* got a duplicate ASCONF */
 614 #ifdef SCTP_DEBUG
 615                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 616                         kprintf("handle_asconf: got duplicate serial number = %xh\n",
 617                                serial_num);
 618                 }
 619 #endif /* SCTP_DEBUG */
 620                 /* resend last ASCONF-ACK... */
 621                 sctp_send_asconf_ack(stcb, 1);
 622                 return;
 623         } else if (serial_num != (asoc->asconf_seq_in + 1)) {
 624 #ifdef SCTP_DEBUG
 625                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 626                         kprintf("handle_asconf: incorrect serial number = %xh (expected next = %xh)\n",
 627                             serial_num, asoc->asconf_seq_in+1);
 628                 }
 629 #endif /* SCTP_DEBUG */
 630                 return;
 631         }
 632
 633         /* it's the expected "next" sequence number, so process it */
 634         asoc->asconf_seq_in = serial_num;       /* update sequence */
 635         /* get length of all the param's in the ASCONF */
 636         asconf_limit = offset + ntohs(cp->ch.chunk_length);
 637 #ifdef SCTP_DEBUG
 638         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 639                 kprintf("handle_asconf: asconf_limit=%u, sequence=%xh\n",
 640                     asconf_limit, serial_num);
 641         }
 642 #endif /* SCTP_DEBUG */
 643         if (asoc->last_asconf_ack_sent != NULL) {
 644                 /* free last ASCONF-ACK message sent */
 645                 sctp_m_freem(asoc->last_asconf_ack_sent);
 646                 asoc->last_asconf_ack_sent = NULL;
 647         }
 648         MGETHDR(m_ack, MB_DONTWAIT, MT_DATA);
 649         if (m_ack == NULL) {
 650 #ifdef SCTP_DEBUG
 651                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 652                         kprintf("handle_asconf: couldn't get mbuf!\n");
 653                 }
 654 #endif /* SCTP_DEBUG */
 655                 return;
 656         }
 657         m_tail = m_ack;         /* current reply chain's tail */
 658
 659         /* fill in ASCONF-ACK header */
 660         ack_cp = mtod(m_ack, struct sctp_asconf_ack_chunk *);
 661         ack_cp->ch.chunk_type = SCTP_ASCONF_ACK;
 662         ack_cp->ch.chunk_flags = 0;
 663         ack_cp->serial_number = htonl(serial_num);
 664         /* set initial lengths (eg. just an ASCONF-ACK), ntohx at the end! */
 665         m_ack->m_len = sizeof(struct sctp_asconf_ack_chunk);
 666         ack_cp->ch.chunk_length = sizeof(struct sctp_asconf_ack_chunk);
 667         m_ack->m_pkthdr.len = sizeof(struct sctp_asconf_ack_chunk);
 668
 669         /* skip the lookup address parameter */
 670         offset += sizeof(struct sctp_asconf_chunk);
 671         p_addr = (struct sctp_ipv6addr_param *)sctp_m_getptr(m, offset, sizeof(struct sctp_paramhdr), (uint8_t *)&aparam_buf);
 672         if (p_addr == NULL) {
 673 #ifdef SCTP_DEBUG
 674                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 675                         kprintf("handle_asconf: couldn't get lookup addr!\n");
 676                 }
 677 #endif /* SCTP_DEBUG */
 678
 679                 /* respond with a missing/invalid mandatory parameter error */
 680                 return;
 681         }
 682         /* param_length is already validated in process_control... */
 683         offset += ntohs(p_addr->ph.param_length);   /* skip lookup addr */
 684
 685         /* get pointer to first asconf param in ASCONF */
 686         aph = (struct sctp_asconf_paramhdr *)sctp_m_getptr(m, offset, sizeof(struct sctp_asconf_paramhdr), (uint8_t *)&aparam_buf);
 687         /* get pointer to first asconf param in ASCONF-ACK */
 688         if (aph == NULL) {
 689                 kprintf("Gak in asconf\n");
 690                 return;
 691         }
 692         ack_aph = (struct sctp_asconf_paramhdr *)(mtod(m_ack, caddr_t) + sizeof(struct sctp_asconf_ack_chunk));
 693         if (ack_aph == NULL) {
 694                 kprintf("Gak in asconf2\n");
 695                 return;
 696         }
 697
 698         /* process through all parameters */
 699         while (aph != NULL) {
 700                 unsigned int param_length, param_type;
 701
 702                 param_type = ntohs(aph->ph.param_type);
 703                 param_length = ntohs(aph->ph.param_length);
 704                 if (offset + param_length > asconf_limit) {
 705                         /* parameter goes beyond end of chunk! */
 706                         sctp_m_freem(m_ack);
 707                         return;
 708                 }
 709                 m_result = NULL;
 710
 711                 if (param_length > sizeof(aparam_buf)) {
 712 #ifdef SCTP_DEBUG
 713                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 714                                 kprintf("handle_asconf: param length (%u) larger than buffer size!\n", param_length);
 715                         }
 716 #endif /* SCTP_DEBUG */
 717                         sctp_m_freem(m_ack);
 718                         return;
 719                 }
 720                 if (param_length <= sizeof(struct sctp_paramhdr)) {
 721 #ifdef SCTP_DEBUG
 722                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 723                                 kprintf("handle_asconf: param length (%u) too short\n", param_length);
 724                         }
 725 #endif /* SCTP_DEBUG */
 726                         sctp_m_freem(m_ack);
 727                 }
 728
 729                 /* get the entire parameter */
 730                 aph = (struct sctp_asconf_paramhdr *)sctp_m_getptr(m, offset, param_length, aparam_buf);
 731                 if (aph == NULL) {
 732                         kprintf("Gag\n");
 733                         sctp_m_freem(m_ack);
 734                         return;
 735                 }
 736                 switch (param_type) {
 737                 case SCTP_ADD_IP_ADDRESS:
 738                         asoc->peer_supports_asconf = 1;
 739                         m_result = sctp_process_asconf_add_ip(aph, stcb, error);
 740                         break;
 741                 case SCTP_DEL_IP_ADDRESS:
 742                         asoc->peer_supports_asconf = 1;
 743                         m_result = sctp_process_asconf_delete_ip(m, aph, stcb,
 744                             error);
 745                         break;
 746                 case SCTP_ERROR_CAUSE_IND:
 747                         /* not valid in an ASCONF chunk */
 748                         break;
 749                 case SCTP_SET_PRIM_ADDR:
 750                         asoc->peer_supports_asconf_setprim = 1;
 751                         m_result = sctp_process_asconf_set_primary(aph, stcb,
 752                             error);
 753                         break;
 754                 case SCTP_SUCCESS_REPORT:
 755                         /* not valid in an ASCONF chunk */
 756                         break;
 757                 case SCTP_ULP_ADAPTION:
 758                         /* FIX */
 759                         break;
 760                 default:
 761                         if ((param_type & 0x8000) == 0) {
 762                                 /* Been told to STOP at this param */
 763                                 asconf_limit = offset;
 764                                 /* FIX FIX - We need to call sctp_arethere_unrecognized_parameters()
 765                                  * to get a operr and send it for any param's with the
 766                                  * 0x4000 bit set OR do it here ourselves... note we still
 767                                  * must STOP if the 0x8000 bit is clear.
 768                                  */
 769                         }
 770                         /* unknown/invalid param type */
 771                         break;
 772                 } /* switch */
 773
 774                 /* add any (error) result to the reply mbuf chain */
 775                 if (m_result != NULL) {
 776 #ifdef SCTP_DEBUG
 777                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 778                                 kprintf("handle_asconf: adding reply...\n");
 779                         }
 780 #endif /* SCTP_DEBUG */
 781                         m_tail->m_next = m_result;
 782                         m_tail = m_result;
 783                         /* update lengths, make sure it's aligned too */
 784                         m_result->m_len = SCTP_SIZE32(m_result->m_len);
 785                         m_ack->m_pkthdr.len += m_result->m_len;
 786                         ack_cp->ch.chunk_length += m_result->m_len;
 787                         /* set flag to force success reports */
 788                         error = 1;
 789                 }
 790
 791                 offset += SCTP_SIZE32(param_length);
 792                 /* update remaining ASCONF message length to process */
 793                 if (offset >= asconf_limit) {
 794                         /* no more data in the mbuf chain */
 795                         break;
 796                 }
 797                 /* get pointer to next asconf param */
 798                 aph = (struct sctp_asconf_paramhdr *)sctp_m_getptr(m, offset,
 799                     sizeof(struct sctp_asconf_paramhdr),
 800                     (uint8_t *)&aparam_buf);
 801                 if (aph == NULL) {
 802                         /* can't get an asconf paramhdr */
 803 #ifdef SCTP_DEBUG
 804                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 805                                 kprintf("handle_asconf: can't get asconf param hdr!\n");
 806                         }
 807 #endif /* SCTP_DEBUG */
 808                         /* FIX ME - add error here... */
 809                 }
 810         } /* while */
 811
 812         ack_cp->ch.chunk_length = htons(ack_cp->ch.chunk_length);
 813         /* save the ASCONF-ACK reply */
 814         asoc->last_asconf_ack_sent = m_ack;
 815         /* and send (a new one) it out... */
 816         sctp_send_asconf_ack(stcb, 0);
 817 }
 818
 819 /*
 820  * does the address match?
 821  * returns 0 if not, 1 if so
 822  */
 823 static uint32_t
 824 sctp_asconf_addr_match(struct sctp_asconf_addr *aa, struct sockaddr *sa)
 825 {
 826 #ifdef INET6
 827         if (sa->sa_family == AF_INET6) {
 828                 /* IPv6 sa address */
 829                 /* XXX scopeid */
 830                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 831                 if ((aa->ap.addrp.ph.param_type == SCTP_IPV6_ADDRESS) &&
 832                     (memcmp(&aa->ap.addrp.addr, &sin6->sin6_addr,
 833                             sizeof(struct in6_addr)) == 0)) {
 834                         return (1);
 835                 }
 836         } else
 837 #endif /* INET6 */
 838         if (sa->sa_family == AF_INET) {
 839                 /* IPv4 sa address */
 840                 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 841                 if ((aa->ap.addrp.ph.param_type == SCTP_IPV4_ADDRESS) &&
 842                     (memcmp(&aa->ap.addrp.addr, &sin->sin_addr,
 843                             sizeof(struct in_addr)) == 0)) {
 844                         return (1);
 845                 }
 846         }
 847         return (0);
 848 }
 849
 850 /*
 851  * Cleanup for non-responded/OP ERR'd ASCONF
 852  */
 853 void
 854 sctp_asconf_cleanup(struct sctp_tcb *stcb, struct sctp_nets *net)
 855 {
 856 #ifdef SCTP_DEBUG
 857         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 858                 kprintf("asconf_cleanup: marking peer ASCONF incapable and cleaning up\n");
 859         }
 860 #endif /* SCTP_DEBUG */
 861         /* mark peer as ASCONF incapable */
 862         stcb->asoc.peer_supports_asconf = 0;
 863         stcb->asoc.peer_supports_asconf_setprim = 0;
 864         /*
 865          * clear out any existing asconfs going out
 866          */
 867         sctp_timer_stop(SCTP_TIMER_TYPE_ASCONF, stcb->sctp_ep, stcb, net);
 868         stcb->asoc.asconf_seq_out++;
 869         /* remove the old ASCONF on our outbound queue */
 870         sctp_toss_old_asconf(stcb);
 871 }
 872
 873 /*
 874  * process an ADD/DELETE IP ack from peer
 875  * ifa:  corresponding ifaddr to the address being added/deleted
 876  * type: SCTP_ADD_IP_ADDRESS or SCTP_DEL_IP_ADDRESS
 877  * flag: 1=success, 0=failure
 878  */
 879 static void
 880 sctp_asconf_addr_mgmt_ack(struct sctp_tcb *stcb, struct ifaddr *addr,
 881     uint16_t type, uint32_t flag)
 882 {
 883
 884         /*
 885          * do the necessary asoc list work-
 886          * if we get a failure indication, leave the address on the
 887          *   "do not use" asoc list
 888          * if we get a success indication, remove the address from
 889          *   the list
 890          */
 891         /*
 892          * Note: this will only occur for ADD_IP_ADDRESS, since
 893          * DEL_IP_ADDRESS is never actually added to the list...
 894          */
 895         if (flag) {
 896                 /* success case, so remove from the list */
 897                 sctp_del_local_addr_assoc(stcb, addr);
 898         }
 899         /* else, leave it on the list */
 900 }
 901
 902 /*
 903  * add an asconf add/delete IP address parameter to the queue
 904  * type = SCTP_ADD_IP_ADDRESS, SCTP_DEL_IP_ADDRESS, SCTP_SET_PRIM_ADDR
 905  * returns 0 if completed, non-zero if not completed
 906  * NOTE: if adding, but delete already scheduled (and not yet
 907  *      sent out), simply remove from queue.  Same for deleting
 908  *      an address already scheduled for add.  If a duplicate
 909  *      operation is found, ignore the new one.
 910  */
 911 static uint32_t
 912 sctp_asconf_queue_add(struct sctp_tcb *stcb, struct ifaddr *ifa, uint16_t type)
 913 {
 914         struct sctp_asconf_addr *aa, *aa_next;
 915 #ifdef SCTP_DEBUG
 916         char buf[128];  /* for address in string format */
 917 #endif /* SCTP_DEBUG */
 918
 919         /* see if peer supports ASCONF */
 920         if (stcb->asoc.peer_supports_asconf == 0) {
 921 #ifdef SCTP_DEBUG
 922                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 923                         kprintf("asconf_queue_add: peer doesn't support ASCONF\n");
 924                 }
 925 #endif /* SCTP_DEBUG */
 926                 return (-1);
 927         }
 928
 929         /* make sure the request isn't already in the queue */
 930         for (aa=TAILQ_FIRST(&stcb->asoc.asconf_queue); aa!=NULL; aa=aa_next) {
 931                 aa_next = TAILQ_NEXT(aa, next);
 932                 /* address match? */
 933                 if (sctp_asconf_addr_match(aa, ifa->ifa_addr) == 0)
 934                         continue;
 935                 /* is the request already in queue (sent or not) */
 936                 if (aa->ap.aph.ph.param_type == type) {
 937 #ifdef SCTP_DEBUG
 938                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 939                                 kprintf("asconf_queue_add: request already exists\n");
 940                         }
 941 #endif /* SCTP_DEBUG */
 942                         return (-1);
 943                 }
 944                 /* is the negative request already in queue, and not sent */
 945                 if (aa->sent == 0 &&
 946                     /* add requested, delete already queued */
 947                     ((type == SCTP_ADD_IP_ADDRESS &&
 948                       aa->ap.aph.ph.param_type == SCTP_DEL_IP_ADDRESS) ||
 949                      /* delete requested, add already queued */
 950                      (type == SCTP_DEL_IP_ADDRESS &&
 951                       aa->ap.aph.ph.param_type == SCTP_ADD_IP_ADDRESS))) {
 952                         /* delete the existing entry in the queue */
 953                         TAILQ_REMOVE(&stcb->asoc.asconf_queue, aa, next);
 954                         /* take the entry off the appropriate list */
 955                         sctp_asconf_addr_mgmt_ack(stcb, aa->ifa, type, 1);
 956                         /* free the entry */
 957                         kfree(aa, M_PCB);
 958
 959 #ifdef SCTP_DEBUG
 960                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 961                                 kprintf("asconf_queue_add: removing 'opposite' queued request\n");
 962                         }
 963 #endif /* SCTP_DEBUG */
 964                         return (-1);
 965                 }
 966         } /* for each aa */
 967
 968         /* adding new request to the queue */
 969         aa = kmalloc(sizeof(*aa), M_PCB, M_NOWAIT);
 970         if (aa == NULL) {
 971                 /* didn't get memory */
 972 #ifdef SCTP_DEBUG
 973                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
 974                         kprintf("asconf_queue_add: failed to get memory!\n");
 975                 }
 976 #endif /* SCTP_DEBUG */
 977                 return (-1);
 978         }
 979         /* fill in asconf address parameter fields */
 980         /* top level elements are "networked" during send */
 981         aa->ap.aph.ph.param_type = type;
 982         aa->ifa = ifa;
 983         /* correlation_id filled in during send routine later... */
 984         if (ifa->ifa_addr->sa_family == AF_INET6) {
 985                 /* IPv6 address */
 986                 struct sockaddr_in6 *sin6;
 987
 988                 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
 989                 aa->ap.addrp.ph.param_type = SCTP_IPV6_ADDRESS;
 990                 aa->ap.addrp.ph.param_length = (sizeof(struct sctp_ipv6addr_param));
 991                 aa->ap.aph.ph.param_length =
 992                     sizeof(struct sctp_asconf_paramhdr) +
 993                     sizeof(struct sctp_ipv6addr_param);
 994                 memcpy(&aa->ap.addrp.addr, &sin6->sin6_addr,
 995                     sizeof(struct in6_addr));
 996 #ifdef SCTP_DEBUG
 997                 strlcpy(buf, ip6_sprintf(&sin6->sin6_addr), sizeof(buf));
 998 #endif /* SCTP_DEBUG */
 999
1000         } else if (ifa->ifa_addr->sa_family == AF_INET) {
1001                 /* IPv4 address */
1002                 struct sockaddr_in *sin = (struct sockaddr_in *)ifa->ifa_addr;
1003                 aa->ap.addrp.ph.param_type = SCTP_IPV4_ADDRESS;
1004                 aa->ap.addrp.ph.param_length = (sizeof(struct sctp_ipv4addr_param));
1005                 aa->ap.aph.ph.param_length =
1006                     sizeof(struct sctp_asconf_paramhdr) +
1007                     sizeof(struct sctp_ipv4addr_param);
1008                 memcpy(&aa->ap.addrp.addr, &sin->sin_addr,
1009                     sizeof(struct in_addr));
1010 #ifdef SCTP_DEBUG
1011                 strlcpy(buf, inet_ntoa(sin->sin_addr), sizeof(buf));
1012 #endif /* SCTP_DEBUG */
1013         } else {
1014                 /* invalid family! */
1015                 return (-1);
1016         }
1017         aa->sent = 0;                   /* clear sent flag */
1018
1019         /*
1020          * if we are deleting an address it should go out last
1021          * otherwise, add it to front of the pending queue
1022          */
1023         if (type == SCTP_ADD_IP_ADDRESS) {
1024                 /* add goes to the front of the queue */
1025                 TAILQ_INSERT_HEAD(&stcb->asoc.asconf_queue, aa, next);
1026 #ifdef SCTP_DEBUG
1027                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1028                         kprintf("asconf_queue_add: appended asconf ADD_IP_ADDRESS: %s\n", buf);
1029                 }
1030 #endif /* SCTP_DEBUG */
1031         } else {
1032                 /* delete and set primary goes to the back of the queue */
1033                 TAILQ_INSERT_TAIL(&stcb->asoc.asconf_queue, aa, next);
1034 #ifdef SCTP_DEBUG
1035                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1036                         if (type == SCTP_DEL_IP_ADDRESS) {
1037                                 kprintf("asconf_queue_add: inserted asconf DEL_IP_ADDRESS: %s\n", buf);
1038                         } else {
1039                                 kprintf("asconf_queue_add: inserted asconf SET_PRIM_ADDR: %s\n", buf);
1040                         }
1041                 }
1042 #endif /* SCTP_DEBUG */
1043         }
1044
1045         return (0);
1046 }
1047
1048 /*
1049  * add an asconf add/delete IP address parameter to the queue by addr
1050  * type = SCTP_ADD_IP_ADDRESS, SCTP_DEL_IP_ADDRESS, SCTP_SET_PRIM_ADDR
1051  * returns 0 if completed, non-zero if not completed
1052  * NOTE: if adding, but delete already scheduled (and not yet
1053  *      sent out), simply remove from queue.  Same for deleting
1054  *      an address already scheduled for add.  If a duplicate
1055  *      operation is found, ignore the new one.
1056  */
1057 static uint32_t
1058 sctp_asconf_queue_add_sa(struct sctp_tcb *stcb, struct sockaddr *sa,
1059     uint16_t type)
1060 {
1061         struct sctp_asconf_addr *aa, *aa_next;
1062
1063         /* see if peer supports ASCONF */
1064         if (stcb->asoc.peer_supports_asconf == 0) {
1065 #ifdef SCTP_DEBUG
1066                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1067                         kprintf("asconf_queue_add_sa: peer doesn't support ASCONF\n");
1068                 }
1069 #endif /* SCTP_DEBUG */
1070                 return (-1);
1071         }
1072
1073         /* make sure the request isn't already in the queue */
1074         for (aa = TAILQ_FIRST(&stcb->asoc.asconf_queue); aa != NULL;
1075             aa = aa_next) {
1076                 aa_next = TAILQ_NEXT(aa, next);
1077                 /* address match? */
1078                 if (sctp_asconf_addr_match(aa, sa) == 0)
1079                         continue;
1080                 /* is the request already in queue (sent or not) */
1081                 if (aa->ap.aph.ph.param_type == type) {
1082 #ifdef SCTP_DEBUG
1083                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1084                                 kprintf("asconf_queue_add_sa: request already exists\n");
1085                         }
1086 #endif /* SCTP_DEBUG */
1087                         return (-1);
1088                 }
1089
1090                 /* is the negative request already in queue, and not sent */
1091                 if (aa->sent == 1)
1092                         continue;
1093                 if (type == SCTP_ADD_IP_ADDRESS &&
1094                     aa->ap.aph.ph.param_type == SCTP_DEL_IP_ADDRESS) {
1095                         /* add requested, delete already queued */
1096
1097                         /* delete the existing entry in the queue */
1098                         TAILQ_REMOVE(&stcb->asoc.asconf_queue, aa, next);
1099                         /* free the entry */
1100                         kfree(aa, M_PCB);
1101 #ifdef SCTP_DEBUG
1102                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1103                                 kprintf("asconf_queue_add_sa: removing queued delete request\n");
1104                         }
1105 #endif /* SCTP_DEBUG */
1106                         return (-1);
1107                 } else if (type == SCTP_DEL_IP_ADDRESS &&
1108                            aa->ap.aph.ph.param_type == SCTP_ADD_IP_ADDRESS) {
1109                         /* delete requested, add already queued */
1110
1111                         /* delete the existing entry in the queue */
1112                         TAILQ_REMOVE(&stcb->asoc.asconf_queue, aa, next);
1113                         /* take the entry off the appropriate list */
1114                         sctp_asconf_addr_mgmt_ack(stcb, aa->ifa, type, 1);
1115                         /* free the entry */
1116                         kfree(aa, M_PCB);
1117 #ifdef SCTP_DEBUG
1118                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1119                                 kprintf("asconf_queue_add_sa: removing queued add request\n");
1120                         }
1121 #endif /* SCTP_DEBUG */
1122                         return (-1);
1123                 }
1124         } /* for each aa */
1125
1126         /* adding new request to the queue */
1127         aa = kmalloc(sizeof(*aa), M_PCB, M_NOWAIT);
1128         if (aa == NULL) {
1129                 /* didn't get memory */
1130 #ifdef SCTP_DEBUG
1131                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1132                         kprintf("asconf_queue_add_sa: failed to get memory!\n");
1133                 }
1134 #endif /* SCTP_DEBUG */
1135                 return (-1);
1136         }
1137         /* fill in asconf address parameter fields */
1138         /* top level elements are "networked" during send */
1139         aa->ap.aph.ph.param_type = type;
1140         aa->ifa = sctp_find_ifa_by_addr(sa);
1141         /* correlation_id filled in during send routine later... */
1142         if (sa->sa_family == AF_INET6) {
1143                 /* IPv6 address */
1144                 struct sockaddr_in6 *sin6;
1145
1146                 sin6 = (struct sockaddr_in6 *)sa;
1147                 aa->ap.addrp.ph.param_type = SCTP_IPV6_ADDRESS;
1148                 aa->ap.addrp.ph.param_length = (sizeof(struct sctp_ipv6addr_param));
1149                 aa->ap.aph.ph.param_length = sizeof(struct sctp_asconf_paramhdr) + sizeof(struct sctp_ipv6addr_param);
1150                 memcpy(&aa->ap.addrp.addr, &sin6->sin6_addr,
1151                     sizeof(struct in6_addr));
1152         } else if (sa->sa_family == AF_INET) {
1153                 /* IPv4 address */
1154                 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
1155                 aa->ap.addrp.ph.param_type = SCTP_IPV4_ADDRESS;
1156                 aa->ap.addrp.ph.param_length = (sizeof(struct sctp_ipv4addr_param));
1157                 aa->ap.aph.ph.param_length = sizeof(struct sctp_asconf_paramhdr) + sizeof(struct sctp_ipv4addr_param);
1158                 memcpy(&aa->ap.addrp.addr, &sin->sin_addr,
1159                     sizeof(struct in_addr));
1160         } else {
1161                 /* invalid family! */
1162                 return (-1);
1163         }
1164         aa->sent = 0;                   /* clear sent flag */
1165
1166         /*
1167          * if we are deleting an address it should go out last
1168          * otherwise, add it to front of the pending queue
1169          */
1170         if (type == SCTP_ADD_IP_ADDRESS) {
1171                 /* add goes to the front of the queue */
1172                 TAILQ_INSERT_HEAD(&stcb->asoc.asconf_queue, aa, next);
1173 #ifdef SCTP_DEBUG
1174                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1175                         kprintf("asconf_queue_add_sa: appended asconf ADD_IP_ADDRESS\n");
1176                 }
1177 #endif /* SCTP_DEBUG */
1178         } else {
1179                 /* delete and set primary goes to the back of the queue */
1180                 TAILQ_INSERT_TAIL(&stcb->asoc.asconf_queue, aa, next);
1181 #ifdef SCTP_DEBUG
1182                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1183                         if (type == SCTP_DEL_IP_ADDRESS) {
1184                                 kprintf("asconf_queue_add_sa: inserted asconf DEL_IP_ADDRESS\n");
1185                         } else {
1186                                 kprintf("asconf_queue_add_sa: inserted asconf SET_PRIM_ADDR\n");
1187                         }
1188                 }
1189 #endif /* SCTP_DEBUG */
1190         }
1191
1192         return (0);
1193 }
1194
1195 /*
1196  * find a specific asconf param on our "sent" queue
1197  */
1198 static struct sctp_asconf_addr *
1199 sctp_asconf_find_param(struct sctp_tcb *stcb, uint32_t correlation_id)
1200 {
1201         struct sctp_asconf_addr *aa;
1202
1203         TAILQ_FOREACH(aa, &stcb->asoc.asconf_queue, next) {
1204                 if (aa->ap.aph.correlation_id == correlation_id &&
1205                     aa->sent == 1) {
1206                         /* found it */
1207                         return (aa);
1208                 }
1209         }
1210         /* didn't find it */
1211         return (NULL);
1212 }
1213
1214 /*
1215  * process an SCTP_ERROR_CAUSE_IND for a ASCONF-ACK parameter
1216  * and do notifications based on the error response
1217  */
1218 static void
1219 sctp_asconf_process_error(struct sctp_tcb *stcb,
1220     struct sctp_asconf_paramhdr *aph)
1221 {
1222         struct sctp_error_cause *eh;
1223         struct sctp_paramhdr *ph;
1224         uint16_t param_type;
1225         uint16_t error_code;
1226
1227         eh = (struct sctp_error_cause *)(aph + 1);
1228         ph = (struct sctp_paramhdr *)(eh + 1);
1229         /* validate lengths */
1230         if (htons(eh->length) + sizeof(struct sctp_error_cause) >
1231             htons(aph->ph.param_length)) {
1232                 /* invalid error cause length */
1233 #ifdef SCTP_DEBUG
1234                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1235                         kprintf("asconf_process_error: cause element too long\n");
1236                 }
1237 #endif /* SCTP_DEBUG */
1238                 return;
1239         }
1240         if (htons(ph->param_length) + sizeof(struct sctp_paramhdr) >
1241             htons(eh->length)) {
1242                 /* invalid included TLV length */
1243 #ifdef SCTP_DEBUG
1244                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1245                         kprintf("asconf_process_error: included TLV too long\n");
1246                 }
1247 #endif /* SCTP_DEBUG */
1248                 return;
1249         }
1250
1251         /* which error code ? */
1252         error_code = ntohs(eh->code);
1253         param_type = ntohs(aph->ph.param_type);
1254         /* FIX: this should go back up the REMOTE_ERROR ULP notify */
1255         switch (error_code) {
1256         case SCTP_ERROR_RESOURCE_SHORTAGE:
1257                 /* we allow ourselves to "try again" for this error */
1258                 break;
1259         default:
1260                 /* peer can't handle it... */
1261                 switch (param_type) {
1262                 case SCTP_ADD_IP_ADDRESS:
1263                 case SCTP_DEL_IP_ADDRESS:
1264                         stcb->asoc.peer_supports_asconf = 0;
1265                         break;
1266                 case SCTP_SET_PRIM_ADDR:
1267                         stcb->asoc.peer_supports_asconf_setprim = 0;
1268                         break;
1269                 default:
1270                         break;
1271                 }
1272         }
1273 }
1274
1275 /*
1276  * process an asconf queue param
1277  * aparam: parameter to process, will be removed from the queue
1278  * flag: 1=success, 0=failure
1279  */
1280 static void
1281 sctp_asconf_process_param_ack(struct sctp_tcb *stcb,
1282     struct sctp_asconf_addr *aparam, uint32_t flag)
1283 {
1284         uint16_t param_type;
1285
1286         /* process this param */
1287         param_type = aparam->ap.aph.ph.param_type;
1288 #ifdef SCTP_DEBUG
1289         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1290                 kprintf("process_param_ack: handling asconf parameter type=%xh\n", param_type);
1291         }
1292 #endif /* SCTP_DEBUG */
1293         switch (param_type) {
1294         case SCTP_ADD_IP_ADDRESS:
1295 #ifdef SCTP_DEBUG
1296                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1297                         kprintf("process_param_ack: added IP address\n");
1298                 }
1299 #endif /* SCTP_DEBUG */
1300                 sctp_asconf_addr_mgmt_ack(stcb, aparam->ifa, param_type, flag);
1301                 break;
1302         case SCTP_DEL_IP_ADDRESS:
1303 #ifdef SCTP_DEBUG
1304                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1305                         kprintf("process_param_ack: deleted IP address\n");
1306                 }
1307 #endif /* SCTP_DEBUG */
1308                 /* nothing really to do... lists already updated */
1309                 break;
1310         case SCTP_SET_PRIM_ADDR:
1311                 /* nothing to do... peer may start using this addr */
1312                 if (flag == 0)
1313                         stcb->asoc.peer_supports_asconf_setprim = 0;
1314                 break;
1315         default:
1316                 /* should NEVER happen */
1317                 break;
1318         } /* switch */
1319
1320         /* remove the param and free it */
1321         TAILQ_REMOVE(&stcb->asoc.asconf_queue, aparam, next);
1322         kfree(aparam, M_PCB);
1323 }
1324
1325 /*
1326  * cleanup from a bad asconf ack parameter
1327  */
1328 static void
1329 sctp_asconf_ack_clear(struct sctp_tcb *stcb)
1330 {
1331         /* assume peer doesn't really know how to do asconfs */
1332         stcb->asoc.peer_supports_asconf = 0;
1333         stcb->asoc.peer_supports_asconf_setprim = 0;
1334         /* XXX we could free the pending queue here */
1335 }
1336
1337 void
1338 sctp_handle_asconf_ack(struct mbuf *m, int offset,
1339     struct sctp_asconf_ack_chunk *cp, struct sctp_tcb *stcb,
1340     struct sctp_nets *net)
1341 {
1342         struct sctp_association *asoc;
1343         uint32_t serial_num;
1344         uint16_t ack_length;
1345         struct sctp_asconf_paramhdr *aph;
1346         struct sctp_asconf_addr *aa, *aa_next;
1347         uint32_t last_error_id = 0;             /* last error correlation id */
1348         uint32_t id;
1349         struct sctp_asconf_addr *ap;
1350         /* asconf param buffer */
1351         static u_int8_t aparam_buf[DEFAULT_PARAM_BUFFER];
1352
1353         /* verify minimum length */
1354         if (ntohs(cp->ch.chunk_length) < sizeof(struct sctp_asconf_ack_chunk)) {
1355 #ifdef SCTP_DEBUG
1356                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1357                         kprintf("handle_asconf_ack: chunk too small = %xh\n",
1358                                ntohs(cp->ch.chunk_length));
1359                 }
1360 #endif /* SCTP_DEBUG */
1361                 return;
1362         }
1363
1364         asoc = &stcb->asoc;
1365         serial_num = ntohl(cp->serial_number);
1366
1367         /*
1368          * NOTE: we may want to handle this differently- currently, we
1369          * will abort when we get an ack for the expected serial number + 1
1370          * (eg. we didn't send it), process an ack normally if it is the
1371          * expected serial number, and re-send the previous ack for *ALL*
1372          * other serial numbers
1373          */
1374
1375         /*
1376          * if the serial number is the next expected, but I didn't send it,
1377          * abort the asoc, since someone probably just hijacked us...
1378          */
1379         if (serial_num == (asoc->asconf_seq_out + 1)) {
1380                 sctp_abort_an_association(stcb->sctp_ep, stcb,
1381                     SCTP_ERROR_ILLEGAL_ASCONF_ACK, NULL);
1382 #ifdef SCTP_DEBUG
1383                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1384                         kprintf("handle_asconf_ack: got unexpected next serial number! Aborting asoc!\n");
1385                 }
1386 #endif /* SCTP_DEBUG */
1387                 return;
1388         }
1389
1390         if (serial_num != asoc->asconf_seq_out) {
1391                 /* got a duplicate/unexpected ASCONF-ACK */
1392 #ifdef SCTP_DEBUG
1393                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1394                         kprintf("handle_asconf_ack: got duplicate/unexpected serial number = %xh (expected = %xh)\n", serial_num, asoc->asconf_seq_out);
1395                 }
1396 #endif /* SCTP_DEBUG */
1397                 return;
1398         }
1399         /* stop our timer */
1400         sctp_timer_stop(SCTP_TIMER_TYPE_ASCONF, stcb->sctp_ep, stcb, net);
1401
1402         /* process the ASCONF-ACK contents */
1403         ack_length = ntohs(cp->ch.chunk_length) -
1404             sizeof(struct sctp_asconf_ack_chunk);
1405         offset += sizeof(struct sctp_asconf_ack_chunk);
1406         /* process through all parameters */
1407         while (ack_length >= sizeof(struct sctp_asconf_paramhdr)) {
1408                 unsigned int param_length, param_type;
1409
1410                 /* get pointer to next asconf parameter */
1411                 aph = (struct sctp_asconf_paramhdr *)sctp_m_getptr(m, offset,
1412                     sizeof(struct sctp_asconf_paramhdr), aparam_buf);
1413                 if (aph == NULL) {
1414                         /* can't get an asconf paramhdr */
1415                         sctp_asconf_ack_clear(stcb);
1416                         return;
1417                 }
1418                 param_type = ntohs(aph->ph.param_type);
1419                 param_length = ntohs(aph->ph.param_length);
1420                 if (param_length > ack_length) {
1421                         sctp_asconf_ack_clear(stcb);
1422                         return;
1423                 }
1424                 if (param_length < sizeof(struct sctp_paramhdr)) {
1425                         sctp_asconf_ack_clear(stcb);
1426                         return;
1427                 }
1428
1429                 /* get the complete parameter... */
1430                 if (param_length > sizeof(aparam_buf)) {
1431 #ifdef SCTP_DEBUG
1432                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1433                                 kprintf("param length (%u) larger than buffer size!\n", param_length);
1434                         }
1435 #endif /* SCTP_DEBUG */
1436                         sctp_asconf_ack_clear(stcb);
1437                         return;
1438                 }
1439                 aph = (struct sctp_asconf_paramhdr *)sctp_m_getptr(m, offset, param_length, aparam_buf);
1440                 if (aph == NULL) {
1441                         sctp_asconf_ack_clear(stcb);
1442                         return;
1443                 }
1444                 /* correlation_id is transparent to peer, no ntohl needed */
1445                 id = aph->correlation_id;
1446
1447                 switch (param_type) {
1448                 case SCTP_ERROR_CAUSE_IND:
1449                         last_error_id = id;
1450                         /* find the corresponding asconf param in our queue */
1451                         ap = sctp_asconf_find_param(stcb, id);
1452                         if (ap == NULL) {
1453                                 /* hmm... can't find this in our queue! */
1454                                 break;
1455                         }
1456                         /* process the parameter, failed flag */
1457                         sctp_asconf_process_param_ack(stcb, ap, 0);
1458                         /* process the error response */
1459                         sctp_asconf_process_error(stcb, aph);
1460                         break;
1461                 case SCTP_SUCCESS_REPORT:
1462                         /* find the corresponding asconf param in our queue */
1463                         ap = sctp_asconf_find_param(stcb, id);
1464                         if (ap == NULL) {
1465                                 /* hmm... can't find this in our queue! */
1466                                 break;
1467                         }
1468                         /* process the parameter, success flag */
1469                         sctp_asconf_process_param_ack(stcb, ap, 1);
1470                         break;
1471                 default:
1472                         break;
1473                 } /* switch */
1474
1475                 /* update remaining ASCONF-ACK message length to process */
1476                 ack_length -= SCTP_SIZE32(param_length);
1477                 if (ack_length <= 0) {
1478                         /* no more data in the mbuf chain */
1479                         break;
1480                 }
1481                 offset += SCTP_SIZE32(param_length);
1482         } /* while */
1483
1484         /*
1485          * if there are any "sent" params still on the queue, these are
1486          * implicitly "success", or "failed" (if we got an error back)
1487          * ... so process these appropriately
1488          *
1489          * we assume that the correlation_id's are monotonically increasing
1490          * beginning from 1 and that we don't have *that* many outstanding
1491          * at any given time
1492          */
1493         if (last_error_id == 0)
1494                 last_error_id--;        /* set to "max" value */
1495         for (aa = TAILQ_FIRST(&stcb->asoc.asconf_queue); aa != NULL;
1496             aa = aa_next) {
1497                 aa_next = TAILQ_NEXT(aa, next);
1498                 if (aa->sent == 1) {
1499                         /*
1500                          * implicitly successful or failed
1501                          * if correlation_id < last_error_id, then success
1502                          * else, failure
1503                          */
1504                         if (aa->ap.aph.correlation_id < last_error_id)
1505                                 sctp_asconf_process_param_ack(stcb, aa,
1506                                     SCTP_SUCCESS_REPORT);
1507                         else
1508                                 sctp_asconf_process_param_ack(stcb, aa,
1509                                     SCTP_ERROR_CAUSE_IND);
1510                 } else {
1511                         /*
1512                          * since we always process in order (FIFO queue)
1513                          * if we reach one that hasn't been sent, the
1514                          * rest should not have been sent either.
1515                          * so, we're done...
1516                          */
1517                         break;
1518                 }
1519         }
1520
1521         /* update the next sequence number to use */
1522         asoc->asconf_seq_out++;
1523         /* remove the old ASCONF on our outbound queue */
1524         sctp_toss_old_asconf(stcb);
1525         /* clear the sent flag to allow new ASCONFs */
1526         asoc->asconf_sent = 0;
1527         if (!TAILQ_EMPTY(&stcb->asoc.asconf_queue)) {
1528                 /* we have more params, so restart our timer */
1529                 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, stcb->sctp_ep,
1530                     stcb, net);
1531         }
1532 }
1533
1534 /* is this an interface that we care about at all? */
1535 static uint32_t
1536 sctp_is_desired_interface_type(struct ifaddr *ifa)
1537 {
1538         int result;
1539
1540         /* check the interface type to see if it's one we care about */
1541         switch (ifa->ifa_ifp->if_type) {
1542         case IFT_ETHER:
1543         case IFT_ISO88023:
1544         case IFT_STARLAN:
1545         case IFT_P10:
1546         case IFT_P80:
1547         case IFT_HY:
1548         case IFT_PPP:
1549         case IFT_XETHER:
1550         case IFT_SLIP:
1551         case IFT_GIF:
1552                 result = 1;
1553                 break;
1554         default:
1555 #ifdef SCTP_DEBUG
1556                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1557                         kprintf("ignoring interface type = %u\n",
1558                                ifa->ifa_ifp->if_type);
1559                 }
1560 #endif /* SCTP_DEBUG */
1561                 result = 0;
1562         } /* end switch */
1563
1564         return (result);
1565 }
1566
1567 static uint32_t
1568 sctp_is_scopeid_in_nets(struct sctp_tcb *stcb, struct sockaddr *sa)
1569 {
1570         struct sockaddr_in6 *sin6, *net6;
1571         struct sctp_nets *net;
1572
1573         if (sa->sa_family != AF_INET6) {
1574                 /* wrong family */
1575                 return (0);
1576         }
1577
1578         sin6 = (struct sockaddr_in6 *)sa;
1579         if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) == 0) {
1580                 /* not link local address */
1581                 return (0);
1582         }
1583
1584         /* hunt through our destination nets list for this scope_id */
1585         TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1586                 if (((struct sockaddr *)(&net->ro._l_addr))->sa_family !=
1587                     AF_INET6)
1588                         continue;
1589                 net6 = (struct sockaddr_in6 *)&net->ro._l_addr;
1590                 if (IN6_IS_ADDR_LINKLOCAL(&net6->sin6_addr) == 0)
1591                         continue;
1592                 if (sctp_is_same_scope(sin6, net6)) {
1593                         /* found one */
1594                         return (1);
1595                 }
1596         }
1597         /* didn't find one */
1598         return (0);
1599 }
1600
1601 /*
1602  * address management functions
1603  */
1604 static void
1605 sctp_addr_mgmt_assoc(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
1606     struct ifaddr *ifa, uint16_t type)
1607 {
1608         int status;
1609 #ifdef SCTP_DEBUG
1610         char buf[128];  /* for address in string format */
1611 #endif /* SCTP_DEBUG */
1612
1613         if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0 &&
1614             (inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) == 0) {
1615                 /* subset bound, no ASCONF allowed case, so ignore */
1616                 return;
1617         }
1618
1619         /*
1620          * note: we know this is not the subset bound, no ASCONF case
1621          *      eg. this is boundall or subset bound w/ASCONF allowed
1622          */
1623
1624         /* first, make sure it's a good address family */
1625         if (ifa->ifa_addr->sa_family != AF_INET6 &&
1626             ifa->ifa_addr->sa_family != AF_INET) {
1627                 return;
1628         }
1629
1630         /* make sure we're "allowed" to add this type of addr */
1631         if (ifa->ifa_addr->sa_family == AF_INET6) {
1632                 struct in6_ifaddr *ifa6;
1633
1634                 /* invalid if we're not a v6 endpoint */
1635                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0)
1636                         return;
1637                 /* is the v6 addr really valid ? */
1638                 ifa6 = (struct in6_ifaddr *)ifa;
1639                 if (IFA6_IS_DEPRECATED(ifa6) ||
1640                     (ifa6->ia6_flags &
1641                      (IN6_IFF_DETACHED | IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) {
1642                         /* can't use an invalid address */
1643                         return;
1644                 }
1645         }
1646
1647         /* put this address on the "pending/do not use yet" list */
1648         /*
1649          * Note: we do this primarily for the subset bind case
1650          * We don't have scoping flags at the EP level, so we must
1651          * add link local/site local addresses to the EP, then need
1652          * to "negate" them here.  Recall that this routine is only
1653          * called for the subset bound w/ASCONF allowed case.
1654          */
1655
1656         /*
1657          * do a scope_id check against any link local addresses
1658          * in the destination nets list to see if we should put
1659          * this local address on the pending list or not
1660          * eg. don't put on the list if we have a link local
1661          * destination with the same scope_id
1662          */
1663         if (type == SCTP_ADD_IP_ADDRESS) {
1664                 if (sctp_is_scopeid_in_nets(stcb, ifa->ifa_addr) == 0) {
1665                         sctp_add_local_addr_assoc(stcb, ifa);
1666 #ifdef SCTP_DEBUG
1667                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1668                                 kprintf("addr_mgmt_assoc: added to pending list ");
1669                                 sctp_print_address(ifa->ifa_addr);
1670                         }
1671 #endif /* SCTP_DEBUG */
1672                 }
1673         }
1674         /*
1675          * check address scope
1676          * if address is out of scope, don't queue anything...
1677          * note: this would leave the address on both inp and asoc lists
1678          */
1679         if (ifa->ifa_addr->sa_family == AF_INET6) {
1680                 struct sockaddr_in6 *sin6;
1681
1682                 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1683 #ifdef SCTP_DEBUG
1684                 strlcpy(buf, ip6_sprintf(&sin6->sin6_addr), sizeof(buf));
1685 #endif /* SCTP_DEBUG */
1686                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
1687                         /* we skip unspecifed addresses */
1688 #ifdef SCTP_DEBUG
1689                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1690                                 kprintf("addr_mgmt_assoc: unspecified IPv6 addr\n");
1691                         }
1692 #endif /* SCTP_DEBUG */
1693                         return;
1694                 }
1695                 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
1696                         if (stcb->asoc.local_scope == 0) {
1697 #ifdef SCTP_DEBUG
1698                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1699                                         kprintf("addr_mgmt_assoc: skipping link local IPv6 addr: %s\n", buf);
1700                                 }
1701 #endif /* SCTP_DEBUG */
1702                                 return;
1703                         }
1704                         /* is it the right link local scope? */
1705                         if (sctp_is_scopeid_in_nets(stcb, ifa->ifa_addr) == 0) {
1706 #ifdef SCTP_DEBUG
1707                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1708                                         kprintf("addr_mgmt_assoc: skipping link local IPv6 addr: %s, wrong scope_id\n", buf);
1709                                 }
1710 #endif /* SCTP_DEBUG */
1711                                 return;
1712                         }
1713                 }
1714                 if (stcb->asoc.site_scope == 0 &&
1715                     IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr)) {
1716 #ifdef SCTP_DEBUG
1717                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1718                                 kprintf("addr_mgmt_assoc: skipping site local IPv6 addr: %s\n", buf);
1719                         }
1720 #endif /* SCTP_DEBUG */
1721                         return;
1722                 }
1723         } else if (ifa->ifa_addr->sa_family == AF_INET) {
1724                 struct sockaddr_in *sin;
1725                 struct in6pcb *inp6;
1726
1727                 inp6 = (struct in6pcb *)&inp->ip_inp.inp;
1728                 /* invalid; we are a v6 only endpoint */
1729                 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6)
1730                         return;
1731
1732                 sin = (struct sockaddr_in *)ifa->ifa_addr;
1733 #ifdef SCTP_DEBUG
1734                 strlcpy(buf, inet_ntoa(sin->sin_addr), sizeof(buf));
1735 #endif /* SCTP_DEBUG */
1736                 if (sin->sin_addr.s_addr == 0) {
1737                         /* we skip unspecifed addresses */
1738 #ifdef SCTP_DEBUG
1739                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1740                                 kprintf("addr_mgmt_assoc: unspecified IPv4 addr\n");
1741                         }
1742 #endif /* SCTP_DEBUG */
1743                         return;
1744                 }
1745                 if (stcb->asoc.ipv4_local_scope == 0 &&
1746                     IN4_ISPRIVATE_ADDRESS(&sin->sin_addr)) {
1747 #ifdef SCTP_DEBUG
1748                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1749                                 kprintf("addr_mgmt_assoc: skipping private IPv4 addr: %s\n", buf);
1750                         }
1751 #endif /* SCTP_DEBUG */
1752                         return;
1753                 }
1754         } else {
1755                 /* else, not AF_INET or AF_INET6, so skip */
1756 #ifdef SCTP_DEBUG
1757                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1758                         kprintf("addr_mgmt_assoc: not AF_INET or AF_INET6\n");
1759                 }
1760 #endif /* SCTP_DEBUG */
1761                 return;
1762         }
1763
1764         /* queue an asconf for this address add/delete */
1765         if (inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) {
1766                 /* does the peer do asconf? */
1767                 if (stcb->asoc.peer_supports_asconf) {
1768                         /* queue an asconf for this addr */
1769                         status = sctp_asconf_queue_add(stcb, ifa, type);
1770                         /*
1771                          * if queued ok, and in correct state, set the
1772                          * ASCONF timer
1773                          * if in non-open state, we will set this timer
1774                          * when the state does go open and do all the
1775                          * asconf's
1776                          */
1777                         if (status == 0 &&
1778                             SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) {
1779                                 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp,
1780                                     stcb, stcb->asoc.primary_destination);
1781                         }
1782                 }
1783         } else {
1784                 /* this is the boundall, no ASCONF case */
1785 #if 0 /* assume kernel will delete this very shortly; add done above */
1786                 if (type == SCTP_DEL_IP_ADDRESS) {
1787                         /* if deleting, add this addr to the do not use list */
1788                         sctp_add_local_addr_assoc(stcb, ifa);
1789                 }
1790 #endif
1791         }
1792 }
1793
1794 static void
1795 sctp_addr_mgmt_ep(struct sctp_inpcb *inp, struct ifaddr *ifa, uint16_t type)
1796 {
1797         struct sctp_tcb *stcb;
1798
1799         SCTP_INP_WLOCK(inp);
1800         /* make sure we're "allowed" to add this type of addr */
1801         if (ifa->ifa_addr->sa_family == AF_INET6) {
1802                 struct in6_ifaddr *ifa6;
1803
1804                 /* invalid if we're not a v6 endpoint */
1805                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {
1806                         SCTP_INP_WUNLOCK(inp);
1807                         return;
1808                 }
1809                 /* is the v6 addr really valid ? */
1810                 ifa6 = (struct in6_ifaddr *)ifa;
1811                 if (IFA6_IS_DEPRECATED(ifa6) ||
1812                     (ifa6->ia6_flags &
1813                      (IN6_IFF_DETACHED | IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) {
1814                         /* can't use an invalid address */
1815                         SCTP_INP_WUNLOCK(inp);
1816                         return;
1817                 }
1818         } else if (ifa->ifa_addr->sa_family == AF_INET) {
1819                 /* invalid; we are a v6 only endpoint */
1820                 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
1821                         SCTP_INP_WUNLOCK(inp);
1822                         return;
1823                 }
1824         } else {
1825                 /* invalid address family */
1826                 SCTP_INP_WUNLOCK(inp);
1827                 return;
1828         }
1829         /* is this endpoint subset bound ? */
1830         if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
1831                 /* subset bound endpoint */
1832                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) == 0) {
1833                         /*
1834                          * subset bound, but ASCONFs not allowed...
1835                          * if adding, nothing to do, since not allowed
1836                          * if deleting, remove address from endpoint
1837                          *      peer will have to "timeout" this addr
1838                          */
1839                         if (type == SCTP_DEL_IP_ADDRESS) {
1840                                 sctp_del_local_addr_ep(inp, ifa);
1841                         }
1842                         /* no asconfs to queue for this inp... */
1843                         SCTP_INP_WUNLOCK(inp);
1844                         return;
1845                 } else {
1846                         /*
1847                          * subset bound, ASCONFs allowed...
1848                          * if adding, add address to endpoint list
1849                          * if deleting, remove address from endpoint
1850                          */
1851                         if (type == SCTP_ADD_IP_ADDRESS) {
1852                                 sctp_add_local_addr_ep(inp, ifa);
1853                         } else {
1854                                 sctp_del_local_addr_ep(inp, ifa);
1855                         }
1856                         /* drop through and notify all asocs */
1857                 }
1858         }
1859
1860         crit_enter();
1861         /* process for all associations for this endpoint */
1862         LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
1863                 SCTP_TCB_LOCK(stcb);
1864                 sctp_addr_mgmt_assoc(inp, stcb, ifa, type);
1865                 SCTP_TCB_UNLOCK(stcb);
1866         } /* for each stcb */
1867         crit_exit();
1868         SCTP_INP_WUNLOCK(inp);
1869 }
1870
1871 /*
1872  * restrict the use of this address
1873  */
1874 static void
1875 sctp_addr_mgmt_restrict_ep(struct sctp_inpcb *inp, struct ifaddr *ifa)
1876 {
1877         struct sctp_tcb *stcb;
1878
1879         /* is this endpoint bound to all? */
1880         if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
1881                 /*
1882                  * Nothing to do for subset bound case.
1883                  * Allow sctp_bindx() to manage the address lists
1884                  */
1885                 return;
1886         }
1887
1888         crit_enter();
1889         SCTP_INP_RLOCK(inp);
1890         /* process for all associations for this endpoint */
1891         LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
1892                 /* put this address on the "pending/do not use yet" list */
1893                 SCTP_TCB_LOCK(stcb);
1894                 sctp_add_local_addr_assoc(stcb, ifa);
1895                 SCTP_TCB_UNLOCK(stcb);
1896 #ifdef SCTP_DEBUG
1897                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1898                         kprintf("restrict_ep: added addr to unusable list\n");
1899                 }
1900 #endif /* SCTP_DEBUG */
1901         } /* for each stcb */
1902         crit_exit();
1903         SCTP_INP_RUNLOCK(inp);
1904 }
1905
1906 /*
1907  * this is only called for kernel initiated address changes
1908  * eg. it will check the PCB_FLAGS_AUTO_ASCONF flag
1909  */
1910 static void
1911 sctp_addr_mgmt(struct ifaddr *ifa, uint16_t type) {
1912         struct sockaddr *sa;
1913         struct sctp_inpcb *inp;
1914
1915         /* make sure we care about this interface... */
1916         if (!sctp_is_desired_interface_type(ifa)) {
1917 #ifdef SCTP_DEBUG
1918                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1919                         kprintf("sctp_addr_mgmt: ignoring this interface\n");
1920                 }
1921 #endif /* SCTP_DEBUG */
1922                 return;
1923         }
1924
1925         sa = ifa->ifa_addr;
1926         if (sa->sa_family != AF_INET && sa->sa_family != AF_INET6)
1927                 return;
1928
1929 #ifdef SCTP_DEBUG
1930         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1931                 if (type == SCTP_ADD_IP_ADDRESS)
1932                         kprintf("sctp_addr_mgmt: kernel adds ");
1933                 else
1934                         kprintf("sctp_addr_mgmt: kernel deletes ");
1935                 sctp_print_address(sa);
1936         }
1937 #endif /* SCTP_DEBUG */
1938
1939         /* go through all our PCB's */
1940         LIST_FOREACH(inp, &sctppcbinfo.listhead, sctp_list) {
1941                 if (inp->sctp_flags & SCTP_PCB_FLAGS_AUTO_ASCONF) {
1942                         sctp_addr_mgmt_ep(inp, ifa, type);
1943                 } else {
1944                         /* this address is going away anyways... */
1945                         if (type == SCTP_DEL_IP_ADDRESS)
1946                                 return;
1947                         /* (temporarily) restrict this address */
1948                         sctp_addr_mgmt_restrict_ep(inp, ifa);
1949                 }
1950                 /* else, not allowing automatic asconf's, so ignore */
1951         } /* for each inp */
1952 }
1953
1954 /*
1955  * add/delete IP address requests from kernel (via routing change)
1956  * assumed that the address is non-broadcast, non-multicast
1957  * all addresses are passed from any type of interface-- need to filter
1958  * duplicate addresses may get requested
1959  */
1960
1961 void
1962 sctp_add_ip_address(struct ifaddr *ifa)
1963 {
1964         sctp_addr_mgmt(ifa, SCTP_ADD_IP_ADDRESS);
1965 }
1966
1967 void
1968 sctp_delete_ip_address(struct ifaddr *ifa)
1969 {
1970         struct sctp_inpcb *inp;
1971
1972         /* process the delete */
1973         sctp_addr_mgmt(ifa, SCTP_DEL_IP_ADDRESS);
1974
1975         /*
1976          * need to remove this ifaddr from any cached routes
1977          * and also any from any assoc "restricted/pending" lists
1978          */
1979         /* make sure we care about this interface... */
1980         if (!sctp_is_desired_interface_type(ifa)) {
1981 #ifdef SCTP_DEBUG
1982                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1983                         kprintf("sctp_delete_ip_address: ignoring this interface\n");
1984                 }
1985 #endif /* SCTP_DEBUG */
1986                 return;
1987         }
1988
1989         /* go through all our PCB's */
1990         SCTP_INP_INFO_RLOCK();
1991         LIST_FOREACH(inp, &sctppcbinfo.listhead, sctp_list) {
1992                 struct sctp_tcb *stcb;
1993                 struct sctp_laddr *laddr, *laddr_next;
1994
1995                 /* process for all associations for this endpoint */
1996                 SCTP_INP_RLOCK(inp);
1997                 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
1998                         struct sctp_nets *net;
1999
2000                         /* process through the nets list */
2001                         TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2002                                 struct rtentry *rt;
2003                                 /* delete this address if cached */
2004                                 rt = net->ro.ro_rt;
2005                                 if (rt != NULL && rt->rt_ifa == ifa) {
2006 /*                                      RTFREE(rt);*/
2007                                         net->ro.ro_rt = NULL;
2008                                 }
2009                         } /* for each net */
2010                         /* process through the asoc "pending" list */
2011                         laddr = LIST_FIRST(&stcb->asoc.sctp_local_addr_list);
2012                         while (laddr != NULL) {
2013                                 laddr_next = LIST_NEXT(laddr, sctp_nxt_addr);
2014                                 /* remove if in use */
2015                                 if (laddr->ifa == ifa) {
2016                                         sctp_remove_laddr(laddr);
2017                                 }
2018                                 laddr = laddr_next;
2019                         } /* while */
2020                 } /* for each stcb */
2021                 /* process through the inp bound addr list */
2022                 laddr = LIST_FIRST(&inp->sctp_addr_list);
2023                 while (laddr != NULL) {
2024                         laddr_next = LIST_NEXT(laddr, sctp_nxt_addr);
2025                         /* remove if in use */
2026                         if (laddr->ifa == ifa) {
2027                                 sctp_remove_laddr(laddr);
2028                         }
2029                         laddr = laddr_next;
2030                 } /* while */
2031                 SCTP_INP_RUNLOCK(inp);
2032         } /* for each inp */
2033         SCTP_INP_INFO_RUNLOCK();
2034 }
2035
2036 /*
2037  * sa is the sockaddr to ask the peer to set primary to
2038  * returns: 0 = completed, -1 = error
2039  */
2040 int32_t
2041 sctp_set_primary_ip_address_sa(struct sctp_tcb *stcb, struct sockaddr *sa)
2042 {
2043         /* NOTE: we currently don't check the validity of the address! */
2044
2045         /* queue an ASCONF:SET_PRIM_ADDR to be sent */
2046         if (!sctp_asconf_queue_add_sa(stcb, sa, SCTP_SET_PRIM_ADDR)) {
2047                 /* set primary queuing succeeded */
2048                 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) {
2049                         sctp_timer_start(SCTP_TIMER_TYPE_ASCONF,
2050                             stcb->sctp_ep, stcb,
2051                             stcb->asoc.primary_destination);
2052                 }
2053 #ifdef SCTP_DEBUG
2054                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2055                         kprintf("set_primary_ip_address_sa: queued on tcb=%p, ",
2056                             stcb);
2057                         sctp_print_address(sa);
2058                 }
2059 #endif /* SCTP_DEBUG */
2060         } else {
2061 #ifdef SCTP_DEBUG
2062                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2063                         kprintf("set_primary_ip_address_sa: failed to add to queue on tcb=%p, ",
2064                             stcb);
2065                         sctp_print_address(sa);
2066                 }
2067 #endif /* SCTP_DEBUG */
2068                 return (-1);
2069         }
2070         return (0);
2071 }
2072
2073 void
2074 sctp_set_primary_ip_address(struct ifaddr *ifa)
2075 {
2076         struct sctp_inpcb *inp;
2077
2078         /* make sure we care about this interface... */
2079         if (!sctp_is_desired_interface_type(ifa)) {
2080 #ifdef SCTP_DEBUG
2081                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2082                         kprintf("set_primary_ip_address: ignoring this interface\n");
2083                 }
2084 #endif /* SCTP_DEBUG */
2085                 return;
2086         }
2087
2088         /* go through all our PCB's */
2089         LIST_FOREACH(inp, &sctppcbinfo.listhead, sctp_list) {
2090                 struct sctp_tcb *stcb;
2091
2092                 /* process for all associations for this endpoint */
2093                 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
2094                         /* queue an ASCONF:SET_PRIM_ADDR to be sent */
2095                         if (!sctp_asconf_queue_add(stcb, ifa,
2096                             SCTP_SET_PRIM_ADDR)) {
2097                                 /* set primary queuing succeeded */
2098                                 if (SCTP_GET_STATE(&stcb->asoc) ==
2099                                     SCTP_STATE_OPEN) {
2100                                         sctp_timer_start(SCTP_TIMER_TYPE_ASCONF,
2101                                             stcb->sctp_ep, stcb,
2102                                             stcb->asoc.primary_destination);
2103                                 }
2104 #ifdef SCTP_DEBUG
2105                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2106                                         kprintf("set_primary_ip_address: queued on stcb=%p, ",
2107                                             stcb);
2108                                         sctp_print_address(ifa->ifa_addr);
2109                                 }
2110 #endif /* SCTP_DEBUG */
2111                         } else {
2112 #ifdef SCTP_DEBUG
2113                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2114                                         kprintf("set_primary_ip_address: failed to add to queue, ");
2115                                         sctp_print_address(ifa->ifa_addr);
2116                                 }
2117 #endif /* SCTP_DEBUG */
2118                         }
2119                 } /* for each stcb */
2120         } /* for each inp */
2121 }
2122
2123 static struct sockaddr *
2124 sctp_find_valid_localaddr(struct sctp_tcb *stcb)
2125 {
2126         struct ifnet *ifn;
2127
2128         TAILQ_FOREACH(ifn, &ifnet, if_list) {
2129                 struct ifaddr_container *ifac;
2130
2131                 if (stcb->asoc.loopback_scope == 0 && ifn->if_type == IFT_LOOP) {
2132                         /* Skip if loopback_scope not set */
2133                         continue;
2134                 }
2135                 TAILQ_FOREACH(ifac, &ifn->if_addrheads[mycpuid], ifa_link) {
2136                         struct ifaddr *ifa = ifac->ifa;
2137
2138                         if (ifa->ifa_addr->sa_family == AF_INET &&
2139                             stcb->asoc.ipv4_addr_legal) {
2140                                 struct sockaddr_in *sin;
2141
2142                                 sin = (struct sockaddr_in *)ifa->ifa_addr;
2143                                 if (sin->sin_addr.s_addr == 0) {
2144                                         /* skip unspecifed addresses */
2145                                         continue;
2146                                 }
2147                                 if (stcb->asoc.ipv4_local_scope == 0 &&
2148                                     IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))
2149                                         continue;
2150
2151                                 if (sctp_is_addr_restricted(stcb,
2152                                     ifa->ifa_addr))
2153                                         continue;
2154                                 /* found a valid local v4 address to use */
2155                                 return (ifa->ifa_addr);
2156                         } else if (ifa->ifa_addr->sa_family == AF_INET6 &&
2157                             stcb->asoc.ipv6_addr_legal) {
2158                                 struct sockaddr_in6 *sin6;
2159                                 struct in6_ifaddr *ifa6;
2160
2161                                 ifa6 = (struct in6_ifaddr *)ifa;
2162                                 if (IFA6_IS_DEPRECATED(ifa6) ||
2163                                     (ifa6->ia6_flags & (IN6_IFF_DETACHED |
2164                                      IN6_IFF_ANYCAST | IN6_IFF_NOTREADY)))
2165                                         continue;
2166
2167                                 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
2168                                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
2169                                         /* we skip unspecifed addresses */
2170                                         continue;
2171                                 }
2172                                 if (stcb->asoc.local_scope == 0 &&
2173                                     IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
2174                                         continue;
2175                                 if (stcb->asoc.site_scope == 0 &&
2176                                     IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))
2177                                         continue;
2178
2179                                 /* found a valid local v6 address to use */
2180                                 return (ifa->ifa_addr);
2181                         }
2182                 }
2183         }
2184         /* no valid addresses found */
2185         return (NULL);
2186 }
2187
2188 static struct sockaddr *
2189 sctp_find_valid_localaddr_ep(struct sctp_tcb *stcb)
2190 {
2191         struct sctp_laddr *laddr;
2192
2193         LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list, sctp_nxt_addr) {
2194                 if (laddr->ifa == NULL) {
2195 #ifdef SCTP_DEBUG
2196                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2197                                 kprintf("find_valid_localaddr_ep: laddr error\n");
2198                         }
2199 #endif /* SCTP_DEBUG */
2200                         continue;
2201                 }
2202                 if (laddr->ifa->ifa_addr == NULL) {
2203 #ifdef SCTP_DEBUG
2204                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2205                                 kprintf("find_valid_localaddr_ep: laddr->ifa error\n");
2206                         }
2207 #endif /* SCTP_DEBUG */
2208                         continue;
2209                 }
2210                 /* is the address restricted ? */
2211                 if (sctp_is_addr_restricted(stcb, laddr->ifa->ifa_addr))
2212                         continue;
2213
2214                 /* found a valid local address to use */
2215                 return (laddr->ifa->ifa_addr);
2216         }
2217         /* no valid addresses found */
2218         return (NULL);
2219 }
2220
2221 /*
2222  * builds an ASCONF chunk from queued ASCONF params
2223  * returns NULL on error (no mbuf, no ASCONF params queued, etc)
2224  */
2225 struct mbuf *
2226 sctp_compose_asconf(struct sctp_tcb *stcb)
2227 {
2228         struct mbuf *m_asconf, *m_asconf_chk;
2229         struct sctp_asconf_addr *aa;
2230         struct sctp_asconf_chunk *acp;
2231         struct sctp_asconf_paramhdr *aph;
2232         struct sctp_asconf_addr_param *aap;
2233         uint32_t p_length;
2234         uint32_t correlation_id = 1;            /* 0 is reserved... */
2235         caddr_t ptr, lookup_ptr;
2236         uint8_t lookup_used = 0;
2237
2238         /* are there any asconf params to send? */
2239         if (TAILQ_EMPTY(&stcb->asoc.asconf_queue)) {
2240                 return (NULL);
2241         }
2242
2243         /*
2244          * get a chunk header mbuf and a cluster for the asconf params
2245          * since it's simpler to fill in the asconf chunk header lookup
2246          * address on the fly
2247          */
2248         m_asconf_chk = NULL;
2249         MGETHDR(m_asconf_chk, MB_DONTWAIT, MT_DATA);
2250         if (m_asconf_chk == NULL) {
2251                 /* no mbuf's */
2252 #ifdef SCTP_DEBUG
2253                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2254                         kprintf("compose_asconf: couldn't get chunk mbuf!\n");
2255 #endif /* SCTP_DEBUG */
2256                 return (NULL);
2257         }
2258         m_asconf = NULL;
2259         MGETHDR(m_asconf, MB_DONTWAIT, MT_HEADER);
2260         if (m_asconf == NULL) {
2261                 /* no mbuf's */
2262 #ifdef SCTP_DEBUG
2263                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2264                         kprintf("compose_asconf: couldn't get mbuf!\n");
2265 #endif /* SCTP_DEBUG */
2266                 sctp_m_freem(m_asconf_chk);
2267                 return (NULL);
2268         }
2269         MCLGET(m_asconf, MB_DONTWAIT);
2270         if ((m_asconf->m_flags & M_EXT) != M_EXT) {
2271                 /* failed to get cluster buffer */
2272 #ifdef SCTP_DEBUG
2273                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2274                         kprintf("compose_asconf: couldn't get cluster!\n");
2275 #endif /* SCTP_DEBUG */
2276                 sctp_m_freem(m_asconf_chk);
2277                 sctp_m_freem(m_asconf);
2278                 return (NULL);
2279         }
2280
2281         m_asconf_chk->m_len = sizeof(struct sctp_asconf_chunk);
2282         m_asconf->m_len = 0;
2283         acp = mtod(m_asconf_chk, struct sctp_asconf_chunk *);
2284         bzero(acp, sizeof(struct sctp_asconf_chunk));
2285         /* save pointers to lookup address and asconf params */
2286         lookup_ptr = (caddr_t)(acp + 1);        /* after the header */
2287         ptr = mtod(m_asconf, caddr_t);          /* beginning of cluster */
2288
2289         /* fill in chunk header info */
2290         acp->ch.chunk_type = SCTP_ASCONF;
2291         acp->ch.chunk_flags = 0;
2292         acp->serial_number = htonl(stcb->asoc.asconf_seq_out);
2293
2294         /* add parameters... up to smallest MTU allowed */
2295         TAILQ_FOREACH(aa, &stcb->asoc.asconf_queue, next) {
2296                 /* get the parameter length */
2297                 p_length = SCTP_SIZE32(aa->ap.aph.ph.param_length);
2298                 /* will it fit in current chunk? */
2299                 if (m_asconf->m_len + p_length > stcb->asoc.smallest_mtu) {
2300                         /* won't fit, so we're done with this chunk */
2301                         break;
2302                 }
2303                 /* assign (and store) a correlation id */
2304                 aa->ap.aph.correlation_id = correlation_id++;
2305
2306                 /*
2307                  * fill in address if we're doing a delete
2308                  * this is a simple way for us to fill in the correlation
2309                  * address, which should only be used by the peer if we're
2310                  * deleting our source address and adding a new address
2311                  * (e.g. renumbering case)
2312                  */
2313                 if (lookup_used == 0 &&
2314                     aa->ap.aph.ph.param_type == SCTP_DEL_IP_ADDRESS) {
2315                         struct sctp_ipv6addr_param *lookup;
2316                         uint16_t p_size, addr_size;
2317
2318                         lookup = (struct sctp_ipv6addr_param *)lookup_ptr;
2319                         lookup->ph.param_type =
2320                             htons(aa->ap.addrp.ph.param_type);
2321                         if (aa->ap.addrp.ph.param_type == SCTP_IPV6_ADDRESS) {
2322                                 /* copy IPv6 address */
2323                                 p_size = sizeof(struct sctp_ipv6addr_param);
2324                                 addr_size = sizeof(struct in6_addr);
2325                         } else {
2326                                 /* copy IPv4 address */
2327                                 p_size = sizeof(struct sctp_ipv4addr_param);
2328                                 addr_size = sizeof(struct in_addr);
2329                         }
2330                         lookup->ph.param_length = htons(SCTP_SIZE32(p_size));
2331                         memcpy(lookup->addr, &aa->ap.addrp.addr, addr_size);
2332                         m_asconf_chk->m_len += SCTP_SIZE32(p_size);
2333                         lookup_used = 1;
2334                 }
2335
2336                 /* copy into current space */
2337                 memcpy(ptr, &aa->ap, p_length);
2338
2339                 /* network elements and update lengths */
2340                 aph = (struct sctp_asconf_paramhdr *) ptr;
2341                 aap = (struct sctp_asconf_addr_param *) ptr;
2342                 /* correlation_id is transparent to peer, no htonl needed */
2343                 aph->ph.param_type = htons(aph->ph.param_type);
2344                 aph->ph.param_length = htons(aph->ph.param_length);
2345                 aap->addrp.ph.param_type = htons(aap->addrp.ph.param_type);
2346                 aap->addrp.ph.param_length = htons(aap->addrp.ph.param_length);
2347
2348                 m_asconf->m_len += SCTP_SIZE32(p_length);
2349                 ptr += SCTP_SIZE32(p_length);
2350
2351                 /*
2352                  * these params are removed off the pending list upon
2353                  * getting an ASCONF-ACK back from the peer, just set flag
2354                  */
2355                 aa->sent = 1;
2356         }
2357         /* check to see if the lookup addr has been populated yet */
2358         if (lookup_used == 0) {
2359                 /* NOTE: if the address param is optional, can skip this... */
2360                 /* add any valid (existing) address... */
2361                 struct sctp_ipv6addr_param *lookup;
2362                 uint16_t p_size, addr_size;
2363                 struct sockaddr *found_addr;
2364                 caddr_t addr_ptr;
2365
2366                 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL)
2367                         found_addr = sctp_find_valid_localaddr(stcb);
2368                 else
2369                         found_addr = sctp_find_valid_localaddr_ep(stcb);
2370
2371                 lookup = (struct sctp_ipv6addr_param *)lookup_ptr;
2372                 if (found_addr != NULL) {
2373                         if (found_addr->sa_family == AF_INET6) {
2374                                 /* copy IPv6 address */
2375                                 lookup->ph.param_type =
2376                                     htons(SCTP_IPV6_ADDRESS);
2377                                 p_size = sizeof(struct sctp_ipv6addr_param);
2378                                 addr_size = sizeof(struct in6_addr);
2379                                 addr_ptr = (caddr_t)&((struct sockaddr_in6 *)
2380                                     found_addr)->sin6_addr;
2381                         } else {
2382                                 /* copy IPv4 address */
2383                                 lookup->ph.param_type =
2384                                     htons(SCTP_IPV4_ADDRESS);
2385                                 p_size = sizeof(struct sctp_ipv4addr_param);
2386                                 addr_size = sizeof(struct in_addr);
2387                                 addr_ptr = (caddr_t)&((struct sockaddr_in *)
2388                                     found_addr)->sin_addr;
2389                         }
2390                         lookup->ph.param_length = htons(SCTP_SIZE32(p_size));
2391                         memcpy(lookup->addr, addr_ptr, addr_size);
2392                         m_asconf_chk->m_len += SCTP_SIZE32(p_size);
2393                         lookup_used = 1;
2394                 } else {
2395                         /* uh oh... don't have any address?? */
2396 #ifdef SCTP_DEBUG
2397                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2398                                 kprintf("compose_asconf: no lookup addr!\n");
2399 #endif /* SCTP_DEBUG */
2400                         /* for now, we send a IPv4 address of 0.0.0.0 */
2401                         lookup->ph.param_type = htons(SCTP_IPV4_ADDRESS);
2402                         lookup->ph.param_length = htons(SCTP_SIZE32(sizeof(struct sctp_ipv4addr_param)));
2403                         bzero(lookup->addr, sizeof(struct in_addr));
2404                         m_asconf_chk->m_len += SCTP_SIZE32(sizeof(struct sctp_ipv4addr_param));
2405                         lookup_used = 1;
2406                 }
2407         }
2408
2409         /* chain it all together */
2410         m_asconf_chk->m_next = m_asconf;
2411         m_asconf_chk->m_pkthdr.len = m_asconf_chk->m_len + m_asconf->m_len;
2412         acp->ch.chunk_length = ntohs(m_asconf_chk->m_pkthdr.len);
2413
2414         /* update "sent" flag */
2415         stcb->asoc.asconf_sent++;
2416
2417         return (m_asconf_chk);
2418 }
2419
2420 /*
2421  * section to handle address changes before an association is up
2422  * eg. changes during INIT/INIT-ACK/COOKIE-ECHO handshake
2423  */
2424
2425 /*
2426  * processes the (local) addresses in the INIT-ACK chunk
2427  */
2428 static void
2429 sctp_process_initack_addresses(struct sctp_tcb *stcb, struct mbuf *m,
2430     unsigned int offset, unsigned int length)
2431 {
2432         struct sctp_paramhdr tmp_param, *ph;
2433         uint16_t plen, ptype;
2434         struct sctp_ipv6addr_param addr_store;
2435         struct sockaddr_in6 sin6;
2436         struct sockaddr_in sin;
2437         struct sockaddr *sa;
2438         struct ifaddr *ifa;
2439
2440 #ifdef SCTP_DEBUG
2441         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2442                 kprintf("processing init-ack addresses\n");
2443         }
2444 #endif /* SCTP_DEBUG */
2445
2446         /* convert to upper bound */
2447         length += offset;
2448
2449         if ((offset + sizeof(struct sctp_paramhdr)) > length) {
2450 #ifdef SCTP_DEBUG
2451                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2452                         kprintf("process_initack_addrs: invalid offset?\n");
2453                 }
2454 #endif /* SCTP_DEBUG */
2455                 return;
2456         }
2457
2458         /* init the addresses */
2459         bzero(&sin6, sizeof(sin6));
2460         sin6.sin6_family = AF_INET6;
2461         sin6.sin6_len = sizeof(sin6);
2462         sin6.sin6_port = stcb->rport;
2463
2464         bzero(&sin, sizeof(sin));
2465         sin.sin_len = sizeof(sin);
2466         sin.sin_family = AF_INET;
2467         sin.sin_port = stcb->rport;
2468
2469         /* go through the addresses in the init-ack */
2470         ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset,
2471             sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param);
2472         while (ph != NULL) {
2473                 ptype = ntohs(ph->param_type);
2474                 plen = ntohs(ph->param_length);
2475                 if (ptype == SCTP_IPV6_ADDRESS) {
2476                         struct sctp_ipv6addr_param *a6p;
2477                         /* get the entire IPv6 address param */
2478 #ifdef SCTP_DEBUG
2479                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2480                                 kprintf("process_initack_addrs: checking IPv6 param\n");
2481                         }
2482 #endif /* SCTP_DEBUG */
2483                         a6p = (struct sctp_ipv6addr_param *)
2484                                 sctp_m_getptr(m, offset,
2485                                     sizeof(struct sctp_ipv6addr_param),
2486                                     (uint8_t *)&addr_store);
2487                         if (plen != sizeof(struct sctp_ipv6addr_param) ||
2488                             a6p == NULL) {
2489 #ifdef SCTP_DEBUG
2490                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2491                                         kprintf("process_initack_addrs: invalid IPv6 param length\n");
2492                                 }
2493 #endif /* SCTP_DEBUG */
2494                                 return;
2495                         }
2496                         memcpy(&sin6.sin6_addr, a6p->addr,
2497                             sizeof(struct in6_addr));
2498                         sa = (struct sockaddr *)&sin6;
2499                 } else if (ptype == SCTP_IPV4_ADDRESS) {
2500                         struct sctp_ipv4addr_param *a4p;
2501                         /* get the entire IPv4 address param */
2502 #ifdef SCTP_DEBUG
2503                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2504                                 kprintf("process_initack_addrs: checking IPv4 param\n");
2505                         }
2506 #endif /* SCTP_DEBUG */
2507                         a4p = (struct sctp_ipv4addr_param *)sctp_m_getptr(m, offset, sizeof(struct sctp_ipv4addr_param), (uint8_t *)&addr_store);
2508                         if (plen != sizeof(struct sctp_ipv4addr_param) ||
2509                             a4p == NULL) {
2510 #ifdef SCTP_DEBUG
2511                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2512                                         kprintf("process_initack_addrs: invalid IPv4 param length\n");
2513                                 }
2514 #endif /* SCTP_DEBUG */
2515                                 return;
2516                         }
2517                         sin.sin_addr.s_addr = a4p->addr;
2518                         sa = (struct sockaddr *)&sin;
2519                 } else {
2520 #ifdef SCTP_DEBUG
2521                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2522                                 kprintf("process_initack_addrs: skipping param type=%xh\n", ptype);
2523                         }
2524 #endif /* SCTP_DEBUG */
2525                         goto next_addr;
2526                 }
2527
2528                 /* see if this address really (still) exists */
2529                 ifa = sctp_find_ifa_by_addr(sa);
2530                 if (ifa == NULL) {
2531                         /* address doesn't exist anymore */
2532                         int status;
2533                         /* are ASCONFs allowed ? */
2534                         if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) &&
2535                             stcb->asoc.peer_supports_asconf) {
2536                                 /* queue an ASCONF DEL_IP_ADDRESS */
2537                                 status = sctp_asconf_queue_add_sa(stcb, sa,
2538                                     SCTP_DEL_IP_ADDRESS);
2539                                 /*
2540                                  * if queued ok, and in correct state,
2541                                  * set the ASCONF timer
2542                                  */
2543                                 if (status == 0 &&
2544                                     SCTP_GET_STATE(&stcb->asoc) ==
2545                                     SCTP_STATE_OPEN) {
2546                                         sctp_timer_start(SCTP_TIMER_TYPE_ASCONF,
2547                                             stcb->sctp_ep, stcb,
2548                                             stcb->asoc.primary_destination);
2549                                 }
2550                         }
2551                 } else {
2552                         /* address still exists */
2553                         /*
2554                          * if subset bound, ep addr's managed by default
2555                          * if not doing ASCONF, add the address to the assoc
2556                          */
2557                         if ((stcb->sctp_ep->sctp_flags &
2558                              SCTP_PCB_FLAGS_BOUNDALL) == 0 &&
2559                             (stcb->sctp_ep->sctp_flags &
2560                              SCTP_PCB_FLAGS_DO_ASCONF) == 0) {
2561 #ifdef SCTP_DEBUG
2562                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2563                                         kprintf("process_initack_addrs: adding local addr to asoc\n");
2564                                 }
2565 #endif /* SCTP_DEBUG */
2566                                 sctp_add_local_addr_assoc(stcb, ifa);
2567                         }
2568                 }
2569
2570         next_addr:
2571                 /* get next parameter */
2572                 offset += SCTP_SIZE32(plen);
2573                 if ((offset + sizeof(struct sctp_paramhdr)) > length)
2574                         return;
2575                 ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset,
2576                     sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param);
2577         } /* while */
2578 }
2579
2580 /* FIX ME: need to verify return result for v6 address type if v6 disabled */
2581 /*
2582  * checks to see if a specific address is in the initack address list
2583  * returns 1 if found, 0 if not
2584  */
2585 static uint32_t
2586 sctp_addr_in_initack(struct sctp_tcb *stcb, struct mbuf *m, unsigned int offset,
2587     unsigned int length, struct sockaddr *sa)
2588 {
2589         struct sctp_paramhdr tmp_param, *ph;
2590         uint16_t plen, ptype;
2591         struct sctp_ipv6addr_param addr_store;
2592         struct sockaddr_in *sin;
2593         struct sctp_ipv4addr_param *a4p;
2594 #ifdef INET6
2595         struct sockaddr_in6 *sin6, sin6_tmp;
2596         struct sctp_ipv6addr_param *a6p;
2597 #endif /* INET6 */
2598
2599         if (
2600 #ifdef INET6
2601                 (sa->sa_family != AF_INET6) &&
2602 #endif /* INET6 */
2603                 (sa->sa_family != AF_INET))
2604                 return (0);
2605
2606 #ifdef SCTP_DEBUG
2607         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2608                 kprintf("find_initack_addr: starting search for ");
2609                 sctp_print_address(sa);
2610         }
2611 #endif /* SCTP_DEBUG */
2612         /* convert to upper bound */
2613         length += offset;
2614
2615         if ((offset + sizeof(struct sctp_paramhdr)) > length) {
2616 #ifdef SCTP_DEBUG
2617                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2618                         kprintf("find_initack_addr: invalid offset?\n");
2619                 }
2620 #endif /* SCTP_DEBUG */
2621                 return (0);
2622         }
2623
2624         /* go through the addresses in the init-ack */
2625         ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset,
2626             sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param);
2627         while (ph != NULL) {
2628                 ptype = ntohs(ph->param_type);
2629                 plen = ntohs(ph->param_length);
2630 #ifdef INET6
2631                 if (ptype == SCTP_IPV6_ADDRESS && sa->sa_family == AF_INET6) {
2632                         /* get the entire IPv6 address param */
2633 #ifdef SCTP_DEBUG
2634                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2635                                 kprintf("addr_in_initack: checking IPv6 param\n");
2636                         }
2637 #endif /* SCTP_DEBUG */
2638                         a6p = (struct sctp_ipv6addr_param *)
2639                                 sctp_m_getptr(m, offset,
2640                                     sizeof(struct sctp_ipv6addr_param),
2641                                     (uint8_t *)&addr_store);
2642                         if (plen != sizeof(struct sctp_ipv6addr_param) ||
2643                             ph == NULL) {
2644 #ifdef SCTP_DEBUG
2645                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2646                                         kprintf("addr_in_initack: invalid IPv6 param length\n");
2647                                 }
2648 #endif /* SCTP_DEBUG */
2649                                 return (0);
2650                         }
2651                         sin6 = (struct sockaddr_in6 *)sa;
2652                         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr)) {
2653                                 /* create a copy and clear scope */
2654                                 memcpy(&sin6_tmp, sin6,
2655                                     sizeof(struct sockaddr_in6));
2656                                 sin6 = &sin6_tmp;
2657                                 in6_clearscope(&sin6->sin6_addr);
2658                         }
2659                         if (memcmp(&sin6->sin6_addr, a6p->addr,
2660                             sizeof(struct in6_addr)) == 0) {
2661                                 /* found it */
2662 #ifdef SCTP_DEBUG
2663                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2664                                         kprintf("addr_in_initack: found IPv6 addr\n");
2665                                 }
2666 #endif /* SCTP_DEBUG */
2667                                 return (1);
2668                         }
2669                 } else
2670 #endif /* INET6 */
2671
2672                 if (ptype == SCTP_IPV4_ADDRESS &&
2673                     sa->sa_family == AF_INET) {
2674                         /* get the entire IPv4 address param */
2675 #ifdef SCTP_DEBUG
2676                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2677                                 kprintf("addr_in_initack: checking IPv4 param\n");
2678                         }
2679 #endif /* SCTP_DEBUG */
2680                         a4p = (struct sctp_ipv4addr_param *)sctp_m_getptr(m,
2681                             offset, sizeof(struct sctp_ipv4addr_param),
2682                             (uint8_t *)&addr_store);
2683                         if (plen != sizeof(struct sctp_ipv4addr_param) ||
2684                             ph == NULL) {
2685 #ifdef SCTP_DEBUG
2686                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2687                                         kprintf("addr_in_initack: invalid IPv4 param length\n");
2688                                 }
2689 #endif /* SCTP_DEBUG */
2690                                 return (0);
2691                         }
2692                         sin = (struct sockaddr_in *)sa;
2693                         if (sin->sin_addr.s_addr == a4p->addr) {
2694                                 /* found it */
2695 #ifdef SCTP_DEBUG
2696                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2697                                         kprintf("addr_in_initack: found IPv4 addr\n");
2698                                 }
2699 #endif /* SCTP_DEBUG */
2700                                 return (1);
2701                         }
2702                 } else {
2703 #ifdef SCTP_DEBUG
2704                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2705                                 kprintf("addr_in_initack: skipping param type=%xh\n", ptype);
2706                         }
2707 #endif /* SCTP_DEBUG */
2708                 }
2709                 /* get next parameter */
2710                 offset += SCTP_SIZE32(plen);
2711                 if (offset + sizeof(struct sctp_paramhdr) > length)
2712                         return (0);
2713                 ph = (struct sctp_paramhdr *)
2714                         sctp_m_getptr(m, offset, sizeof(struct sctp_paramhdr),
2715                             (uint8_t *)&tmp_param);
2716         } /* while */
2717         /* not found! */
2718 #ifdef SCTP_DEBUG
2719         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2720                 kprintf("addr_in_initack: not found!\n");
2721         }
2722 #endif /* SCTP_DEBUG */
2723         return (0);
2724 }
2725
2726 /*
2727  * makes sure that the current endpoint local addr list is consistent
2728  * with the new association (eg. subset bound, asconf allowed)
2729  * adds addresses as necessary
2730  */
2731 static void
2732 sctp_check_address_list_ep(struct sctp_tcb *stcb, struct mbuf *m, int offset,
2733     int length, struct sockaddr *init_addr)
2734 {
2735         struct sctp_laddr *laddr;
2736
2737         /* go through the endpoint list */
2738         LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list, sctp_nxt_addr) {
2739                 /* be paranoid and validate the laddr */
2740                 if (laddr->ifa == NULL) {
2741 #ifdef SCTP_DEBUG
2742                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2743                                 kprintf("check_addr_list_ep: laddr->ifa is NULL");
2744                         }
2745 #endif
2746                         continue;
2747                 }
2748                 if (laddr->ifa->ifa_addr == NULL) {
2749 #ifdef SCTP_DEBUG
2750                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2751                                 kprintf("check_addr_list_ep: laddr->ifa->ifa_addr is NULL");
2752                         }
2753 #endif
2754                         continue;
2755                 }
2756                 /* do i have it implicitly? */
2757                 if (sctp_cmpaddr(laddr->ifa->ifa_addr, init_addr)) {
2758 #ifdef SCTP_DEBUG
2759                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2760                                 kprintf("check_address_list_all: skipping ");
2761                                 sctp_print_address(laddr->ifa->ifa_addr);
2762                         }
2763 #endif /* SCTP_DEBUG */
2764                         continue;
2765                 }
2766                 /* check to see if in the init-ack */
2767                 if (!sctp_addr_in_initack(stcb, m, offset, length,
2768                                           laddr->ifa->ifa_addr)) {
2769                         /* try to add it */
2770                         sctp_addr_mgmt_assoc(stcb->sctp_ep, stcb, laddr->ifa,
2771                             SCTP_ADD_IP_ADDRESS);
2772                 }
2773         }
2774 }
2775
2776 /*
2777  * makes sure that the current kernel address list is consistent
2778  * with the new association (with all addrs bound)
2779  * adds addresses as necessary
2780  */
2781 static void
2782 sctp_check_address_list_all(struct sctp_tcb *stcb, struct mbuf *m, int offset,
2783     int length, struct sockaddr *init_addr, uint16_t local_scope,
2784     uint16_t site_scope, uint16_t ipv4_scope, uint16_t loopback_scope)
2785 {
2786         struct ifnet *ifn;
2787
2788         /* go through all our known interfaces */
2789         TAILQ_FOREACH(ifn, &ifnet, if_list) {
2790                 struct ifaddr_container *ifac;
2791
2792                 if (loopback_scope == 0 && ifn->if_type == IFT_LOOP) {
2793                         /* skip loopback interface */
2794                         continue;
2795                 }
2796
2797                 /* go through each interface address */
2798                 TAILQ_FOREACH(ifac, &ifn->if_addrheads[mycpuid], ifa_link) {
2799                         struct ifaddr *ifa = ifac->ifa;
2800
2801                         /* do i have it implicitly? */
2802                         if (sctp_cmpaddr(ifa->ifa_addr, init_addr)) {
2803 #ifdef SCTP_DEBUG
2804                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2805                                         kprintf("check_address_list_all: "
2806                                                 "skipping ");
2807                                         sctp_print_address(ifa->ifa_addr);
2808                                 }
2809 #endif /* SCTP_DEBUG */
2810                                 continue;
2811                         }
2812                         /* check to see if in the init-ack */
2813                         if (!sctp_addr_in_initack(stcb, m, offset, length,
2814                             ifa->ifa_addr)) {
2815                                 /* try to add it */
2816                                 sctp_addr_mgmt_assoc(stcb->sctp_ep, stcb,
2817                                     ifa, SCTP_ADD_IP_ADDRESS);
2818                         }
2819                 } /* end foreach ifa */
2820         } /* end foreach ifn */
2821 }
2822
2823 /*
2824  * validates an init-ack chunk (from a cookie-echo) with current addresses
2825  * adds addresses from the init-ack into our local address list, if needed
2826  * queues asconf adds/deletes addresses as needed and makes appropriate
2827  * list changes for source address selection
2828  * m, offset: points to the start of the address list in an init-ack chunk
2829  * length: total length of the address params only
2830  * init_addr: address where my INIT-ACK was sent from
2831  */
2832 void
2833 sctp_check_address_list(struct sctp_tcb *stcb, struct mbuf *m, int offset,
2834     int length, struct sockaddr *init_addr, uint16_t local_scope,
2835     uint16_t site_scope, uint16_t ipv4_scope, uint16_t loopback_scope)
2836 {
2837
2838         /* process the local addresses in the initack */
2839         sctp_process_initack_addresses(stcb, m, offset, length);
2840
2841         if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
2842                 /* bound all case */
2843                 sctp_check_address_list_all(stcb, m, offset, length, init_addr,
2844                     local_scope, site_scope, ipv4_scope, loopback_scope);
2845         } else {
2846                 /* subset bound case */
2847                 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) {
2848                         /* asconf's allowed */
2849                         sctp_check_address_list_ep(stcb, m, offset, length,
2850                             init_addr);
2851                 }
2852                 /* else, no asconfs allowed, so what we sent is what we get */
2853         }
2854 }
2855
2856 /*
2857  * sctp_bindx() support
2858  */
2859 uint32_t
2860 sctp_addr_mgmt_ep_sa(struct sctp_inpcb *inp, struct sockaddr *sa, uint16_t type)
2861 {
2862         struct ifaddr *ifa;
2863
2864         if (sa->sa_len == 0)
2865                 return (EINVAL);
2866
2867         ifa = sctp_find_ifa_by_addr(sa);
2868         if (ifa != NULL) {
2869 #ifdef INET6
2870                 if (ifa->ifa_addr->sa_family == AF_INET6) {
2871                         struct in6_ifaddr *ifa6;
2872                         ifa6 = (struct in6_ifaddr *)ifa;
2873                         if (IFA6_IS_DEPRECATED(ifa6) ||
2874                             (ifa6->ia6_flags & (IN6_IFF_DETACHED |
2875                              IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) {
2876                                 /* Can't bind a non-existent addr. */
2877                                 return (EINVAL);
2878                         }
2879                 }
2880 #endif /* INET6 */
2881                 /* add this address */
2882                 sctp_addr_mgmt_ep(inp, ifa, type);
2883         } else {
2884                 /* invalid address! */
2885 #ifdef SCTP_DEBUG
2886                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2887                         kprintf("addr_mgmt_ep_sa: got invalid address!\n");
2888                 }
2889 #endif /* SCTP_DEBUG */
2890                 return (EADDRNOTAVAIL);
2891         }
2892         return (0);
2893 }