kernel/net/sctp/sctp_notify.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #include <sys/types.h>
  26 #include <sys/systm.h>
  27 #include <sys/stream.h>
  28 #include <sys/cmn_err.h>
  29 #include <sys/tihdr.h>
  30 #include <sys/kmem.h>
  31 #define _SUN_TPI_VERSION 2
  32 #include <sys/tihdr.h>
  33 #include <sys/socket.h>
  34
  35 #include <netinet/in.h>
  36 #include <netinet/sctp.h>
  37
  38 #include <inet/common.h>
  39 #include <inet/ipclassifier.h>
  40 #include <inet/ip.h>
  41
  42 #include <inet/sctp/sctp_impl.h>
  43
  44 /* ARGSUSED */
  45 static void
  46 sctp_notify(sctp_t *sctp, mblk_t *emp, size_t len)
  47 {
  48         struct T_unitdata_ind *tudi;
  49         mblk_t *mp;
  50         sctp_faddr_t *fp;
  51         int32_t rwnd = 0;
  52         int error;
  53         conn_t *connp = sctp->sctp_connp;
  54
  55         if ((mp = allocb(sizeof (*tudi) + sizeof (void *) +
  56                 sizeof (struct sockaddr_in6), BPRI_HI)) == NULL) {
  57                 /* XXX trouble: don't want to drop events. should queue it. */
  58                 freemsg(emp);
  59                 return;
  60         }
  61         dprint(3, ("sctp_notify: event %d\n", (*(uint16_t *)emp->b_rptr)));
  62
  63         mp->b_datap->db_type = M_PROTO;
  64         mp->b_flag |= MSGMARK;
  65         mp->b_rptr += sizeof (void *); /* pointer worth of padding */
  66
  67         tudi = (struct T_unitdata_ind *)mp->b_rptr;
  68         tudi->PRIM_type = T_UNITDATA_IND;
  69         tudi->SRC_offset = sizeof (*tudi);
  70         tudi->OPT_length = 0;
  71         tudi->OPT_offset = 0;
  72
  73         fp = sctp->sctp_primary;
  74         ASSERT(fp);
  75
  76         /*
  77          * Fill in primary remote address.
  78          */
  79         if (IN6_IS_ADDR_V4MAPPED(&fp->sf_faddr)) {
  80                 struct sockaddr_in *sin4;
  81
  82                 tudi->SRC_length = sizeof (*sin4);
  83                 sin4 = (struct sockaddr_in *)(tudi + 1);
  84                 sin4->sin_family = AF_INET;
  85                 sin4->sin_port = connp->conn_fport;
  86                 IN6_V4MAPPED_TO_IPADDR(&fp->sf_faddr, sin4->sin_addr.s_addr);
  87                 mp->b_wptr = (uchar_t *)(sin4 + 1);
  88         } else {
  89                 struct sockaddr_in6 *sin6;
  90
  91                 tudi->SRC_length = sizeof (*sin6);
  92                 sin6 = (struct sockaddr_in6 *)(tudi + 1);
  93                 sin6->sin6_family = AF_INET6;
  94                 sin6->sin6_port = connp->conn_fport;
  95                 sin6->sin6_addr = fp->sf_faddr;
  96                 mp->b_wptr = (uchar_t *)(sin6 + 1);
  97         }
  98
  99         mp->b_cont = emp;
 100
 101         /*
 102          * Notifications are queued regardless of socket rx space.  So
 103          * we do not decrement sctp_rwnd here as this will confuse the
 104          * other side.
 105          */
 106 #ifdef DEBUG
 107         for (emp = mp->b_cont; emp; emp = emp->b_cont) {
 108                 rwnd += emp->b_wptr - emp->b_rptr;
 109         }
 110         ASSERT(len == rwnd);
 111 #endif
 112
 113         /*
 114          * Override b_flag for SCTP sockfs internal use
 115          */
 116         mp->b_flag = (short)SCTP_NOTIFICATION;
 117
 118         rwnd = sctp->sctp_ulp_recv(sctp->sctp_ulpd, mp, msgdsize(mp), 0,
 119             &error, NULL);
 120         if (rwnd > sctp->sctp_rwnd) {
 121                 sctp->sctp_rwnd = rwnd;
 122         }
 123 }
 124
 125 void
 126 sctp_assoc_event(sctp_t *sctp, uint16_t state, uint16_t error,
 127     sctp_chunk_hdr_t *ch)
 128 {
 129         struct sctp_assoc_change *sacp;
 130         mblk_t *mp;
 131         uint16_t ch_len;
 132
 133         if (!sctp->sctp_recvassocevnt) {
 134                 return;
 135         }
 136
 137         ch_len = (ch != NULL) ? ntohs(ch->sch_len) : 0;
 138
 139         if ((mp = allocb(sizeof (*sacp) + ch_len, BPRI_MED)) == NULL) {
 140                 return;
 141         }
 142
 143         sacp = (struct sctp_assoc_change *)mp->b_rptr;
 144         sacp->sac_type = SCTP_ASSOC_CHANGE;
 145         sacp->sac_flags = sctp->sctp_prsctp_aware ? SCTP_PRSCTP_CAPABLE : 0;
 146         sacp->sac_length = sizeof (*sacp) + ch_len;
 147         sacp->sac_state = state;
 148         sacp->sac_error = error;
 149         sacp->sac_outbound_streams = sctp->sctp_num_ostr;
 150         sacp->sac_inbound_streams = sctp->sctp_num_istr;
 151         sacp->sac_assoc_id = 0;
 152
 153         if (ch != NULL)
 154                 bcopy(ch, sacp + 1, ch_len);
 155         mp->b_wptr += sacp->sac_length;
 156         sctp_notify(sctp, mp, sacp->sac_length);
 157 }
 158
 159 /*
 160  * Send failure event. Message is expected to have message header still
 161  * in place, data follows in subsequent mblk's.
 162  */
 163 static void
 164 sctp_sendfail(sctp_t *sctp, mblk_t *msghdr, uint16_t flags, int error)
 165 {
 166         struct sctp_send_failed *sfp;
 167         mblk_t *mp;
 168         sctp_msg_hdr_t *smh;
 169
 170         /* Allocate a mblk for the notification header */
 171         if ((mp = allocb(sizeof (*sfp), BPRI_MED)) == NULL) {
 172                 /* give up */
 173                 freemsg(msghdr);
 174                 return;
 175         }
 176
 177         smh = (sctp_msg_hdr_t *)msghdr->b_rptr;
 178         sfp = (struct sctp_send_failed *)mp->b_rptr;
 179         sfp->ssf_type = SCTP_SEND_FAILED;
 180         sfp->ssf_flags = flags;
 181         sfp->ssf_length = smh->smh_msglen + sizeof (*sfp);
 182         sfp->ssf_error = error;
 183         sfp->ssf_assoc_id = 0;
 184
 185         bzero(&sfp->ssf_info, sizeof (sfp->ssf_info));
 186         sfp->ssf_info.sinfo_stream = smh->smh_sid;
 187         sfp->ssf_info.sinfo_flags = smh->smh_flags;
 188         sfp->ssf_info.sinfo_ppid = smh->smh_ppid;
 189         sfp->ssf_info.sinfo_context = smh->smh_context;
 190         sfp->ssf_info.sinfo_timetolive = TICK_TO_MSEC(smh->smh_ttl);
 191
 192         mp->b_wptr = (uchar_t *)(sfp + 1);
 193         mp->b_cont = msghdr->b_cont;
 194
 195         freeb(msghdr);
 196
 197         sctp_notify(sctp, mp, sfp->ssf_length);
 198
 199 }
 200
 201 /*
 202  * Send failure when the message has been fully chunkified.
 203  */
 204 static void
 205 sctp_sendfail_sent(sctp_t *sctp, mblk_t *meta, int error)
 206 {
 207         mblk_t          *mp;
 208         mblk_t          *nmp;
 209         mblk_t          *tail;
 210         uint16_t        flags = SCTP_DATA_SENT;
 211
 212         if (!sctp->sctp_recvsendfailevnt) {
 213                 sctp_free_msg(meta);
 214                 return;
 215         }
 216
 217         /*
 218          * We need to remove all data_hdr's.
 219          */
 220         nmp = meta->b_cont;
 221         tail = meta;
 222         do {
 223                 mp = nmp->b_next;
 224                 nmp->b_next = NULL;
 225
 226                 /*
 227                  * If one of the chunks hasn't been sent yet, say that
 228                  * the message hasn't been sent.
 229                  */
 230                 if (!SCTP_CHUNK_ISSENT(nmp)) {
 231                         flags = SCTP_DATA_UNSENT;
 232                 }
 233                 nmp->b_rptr += sizeof (sctp_data_hdr_t);
 234                 if (nmp->b_rptr == nmp->b_wptr) {
 235                         tail->b_cont = nmp->b_cont;
 236                         freeb(nmp);
 237                 } else {
 238                         tail->b_cont = nmp;
 239                 }
 240                 while (tail->b_cont) {
 241                         tail = tail->b_cont;
 242                 }
 243         } while ((nmp = mp) != NULL);
 244
 245         sctp_sendfail(sctp, meta, flags, error);
 246 }
 247
 248 /*
 249  * Send failure when the message hasn't been fully chunkified.
 250  */
 251 void
 252 sctp_sendfail_event(sctp_t *sctp, mblk_t *meta, int error, boolean_t chunkified)
 253 {
 254         mblk_t  *mp;
 255         mblk_t  *nmp;
 256         mblk_t  *tail;
 257
 258         if (meta == NULL)
 259                 return;
 260
 261         if (!sctp->sctp_recvsendfailevnt) {
 262                 sctp_free_msg(meta);
 263                 return;
 264         }
 265
 266         /* If the message is fully chunkified */
 267         if (chunkified) {
 268                 sctp_sendfail_sent(sctp, meta, error);
 269                 return;
 270         }
 271         /*
 272          * Message might be partially chunkified, we need to remove
 273          * all data_hdr's.
 274          */
 275         mp = meta->b_cont;
 276         tail = meta;
 277         while ((nmp = mp->b_next) != NULL) {
 278                 mp->b_next = nmp->b_next;
 279                 nmp->b_next = NULL;
 280                 nmp->b_rptr += sizeof (sctp_data_hdr_t);
 281                 if (nmp->b_rptr == nmp->b_wptr) {
 282                         tail->b_cont = nmp->b_cont;
 283                         freeb(nmp);
 284                 } else {
 285                         tail->b_cont = nmp;
 286                 }
 287                 while (tail->b_cont) {
 288                         tail = tail->b_cont;
 289                 }
 290         }
 291         tail->b_cont = mp;
 292
 293         sctp_sendfail(sctp, meta, SCTP_DATA_UNSENT, error);
 294 }
 295
 296 void
 297 sctp_regift_xmitlist(sctp_t *sctp)
 298 {
 299         mblk_t *mp;
 300
 301         if (!sctp->sctp_recvsendfailevnt) {
 302                 return;
 303         }
 304
 305         while ((mp = sctp->sctp_xmit_head) != NULL) {
 306                 sctp->sctp_xmit_head = mp->b_next;
 307                 mp->b_next = NULL;
 308                 if (sctp->sctp_xmit_head != NULL)
 309                         sctp->sctp_xmit_head->b_prev = NULL;
 310                 sctp_sendfail_event(sctp, mp, 0, B_TRUE);
 311         }
 312         while ((mp = sctp->sctp_xmit_unsent) != NULL) {
 313                 sctp->sctp_xmit_unsent = mp->b_next;
 314                 mp->b_next = NULL;
 315                 sctp_sendfail_event(sctp, mp, 0, B_FALSE);
 316         }
 317         sctp->sctp_xmit_tail = sctp->sctp_xmit_unsent_tail = NULL;
 318         sctp->sctp_unacked = sctp->sctp_unsent = 0;
 319 }
 320
 321 void
 322 sctp_intf_event(sctp_t *sctp, in6_addr_t addr, int state, int error)
 323 {
 324         struct sctp_paddr_change *spc;
 325         ipaddr_t addr4;
 326         struct sockaddr_in *sin;
 327         struct sockaddr_in6 *sin6;
 328         mblk_t *mp;
 329
 330         if (!sctp->sctp_recvpathevnt) {
 331                 return;
 332         }
 333
 334         if ((mp = allocb(sizeof (*spc), BPRI_MED)) == NULL) {
 335                 return;
 336         }
 337
 338         spc = (struct sctp_paddr_change *)mp->b_rptr;
 339         spc->spc_type = SCTP_PEER_ADDR_CHANGE;
 340         spc->spc_flags = 0;
 341         spc->spc_length = sizeof (*spc);
 342         if (IN6_IS_ADDR_V4MAPPED(&addr)) {
 343                 IN6_V4MAPPED_TO_IPADDR(&addr, addr4);
 344                 sin = (struct sockaddr_in *)&spc->spc_aaddr;
 345                 sin->sin_family = AF_INET;
 346                 sin->sin_port = 0;
 347                 sin->sin_addr.s_addr = addr4;
 348         } else {
 349                 sin6 = (struct sockaddr_in6 *)&spc->spc_aaddr;
 350                 sin6->sin6_family = AF_INET6;
 351                 sin6->sin6_port = 0;
 352                 sin6->sin6_addr = addr;
 353         }
 354         spc->spc_state = state;
 355         spc->spc_error = error;
 356         spc->spc_assoc_id = 0;
 357
 358         mp->b_wptr = (uchar_t *)(spc + 1);
 359         sctp_notify(sctp, mp, spc->spc_length);
 360 }
 361
 362 void
 363 sctp_error_event(sctp_t *sctp, sctp_chunk_hdr_t *ch, boolean_t is_asconf)
 364 {
 365         struct sctp_remote_error *sre;
 366         mblk_t *mp;
 367         size_t len;
 368         sctp_parm_hdr_t *errh = NULL;
 369         uint16_t dlen = 0;
 370         uint16_t error = 0;
 371         void *dtail = NULL;
 372
 373         if (!sctp->sctp_recvpeererr) {
 374                 return;
 375         }
 376
 377         /*
 378          * ASCONF PARM error chunks :
 379          * PARM_ERROR_IND parm type is always followed by correlation id.
 380          * See sctp_asconf_adderr() and sctp_asconf_prepend_errwrap() as to
 381          * how these error chunks are build.
 382          * error cause wrapper (PARM_ERROR_IND) + correlation id +
 383          * error cause + error cause details.
 384          *
 385          * Regular error chunks :
 386          * See sctp_make_err() as to how these error chunks are build.
 387          * error chunk header (CHUNK_ERROR) + error cause + error cause details.
 388          */
 389         if (is_asconf) {
 390                 if (ntohs(ch->sch_len) >
 391                     (sizeof (*ch) + sizeof (uint32_t))) {
 392                         errh = (sctp_parm_hdr_t *)((char *)ch +
 393                             sizeof (uint32_t) + sizeof (sctp_parm_hdr_t));
 394                 }
 395         } else {
 396                 if (ntohs(ch->sch_len) > sizeof (*ch)) {
 397                         errh = (sctp_parm_hdr_t *)(ch + 1);
 398                 }
 399         }
 400
 401         if (errh != NULL) {
 402                 error = ntohs(errh->sph_type);
 403                 dlen = ntohs(errh->sph_len) - sizeof (*errh);
 404                 if (dlen > 0) {
 405                         dtail = errh + 1;
 406                 }
 407         }
 408
 409         len = sizeof (*sre) + dlen;
 410         if ((mp = allocb(len, BPRI_MED)) == NULL) {
 411                 return;
 412         }
 413
 414         sre = (struct sctp_remote_error *)mp->b_rptr;
 415         sre->sre_type = SCTP_REMOTE_ERROR;
 416         sre->sre_flags = 0;
 417         sre->sre_length = len;
 418         sre->sre_assoc_id = 0;
 419         sre->sre_error = error;
 420         if (dtail != NULL) {
 421                 bcopy(dtail, sre + 1, dlen);
 422         }
 423
 424         mp->b_wptr = mp->b_rptr + len;
 425         sctp_notify(sctp, mp, len);
 426 }
 427
 428 void
 429 sctp_shutdown_event(sctp_t *sctp)
 430 {
 431         struct sctp_shutdown_event *sse;
 432         mblk_t *mp;
 433
 434         if (!sctp->sctp_recvshutdownevnt) {
 435                 return;
 436         }
 437
 438         if ((mp = allocb(sizeof (*sse), BPRI_MED)) == NULL) {
 439                 return;
 440         }
 441
 442         sse = (struct sctp_shutdown_event *)mp->b_rptr;
 443         sse->sse_type = SCTP_SHUTDOWN_EVENT;
 444         sse->sse_flags = 0;
 445         sse->sse_length = sizeof (*sse);
 446         sse->sse_assoc_id = 0;
 447
 448         mp->b_wptr = (uchar_t *)(sse + 1);
 449         sctp_notify(sctp, mp, sse->sse_length);
 450 }
 451
 452 void
 453 sctp_adaptation_event(sctp_t *sctp)
 454 {
 455         struct sctp_adaptation_event *sai;
 456         mblk_t *mp;
 457
 458         if (!sctp->sctp_recvalevnt || !sctp->sctp_recv_adaptation) {
 459                 return;
 460         }
 461         if ((mp = allocb(sizeof (*sai), BPRI_MED)) == NULL) {
 462                 return;
 463         }
 464
 465         sai = (struct sctp_adaptation_event *)mp->b_rptr;
 466         sai->sai_type = SCTP_ADAPTATION_INDICATION;
 467         sai->sai_flags = 0;
 468         sai->sai_length = sizeof (*sai);
 469         sai->sai_assoc_id = 0;
 470         /*
 471          * Adaptation code delivered in network byte order.
 472          */
 473         sai->sai_adaptation_ind = sctp->sctp_rx_adaptation_code;
 474
 475         mp->b_wptr = (uchar_t *)(sai + 1);
 476         sctp_notify(sctp, mp, sai->sai_length);
 477
 478         sctp->sctp_recv_adaptation = 0; /* in case there's a restart later */
 479 }
 480
 481 /* Send partial deliver event */
 482 void
 483 sctp_partial_delivery_event(sctp_t *sctp)
 484 {
 485         struct sctp_pdapi_event *pdapi;
 486         mblk_t                  *mp;
 487
 488         if (!sctp->sctp_recvpdevnt)
 489                 return;
 490
 491         if ((mp = allocb(sizeof (*pdapi), BPRI_MED)) == NULL)
 492                 return;
 493
 494         pdapi = (struct sctp_pdapi_event *)mp->b_rptr;
 495         pdapi->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;
 496         pdapi->pdapi_flags = 0;
 497         pdapi->pdapi_length = sizeof (*pdapi);
 498         pdapi->pdapi_indication = SCTP_PARTIAL_DELIVERY_ABORTED;
 499         pdapi->pdapi_assoc_id = 0;
 500         mp->b_wptr = (uchar_t *)(pdapi + 1);
 501         sctp_notify(sctp, mp, pdapi->pdapi_length);
 502 }