* At this point, the IPv6 scopes will be mapped to these internal scopes
  * as much as possible.
  */
-typedef enum {
+enum sctp_scope {
        SCTP_SCOPE_GLOBAL,              /* IPv4 global addresses */
        SCTP_SCOPE_PRIVATE,             /* IPv4 private addresses */
        SCTP_SCOPE_LINK,                /* IPv4 link local address */
        SCTP_SCOPE_LOOPBACK,            /* IPv4 loopback address */
        SCTP_SCOPE_UNUSABLE,            /* IPv4 unusable addresses */
-} sctp_scope_t;
+};
 
 enum {
        SCTP_SCOPE_POLICY_DISABLE,      /* Disable IPv4 address scoping */
 
 /*
  * sctp/protocol.c
  */
-int sctp_copy_local_addr_list(struct net *, struct sctp_bind_addr *,
-                             sctp_scope_t, gfp_t gfp, int flags);
+int sctp_copy_local_addr_list(struct net *net, struct sctp_bind_addr *addr,
+                             enum sctp_scope, gfp_t gfp, int flags);
 struct sctp_pf *sctp_get_pf_specific(sa_family_t family);
 int sctp_register_pf(struct sctp_pf *, sa_family_t);
 void sctp_addr_wq_mgmt(struct net *, struct sctp_sockaddr_entry *, int);
 
        int             (*addr_valid)   (union sctp_addr *,
                                         struct sctp_sock *,
                                         const struct sk_buff *);
-       sctp_scope_t    (*scope) (union sctp_addr *);
+       enum sctp_scope (*scope)(union sctp_addr *);
        void            (*inaddr_any)   (union sctp_addr *, __be16);
        int             (*is_any)       (const union sctp_addr *);
        int             (*available)    (union sctp_addr *,
 void sctp_bind_addr_free(struct sctp_bind_addr *);
 int sctp_bind_addr_copy(struct net *net, struct sctp_bind_addr *dest,
                        const struct sctp_bind_addr *src,
-                       sctp_scope_t scope, gfp_t gfp,
+                       enum sctp_scope scope, gfp_t gfp,
                        int flags);
 int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
                        const struct sctp_bind_addr *src,
 int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw, int len,
                           __u16 port, gfp_t gfp);
 
-sctp_scope_t sctp_scope(const union sctp_addr *);
-int sctp_in_scope(struct net *net, const union sctp_addr *addr, const sctp_scope_t scope);
+enum sctp_scope sctp_scope(const union sctp_addr *addr);
+int sctp_in_scope(struct net *net, const union sctp_addr *addr,
+                 const enum sctp_scope scope);
 int sctp_is_any(struct sock *sk, const union sctp_addr *addr);
 int sctp_is_ep_boundall(struct sock *sk);
 
 
 
 struct sctp_association *
-sctp_association_new(const struct sctp_endpoint *, const struct sock *,
-                    sctp_scope_t scope, gfp_t gfp);
+sctp_association_new(const struct sctp_endpoint *ep, const struct sock *sk,
+                    enum sctp_scope scope, gfp_t gfp);
 void sctp_association_free(struct sctp_association *);
 void sctp_association_put(struct sctp_association *);
 void sctp_association_hold(struct sctp_association *);
                            struct sctp_transport *);
 void sctp_assoc_del_nonprimary_peers(struct sctp_association *,
                                    struct sctp_transport *);
-int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *,
-                                    sctp_scope_t, gfp_t);
+int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
+                                    enum sctp_scope scope, gfp_t gfp);
 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
                                         struct sctp_cookie*,
                                         gfp_t gfp);
 
 /* 1st Level Abstractions. */
 
 /* Initialize a new association from provided memory. */
