linux/net/sctp/bind_addr.c
<<
>>
Prefs
   1/* SCTP kernel implementation
   2 * (C) Copyright IBM Corp. 2001, 2003
   3 * Copyright (c) Cisco 1999,2000
   4 * Copyright (c) Motorola 1999,2000,2001
   5 * Copyright (c) La Monte H.P. Yarroll 2001
   6 *
   7 * This file is part of the SCTP kernel implementation.
   8 *
   9 * A collection class to handle the storage of transport addresses.
  10 *
  11 * This SCTP implementation is free software;
  12 * you can redistribute it and/or modify it under the terms of
  13 * the GNU General Public License as published by
  14 * the Free Software Foundation; either version 2, or (at your option)
  15 * any later version.
  16 *
  17 * This SCTP implementation is distributed in the hope that it
  18 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  19 *                 ************************
  20 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  21 * See the GNU General Public License for more details.
  22 *
  23 * You should have received a copy of the GNU General Public License
  24 * along with GNU CC; see the file COPYING.  If not, write to
  25 * the Free Software Foundation, 59 Temple Place - Suite 330,
  26 * Boston, MA 02111-1307, USA.
  27 *
  28 * Please send any bug reports or fixes you make to the
  29 * email address(es):
  30 *    lksctp developers <lksctp-developers@lists.sourceforge.net>
  31 *
  32 * Or submit a bug report through the following website:
  33 *    http://www.sf.net/projects/lksctp
  34 *
  35 * Written or modified by:
  36 *    La Monte H.P. Yarroll <piggy@acm.org>
  37 *    Karl Knutson          <karl@athena.chicago.il.us>
  38 *    Jon Grimm             <jgrimm@us.ibm.com>
  39 *    Daisy Chang           <daisyc@us.ibm.com>
  40 *
  41 * Any bugs reported given to us we will try to fix... any fixes shared will
  42 * be incorporated into the next SCTP release.
  43 */
  44
  45#include <linux/types.h>
  46#include <linux/slab.h>
  47#include <linux/in.h>
  48#include <net/sock.h>
  49#include <net/ipv6.h>
  50#include <net/if_inet6.h>
  51#include <net/sctp/sctp.h>
  52#include <net/sctp/sm.h>
  53
  54/* Forward declarations for internal helpers. */
  55static int sctp_copy_one_addr(struct net *, struct sctp_bind_addr *,
  56                              union sctp_addr *, sctp_scope_t scope, gfp_t gfp,
  57                              int flags);
  58static void sctp_bind_addr_clean(struct sctp_bind_addr *);
  59
  60/* First Level Abstractions. */
  61
  62/* Copy 'src' to 'dest' taking 'scope' into account.  Omit addresses
  63 * in 'src' which have a broader scope than 'scope'.
  64 */
  65int sctp_bind_addr_copy(struct net *net, struct sctp_bind_addr *dest,
  66                        const struct sctp_bind_addr *src,
  67                        sctp_scope_t scope, gfp_t gfp,
  68                        int flags)
  69{
  70        struct sctp_sockaddr_entry *addr;
  71        int error = 0;
  72
  73        /* All addresses share the same port.  */
  74        dest->port = src->port;
  75
  76        /* Extract the addresses which are relevant for this scope.  */
  77        list_for_each_entry(addr, &src->address_list, list) {
  78                error = sctp_copy_one_addr(net, dest, &addr->a, scope,
  79                                           gfp, flags);
  80                if (error < 0)
  81                        goto out;
  82        }
  83
  84        /* If there are no addresses matching the scope and
  85         * this is global scope, try to get a link scope address, with
  86         * the assumption that we must be sitting behind a NAT.
  87         */
  88        if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
  89                list_for_each_entry(addr, &src->address_list, list) {
  90                        error = sctp_copy_one_addr(net, dest, &addr->a,
  91                                                   SCTP_SCOPE_LINK, gfp,
  92                                                   flags);
  93                        if (error < 0)
  94                                goto out;
  95                }
  96        }
  97
  98out:
  99        if (error)
 100                sctp_bind_addr_clean(dest);
 101
 102        return error;
 103}
 104
 105/* Exactly duplicate the address lists.  This is necessary when doing
 106 * peer-offs and accepts.  We don't want to put all the current system
 107 * addresses into the endpoint.  That's useless.  But we do want duplicat
 108 * the list of bound addresses that the older endpoint used.
 109 */
 110int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
 111                        const struct sctp_bind_addr *src,
 112                        gfp_t gfp)
 113{
 114        struct sctp_sockaddr_entry *addr;
 115        int error = 0;
 116
 117        /* All addresses share the same port.  */
 118        dest->port = src->port;
 119
 120        list_for_each_entry(addr, &src->address_list, list) {
 121                error = sctp_add_bind_addr(dest, &addr->a, 1, gfp);
 122                if (error < 0)
 123                        break;
 124        }
 125
 126        return error;
 127}
 128
 129/* Initialize the SCTP_bind_addr structure for either an endpoint or
 130 * an association.
 131 */
 132void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port)
 133{
 134        bp->malloced = 0;
 135
 136        INIT_LIST_HEAD(&bp->address_list);
 137        bp->port = port;
 138}
 139
 140/* Dispose of the address list. */
 141static void sctp_bind_addr_clean(struct sctp_bind_addr *bp)
 142{
 143        struct sctp_sockaddr_entry *addr, *temp;
 144
 145        /* Empty the bind address list. */
 146        list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
 147                list_del_rcu(&addr->list);
 148                kfree_rcu(addr, rcu);
 149                SCTP_DBG_OBJCNT_DEC(addr);
 150        }
 151}
 152
 153/* Dispose of an SCTP_bind_addr structure  */
 154void sctp_bind_addr_free(struct sctp_bind_addr *bp)
 155{
 156        /* Empty the bind address list. */
 157        sctp_bind_addr_clean(bp);
 158
 159        if (bp->malloced) {
 160                kfree(bp);
 161                SCTP_DBG_OBJCNT_DEC(bind_addr);
 162        }
 163}
 164
 165/* Add an address to the bind address list in the SCTP_bind_addr structure. */
 166int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
 167                       __u8 addr_state, gfp_t gfp)
 168{
 169        struct sctp_sockaddr_entry *addr;
 170
 171        /* Add the address to the bind address list.  */
 172        addr = t_new(struct sctp_sockaddr_entry, gfp);
 173        if (!addr)
 174                return -ENOMEM;
 175
 176        memcpy(&addr->a, new, sizeof(*new));
 177
 178        /* Fix up the port if it has not yet been set.
 179         * Both v4 and v6 have the port at the same offset.
 180         */
 181        if (!addr->a.v4.sin_port)
 182                addr->a.v4.sin_port = htons(bp->port);
 183
 184        addr->state = addr_state;
 185        addr->valid = 1;
 186
 187        INIT_LIST_HEAD(&addr->list);
 188
 189        /* We always hold a socket lock when calling this function,
 190         * and that acts as a writer synchronizing lock.
 191         */
 192        list_add_tail_rcu(&addr->list, &bp->address_list);
 193        SCTP_DBG_OBJCNT_INC(addr);
 194
 195        return 0;
 196}
 197
 198/* Delete an address from the bind address list in the SCTP_bind_addr
 199 * structure.
 200 */
 201int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
 202{
 203        struct sctp_sockaddr_entry *addr, *temp;
 204        int found = 0;
 205
 206        /* We hold the socket lock when calling this function,
 207         * and that acts as a writer synchronizing lock.
 208         */
 209        list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
 210                if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
 211                        /* Found the exact match. */
 212                        found = 1;
 213                        addr->valid = 0;
 214                        list_del_rcu(&addr->list);
 215                        break;
 216                }
 217        }
 218
 219        if (found) {
 220                kfree_rcu(addr, rcu);
 221                SCTP_DBG_OBJCNT_DEC(addr);
 222                return 0;
 223        }
 224
 225        return -EINVAL;
 226}
 227
 228/* Create a network byte-order representation of all the addresses
 229 * formated as SCTP parameters.
 230 *
 231 * The second argument is the return value for the length.
 232 */
 233union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
 234                                         int *addrs_len,
 235                                         gfp_t gfp)
 236{
 237        union sctp_params addrparms;
 238        union sctp_params retval;
 239        int addrparms_len;
 240        union sctp_addr_param rawaddr;
 241        int len;
 242        struct sctp_sockaddr_entry *addr;
 243        struct list_head *pos;
 244        struct sctp_af *af;
 245
 246        addrparms_len = 0;
 247        len = 0;
 248
 249        /* Allocate enough memory at once. */
 250        list_for_each(pos, &bp->address_list) {
 251                len += sizeof(union sctp_addr_param);
 252        }
 253
 254        /* Don't even bother embedding an address if there
 255         * is only one.
 256         */
 257        if (len == sizeof(union sctp_addr_param)) {
 258                retval.v = NULL;
 259                goto end_raw;
 260        }
 261
 262        retval.v = kmalloc(len, gfp);
 263        if (!retval.v)
 264                goto end_raw;
 265
 266        addrparms = retval;
 267
 268        list_for_each_entry(addr, &bp->address_list, list) {
 269                af = sctp_get_af_specific(addr->a.v4.sin_family);
 270                len = af->to_addr_param(&addr->a, &rawaddr);
 271                memcpy(addrparms.v, &rawaddr, len);
 272                addrparms.v += len;
 273                addrparms_len += len;
 274        }
 275
 276end_raw:
 277        *addrs_len = addrparms_len;
 278        return retval;
 279}
 280
 281/*
 282 * Create an address list out of the raw address list format (IPv4 and IPv6
 283 * address parameters).
 284 */
 285int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
 286                           int addrs_len, __u16 port, gfp_t gfp)
 287{
 288        union sctp_addr_param *rawaddr;
 289        struct sctp_paramhdr *param;
 290        union sctp_addr addr;
 291        int retval = 0;
 292        int len;
 293        struct sctp_af *af;
 294
 295        /* Convert the raw address to standard address format */
 296        while (addrs_len) {
 297                param = (struct sctp_paramhdr *)raw_addr_list;
 298                rawaddr = (union sctp_addr_param *)raw_addr_list;
 299
 300                af = sctp_get_af_specific(param_type2af(param->type));
 301                if (unlikely(!af)) {
 302                        retval = -EINVAL;
 303                        sctp_bind_addr_clean(bp);
 304                        break;
 305                }
 306
 307                af->from_addr_param(&addr, rawaddr, htons(port), 0);
 308                retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp);
 309                if (retval) {
 310                        /* Can't finish building the list, clean up. */
 311                        sctp_bind_addr_clean(bp);
 312                        break;
 313                }
 314
 315                len = ntohs(param->length);
 316                addrs_len -= len;
 317                raw_addr_list += len;
 318        }
 319
 320        return retval;
 321}
 322
 323/********************************************************************
 324 * 2nd Level Abstractions
 325 ********************************************************************/
 326
 327/* Does this contain a specified address?  Allow wildcarding. */
 328int sctp_bind_addr_match(struct sctp_bind_addr *bp,
 329                         const union sctp_addr *addr,
 330                         struct sctp_sock *opt)
 331{
 332        struct sctp_sockaddr_entry *laddr;
 333        int match = 0;
 334
 335        rcu_read_lock();
 336        list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 337                if (!laddr->valid)
 338                        continue;
 339                if (opt->pf->cmp_addr(&laddr->a, addr, opt)) {
 340                        match = 1;
 341                        break;
 342                }
 343        }
 344        rcu_read_unlock();
 345
 346        return match;
 347}
 348
 349/* Does the address 'addr' conflict with any addresses in
 350 * the bp.
 351 */
 352int sctp_bind_addr_conflict(struct sctp_bind_addr *bp,
 353                            const union sctp_addr *addr,
 354                            struct sctp_sock *bp_sp,
 355                            struct sctp_sock *addr_sp)
 356{
 357        struct sctp_sockaddr_entry *laddr;
 358        int conflict = 0;
 359        struct sctp_sock *sp;
 360
 361        /* Pick the IPv6 socket as the basis of comparison
 362         * since it's usually a superset of the IPv4.
 363         * If there is no IPv6 socket, then default to bind_addr.
 364         */
 365        if (sctp_opt2sk(bp_sp)->sk_family == AF_INET6)
 366                sp = bp_sp;
 367        else if (sctp_opt2sk(addr_sp)->sk_family == AF_INET6)
 368                sp = addr_sp;
 369        else
 370                sp = bp_sp;
 371
 372        rcu_read_lock();
 373        list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 374                if (!laddr->valid)
 375                        continue;
 376
 377                conflict = sp->pf->cmp_addr(&laddr->a, addr, sp);
 378                if (conflict)
 379                        break;
 380        }
 381        rcu_read_unlock();
 382
 383        return conflict;
 384}
 385
 386/* Get the state of the entry in the bind_addr_list */
 387int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
 388                         const union sctp_addr *addr)
 389{
 390        struct sctp_sockaddr_entry *laddr;
 391        struct sctp_af *af;
 392        int state = -1;
 393
 394        af = sctp_get_af_specific(addr->sa.sa_family);
 395        if (unlikely(!af))
 396                return state;
 397
 398        rcu_read_lock();
 399        list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 400                if (!laddr->valid)
 401                        continue;
 402                if (af->cmp_addr(&laddr->a, addr)) {
 403                        state = laddr->state;
 404                        break;
 405                }
 406        }
 407        rcu_read_unlock();
 408
 409        return state;
 410}
 411
 412/* Find the first address in the bind address list that is not present in
 413 * the addrs packed array.
 414 */
 415union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr   *bp,
 416                                        const union sctp_addr   *addrs,
 417                                        int                     addrcnt,
 418                                        struct sctp_sock        *opt)
 419{
 420        struct sctp_sockaddr_entry      *laddr;
 421        union sctp_addr                 *addr;
 422        void                            *addr_buf;
 423        struct sctp_af                  *af;
 424        int                             i;
 425
 426        /* This is only called sctp_send_asconf_del_ip() and we hold
 427         * the socket lock in that code patch, so that address list
 428         * can't change.
 429         */
 430        list_for_each_entry(laddr, &bp->address_list, list) {
 431                addr_buf = (union sctp_addr *)addrs;
 432                for (i = 0; i < addrcnt; i++) {
 433                        addr = addr_buf;
 434                        af = sctp_get_af_specific(addr->v4.sin_family);
 435                        if (!af)
 436                                break;
 437
 438                        if (opt->pf->cmp_addr(&laddr->a, addr, opt))
 439                                break;
 440
 441                        addr_buf += af->sockaddr_len;
 442                }
 443                if (i == addrcnt)
 444                        return &laddr->a;
 445        }
 446
 447        return NULL;
 448}
 449
 450/* Copy out addresses from the global local address list. */
 451static int sctp_copy_one_addr(struct net *net, struct sctp_bind_addr *dest,
 452                              union sctp_addr *addr,
 453                              sctp_scope_t scope, gfp_t gfp,
 454                              int flags)
 455{
 456        int error = 0;
 457
 458        if (sctp_is_any(NULL, addr)) {
 459                error = sctp_copy_local_addr_list(net, dest, scope, gfp, flags);
 460        } else if (sctp_in_scope(net, addr, scope)) {
 461                /* Now that the address is in scope, check to see if
 462                 * the address type is supported by local sock as
 463                 * well as the remote peer.
 464                 */
 465                if ((((AF_INET == addr->sa.sa_family) &&
 466                      (flags & SCTP_ADDR4_PEERSUPP))) ||
 467                    (((AF_INET6 == addr->sa.sa_family) &&
 468                      (flags & SCTP_ADDR6_ALLOWED) &&
 469                      (flags & SCTP_ADDR6_PEERSUPP))))
 470                        error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
 471                                                    gfp);
 472        }
 473
 474        return error;
 475}
 476
 477/* Is this a wildcard address?  */
 478int sctp_is_any(struct sock *sk, const union sctp_addr *addr)
 479{
 480        unsigned short fam = 0;
 481        struct sctp_af *af;
 482
 483        /* Try to get the right address family */
 484        if (addr->sa.sa_family != AF_UNSPEC)
 485                fam = addr->sa.sa_family;
 486        else if (sk)
 487                fam = sk->sk_family;
 488
 489        af = sctp_get_af_specific(fam);
 490        if (!af)
 491                return 0;
 492
 493        return af->is_any(addr);
 494}
 495
 496/* Is 'addr' valid for 'scope'?  */
 497int sctp_in_scope(struct net *net, const union sctp_addr *addr, sctp_scope_t scope)
 498{
 499        sctp_scope_t addr_scope = sctp_scope(addr);
 500
 501        /* The unusable SCTP addresses will not be considered with
 502         * any defined scopes.
 503         */
 504        if (SCTP_SCOPE_UNUSABLE == addr_scope)
 505                return 0;
 506        /*
 507         * For INIT and INIT-ACK address list, let L be the level of
 508         * of requested destination address, sender and receiver
 509         * SHOULD include all of its addresses with level greater
 510         * than or equal to L.
 511         *
 512         * Address scoping can be selectively controlled via sysctl
 513         * option
 514         */
 515        switch (net->sctp.scope_policy) {
 516        case SCTP_SCOPE_POLICY_DISABLE:
 517                return 1;
 518        case SCTP_SCOPE_POLICY_ENABLE:
 519                if (addr_scope <= scope)
 520                        return 1;
 521                break;
 522        case SCTP_SCOPE_POLICY_PRIVATE:
 523                if (addr_scope <= scope || SCTP_SCOPE_PRIVATE == addr_scope)
 524                        return 1;
 525                break;
 526        case SCTP_SCOPE_POLICY_LINK:
 527                if (addr_scope <= scope || SCTP_SCOPE_LINK == addr_scope)
 528                        return 1;
 529                break;
 530        default:
 531                break;
 532        }
 533
 534        return 0;
 535}
 536
 537int sctp_is_ep_boundall(struct sock *sk)
 538{
 539        struct sctp_bind_addr *bp;
 540        struct sctp_sockaddr_entry *addr;
 541
 542        bp = &sctp_sk(sk)->ep->base.bind_addr;
 543        if (sctp_list_single_entry(&bp->address_list)) {
 544                addr = list_entry(bp->address_list.next,
 545                                  struct sctp_sockaddr_entry, list);
 546                if (sctp_is_any(sk, &addr->a))
 547                        return 1;
 548        }
 549        return 0;
 550}
 551
 552/********************************************************************
 553 * 3rd Level Abstractions
 554 ********************************************************************/
 555
 556/* What is the scope of 'addr'?  */
 557sctp_scope_t sctp_scope(const union sctp_addr *addr)
 558{
 559        struct sctp_af *af;
 560
 561        af = sctp_get_af_specific(addr->sa.sa_family);
 562        if (!af)
 563                return SCTP_SCOPE_UNUSABLE;
 564
 565        return af->scope((union sctp_addr *)addr);
 566}
 567
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.