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 if we are a v6 only endpoint */
1729                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
1730 #if defined(__OpenBSD__)
1731                     (0) /* we always do dual bind */
1732 #elif defined (__NetBSD__)
1733                     (inp6->in6p_flags & IN6P_IPV6_V6ONLY)
1734 #else
1735                     (inp6->inp_flags & IN6P_IPV6_V6ONLY)
1736 #endif
1737                         )
1738                         return;
1739
1740                 sin = (struct sockaddr_in *)ifa->ifa_addr;
1741 #ifdef SCTP_DEBUG
1742                 strlcpy(buf, inet_ntoa(sin->sin_addr), sizeof(buf));
1743 #endif /* SCTP_DEBUG */
1744                 if (sin->sin_addr.s_addr == 0) {
1745                         /* we skip unspecifed addresses */
1746 #ifdef SCTP_DEBUG
1747                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1748                                 kprintf("addr_mgmt_assoc: unspecified IPv4 addr\n");
1749                         }
1750 #endif /* SCTP_DEBUG */
1751                         return;
1752                 }
1753                 if (stcb->asoc.ipv4_local_scope == 0 &&
1754                     IN4_ISPRIVATE_ADDRESS(&sin->sin_addr)) {
1755 #ifdef SCTP_DEBUG
1756                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1757                                 kprintf("addr_mgmt_assoc: skipping private IPv4 addr: %s\n", buf);
1758                         }
1759 #endif /* SCTP_DEBUG */
1760                         return;
1761                 }
1762         } else {
1763                 /* else, not AF_INET or AF_INET6, so skip */
1764 #ifdef SCTP_DEBUG
1765                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1766                         kprintf("addr_mgmt_assoc: not AF_INET or AF_INET6\n");
1767                 }
1768 #endif /* SCTP_DEBUG */
1769                 return;
1770         }
1771
1772         /* queue an asconf for this address add/delete */
1773         if (inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) {
1774                 /* does the peer do asconf? */
1775                 if (stcb->asoc.peer_supports_asconf) {
1776                         /* queue an asconf for this addr */
1777                         status = sctp_asconf_queue_add(stcb, ifa, type);
1778                         /*
1779                          * if queued ok, and in correct state, set the
1780                          * ASCONF timer
1781                          * if in non-open state, we will set this timer
1782                          * when the state does go open and do all the
1783                          * asconf's
1784                          */
1785                         if (status == 0 &&
1786                             SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) {
1787                                 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp,
1788                                     stcb, stcb->asoc.primary_destination);
1789                         }
1790                 }
1791         } else {
1792                 /* this is the boundall, no ASCONF case */
1793 #if 0 /* assume kernel will delete this very shortly; add done above */
1794                 if (type == SCTP_DEL_IP_ADDRESS) {
1795                         /* if deleting, add this addr to the do not use list */
1796                         sctp_add_local_addr_assoc(stcb, ifa);
1797                 }
1798 #endif
1799         }
1800 }
1801
1802 static void
1803 sctp_addr_mgmt_ep(struct sctp_inpcb *inp, struct ifaddr *ifa, uint16_t type)
1804 {
1805         struct sctp_tcb *stcb;
1806
1807         SCTP_INP_WLOCK(inp);
1808         /* make sure we're "allowed" to add this type of addr */
1809         if (ifa->ifa_addr->sa_family == AF_INET6) {
1810                 struct in6_ifaddr *ifa6;
1811
1812                 /* invalid if we're not a v6 endpoint */
1813                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {
1814                         SCTP_INP_WUNLOCK(inp);
1815                         return;
1816                 }
1817                 /* is the v6 addr really valid ? */
1818                 ifa6 = (struct in6_ifaddr *)ifa;
1819                 if (IFA6_IS_DEPRECATED(ifa6) ||
1820                     (ifa6->ia6_flags &
1821                      (IN6_IFF_DETACHED | IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) {
1822                         /* can't use an invalid address */
1823                         SCTP_INP_WUNLOCK(inp);
1824                         return;
1825                 }
1826         } else if (ifa->ifa_addr->sa_family == AF_INET) {
1827                 /* invalid if we are a v6 only endpoint */
1828                 struct in6pcb *inp6;
1829                 inp6 = (struct in6pcb *)&inp->ip_inp.inp;
1830
1831                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
1832 #if defined(__OpenBSD__)
1833                     (0) /* we always do dual bind */
1834 #elif defined (__NetBSD__)
1835                     (inp6->in6p_flags & IN6P_IPV6_V6ONLY)
1836 #else
1837                     (inp6->inp_flags & IN6P_IPV6_V6ONLY)
1838 #endif
1839                         ) {
1840                         SCTP_INP_WUNLOCK(inp);
1841                         return;
1842                 }
1843         } else {
1844                 /* invalid address family */
1845                 SCTP_INP_WUNLOCK(inp);
1846                 return;
1847         }
1848         /* is this endpoint subset bound ? */
1849         if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
1850                 /* subset bound endpoint */
1851                 if ((inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) == 0) {
1852                         /*
1853                          * subset bound, but ASCONFs not allowed...
1854                          * if adding, nothing to do, since not allowed
1855                          * if deleting, remove address from endpoint
1856                          *      peer will have to "timeout" this addr
1857                          */
1858                         if (type == SCTP_DEL_IP_ADDRESS) {
1859                                 sctp_del_local_addr_ep(inp, ifa);
1860                         }
1861                         /* no asconfs to queue for this inp... */
1862                         SCTP_INP_WUNLOCK(inp);
1863                         return;
1864                 } else {
1865                         /*
1866                          * subset bound, ASCONFs allowed...
1867                          * if adding, add address to endpoint list
1868                          * if deleting, remove address from endpoint
1869                          */
1870                         if (type == SCTP_ADD_IP_ADDRESS) {
1871                                 sctp_add_local_addr_ep(inp, ifa);
1872                         } else {
1873                                 sctp_del_local_addr_ep(inp, ifa);
1874                         }
1875                         /* drop through and notify all asocs */
1876                 }
1877         }
1878
1879         crit_enter();
1880         /* process for all associations for this endpoint */
1881         LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
1882                 SCTP_TCB_LOCK(stcb);
1883                 sctp_addr_mgmt_assoc(inp, stcb, ifa, type);
1884                 SCTP_TCB_UNLOCK(stcb);
1885         } /* for each stcb */
1886         crit_exit();
1887         SCTP_INP_WUNLOCK(inp);
1888 }
1889
1890 /*
1891  * restrict the use of this address
1892  */
1893 static void
1894 sctp_addr_mgmt_restrict_ep(struct sctp_inpcb *inp, struct ifaddr *ifa)
1895 {
1896         struct sctp_tcb *stcb;
1897
1898         /* is this endpoint bound to all? */
1899         if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
1900                 /*
1901                  * Nothing to do for subset bound case.
1902                  * Allow sctp_bindx() to manage the address lists
1903                  */
1904                 return;
1905         }
1906
1907         crit_enter();
1908         SCTP_INP_RLOCK(inp);
1909         /* process for all associations for this endpoint */
1910         LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
1911                 /* put this address on the "pending/do not use yet" list */
1912                 SCTP_TCB_LOCK(stcb);
1913                 sctp_add_local_addr_assoc(stcb, ifa);
1914                 SCTP_TCB_UNLOCK(stcb);
1915 #ifdef SCTP_DEBUG
1916                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1917                         kprintf("restrict_ep: added addr to unusable list\n");
1918                 }
1919 #endif /* SCTP_DEBUG */
1920         } /* for each stcb */
1921         crit_exit();
1922         SCTP_INP_RUNLOCK(inp);
1923 }
1924
1925 /*
1926  * this is only called for kernel initiated address changes
1927  * eg. it will check the PCB_FLAGS_AUTO_ASCONF flag
1928  */
1929 static void
1930 sctp_addr_mgmt(struct ifaddr *ifa, uint16_t type) {
1931         struct sockaddr *sa;
1932         struct sctp_inpcb *inp;
1933
1934         /* make sure we care about this interface... */
1935         if (!sctp_is_desired_interface_type(ifa)) {
1936 #ifdef SCTP_DEBUG
1937                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1938                         kprintf("sctp_addr_mgmt: ignoring this interface\n");
1939                 }
1940 #endif /* SCTP_DEBUG */
1941                 return;
1942         }
1943
1944         sa = ifa->ifa_addr;
1945         if (sa->sa_family != AF_INET && sa->sa_family != AF_INET6)
1946                 return;
1947
1948 #ifdef SCTP_DEBUG
1949         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
1950                 if (type == SCTP_ADD_IP_ADDRESS)
1951                         kprintf("sctp_addr_mgmt: kernel adds ");
1952                 else
1953                         kprintf("sctp_addr_mgmt: kernel deletes ");
1954                 sctp_print_address(sa);
1955         }
1956 #endif /* SCTP_DEBUG */
1957
1958         /* go through all our PCB's */
1959         LIST_FOREACH(inp, &sctppcbinfo.listhead, sctp_list) {
1960                 if (inp->sctp_flags & SCTP_PCB_FLAGS_AUTO_ASCONF) {
1961                         sctp_addr_mgmt_ep(inp, ifa, type);
1962                 } else {
1963                         /* this address is going away anyways... */
1964                         if (type == SCTP_DEL_IP_ADDRESS)
1965                                 return;
1966                         /* (temporarily) restrict this address */
1967                         sctp_addr_mgmt_restrict_ep(inp, ifa);
1968                 }
1969                 /* else, not allowing automatic asconf's, so ignore */
1970         } /* for each inp */
1971 }
1972
1973 /*
1974  * add/delete IP address requests from kernel (via routing change)
1975  * assumed that the address is non-broadcast, non-multicast
1976  * all addresses are passed from any type of interface-- need to filter
1977  * duplicate addresses may get requested
1978  */
1979
1980 void
1981 sctp_add_ip_address(struct ifaddr *ifa)
1982 {
1983         sctp_addr_mgmt(ifa, SCTP_ADD_IP_ADDRESS);
1984 }
1985
1986 void
1987 sctp_delete_ip_address(struct ifaddr *ifa)
1988 {
1989         struct sctp_inpcb *inp;
1990
1991         /* process the delete */
1992         sctp_addr_mgmt(ifa, SCTP_DEL_IP_ADDRESS);
1993
1994         /*
1995          * need to remove this ifaddr from any cached routes
1996          * and also any from any assoc "restricted/pending" lists
1997          */
1998         /* make sure we care about this interface... */
1999         if (!sctp_is_desired_interface_type(ifa)) {
2000 #ifdef SCTP_DEBUG
2001                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2002                         kprintf("sctp_delete_ip_address: ignoring this interface\n");
2003                 }
2004 #endif /* SCTP_DEBUG */
2005                 return;
2006         }
2007
2008         /* go through all our PCB's */
2009         SCTP_INP_INFO_RLOCK();
2010         LIST_FOREACH(inp, &sctppcbinfo.listhead, sctp_list) {
2011                 struct sctp_tcb *stcb;
2012                 struct sctp_laddr *laddr, *laddr_next;
2013
2014                 /* process for all associations for this endpoint */
2015                 SCTP_INP_RLOCK(inp);
2016                 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
2017                         struct sctp_nets *net;
2018
2019                         /* process through the nets list */
2020                         TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2021                                 struct rtentry *rt;
2022                                 /* delete this address if cached */
2023                                 rt = net->ro.ro_rt;
2024                                 if (rt != NULL && rt->rt_ifa == ifa) {
2025 /*                                      RTFREE(rt);*/
2026                                         net->ro.ro_rt = NULL;
2027                                 }
2028                         } /* for each net */
2029                         /* process through the asoc "pending" list */
2030                         laddr = LIST_FIRST(&stcb->asoc.sctp_local_addr_list);
2031                         while (laddr != NULL) {
2032                                 laddr_next = LIST_NEXT(laddr, sctp_nxt_addr);
2033                                 /* remove if in use */
2034                                 if (laddr->ifa == ifa) {
2035                                         sctp_remove_laddr(laddr);
2036                                 }
2037                                 laddr = laddr_next;
2038                         } /* while */
2039                 } /* for each stcb */
2040                 /* process through the inp bound addr list */
2041                 laddr = LIST_FIRST(&inp->sctp_addr_list);
2042                 while (laddr != NULL) {
2043                         laddr_next = LIST_NEXT(laddr, sctp_nxt_addr);
2044                         /* remove if in use */
2045                         if (laddr->ifa == ifa) {
2046                                 sctp_remove_laddr(laddr);
2047                         }
2048                         laddr = laddr_next;
2049                 } /* while */
2050                 SCTP_INP_RUNLOCK(inp);
2051         } /* for each inp */
2052         SCTP_INP_INFO_RUNLOCK();
2053 }
2054
2055 /*
2056  * sa is the sockaddr to ask the peer to set primary to
2057  * returns: 0 = completed, -1 = error
2058  */
2059 int32_t
2060 sctp_set_primary_ip_address_sa(struct sctp_tcb *stcb, struct sockaddr *sa)
2061 {
2062         /* NOTE: we currently don't check the validity of the address! */
2063
2064         /* queue an ASCONF:SET_PRIM_ADDR to be sent */
2065         if (!sctp_asconf_queue_add_sa(stcb, sa, SCTP_SET_PRIM_ADDR)) {
2066                 /* set primary queuing succeeded */
2067                 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) {
2068                         sctp_timer_start(SCTP_TIMER_TYPE_ASCONF,
2069                             stcb->sctp_ep, stcb,
2070                             stcb->asoc.primary_destination);
2071                 }
2072 #ifdef SCTP_DEBUG
2073                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2074                         kprintf("set_primary_ip_address_sa: queued on tcb=%p, ",
2075                             stcb);
2076                         sctp_print_address(sa);
2077                 }
2078 #endif /* SCTP_DEBUG */
2079         } else {
2080 #ifdef SCTP_DEBUG
2081                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2082                         kprintf("set_primary_ip_address_sa: failed to add to queue on tcb=%p, ",
2083                             stcb);
2084                         sctp_print_address(sa);
2085                 }
2086 #endif /* SCTP_DEBUG */
2087                 return (-1);
2088         }
2089         return (0);
2090 }
2091
2092 void
2093 sctp_set_primary_ip_address(struct ifaddr *ifa)
2094 {
2095         struct sctp_inpcb *inp;
2096
2097         /* make sure we care about this interface... */
2098         if (!sctp_is_desired_interface_type(ifa)) {
2099 #ifdef SCTP_DEBUG
2100                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2101                         kprintf("set_primary_ip_address: ignoring this interface\n");
2102                 }
2103 #endif /* SCTP_DEBUG */
2104                 return;
2105         }
2106
2107         /* go through all our PCB's */
2108         LIST_FOREACH(inp, &sctppcbinfo.listhead, sctp_list) {
2109                 struct sctp_tcb *stcb;
2110
2111                 /* process for all associations for this endpoint */
2112                 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
2113                         /* queue an ASCONF:SET_PRIM_ADDR to be sent */
2114                         if (!sctp_asconf_queue_add(stcb, ifa,
2115                             SCTP_SET_PRIM_ADDR)) {
2116                                 /* set primary queuing succeeded */
2117                                 if (SCTP_GET_STATE(&stcb->asoc) ==
2118                                     SCTP_STATE_OPEN) {
2119                                         sctp_timer_start(SCTP_TIMER_TYPE_ASCONF,
2120                                             stcb->sctp_ep, stcb,
2121                                             stcb->asoc.primary_destination);
2122                                 }
2123 #ifdef SCTP_DEBUG
2124                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2125                                         kprintf("set_primary_ip_address: queued on stcb=%p, ",
2126                                             stcb);
2127                                         sctp_print_address(ifa->ifa_addr);
2128                                 }
2129 #endif /* SCTP_DEBUG */
2130                         } else {
2131 #ifdef SCTP_DEBUG
2132                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2133                                         kprintf("set_primary_ip_address: failed to add to queue, ");
2134                                         sctp_print_address(ifa->ifa_addr);
2135                                 }
2136 #endif /* SCTP_DEBUG */
2137                         }
2138                 } /* for each stcb */
2139         } /* for each inp */
2140 }
2141
2142 static struct sockaddr *
2143 sctp_find_valid_localaddr(struct sctp_tcb *stcb)
2144 {
2145         struct ifnet *ifn;
2146
2147         TAILQ_FOREACH(ifn, &ifnet, if_list) {
2148                 struct ifaddr_container *ifac;
2149
2150                 if (stcb->asoc.loopback_scope == 0 && ifn->if_type == IFT_LOOP) {
2151                         /* Skip if loopback_scope not set */
2152                         continue;
2153                 }
2154                 TAILQ_FOREACH(ifac, &ifn->if_addrheads[mycpuid], ifa_link) {
2155                         struct ifaddr *ifa = ifac->ifa;
2156
2157                         if (ifa->ifa_addr->sa_family == AF_INET &&
2158                             stcb->asoc.ipv4_addr_legal) {
2159                                 struct sockaddr_in *sin;
2160
2161                                 sin = (struct sockaddr_in *)ifa->ifa_addr;
2162                                 if (sin->sin_addr.s_addr == 0) {
2163                                         /* skip unspecifed addresses */
2164                                         continue;
2165                                 }
2166                                 if (stcb->asoc.ipv4_local_scope == 0 &&
2167                                     IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))
2168                                         continue;
2169
2170                                 if (sctp_is_addr_restricted(stcb,
2171                                     ifa->ifa_addr))
2172                                         continue;
2173                                 /* found a valid local v4 address to use */
2174                                 return (ifa->ifa_addr);
2175                         } else if (ifa->ifa_addr->sa_family == AF_INET6 &&
2176                             stcb->asoc.ipv6_addr_legal) {
2177                                 struct sockaddr_in6 *sin6;
2178                                 struct in6_ifaddr *ifa6;
2179
2180                                 ifa6 = (struct in6_ifaddr *)ifa;
2181                                 if (IFA6_IS_DEPRECATED(ifa6) ||
2182                                     (ifa6->ia6_flags & (IN6_IFF_DETACHED |
2183                                      IN6_IFF_ANYCAST | IN6_IFF_NOTREADY)))
2184                                         continue;
2185
2186                                 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
2187                                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
2188                                         /* we skip unspecifed addresses */
2189                                         continue;
2190                                 }
2191                                 if (stcb->asoc.local_scope == 0 &&
2192                                     IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
2193                                         continue;
2194                                 if (stcb->asoc.site_scope == 0 &&
2195                                     IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))
2196                                         continue;
2197
2198                                 /* found a valid local v6 address to use */
2199                                 return (ifa->ifa_addr);
2200                         }
2201                 }
2202         }
2203         /* no valid addresses found */
2204         return (NULL);
2205 }
2206
2207 static struct sockaddr *
2208 sctp_find_valid_localaddr_ep(struct sctp_tcb *stcb)
2209 {
2210         struct sctp_laddr *laddr;
2211
2212         LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list, sctp_nxt_addr) {
2213                 if (laddr->ifa == NULL) {
2214 #ifdef SCTP_DEBUG
2215                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2216                                 kprintf("find_valid_localaddr_ep: laddr error\n");
2217                         }
2218 #endif /* SCTP_DEBUG */
2219                         continue;
2220                 }
2221                 if (laddr->ifa->ifa_addr == NULL) {
2222 #ifdef SCTP_DEBUG
2223                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2224                                 kprintf("find_valid_localaddr_ep: laddr->ifa error\n");
2225                         }
2226 #endif /* SCTP_DEBUG */
2227                         continue;
2228                 }
2229                 /* is the address restricted ? */
2230                 if (sctp_is_addr_restricted(stcb, laddr->ifa->ifa_addr))
2231                         continue;
2232
2233                 /* found a valid local address to use */
2234                 return (laddr->ifa->ifa_addr);
2235         }
2236         /* no valid addresses found */
2237         return (NULL);
2238 }
2239
2240 /*
2241  * builds an ASCONF chunk from queued ASCONF params
2242  * returns NULL on error (no mbuf, no ASCONF params queued, etc)
2243  */
2244 struct mbuf *
2245 sctp_compose_asconf(struct sctp_tcb *stcb)
2246 {
2247         struct mbuf *m_asconf, *m_asconf_chk;
2248         struct sctp_asconf_addr *aa;
2249         struct sctp_asconf_chunk *acp;
2250         struct sctp_asconf_paramhdr *aph;
2251         struct sctp_asconf_addr_param *aap;
2252         uint32_t p_length;
2253         uint32_t correlation_id = 1;            /* 0 is reserved... */
2254         caddr_t ptr, lookup_ptr;
2255         uint8_t lookup_used = 0;
2256
2257         /* are there any asconf params to send? */
2258         if (TAILQ_EMPTY(&stcb->asoc.asconf_queue)) {
2259                 return (NULL);
2260         }
2261
2262         /*
2263          * get a chunk header mbuf and a cluster for the asconf params
2264          * since it's simpler to fill in the asconf chunk header lookup
2265          * address on the fly
2266          */
2267         m_asconf_chk = NULL;
2268         MGETHDR(m_asconf_chk, MB_DONTWAIT, MT_DATA);
2269         if (m_asconf_chk == NULL) {
2270                 /* no mbuf's */
2271 #ifdef SCTP_DEBUG
2272                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2273                         kprintf("compose_asconf: couldn't get chunk mbuf!\n");
2274 #endif /* SCTP_DEBUG */
2275                 return (NULL);
2276         }
2277         m_asconf = NULL;
2278         MGETHDR(m_asconf, MB_DONTWAIT, MT_HEADER);
2279         if (m_asconf == NULL) {
2280                 /* no mbuf's */
2281 #ifdef SCTP_DEBUG
2282                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2283                         kprintf("compose_asconf: couldn't get mbuf!\n");
2284 #endif /* SCTP_DEBUG */
2285                 sctp_m_freem(m_asconf_chk);
2286                 return (NULL);
2287         }
2288         MCLGET(m_asconf, MB_DONTWAIT);
2289         if ((m_asconf->m_flags & M_EXT) != M_EXT) {
2290                 /* failed to get cluster buffer */
2291 #ifdef SCTP_DEBUG
2292                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2293                         kprintf("compose_asconf: couldn't get cluster!\n");
2294 #endif /* SCTP_DEBUG */
2295                 sctp_m_freem(m_asconf_chk);
2296                 sctp_m_freem(m_asconf);
2297                 return (NULL);
2298         }
2299
2300         m_asconf_chk->m_len = sizeof(struct sctp_asconf_chunk);
2301         m_asconf->m_len = 0;
2302         acp = mtod(m_asconf_chk, struct sctp_asconf_chunk *);
2303         bzero(acp, sizeof(struct sctp_asconf_chunk));
2304         /* save pointers to lookup address and asconf params */
2305         lookup_ptr = (caddr_t)(acp + 1);        /* after the header */
2306         ptr = mtod(m_asconf, caddr_t);          /* beginning of cluster */
2307
2308         /* fill in chunk header info */
2309         acp->ch.chunk_type = SCTP_ASCONF;
2310         acp->ch.chunk_flags = 0;
2311         acp->serial_number = htonl(stcb->asoc.asconf_seq_out);
2312
2313         /* add parameters... up to smallest MTU allowed */
2314         TAILQ_FOREACH(aa, &stcb->asoc.asconf_queue, next) {
2315                 /* get the parameter length */
2316                 p_length = SCTP_SIZE32(aa->ap.aph.ph.param_length);
2317                 /* will it fit in current chunk? */
2318                 if (m_asconf->m_len + p_length > stcb->asoc.smallest_mtu) {
2319                         /* won't fit, so we're done with this chunk */
2320                         break;
2321                 }
2322                 /* assign (and store) a correlation id */
2323                 aa->ap.aph.correlation_id = correlation_id++;
2324
2325                 /*
2326                  * fill in address if we're doing a delete
2327                  * this is a simple way for us to fill in the correlation
2328                  * address, which should only be used by the peer if we're
2329                  * deleting our source address and adding a new address
2330                  * (e.g. renumbering case)
2331                  */
2332                 if (lookup_used == 0 &&
2333                     aa->ap.aph.ph.param_type == SCTP_DEL_IP_ADDRESS) {
2334                         struct sctp_ipv6addr_param *lookup;
2335                         uint16_t p_size, addr_size;
2336
2337                         lookup = (struct sctp_ipv6addr_param *)lookup_ptr;
2338                         lookup->ph.param_type =
2339                             htons(aa->ap.addrp.ph.param_type);
2340                         if (aa->ap.addrp.ph.param_type == SCTP_IPV6_ADDRESS) {
2341                                 /* copy IPv6 address */
2342                                 p_size = sizeof(struct sctp_ipv6addr_param);
2343                                 addr_size = sizeof(struct in6_addr);
2344                         } else {
2345                                 /* copy IPv4 address */
2346                                 p_size = sizeof(struct sctp_ipv4addr_param);
2347                                 addr_size = sizeof(struct in_addr);
2348                         }
2349                         lookup->ph.param_length = htons(SCTP_SIZE32(p_size));
2350                         memcpy(lookup->addr, &aa->ap.addrp.addr, addr_size);
2351                         m_asconf_chk->m_len += SCTP_SIZE32(p_size);
2352                         lookup_used = 1;
2353                 }
2354
2355                 /* copy into current space */
2356                 memcpy(ptr, &aa->ap, p_length);
2357
2358                 /* network elements and update lengths */
2359                 aph = (struct sctp_asconf_paramhdr *) ptr;
2360                 aap = (struct sctp_asconf_addr_param *) ptr;
2361                 /* correlation_id is transparent to peer, no htonl needed */
2362                 aph->ph.param_type = htons(aph->ph.param_type);
2363                 aph->ph.param_length = htons(aph->ph.param_length);
2364                 aap->addrp.ph.param_type = htons(aap->addrp.ph.param_type);
2365                 aap->addrp.ph.param_length = htons(aap->addrp.ph.param_length);
2366
2367                 m_asconf->m_len += SCTP_SIZE32(p_length);
2368                 ptr += SCTP_SIZE32(p_length);
2369
2370                 /*
2371                  * these params are removed off the pending list upon
2372                  * getting an ASCONF-ACK back from the peer, just set flag
2373                  */
2374                 aa->sent = 1;
2375         }
2376         /* check to see if the lookup addr has been populated yet */
2377         if (lookup_used == 0) {
2378                 /* NOTE: if the address param is optional, can skip this... */
2379                 /* add any valid (existing) address... */
2380                 struct sctp_ipv6addr_param *lookup;
2381                 uint16_t p_size, addr_size;
2382                 struct sockaddr *found_addr;
2383                 caddr_t addr_ptr;
2384
2385                 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL)
2386                         found_addr = sctp_find_valid_localaddr(stcb);
2387                 else
2388                         found_addr = sctp_find_valid_localaddr_ep(stcb);
2389
2390                 lookup = (struct sctp_ipv6addr_param *)lookup_ptr;
2391                 if (found_addr != NULL) {
2392                         if (found_addr->sa_family == AF_INET6) {
2393                                 /* copy IPv6 address */
2394                                 lookup->ph.param_type =
2395                                     htons(SCTP_IPV6_ADDRESS);
2396                                 p_size = sizeof(struct sctp_ipv6addr_param);
2397                                 addr_size = sizeof(struct in6_addr);
2398                                 addr_ptr = (caddr_t)&((struct sockaddr_in6 *)
2399                                     found_addr)->sin6_addr;
2400                         } else {
2401                                 /* copy IPv4 address */
2402                                 lookup->ph.param_type =
2403                                     htons(SCTP_IPV4_ADDRESS);
2404                                 p_size = sizeof(struct sctp_ipv4addr_param);
2405                                 addr_size = sizeof(struct in_addr);
2406                                 addr_ptr = (caddr_t)&((struct sockaddr_in *)
2407                                     found_addr)->sin_addr;
2408                         }
2409                         lookup->ph.param_length = htons(SCTP_SIZE32(p_size));
2410                         memcpy(lookup->addr, addr_ptr, addr_size);
2411                         m_asconf_chk->m_len += SCTP_SIZE32(p_size);
2412                         lookup_used = 1;
2413                 } else {
2414                         /* uh oh... don't have any address?? */
2415 #ifdef SCTP_DEBUG
2416                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1)
2417                                 kprintf("compose_asconf: no lookup addr!\n");
2418 #endif /* SCTP_DEBUG */
2419                         /* for now, we send a IPv4 address of 0.0.0.0 */
2420                         lookup->ph.param_type = htons(SCTP_IPV4_ADDRESS);
2421                         lookup->ph.param_length = htons(SCTP_SIZE32(sizeof(struct sctp_ipv4addr_param)));
2422                         bzero(lookup->addr, sizeof(struct in_addr));
2423                         m_asconf_chk->m_len += SCTP_SIZE32(sizeof(struct sctp_ipv4addr_param));
2424                         lookup_used = 1;
2425                 }
2426         }
2427
2428         /* chain it all together */
2429         m_asconf_chk->m_next = m_asconf;
2430         m_asconf_chk->m_pkthdr.len = m_asconf_chk->m_len + m_asconf->m_len;
2431         acp->ch.chunk_length = ntohs(m_asconf_chk->m_pkthdr.len);
2432
2433         /* update "sent" flag */
2434         stcb->asoc.asconf_sent++;
2435
2436         return (m_asconf_chk);
2437 }
2438
2439 /*
2440  * section to handle address changes before an association is up
2441  * eg. changes during INIT/INIT-ACK/COOKIE-ECHO handshake
2442  */
2443
2444 /*
2445  * processes the (local) addresses in the INIT-ACK chunk
2446  */
2447 static void
2448 sctp_process_initack_addresses(struct sctp_tcb *stcb, struct mbuf *m,
2449     unsigned int offset, unsigned int length)
2450 {
2451         struct sctp_paramhdr tmp_param, *ph;
2452         uint16_t plen, ptype;
2453         struct sctp_ipv6addr_param addr_store;
2454         struct sockaddr_in6 sin6;
2455         struct sockaddr_in sin;
2456         struct sockaddr *sa;
2457         struct ifaddr *ifa;
2458
2459 #ifdef SCTP_DEBUG
2460         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2461                 kprintf("processing init-ack addresses\n");
2462         }
2463 #endif /* SCTP_DEBUG */
2464
2465         /* convert to upper bound */
2466         length += offset;
2467
2468         if ((offset + sizeof(struct sctp_paramhdr)) > length) {
2469 #ifdef SCTP_DEBUG
2470                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2471                         kprintf("process_initack_addrs: invalid offset?\n");
2472                 }
2473 #endif /* SCTP_DEBUG */
2474                 return;
2475         }
2476
2477         /* init the addresses */
2478         bzero(&sin6, sizeof(sin6));
2479         sin6.sin6_family = AF_INET6;
2480         sin6.sin6_len = sizeof(sin6);
2481         sin6.sin6_port = stcb->rport;
2482
2483         bzero(&sin, sizeof(sin));
2484         sin.sin_len = sizeof(sin);
2485         sin.sin_family = AF_INET;
2486         sin.sin_port = stcb->rport;
2487
2488         /* go through the addresses in the init-ack */
2489         ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset,
2490             sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param);
2491         while (ph != NULL) {
2492                 ptype = ntohs(ph->param_type);
2493                 plen = ntohs(ph->param_length);
2494                 if (ptype == SCTP_IPV6_ADDRESS) {
2495                         struct sctp_ipv6addr_param *a6p;
2496                         /* get the entire IPv6 address param */
2497 #ifdef SCTP_DEBUG
2498                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2499                                 kprintf("process_initack_addrs: checking IPv6 param\n");
2500                         }
2501 #endif /* SCTP_DEBUG */
2502                         a6p = (struct sctp_ipv6addr_param *)
2503                                 sctp_m_getptr(m, offset,
2504                                     sizeof(struct sctp_ipv6addr_param),
2505                                     (uint8_t *)&addr_store);
2506                         if (plen != sizeof(struct sctp_ipv6addr_param) ||
2507                             a6p == NULL) {
2508 #ifdef SCTP_DEBUG
2509                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2510                                         kprintf("process_initack_addrs: invalid IPv6 param length\n");
2511                                 }
2512 #endif /* SCTP_DEBUG */
2513                                 return;
2514                         }
2515                         memcpy(&sin6.sin6_addr, a6p->addr,
2516                             sizeof(struct in6_addr));
2517                         sa = (struct sockaddr *)&sin6;
2518                 } else if (ptype == SCTP_IPV4_ADDRESS) {
2519                         struct sctp_ipv4addr_param *a4p;
2520                         /* get the entire IPv4 address param */
2521 #ifdef SCTP_DEBUG
2522                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2523                                 kprintf("process_initack_addrs: checking IPv4 param\n");
2524                         }
2525 #endif /* SCTP_DEBUG */
2526                         a4p = (struct sctp_ipv4addr_param *)sctp_m_getptr(m, offset, sizeof(struct sctp_ipv4addr_param), (uint8_t *)&addr_store);
2527                         if (plen != sizeof(struct sctp_ipv4addr_param) ||
2528                             a4p == NULL) {
2529 #ifdef SCTP_DEBUG
2530                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2531                                         kprintf("process_initack_addrs: invalid IPv4 param length\n");
2532                                 }
2533 #endif /* SCTP_DEBUG */
2534                                 return;
2535                         }
2536                         sin.sin_addr.s_addr = a4p->addr;
2537                         sa = (struct sockaddr *)&sin;
2538                 } else {
2539 #ifdef SCTP_DEBUG
2540                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2541                                 kprintf("process_initack_addrs: skipping param type=%xh\n", ptype);
2542                         }
2543 #endif /* SCTP_DEBUG */
2544                         goto next_addr;
2545                 }
2546
2547                 /* see if this address really (still) exists */
2548                 ifa = sctp_find_ifa_by_addr(sa);
2549                 if (ifa == NULL) {
2550                         /* address doesn't exist anymore */
2551                         int status;
2552                         /* are ASCONFs allowed ? */
2553                         if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) &&
2554                             stcb->asoc.peer_supports_asconf) {
2555                                 /* queue an ASCONF DEL_IP_ADDRESS */
2556                                 status = sctp_asconf_queue_add_sa(stcb, sa,
2557                                     SCTP_DEL_IP_ADDRESS);
2558                                 /*
2559                                  * if queued ok, and in correct state,
2560                                  * set the ASCONF timer
2561                                  */
2562                                 if (status == 0 &&
2563                                     SCTP_GET_STATE(&stcb->asoc) ==
2564                                     SCTP_STATE_OPEN) {
2565                                         sctp_timer_start(SCTP_TIMER_TYPE_ASCONF,
2566                                             stcb->sctp_ep, stcb,
2567                                             stcb->asoc.primary_destination);
2568                                 }
2569                         }
2570                 } else {
2571                         /* address still exists */
2572                         /*
2573                          * if subset bound, ep addr's managed by default
2574                          * if not doing ASCONF, add the address to the assoc
2575                          */
2576                         if ((stcb->sctp_ep->sctp_flags &
2577                              SCTP_PCB_FLAGS_BOUNDALL) == 0 &&
2578                             (stcb->sctp_ep->sctp_flags &
2579                              SCTP_PCB_FLAGS_DO_ASCONF) == 0) {
2580 #ifdef SCTP_DEBUG
2581                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2582                                         kprintf("process_initack_addrs: adding local addr to asoc\n");
2583                                 }
2584 #endif /* SCTP_DEBUG */
2585                                 sctp_add_local_addr_assoc(stcb, ifa);
2586                         }
2587                 }
2588
2589         next_addr:
2590                 /* get next parameter */
2591                 offset += SCTP_SIZE32(plen);
2592                 if ((offset + sizeof(struct sctp_paramhdr)) > length)
2593                         return;
2594                 ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset,
2595                     sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param);
2596         } /* while */
2597 }
2598
2599 /* FIX ME: need to verify return result for v6 address type if v6 disabled */
2600 /*
2601  * checks to see if a specific address is in the initack address list
2602  * returns 1 if found, 0 if not
2603  */
2604 static uint32_t
2605 sctp_addr_in_initack(struct sctp_tcb *stcb, struct mbuf *m, unsigned int offset,
2606     unsigned int length, struct sockaddr *sa)
2607 {
2608         struct sctp_paramhdr tmp_param, *ph;
2609         uint16_t plen, ptype;
2610         struct sctp_ipv6addr_param addr_store;
2611         struct sockaddr_in *sin;
2612         struct sctp_ipv4addr_param *a4p;
2613 #ifdef INET6
2614         struct sockaddr_in6 *sin6, sin6_tmp;
2615         struct sctp_ipv6addr_param *a6p;
2616 #endif /* INET6 */
2617
2618         if (
2619 #ifdef INET6
2620                 (sa->sa_family != AF_INET6) &&
2621 #endif /* INET6 */
2622                 (sa->sa_family != AF_INET))
2623                 return (0);
2624
2625 #ifdef SCTP_DEBUG
2626         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2627                 kprintf("find_initack_addr: starting search for ");
2628                 sctp_print_address(sa);
2629         }
2630 #endif /* SCTP_DEBUG */
2631         /* convert to upper bound */
2632         length += offset;
2633
2634         if ((offset + sizeof(struct sctp_paramhdr)) > length) {
2635 #ifdef SCTP_DEBUG
2636                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2637                         kprintf("find_initack_addr: invalid offset?\n");
2638                 }
2639 #endif /* SCTP_DEBUG */
2640                 return (0);
2641         }
2642
2643         /* go through the addresses in the init-ack */
2644         ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset,
2645             sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param);
2646         while (ph != NULL) {
2647                 ptype = ntohs(ph->param_type);
2648                 plen = ntohs(ph->param_length);
2649 #ifdef INET6
2650                 if (ptype == SCTP_IPV6_ADDRESS && sa->sa_family == AF_INET6) {
2651                         /* get the entire IPv6 address param */
2652 #ifdef SCTP_DEBUG
2653                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2654                                 kprintf("addr_in_initack: checking IPv6 param\n");
2655                         }
2656 #endif /* SCTP_DEBUG */
2657                         a6p = (struct sctp_ipv6addr_param *)
2658                                 sctp_m_getptr(m, offset,
2659                                     sizeof(struct sctp_ipv6addr_param),
2660                                     (uint8_t *)&addr_store);
2661                         if (plen != sizeof(struct sctp_ipv6addr_param) ||
2662                             ph == NULL) {
2663 #ifdef SCTP_DEBUG
2664                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2665                                         kprintf("addr_in_initack: invalid IPv6 param length\n");
2666                                 }
2667 #endif /* SCTP_DEBUG */
2668                                 return (0);
2669                         }
2670                         sin6 = (struct sockaddr_in6 *)sa;
2671                         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr)) {
2672                                 /* create a copy and clear scope */
2673                                 memcpy(&sin6_tmp, sin6,
2674                                     sizeof(struct sockaddr_in6));
2675                                 sin6 = &sin6_tmp;
2676                                 in6_clearscope(&sin6->sin6_addr);
2677                         }
2678                         if (memcmp(&sin6->sin6_addr, a6p->addr,
2679                             sizeof(struct in6_addr)) == 0) {
2680                                 /* found it */
2681 #ifdef SCTP_DEBUG
2682                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2683                                         kprintf("addr_in_initack: found IPv6 addr\n");
2684                                 }
2685 #endif /* SCTP_DEBUG */
2686                                 return (1);
2687                         }
2688                 } else
2689 #endif /* INET6 */
2690
2691                 if (ptype == SCTP_IPV4_ADDRESS &&
2692                     sa->sa_family == AF_INET) {
2693                         /* get the entire IPv4 address param */
2694 #ifdef SCTP_DEBUG
2695                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2696                                 kprintf("addr_in_initack: checking IPv4 param\n");
2697                         }
2698 #endif /* SCTP_DEBUG */
2699                         a4p = (struct sctp_ipv4addr_param *)sctp_m_getptr(m,
2700                             offset, sizeof(struct sctp_ipv4addr_param),
2701                             (uint8_t *)&addr_store);
2702                         if (plen != sizeof(struct sctp_ipv4addr_param) ||
2703                             ph == NULL) {
2704 #ifdef SCTP_DEBUG
2705                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2706                                         kprintf("addr_in_initack: invalid IPv4 param length\n");
2707                                 }
2708 #endif /* SCTP_DEBUG */
2709                                 return (0);
2710                         }
2711                         sin = (struct sockaddr_in *)sa;
2712                         if (sin->sin_addr.s_addr == a4p->addr) {
2713                                 /* found it */
2714 #ifdef SCTP_DEBUG
2715                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2716                                         kprintf("addr_in_initack: found IPv4 addr\n");
2717                                 }
2718 #endif /* SCTP_DEBUG */
2719                                 return (1);
2720                         }
2721                 } else {
2722 #ifdef SCTP_DEBUG
2723                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2724                                 kprintf("addr_in_initack: skipping param type=%xh\n", ptype);
2725                         }
2726 #endif /* SCTP_DEBUG */
2727                 }
2728                 /* get next parameter */
2729                 offset += SCTP_SIZE32(plen);
2730                 if (offset + sizeof(struct sctp_paramhdr) > length)
2731                         return (0);
2732                 ph = (struct sctp_paramhdr *)
2733                         sctp_m_getptr(m, offset, sizeof(struct sctp_paramhdr),
2734                             (uint8_t *)&tmp_param);
2735         } /* while */
2736         /* not found! */
2737 #ifdef SCTP_DEBUG
2738         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2739                 kprintf("addr_in_initack: not found!\n");
2740         }
2741 #endif /* SCTP_DEBUG */
2742         return (0);
2743 }
2744
2745 /*
2746  * makes sure that the current endpoint local addr list is consistent
2747  * with the new association (eg. subset bound, asconf allowed)
2748  * adds addresses as necessary
2749  */
2750 static void
2751 sctp_check_address_list_ep(struct sctp_tcb *stcb, struct mbuf *m, int offset,
2752     int length, struct sockaddr *init_addr)
2753 {
2754         struct sctp_laddr *laddr;
2755
2756         /* go through the endpoint list */
2757         LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list, sctp_nxt_addr) {
2758                 /* be paranoid and validate the laddr */
2759                 if (laddr->ifa == NULL) {
2760 #ifdef SCTP_DEBUG
2761                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2762                                 kprintf("check_addr_list_ep: laddr->ifa is NULL");
2763                         }
2764 #endif
2765                         continue;
2766                 }
2767                 if (laddr->ifa->ifa_addr == NULL) {
2768 #ifdef SCTP_DEBUG
2769                         if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2770                                 kprintf("check_addr_list_ep: laddr->ifa->ifa_addr is NULL");
2771                         }
2772 #endif
2773                         continue;
2774                 }
2775                 /* do i have it implicitly? */
2776                 if (sctp_cmpaddr(laddr->ifa->ifa_addr, init_addr)) {
2777 #ifdef SCTP_DEBUG
2778                         if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2779                                 kprintf("check_address_list_all: skipping ");
2780                                 sctp_print_address(laddr->ifa->ifa_addr);
2781                         }
2782 #endif /* SCTP_DEBUG */
2783                         continue;
2784                 }
2785                 /* check to see if in the init-ack */
2786                 if (!sctp_addr_in_initack(stcb, m, offset, length,
2787                                           laddr->ifa->ifa_addr)) {
2788                         /* try to add it */
2789                         sctp_addr_mgmt_assoc(stcb->sctp_ep, stcb, laddr->ifa,
2790                             SCTP_ADD_IP_ADDRESS);
2791                 }
2792         }
2793 }
2794
2795 /*
2796  * makes sure that the current kernel address list is consistent
2797  * with the new association (with all addrs bound)
2798  * adds addresses as necessary
2799  */
2800 static void
2801 sctp_check_address_list_all(struct sctp_tcb *stcb, struct mbuf *m, int offset,
2802     int length, struct sockaddr *init_addr, uint16_t local_scope,
2803     uint16_t site_scope, uint16_t ipv4_scope, uint16_t loopback_scope)
2804 {
2805         struct ifnet *ifn;
2806
2807         /* go through all our known interfaces */
2808         TAILQ_FOREACH(ifn, &ifnet, if_list) {
2809                 struct ifaddr_container *ifac;
2810
2811                 if (loopback_scope == 0 && ifn->if_type == IFT_LOOP) {
2812                         /* skip loopback interface */
2813                         continue;
2814                 }
2815
2816                 /* go through each interface address */
2817                 TAILQ_FOREACH(ifac, &ifn->if_addrheads[mycpuid], ifa_link) {
2818                         struct ifaddr *ifa = ifac->ifa;
2819
2820                         /* do i have it implicitly? */
2821                         if (sctp_cmpaddr(ifa->ifa_addr, init_addr)) {
2822 #ifdef SCTP_DEBUG
2823                                 if (sctp_debug_on & SCTP_DEBUG_ASCONF2) {
2824                                         kprintf("check_address_list_all: "
2825                                                 "skipping ");
2826                                         sctp_print_address(ifa->ifa_addr);
2827                                 }
2828 #endif /* SCTP_DEBUG */
2829                                 continue;
2830                         }
2831                         /* check to see if in the init-ack */
2832                         if (!sctp_addr_in_initack(stcb, m, offset, length,
2833                             ifa->ifa_addr)) {
2834                                 /* try to add it */
2835                                 sctp_addr_mgmt_assoc(stcb->sctp_ep, stcb,
2836                                     ifa, SCTP_ADD_IP_ADDRESS);
2837                         }
2838                 } /* end foreach ifa */
2839         } /* end foreach ifn */
2840 }
2841
2842 /*
2843  * validates an init-ack chunk (from a cookie-echo) with current addresses
2844  * adds addresses from the init-ack into our local address list, if needed
2845  * queues asconf adds/deletes addresses as needed and makes appropriate
2846  * list changes for source address selection
2847  * m, offset: points to the start of the address list in an init-ack chunk
2848  * length: total length of the address params only
2849  * init_addr: address where my INIT-ACK was sent from
2850  */
2851 void
2852 sctp_check_address_list(struct sctp_tcb *stcb, struct mbuf *m, int offset,
2853     int length, struct sockaddr *init_addr, uint16_t local_scope,
2854     uint16_t site_scope, uint16_t ipv4_scope, uint16_t loopback_scope)
2855 {
2856
2857         /* process the local addresses in the initack */
2858         sctp_process_initack_addresses(stcb, m, offset, length);
2859
2860         if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
2861                 /* bound all case */
2862                 sctp_check_address_list_all(stcb, m, offset, length, init_addr,
2863                     local_scope, site_scope, ipv4_scope, loopback_scope);
2864         } else {
2865                 /* subset bound case */
2866                 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) {
2867                         /* asconf's allowed */
2868                         sctp_check_address_list_ep(stcb, m, offset, length,
2869                             init_addr);
2870                 }
2871                 /* else, no asconfs allowed, so what we sent is what we get */
2872         }
2873 }
2874
2875 /*
2876  * sctp_bindx() support
2877  */
2878 uint32_t
2879 sctp_addr_mgmt_ep_sa(struct sctp_inpcb *inp, struct sockaddr *sa, uint16_t type)
2880 {
2881         struct ifaddr *ifa;
2882
2883         if (sa->sa_len == 0)
2884                 return (EINVAL);
2885
2886         ifa = sctp_find_ifa_by_addr(sa);
2887         if (ifa != NULL) {
2888 #ifdef INET6
2889                 if (ifa->ifa_addr->sa_family == AF_INET6) {
2890                         struct in6_ifaddr *ifa6;
2891                         ifa6 = (struct in6_ifaddr *)ifa;
2892                         if (IFA6_IS_DEPRECATED(ifa6) ||
2893                             (ifa6->ia6_flags & (IN6_IFF_DETACHED |
2894                              IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) {
2895                                 /* Can't bind a non-existent addr. */
2896                                 return (EINVAL);
2897                         }
2898                 }
2899 #endif /* INET6 */
2900                 /* add this address */
2901                 sctp_addr_mgmt_ep(inp, ifa, type);
2902         } else {
2903                 /* invalid address! */
2904 #ifdef SCTP_DEBUG
2905                 if (sctp_debug_on & SCTP_DEBUG_ASCONF1) {
2906                         kprintf("addr_mgmt_ep_sa: got invalid address!\n");
2907                 }
2908 #endif /* SCTP_DEBUG */
2909                 return (EADDRNOTAVAIL);
2910         }
2911         return (0);
2912 }