-static struct sctp_association *sctp_association_init(struct sctp_association *asoc,
-                                         const struct sctp_endpoint *ep,
-                                         const struct sock *sk,
-                                         sctp_scope_t scope,
-                                         gfp_t gfp)
+static struct sctp_association *sctp_association_init(
+                                       struct sctp_association *asoc,
+                                       const struct sctp_endpoint *ep,
+                                       const struct sock *sk,
+                                       enum sctp_scope scope, gfp_t gfp)
 {
        struct net *net = sock_net(sk);
        struct sctp_sock *sp;
 
 /* Allocate and initialize a new association */
 struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,
-                                        const struct sock *sk,
-                                        sctp_scope_t scope,
-                                        gfp_t gfp)
+                                             const struct sock *sk,
+                                             enum sctp_scope scope, gfp_t gfp)
 {
        struct sctp_association *asoc;
 
  * local endpoint and the remote peer.
  */
 int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
-                                    sctp_scope_t scope, gfp_t gfp)
+                                    enum sctp_scope scope, gfp_t gfp)
 {
        int flags;
 
 
 #include <net/sctp/sm.h>
 
 /* Forward declarations for internal helpers. */
-static int sctp_copy_one_addr(struct net *, struct sctp_bind_addr *,
-                             union sctp_addr *, sctp_scope_t scope, gfp_t gfp,
-                             int flags);
+static int sctp_copy_one_addr(struct net *net, struct sctp_bind_addr *dest,
+                             union sctp_addr *addr, enum sctp_scope scope,
+                             gfp_t gfp, int flags);
 static void sctp_bind_addr_clean(struct sctp_bind_addr *);
 
 /* First Level Abstractions. */
  */
 int sctp_bind_addr_copy(struct net *net, struct sctp_bind_addr *dest,
                        const struct sctp_bind_addr *src,
-                       sctp_scope_t scope, gfp_t gfp,
+                       enum sctp_scope scope, gfp_t gfp,
                        int flags)
 {
        struct sctp_sockaddr_entry *addr;
 
 /* Copy out addresses from the global local address list. */
 static int sctp_copy_one_addr(struct net *net, struct sctp_bind_addr *dest,
-                             union sctp_addr *addr,
-                             sctp_scope_t scope, gfp_t gfp,
-                             int flags)
+                             union sctp_addr *addr, enum sctp_scope scope,
+                             gfp_t gfp, int flags)
 {
        int error = 0;
 
 }
 
 /* Is 'addr' valid for 'scope'?  */
-int sctp_in_scope(struct net *net, const union sctp_addr *addr, sctp_scope_t scope)
+int sctp_in_scope(struct net *net, const union sctp_addr *addr,
+                 enum sctp_scope scope)
 {
-       sctp_scope_t addr_scope = sctp_scope(addr);
+       enum sctp_scope addr_scope = sctp_scope(addr);
 
        /* The unusable SCTP addresses will not be considered with
         * any defined scopes.
  ********************************************************************/
 
 /* What is the scope of 'addr'?  */
-sctp_scope_t sctp_scope(const union sctp_addr *addr)
+enum sctp_scope sctp_scope(const union sctp_addr *addr)
 {
        struct sctp_af *af;
 
 
        union sctp_addr *daddr = &t->ipaddr;
        union sctp_addr dst_saddr;
        struct in6_addr *final_p, final;
+       enum sctp_scope scope;
        __u8 matchlen = 0;
-       sctp_scope_t scope;
 
        memset(fl6, 0, sizeof(struct flowi6));
        fl6->daddr = daddr->v6.sin6_addr;
 }
 
 /* What is the scope of 'addr'?  */
-static sctp_scope_t sctp_v6_scope(union sctp_addr *addr)
+static enum sctp_scope sctp_v6_scope(union sctp_addr *addr)
 {
+       enum sctp_scope retval;
        int v6scope;
-       sctp_scope_t retval;
 
        /* The IPv6 scope is really a set of bit fields.
         * See IFA_* in <net/if_inet6.h>.  Map to a generic SCTP scope.
 
 
 /* Copy the local addresses which are valid for 'scope' into 'bp'.  */
 int sctp_copy_local_addr_list(struct net *net, struct sctp_bind_addr *bp,
-                             sctp_scope_t scope, gfp_t gfp, int copy_flags)
+                             enum sctp_scope scope, gfp_t gfp, int copy_flags)
 {
        struct sctp_sockaddr_entry *addr;
        union sctp_addr laddr;
  * IPv4 scoping can be controlled through sysctl option
  * net.sctp.addr_scope_policy
  */
-static sctp_scope_t sctp_v4_scope(union sctp_addr *addr)
+static enum sctp_scope sctp_v4_scope(union sctp_addr *addr)
 {
-       sctp_scope_t retval;
+       enum sctp_scope retval;
 
        /* Check for unusable SCTP addresses. */
        if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr)) {
 
                                        gfp_t gfp)
 {
        struct sctp_association *asoc;
+       enum sctp_scope scope;
        struct sk_buff *skb;
-       sctp_scope_t scope;
 
        /* Create the bare association.  */
        scope = sctp_scope(sctp_source(chunk));
        int headersize, bodysize, fixed_size;
        __u8 *digest = ep->digest;
        unsigned int len;
-       sctp_scope_t scope;
+       enum sctp_scope scope;
        struct sk_buff *skb = chunk->skb;
        ktime_t kt;
 
        int i;
        __u16 sat;
        int retval = 1;
-       sctp_scope_t scope;
+       enum sctp_scope scope;
        u32 stale;
        struct sctp_af *af;
        union sctp_addr_param *addr_param;
 
        struct sctp_association *asoc2;
        struct sctp_transport *transport;
        union sctp_addr to;
-       sctp_scope_t scope;
+       enum sctp_scope scope;
        long timeo;
        int err = 0;
        int addrcnt = 0;
        struct sctp_initmsg *sinit;
        sctp_assoc_t associd = 0;
        sctp_cmsgs_t cmsgs = { NULL };
-       sctp_scope_t scope;
+       enum sctp_scope scope;
        bool fill_sinfo_ttl = false, wait_connect = false;
        struct sctp_datamsg *datamsg;
        int msg_flags = msg->msg_flags;