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 sctp_bind_addr *, union sctp_addr *,
  56                              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 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(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(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;
 144        struct list_head *pos, *temp;
 145
 146        /* Empty the bind address list. */
 147        list_for_each_safe(pos, temp, &bp->address_list) {
 148                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
 149                list_del(pos);
 150                kfree(addr);
 151                SCTP_DBG_OBJCNT_DEC(addr);
 152        }
 153}
 154
 155/* Dispose of an SCTP_bind_addr structure  */
 156void sctp_bind_addr_free(struct sctp_bind_addr *bp)
 157{
 158        /* Empty the bind address list. */
 159        sctp_bind_addr_clean(bp);
 160
 161        if (bp->malloced) {
 162                kfree(bp);
 163                SCTP_DBG_OBJCNT_DEC(bind_addr);
 164        }
 165}
 166
 167/* Add an address to the bind address list in the SCTP_bind_addr structure. */
 168int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
 169                       __u8 addr_state, gfp_t gfp)
 170{
 171        struct sctp_sockaddr_entry *addr;
 172
 173        /* Add the address to the bind address list.  */
 174        addr = t_new(struct sctp_sockaddr_entry, gfp);
 175        if (!addr)
 176                return -ENOMEM;
 177
 178        memcpy(&addr->a, new, sizeof(*new));
 179
 180        /* Fix up the port if it has not yet been set.
 181         * Both v4 and v6 have the port at the same offset.
 182         */
 183        if (!addr->a.v4.sin_port)
 184                addr->a.v4.sin_port = htons(bp->port);
 185
 186        addr->state = addr_state;
 187        addr->valid = 1;
 188
 189        INIT_LIST_HEAD(&addr->list);
 190
 191        /* We always hold a socket lock when calling this function,
 192         * and that acts as a writer synchronizing lock.
 193         */
 194        list_add_tail_rcu(&addr->list, &bp->address_list);
 195        SCTP_DBG_OBJCNT_INC(addr);
 196
 197        return 0;
 198}
 199
 200/* Delete an address from the bind address list in the SCTP_bind_addr
 201 * structure.
 202 */
 203int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
 204{
 205        struct sctp_sockaddr_entry *addr, *temp;
 206        int found = 0;
 207
 208        /* We hold the socket lock when calling this function,
 209         * and that acts as a writer synchronizing lock.
 210         */
 211        list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
 212                if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
 213                        /* Found the exact match. */
 214                        found = 1;
 215                        addr->valid = 0;
 216                        list_del_rcu(&addr->list);
 217                        break;
 218                }
 219        }
 220
 221        if (found) {
 222                call_rcu(&addr->rcu, sctp_local_addr_free);
 223                SCTP_DBG_OBJCNT_DEC(addr);
 224                return 0;
 225        }
 226
 227        return -EINVAL;
 228}
 229
 230/* Create a network byte-order representation of all the addresses
 231 * formated as SCTP parameters.
 232 *
 233 * The second argument is the return value for the length.
 234 */
 235union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
 236                                         int *addrs_len,
 237                                         gfp_t gfp)
 238{
 239        union sctp_params addrparms;
 240        union sctp_params retval;
 241        int addrparms_len;
 242        union sctp_addr_param rawaddr;
 243        int len;
 244        struct sctp_sockaddr_entry *addr;
 245        struct list_head *pos;
 246        struct sctp_af *af;
 247
 248        addrparms_len = 0;
 249        len = 0;
 250
 251        /* Allocate enough memory at once. */
 252        list_for_each(pos, &bp->address_list) {
 253                len += sizeof(union sctp_addr_param);
 254        }
 255
 256        /* Don't even bother embedding an address if there
 257         * is only one.
 258         */
 259        if (len == sizeof(union sctp_addr_param)) {
 260                retval.v = NULL;
 261                goto end_raw;
 262        }
 263
 264        retval.v = kmalloc(len, gfp);
 265        if (!retval.v)
 266                goto end_raw;
 267
 268        addrparms = retval;
 269
 270        list_for_each_entry(addr, &bp->address_list, list) {
 271                af = sctp_get_af_specific(addr->a.v4.sin_family);
 272                len = af->to_addr_param(&addr->a, &rawaddr);
 273                memcpy(addrparms.v, &rawaddr, len);
 274                addrparms.v += len;
 275                addrparms_len += len;
 276        }
 277
 278end_raw:
 279        *addrs_len = addrparms_len;
 280        return retval;
 281}
 282
 283/*
 284 * Create an address list out of the raw address list format (IPv4 and IPv6
 285 * address parameters).
 286 */
 287int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
 288                           int addrs_len, __u16 port, gfp_t gfp)
 289{
 290        union sctp_addr_param *rawaddr;
 291        struct sctp_paramhdr *param;
 292        union sctp_addr addr;
 293        int retval = 0;
 294        int len;
 295        struct sctp_af *af;
 296
 297        /* Convert the raw address to standard address format */
 298        while (addrs_len) {
 299                param = (struct sctp_paramhdr *)raw_addr_list;
 300                rawaddr = (union sctp_addr_param *)raw_addr_list;
 301
 302                af = sctp_get_af_specific(param_type2af(param->type));
 303                if (unlikely(!af)) {
 304                        retval = -EINVAL;
 305                        sctp_bind_addr_clean(bp);
 306                        break;
 307                }
 308
 309                af->from_addr_param(&addr, rawaddr, htons(port), 0);
 310                retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp);
 311                if (retval) {
 312                        /* Can't finish building the list, clean up. */
 313                        sctp_bind_addr_clean(bp);
 314                        break;
 315                }
 316
 317                len = ntohs(param->length);
 318                addrs_len -= len;
 319                raw_addr_list += len;
 320        }
 321
 322        return retval;
 323}
 324
 325/********************************************************************
 326 * 2nd Level Abstractions
 327 ********************************************************************/
 328
 329/* Does this contain a specified address?  Allow wildcarding. */
 330int sctp_bind_addr_match(struct sctp_bind_addr *bp,
 331                         const union sctp_addr *addr,
 332                         struct sctp_sock *opt)
 333{
 334        struct sctp_sockaddr_entry *laddr;
 335        int match = 0;
 336
 337        rcu_read_lock();
 338        list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 339                if (!laddr->valid)
 340                        continue;
 341                if (opt->pf->cmp_addr(&laddr->a, addr, opt)) {
 342                        match = 1;
 343                        break;
 344                }
 345        }
 346        rcu_read_unlock();
 347
 348        return match;
 349}
 350
 351/* Does the address 'addr' conflict with any addresses in
 352 * the bp.
 353 */
 354int sctp_bind_addr_conflict(struct sctp_bind_addr *bp,
 355                            const union sctp_addr *addr,
 356                            struct sctp_sock *bp_sp,
 357                            struct sctp_sock *addr_sp)
 358{
 359        struct sctp_sockaddr_entry *laddr;
 360        int conflict = 0;
 361        struct sctp_sock *sp;
 362
 363        /* Pick the IPv6 socket as the basis of comparison
 364         * since it's usually a superset of the IPv4.
 365         * If there is no IPv6 socket, then default to bind_addr.
 366         */
 367        if (sctp_opt2sk(bp_sp)->sk_family == AF_INET6)
 368                sp = bp_sp;
 369        else if (sctp_opt2sk(addr_sp)->sk_family == AF_INET6)
 370                sp = addr_sp;
 371        else
 372                sp = bp_sp;
 373
 374        rcu_read_lock();
 375        list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 376                if (!laddr->valid)
 377                        continue;
 378
 379                conflict = sp->pf->cmp_addr(&laddr->a, addr, sp);
 380                if (conflict)
 381                        break;
 382        }
 383        rcu_read_unlock();
 384
 385        return conflict;
 386}
 387
 388/* Get the state of the entry in the bind_addr_list */
 389int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
 390                         const union sctp_addr *addr)
 391{
 392        struct sctp_sockaddr_entry *laddr;
 393        struct sctp_af *af;
 394        int state = -1;
 395
 396        af = sctp_get_af_specific(addr->sa.sa_family);
 397        if (unlikely(!af))
 398                return state;
 399
 400        rcu_read_lock();
 401        list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 402                if (!laddr->valid)
 403                        continue;
 404                if (af->cmp_addr(&laddr->a, addr)) {
 405                        state = laddr->state;
 406                        break;
 407                }
 408        }
 409        rcu_read_unlock();
 410
 411        return state;
 412}
 413
 414/* Find the first address in the bind address list that is not present in
 415 * the addrs packed array.
 416 */
 417union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr   *bp,
 418                                        const union sctp_addr   *addrs,
 419                                        int                     addrcnt,
 420                                        struct sctp_sock        *opt)
 421{
 422        struct sctp_sockaddr_entry      *laddr;
 423        union sctp_addr                 *addr;
 424        void                            *addr_buf;
 425        struct sctp_af                  *af;
 426        int                             i;
 427
 428        /* This is only called sctp_send_asconf_del_ip() and we hold
 429         * the socket lock in that code patch, so that address list
 430         * can't change.
 431         */
 432        list_for_each_entry(laddr, &bp->address_list, list) {
 433                addr_buf = (union sctp_addr *)addrs;
 434                for (i = 0; i < addrcnt; i++) {
 435                        addr = (union sctp_addr *)addr_buf;
 436                        af = sctp_get_af_specific(addr->v4.sin_family);
 437                        if (!af)
 438                                break;
 439
 440                        if (opt->pf->cmp_addr(&laddr->a, addr, opt))
 441                                break;
 442
 443                        addr_buf += af->sockaddr_len;
 444                }
 445                if (i == addrcnt)
 446                        return &laddr->a;
 447        }
 448
 449        return NULL;
 450}
 451
 452/* Copy out addresses from the global local address list. */
 453static int sctp_copy_one_addr(struct sctp_bind_addr *dest,
 454                              union sctp_addr *addr,
 455                              sctp_scope_t scope, gfp_t gfp,
 456                              int flags)
 457{
 458        int error = 0;
 459
 460        if (sctp_is_any(NULL, addr)) {
 461                error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
 462        } else if (sctp_in_scope(addr, scope)) {
 463                /* Now that the address is in scope, check to see if
 464                 * the address type is supported by local sock as
 465                 * well as the remote peer.
 466                 */
 467                if ((((AF_INET == addr->sa.sa_family) &&
 468                      (flags & SCTP_ADDR4_PEERSUPP))) ||
 469                    (((AF_INET6 == addr->sa.sa_family) &&
 470                      (flags & SCTP_ADDR6_ALLOWED) &&
 471                      (flags & SCTP_ADDR6_PEERSUPP))))
 472                        error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
 473                                                    gfp);
 474        }
 475
 476        return error;
 477}
 478
 479/* Is this a wildcard address?  */
 480int sctp_is_any(struct sock *sk, const union sctp_addr *addr)
 481{
 482        unsigned short fam = 0;
 483        struct sctp_af *af;
 484
 485        /* Try to get the right address family */
 486        if (addr->sa.sa_family != AF_UNSPEC)
 487                fam = addr->sa.sa_family;
 488        else if (sk)
 489                fam = sk->sk_family;
 490
 491        af = sctp_get_af_specific(fam);
 492        if (!af)
 493                return 0;
 494
 495        return af->is_any(addr);
 496}
 497
 498/* Is 'addr' valid for 'scope'?  */
 499int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope)
 500{
 501        sctp_scope_t addr_scope = sctp_scope(addr);
 502
 503        /* The unusable SCTP addresses will not be considered with
 504         * any defined scopes.
 505         */
 506        if (SCTP_SCOPE_UNUSABLE == addr_scope)
 507                return 0;
 508        /*
 509         * For INIT and INIT-ACK address list, let L be the level of
 510         * of requested destination address, sender and receiver
 511         * SHOULD include all of its addresses with level greater
 512         * than or equal to L.
 513         *
 514         * Address scoping can be selectively controlled via sysctl
 515         * option
 516         */
 517        switch (sctp_scope_policy) {
 518        case SCTP_SCOPE_POLICY_DISABLE:
 519                return 1;
 520        case SCTP_SCOPE_POLICY_ENABLE:
 521                if (addr_scope <= scope)
 522                        return 1;
 523                break;
 524        case SCTP_SCOPE_POLICY_PRIVATE:
 525                if (addr_scope <= scope || SCTP_SCOPE_PRIVATE == addr_scope)
 526                        return 1;
 527                break;
 528        case SCTP_SCOPE_POLICY_LINK:
 529                if (addr_scope <= scope || SCTP_SCOPE_LINK == addr_scope)
 530                        return 1;
 531                break;
 532        default:
 533                break;
 534        }
 535
 536        return 0;
 537}
 538
 539/********************************************************************
 540 * 3rd Level Abstractions
 541 ********************************************************************/
 542
 543/* What is the scope of 'addr'?  */
 544sctp_scope_t sctp_scope(const union sctp_addr *addr)
 545{
 546        struct sctp_af *af;
 547
 548        af = sctp_get_af_specific(addr->sa.sa_family);
 549        if (!af)
 550                return SCTP_SCOPE_UNUSABLE;
 551
 552        return af->scope((union sctp_addr *)addr);
 553}
 554