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/in.h>
  47#include <net/sock.h>
  48#include <net/ipv6.h>
  49#include <net/if_inet6.h>
  50#include <net/sctp/sctp.h>
  51#include <net/sctp/sm.h>
  52
  53/* Forward declarations for internal helpers. */
  54static int sctp_copy_one_addr(struct sctp_bind_addr *, union sctp_addr *,
  55                              sctp_scope_t scope, gfp_t gfp,
  56                              int flags);
  57static void sctp_bind_addr_clean(struct sctp_bind_addr *);
  58
  59/* First Level Abstractions. */
  60
  61/* Copy 'src' to 'dest' taking 'scope' into account.  Omit addresses
  62 * in 'src' which have a broader scope than 'scope'.
  63 */
  64int sctp_bind_addr_copy(struct sctp_bind_addr *dest,
  65                        const struct sctp_bind_addr *src,
  66                        sctp_scope_t scope, gfp_t gfp,
  67                        int flags)
  68{
  69        struct sctp_sockaddr_entry *addr;
  70        int error = 0;
  71
  72        /* All addresses share the same port.  */
  73        dest->port = src->port;
  74
  75        /* Extract the addresses which are relevant for this scope.  */
  76        list_for_each_entry(addr, &src->address_list, list) {
  77                error = sctp_copy_one_addr(dest, &addr->a, scope,
  78                                           gfp, flags);
  79                if (error < 0)
  80                        goto out;
  81        }
  82
  83        /* If there are no addresses matching the scope and
  84         * this is global scope, try to get a link scope address, with
  85         * the assumption that we must be sitting behind a NAT.
  86         */
  87        if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
  88                list_for_each_entry(addr, &src->address_list, list) {
  89                        error = sctp_copy_one_addr(dest, &addr->a,
  90                                                   SCTP_SCOPE_LINK, gfp,
  91                                                   flags);
  92                        if (error < 0)
  93                                goto out;
  94                }
  95        }
  96
  97out:
  98        if (error)
  99                sctp_bind_addr_clean(dest);
 100
 101        return error;
 102}
 103
 104/* Exactly duplicate the address lists.  This is necessary when doing
 105 * peer-offs and accepts.  We don't want to put all the current system
 106 * addresses into the endpoint.  That's useless.  But we do want duplicat
 107 * the list of bound addresses that the older endpoint used.
 108 */
 109int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
 110                        const struct sctp_bind_addr *src,
 111                        gfp_t gfp)
 112{
 113        struct sctp_sockaddr_entry *addr;
 114        int error = 0;
 115
 116        /* All addresses share the same port.  */
 117        dest->port = src->port;
 118
 119        list_for_each_entry(addr, &src->address_list, list) {
 120                error = sctp_add_bind_addr(dest, &addr->a, 1, gfp);
 121                if (error < 0)
 122                        break;
 123        }
 124
 125        return error;
 126}
 127
 128/* Initialize the SCTP_bind_addr structure for either an endpoint or
 129 * an association.
 130 */
 131void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port)
 132{
 133        bp->malloced = 0;
 134
 135        INIT_LIST_HEAD(&bp->address_list);
 136        bp->port = port;
 137}
 138
 139/* Dispose of the address list. */
 140static void sctp_bind_addr_clean(struct sctp_bind_addr *bp)
 141{
 142        struct sctp_sockaddr_entry *addr;
 143        struct list_head *pos, *temp;
 144
 145        /* Empty the bind address list. */
 146        list_for_each_safe(pos, temp, &bp->address_list) {
 147                addr = list_entry(pos, struct sctp_sockaddr_entry, list);
 148                list_del(pos);
 149                kfree(addr);
 150                SCTP_DBG_OBJCNT_DEC(addr);
 151        }
 152}
 153
 154/* Dispose of an SCTP_bind_addr structure  */
 155void sctp_bind_addr_free(struct sctp_bind_addr *bp)
 156{
 157        /* Empty the bind address list. */
 158        sctp_bind_addr_clean(bp);
 159
 160        if (bp->malloced) {
 161                kfree(bp);
 162                SCTP_DBG_OBJCNT_DEC(bind_addr);
 163        }
 164}
 165
 166/* Add an address to the bind address list in the SCTP_bind_addr structure. */
 167int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
 168                       __u8 addr_state, gfp_t gfp)
 169{
 170        struct sctp_sockaddr_entry *addr;
 171
 172        /* Add the address to the bind address list.  */
 173        addr = t_new(struct sctp_sockaddr_entry, gfp);
 174        if (!addr)
 175                return -ENOMEM;
 176
 177        memcpy(&addr->a, new, sizeof(*new));
 178
 179        /* Fix up the port if it has not yet been set.
 180         * Both v4 and v6 have the port at the same offset.
 181         */
 182        if (!addr->a.v4.sin_port)
 183                addr->a.v4.sin_port = htons(bp->port);
 184
 185        addr->state = addr_state;
 186        addr->valid = 1;
 187
 188        INIT_LIST_HEAD(&addr->list);
 189        INIT_RCU_HEAD(&addr->rcu);
 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        if (addr_scope <= scope)
 515                return 1;
 516
 517        return 0;
 518}
 519
 520/********************************************************************
 521 * 3rd Level Abstractions
 522 ********************************************************************/
 523
 524/* What is the scope of 'addr'?  */
 525sctp_scope_t sctp_scope(const union sctp_addr *addr)
 526{
 527        struct sctp_af *af;
 528
 529        af = sctp_get_af_specific(addr->sa.sa_family);
 530        if (!af)
 531                return SCTP_SCOPE_UNUSABLE;
 532
 533        return af->scope((union sctp_addr *)addr);
 534}
 535