decnet: Reduce switch/case indent

Make the case labels the same indent as the switch.

git diff -w shows differences for line wrapping.
(fit multiple lines to 80 columns, join where possible)

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
index ea3b6ee21fc9343c63a85bb3ad5c5a3d74c9a72e..19acd00a63826b66bb3f8076bc75b7fa48d2f241 100644 (file)
--- a/net/decnet/af_decnet.c
+++ b/net/decnet/af_decnet.c
@@ -291,23 +291,23 @@ int dn_sockaddr2username(struct sockaddr_dn *sdn, unsigned char *buf, unsigned c
 
        *buf++ = type;
 
-       switch(type) {
-               case 0:
-                       *buf++ = sdn->sdn_objnum;
-                       break;
-               case 1:
-                       *buf++ = 0;
-                       *buf++ = le16_to_cpu(sdn->sdn_objnamel);
-                       memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel));
-                       len = 3 + le16_to_cpu(sdn->sdn_objnamel);
-                       break;
-               case 2:
-                       memset(buf, 0, 5);
-                       buf += 5;
-                       *buf++ = le16_to_cpu(sdn->sdn_objnamel);
-                       memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel));
-                       len = 7 + le16_to_cpu(sdn->sdn_objnamel);
-                       break;
+       switch (type) {
+       case 0:
+               *buf++ = sdn->sdn_objnum;
+               break;
+       case 1:
+               *buf++ = 0;
+               *buf++ = le16_to_cpu(sdn->sdn_objnamel);
+               memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel));
+               len = 3 + le16_to_cpu(sdn->sdn_objnamel);
+               break;
+       case 2:
+               memset(buf, 0, 5);
+               buf += 5;
+               *buf++ = le16_to_cpu(sdn->sdn_objnamel);
+               memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel));
+               len = 7 + le16_to_cpu(sdn->sdn_objnamel);
+               break;
        }
 
        return len;
@@ -337,23 +337,23 @@ int dn_username2sockaddr(unsigned char *data, int len, struct sockaddr_dn *sdn,
        *fmt = *data++;
        type = *data++;
 
-       switch(*fmt) {
-               case 0:
-                       sdn->sdn_objnum = type;
-                       return 2;
-               case 1:
-                       namel = 16;
-                       break;
-               case 2:
-                       len  -= 4;
-                       data += 4;
-                       break;
-               case 4:
-                       len  -= 8;
-                       data += 8;
-                       break;
-               default:
-                       return -1;
+       switch (*fmt) {
+       case 0:
+               sdn->sdn_objnum = type;
+               return 2;
+       case 1:
+               namel = 16;
+               break;
+       case 2:
+               len  -= 4;
+               data += 4;
+               break;
+       case 4:
+               len  -= 8;
+               data += 8;
+               break;
+       default:
+               return -1;
        }
 
        len -= 1;
@@ -575,25 +575,26 @@ int dn_destroy_timer(struct sock *sk)
 
        scp->persist = dn_nsp_persist(sk);
 
-       switch(scp->state) {
-               case DN_DI:
-                       dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
-                       if (scp->nsp_rxtshift >= decnet_di_count)
-                               scp->state = DN_CN;
-                       return 0;
+       switch (scp->state) {
+       case DN_DI:
+               dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
+               if (scp->nsp_rxtshift >= decnet_di_count)
+                       scp->state = DN_CN;
+               return 0;
 
-               case DN_DR:
-                       dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
-                       if (scp->nsp_rxtshift >= decnet_dr_count)
-                               scp->state = DN_DRC;
-                       return 0;
+       case DN_DR:
+               dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
+               if (scp->nsp_rxtshift >= decnet_dr_count)
+                       scp->state = DN_DRC;
+               return 0;
 
-               case DN_DN:
-                       if (scp->nsp_rxtshift < decnet_dn_count) {
-                               /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */
-                               dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, GFP_ATOMIC);
-                               return 0;
-                       }
+       case DN_DN:
+               if (scp->nsp_rxtshift < decnet_dn_count) {
+                       /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */
+                       dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC,
+                                        GFP_ATOMIC);
+                       return 0;
+               }
        }
 
        scp->persist = (HZ * decnet_time_wait);
@@ -623,42 +624,42 @@ static void dn_destroy_sock(struct sock *sk)
 
        sk->sk_state = TCP_CLOSE;
 
-       switch(scp->state) {
-               case DN_DN:
-                       dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC,
-                                        sk->sk_allocation);
-                       scp->persist_fxn = dn_destroy_timer;
-                       scp->persist = dn_nsp_persist(sk);
-                       break;
-               case DN_CR:
-                       scp->state = DN_DR;
-                       goto disc_reject;
-               case DN_RUN:
-                       scp->state = DN_DI;
-               case DN_DI:
-               case DN_DR:
+       switch (scp->state) {
+       case DN_DN:
+               dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC,
+                                sk->sk_allocation);
+               scp->persist_fxn = dn_destroy_timer;
+               scp->persist = dn_nsp_persist(sk);
+               break;
+       case DN_CR:
+               scp->state = DN_DR;
+               goto disc_reject;
+       case DN_RUN:
+               scp->state = DN_DI;
+       case DN_DI:
+       case DN_DR:
 disc_reject:
-                       dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation);
-               case DN_NC:
-               case DN_NR:
-               case DN_RJ:
-               case DN_DIC:
-               case DN_CN:
-               case DN_DRC:
-               case DN_CI:
-               case DN_CD:
-                       scp->persist_fxn = dn_destroy_timer;
-                       scp->persist = dn_nsp_persist(sk);
-                       break;
-               default:
-                       printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n");
-               case DN_O:
-                       dn_stop_slow_timer(sk);
+               dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation);
+       case DN_NC:
+       case DN_NR:
+       case DN_RJ:
+       case DN_DIC:
+       case DN_CN:
+       case DN_DRC:
+       case DN_CI:
+       case DN_CD:
+               scp->persist_fxn = dn_destroy_timer;
+               scp->persist = dn_nsp_persist(sk);
+               break;
+       default:
+               printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n");
+       case DN_O:
+               dn_stop_slow_timer(sk);
 
-                       dn_unhash_sock_bh(sk);
-                       sock_put(sk);
+               dn_unhash_sock_bh(sk);
+               sock_put(sk);
 
-                       break;
+               break;
        }
 }
 
@@ -683,15 +684,15 @@ static int dn_create(struct net *net, struct socket *sock, int protocol,
        if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
-       switch(sock->type) {
-               case SOCK_SEQPACKET:
-                       if (protocol != DNPROTO_NSP)
-                               return -EPROTONOSUPPORT;
-                       break;
-               case SOCK_STREAM:
-                       break;
-               default:
-                       return -ESOCKTNOSUPPORT;
+       switch (sock->type) {
+       case SOCK_SEQPACKET:
+               if (protocol != DNPROTO_NSP)
+                       return -EPROTONOSUPPORT;
+               break;
+       case SOCK_STREAM:
+               break;
+       default:
+               return -ESOCKTNOSUPPORT;
        }
 
 
@@ -987,16 +988,16 @@ static inline int dn_check_state(struct sock *sk, struct sockaddr_dn *addr, int
 {
        struct dn_scp *scp = DN_SK(sk);
 
-       switch(scp->state) {
-               case DN_RUN:
-                       return 0;
-               case DN_CR:
-                       return dn_confirm_accept(sk, timeo, sk->sk_allocation);
-               case DN_CI:
-               case DN_CC:
-                       return dn_wait_run(sk, timeo);
-               case DN_O:
-                       return __dn_connect(sk, addr, addrlen, timeo, flags);
+       switch (scp->state) {
+       case DN_RUN:
+               return 0;
+       case DN_CR:
+               return dn_confirm_accept(sk, timeo, sk->sk_allocation);
+       case DN_CI:
+       case DN_CC:
+               return dn_wait_run(sk, timeo);
+       case DN_O:
+               return __dn_connect(sk, addr, addrlen, timeo, flags);
        }
 
        return -EINVAL;
@@ -1363,141 +1364,140 @@ static int __dn_setsockopt(struct socket *sock, int level,int optname, char __us
        if (copy_from_user(&u, optval, optlen))
                return -EFAULT;
 
-       switch(optname) {
-               case DSO_CONDATA:
-                       if (sock->state == SS_CONNECTED)
-                               return -EISCONN;
-                       if ((scp->state != DN_O) && (scp->state != DN_CR))
-                               return -EINVAL;
+       switch (optname) {
+       case DSO_CONDATA:
+               if (sock->state == SS_CONNECTED)
+                       return -EISCONN;
+               if ((scp->state != DN_O) && (scp->state != DN_CR))
+                       return -EINVAL;
 
-                       if (optlen != sizeof(struct optdata_dn))
-                               return -EINVAL;
+               if (optlen != sizeof(struct optdata_dn))
+                       return -EINVAL;
 
-                       if (le16_to_cpu(u.opt.opt_optl) > 16)
-                               return -EINVAL;
+               if (le16_to_cpu(u.opt.opt_optl) > 16)
+                       return -EINVAL;
 
-                       memcpy(&scp->conndata_out, &u.opt, optlen);
-                       break;
-
-               case DSO_DISDATA:
-                       if (sock->state != SS_CONNECTED && scp->accept_mode == ACC_IMMED)
-                               return -ENOTCONN;
-
-                       if (optlen != sizeof(struct optdata_dn))
-                               return -EINVAL;
+               memcpy(&scp->conndata_out, &u.opt, optlen);
+               break;
 
-                       if (le16_to_cpu(u.opt.opt_optl) > 16)
-                               return -EINVAL;
+       case DSO_DISDATA:
+               if (sock->state != SS_CONNECTED &&
+                   scp->accept_mode == ACC_IMMED)
+                       return -ENOTCONN;
 
-                       memcpy(&scp->discdata_out, &u.opt, optlen);
-                       break;
+               if (optlen != sizeof(struct optdata_dn))
+                       return -EINVAL;
 
-               case DSO_CONACCESS:
-                       if (sock->state == SS_CONNECTED)
-                               return -EISCONN;
-                       if (scp->state != DN_O)
-                               return -EINVAL;
+               if (le16_to_cpu(u.opt.opt_optl) > 16)
+                       return -EINVAL;
 
-                       if (optlen != sizeof(struct accessdata_dn))
-                               return -EINVAL;
+               memcpy(&scp->discdata_out, &u.opt, optlen);
+               break;
 
-                       if ((u.acc.acc_accl > DN_MAXACCL) ||
-                                       (u.acc.acc_passl > DN_MAXACCL) ||
-                                       (u.acc.acc_userl > DN_MAXACCL))
-                               return -EINVAL;
+       case DSO_CONACCESS:
+               if (sock->state == SS_CONNECTED)
+                       return -EISCONN;
+               if (scp->state != DN_O)
+                       return -EINVAL;
 
-                       memcpy(&scp->accessdata, &u.acc, optlen);
-                       break;
+               if (optlen != sizeof(struct accessdata_dn))
+                       return -EINVAL;
 
-               case DSO_ACCEPTMODE:
-                       if (sock->state == SS_CONNECTED)
-                               return -EISCONN;
-                       if (scp->state != DN_O)
-                               return -EINVAL;
+               if ((u.acc.acc_accl > DN_MAXACCL) ||
+                   (u.acc.acc_passl > DN_MAXACCL) ||
+                   (u.acc.acc_userl > DN_MAXACCL))
+                       return -EINVAL;
 
-                       if (optlen != sizeof(int))
-                               return -EINVAL;
+               memcpy(&scp->accessdata, &u.acc, optlen);
+               break;
 
-                       if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER))
-                               return -EINVAL;
+       case DSO_ACCEPTMODE:
+               if (sock->state == SS_CONNECTED)
+                       return -EISCONN;
+               if (scp->state != DN_O)
+                       return -EINVAL;
 
-                       scp->accept_mode = (unsigned char)u.mode;
-                       break;
+               if (optlen != sizeof(int))
+                       return -EINVAL;
 
-               case DSO_CONACCEPT:
+               if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER))
+                       return -EINVAL;
 
-                       if (scp->state != DN_CR)
-                               return -EINVAL;
-                       timeo = sock_rcvtimeo(sk, 0);
-                       err = dn_confirm_accept(sk, &timeo, sk->sk_allocation);
-                       return err;
+               scp->accept_mode = (unsigned char)u.mode;
+               break;
 
-               case DSO_CONREJECT:
+       case DSO_CONACCEPT:
+               if (scp->state != DN_CR)
+                       return -EINVAL;
+               timeo = sock_rcvtimeo(sk, 0);
+               err = dn_confirm_accept(sk, &timeo, sk->sk_allocation);
+               return err;
 
-                       if (scp->state != DN_CR)
-                               return -EINVAL;
+       case DSO_CONREJECT:
+               if (scp->state != DN_CR)
+                       return -EINVAL;
 
-                       scp->state = DN_DR;
-                       sk->sk_shutdown = SHUTDOWN_MASK;
-                       dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation);
-                       break;
+               scp->state = DN_DR;
+               sk->sk_shutdown = SHUTDOWN_MASK;
+               dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation);
+               break;
 
-               default:
+       default:
 #ifdef CONFIG_NETFILTER
                return nf_setsockopt(sk, PF_DECnet, optname, optval, optlen);
 #endif
-               case DSO_LINKINFO:
-               case DSO_STREAM:
-               case DSO_SEQPACKET:
-                       return -ENOPROTOOPT;
-
-               case DSO_MAXWINDOW:
-                       if (optlen != sizeof(unsigned long))
-                               return -EINVAL;
-                       if (u.win > NSP_MAX_WINDOW)
-                               u.win = NSP_MAX_WINDOW;
-                       if (u.win == 0)
-                               return -EINVAL;
-                       scp->max_window = u.win;
-                       if (scp->snd_window > u.win)
-                               scp->snd_window = u.win;
-                       break;
+       case DSO_LINKINFO:
+       case DSO_STREAM:
+       case DSO_SEQPACKET:
+               return -ENOPROTOOPT;
+
+       case DSO_MAXWINDOW:
+               if (optlen != sizeof(unsigned long))
+                       return -EINVAL;
+               if (u.win > NSP_MAX_WINDOW)
+                       u.win = NSP_MAX_WINDOW;
+               if (u.win == 0)
+                       return -EINVAL;
+               scp->max_window = u.win;
+               if (scp->snd_window > u.win)
+                       scp->snd_window = u.win;
+               break;
 
-               case DSO_NODELAY:
-                       if (optlen != sizeof(int))
-                               return -EINVAL;
-                       if (scp->nonagle == 2)
-                               return -EINVAL;
-                       scp->nonagle = (u.val == 0) ? 0 : 1;
-                       /* if (scp->nonagle == 1) { Push pending frames } */
-                       break;
+       case DSO_NODELAY:
+               if (optlen != sizeof(int))
+                       return -EINVAL;
+               if (scp->nonagle == 2)
+                       return -EINVAL;
+               scp->nonagle = (u.val == 0) ? 0 : 1;
+               /* if (scp->nonagle == 1) { Push pending frames } */
+               break;
 
-               case DSO_CORK:
-                       if (optlen != sizeof(int))
-                               return -EINVAL;
-                       if (scp->nonagle == 1)
-                               return -EINVAL;
-                       scp->nonagle = (u.val == 0) ? 0 : 2;
-                       /* if (scp->nonagle == 0) { Push pending frames } */
-                       break;
+       case DSO_CORK:
+               if (optlen != sizeof(int))
+                       return -EINVAL;
+               if (scp->nonagle == 1)
+                       return -EINVAL;
+               scp->nonagle = (u.val == 0) ? 0 : 2;
+               /* if (scp->nonagle == 0) { Push pending frames } */
+               break;
 
-               case DSO_SERVICES:
-                       if (optlen != sizeof(unsigned char))
-                               return -EINVAL;
-                       if ((u.services & ~NSP_FC_MASK) != 0x01)
-                               return -EINVAL;
-                       if ((u.services & NSP_FC_MASK) == NSP_FC_MASK)
-                               return -EINVAL;
-                       scp->services_loc = u.services;
-                       break;
+       case DSO_SERVICES:
+               if (optlen != sizeof(unsigned char))
+                       return -EINVAL;
+               if ((u.services & ~NSP_FC_MASK) != 0x01)
+                       return -EINVAL;
+               if ((u.services & NSP_FC_MASK) == NSP_FC_MASK)
+                       return -EINVAL;
+               scp->services_loc = u.services;
+               break;
 
-               case DSO_INFO:
-                       if (optlen != sizeof(unsigned char))
-                               return -EINVAL;
-                       if (u.info & 0xfc)
-                               return -EINVAL;
-                       scp->info_loc = u.info;
-                       break;
+       case DSO_INFO:
+               if (optlen != sizeof(unsigned char))
+                       return -EINVAL;
+               if (u.info & 0xfc)
+                       return -EINVAL;
+               scp->info_loc = u.info;
+               break;
        }
 
        return 0;
@@ -1527,107 +1527,106 @@ static int __dn_getsockopt(struct socket *sock, int level,int optname, char __us
        if(get_user(r_len , optlen))
                return -EFAULT;
 
-       switch(optname) {
-               case DSO_CONDATA:
-                       if (r_len > sizeof(struct optdata_dn))
-                               r_len = sizeof(struct optdata_dn);
-                       r_data = &scp->conndata_in;
-                       break;
-
-               case DSO_DISDATA:
-                       if (r_len > sizeof(struct optdata_dn))
-                               r_len = sizeof(struct optdata_dn);
-                       r_data = &scp->discdata_in;
-                       break;
+       switch (optname) {
+       case DSO_CONDATA:
+               if (r_len > sizeof(struct optdata_dn))
+                       r_len = sizeof(struct optdata_dn);
+               r_data = &scp->conndata_in;
+               break;
 
-               case DSO_CONACCESS:
-                       if (r_len > sizeof(struct accessdata_dn))
-                               r_len = sizeof(struct accessdata_dn);
-                       r_data = &scp->accessdata;
-                       break;
+       case DSO_DISDATA:
+               if (r_len > sizeof(struct optdata_dn))
+                       r_len = sizeof(struct optdata_dn);
+               r_data = &scp->discdata_in;
+               break;
 
-               case DSO_ACCEPTMODE:
-                       if (r_len > sizeof(unsigned char))
-                               r_len = sizeof(unsigned char);
-                       r_data = &scp->accept_mode;
-                       break;
+       case DSO_CONACCESS:
+               if (r_len > sizeof(struct accessdata_dn))
+                       r_len = sizeof(struct accessdata_dn);
+               r_data = &scp->accessdata;
+               break;
 
-               case DSO_LINKINFO:
-                       if (r_len > sizeof(struct linkinfo_dn))
-                               r_len = sizeof(struct linkinfo_dn);
+       case DSO_ACCEPTMODE:
+               if (r_len > sizeof(unsigned char))
+                       r_len = sizeof(unsigned char);
+               r_data = &scp->accept_mode;
+               break;
 
-                       memset(&link, 0, sizeof(link));
+       case DSO_LINKINFO:
+               if (r_len > sizeof(struct linkinfo_dn))
+                       r_len = sizeof(struct linkinfo_dn);
 
-                       switch(sock->state) {
-                               case SS_CONNECTING:
-                                       link.idn_linkstate = LL_CONNECTING;
-                                       break;
-                               case SS_DISCONNECTING:
-                                       link.idn_linkstate = LL_DISCONNECTING;
-                                       break;
-                               case SS_CONNECTED:
-                                       link.idn_linkstate = LL_RUNNING;
-                                       break;
-                               default:
-                                       link.idn_linkstate = LL_INACTIVE;
-                       }
+               memset(&link, 0, sizeof(link));
 
-                       link.idn_segsize = scp->segsize_rem;
-                       r_data = &link;
+               switch (sock->state) {
+               case SS_CONNECTING:
+                       link.idn_linkstate = LL_CONNECTING;
+                       break;
+               case SS_DISCONNECTING:
+                       link.idn_linkstate = LL_DISCONNECTING;
+                       break;
+               case SS_CONNECTED:
+                       link.idn_linkstate = LL_RUNNING;
                        break;
-
                default:
+                       link.idn_linkstate = LL_INACTIVE;
+               }
+
+               link.idn_segsize = scp->segsize_rem;
+               r_data = &link;
+               break;
+
+       default:
 #ifdef CONFIG_NETFILTER
-               {
-                       int ret, len;
+       {
+               int ret, len;
 
-                       if(get_user(len, optlen))
-                               return -EFAULT;
+               if (get_user(len, optlen))
+                       return -EFAULT;
 
-                       ret = nf_getsockopt(sk, PF_DECnet, optname,
-                                                       optval, &len);
-                       if (ret >= 0)
-                               ret = put_user(len, optlen);
-                       return ret;
-               }
+               ret = nf_getsockopt(sk, PF_DECnet, optname, optval, &len);
+               if (ret >= 0)
+                       ret = put_user(len, optlen);
+               return ret;
+       }
 #endif
-               case DSO_STREAM:
-               case DSO_SEQPACKET:
-               case DSO_CONACCEPT:
-               case DSO_CONREJECT:
-                       return -ENOPROTOOPT;
-
-               case DSO_MAXWINDOW:
-                       if (r_len > sizeof(unsigned long))
-                               r_len = sizeof(unsigned long);
-                       r_data = &scp->max_window;
-                       break;
+       case DSO_STREAM:
+       case DSO_SEQPACKET:
+       case DSO_CONACCEPT:
+       case DSO_CONREJECT:
+               return -ENOPROTOOPT;
+
+       case DSO_MAXWINDOW:
+               if (r_len > sizeof(unsigned long))
+                       r_len = sizeof(unsigned long);
+               r_data = &scp->max_window;
+               break;
 
-               case DSO_NODELAY:
-                       if (r_len > sizeof(int))
-                               r_len = sizeof(int);
-                       val = (scp->nonagle == 1);
-                       r_data = &val;
-                       break;
+       case DSO_NODELAY:
+               if (r_len > sizeof(int))
+                       r_len = sizeof(int);
+               val = (scp->nonagle == 1);
+               r_data = &val;
+               break;
 
-               case DSO_CORK:
-                       if (r_len > sizeof(int))
-                               r_len = sizeof(int);
-                       val = (scp->nonagle == 2);
-                       r_data = &val;
-                       break;
+       case DSO_CORK:
+               if (r_len > sizeof(int))
+                       r_len = sizeof(int);
+               val = (scp->nonagle == 2);
+               r_data = &val;
+               break;
 
-               case DSO_SERVICES:
-                       if (r_len > sizeof(unsigned char))
-                               r_len = sizeof(unsigned char);
-                       r_data = &scp->services_rem;
-                       break;
+       case DSO_SERVICES:
+               if (r_len > sizeof(unsigned char))
+                       r_len = sizeof(unsigned char);
+               r_data = &scp->services_rem;
+               break;
 
-               case DSO_INFO:
-                       if (r_len > sizeof(unsigned char))
-                               r_len = sizeof(unsigned char);
-                       r_data = &scp->info_rem;
-                       break;
+       case DSO_INFO:
+               if (r_len > sizeof(unsigned char))
+                       r_len = sizeof(unsigned char);
+               r_data = &scp->info_rem;
+               break;
        }
 
        if (r_data) {
@@ -2088,15 +2087,15 @@ static int dn_device_event(struct notifier_block *this, unsigned long event,
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
-       switch(event) {
-               case NETDEV_UP:
-                       dn_dev_up(dev);
-                       break;
-               case NETDEV_DOWN:
-                       dn_dev_down(dev);
-                       break;
-               default:
-                       break;
+       switch (event) {
+       case NETDEV_UP:
+               dn_dev_up(dev);
+               break;
+       case NETDEV_DOWN:
+               dn_dev_down(dev);
+               break;
+       default:
+               break;
        }
 
        return NOTIFY_DONE;
@@ -2209,54 +2208,54 @@ static void dn_printable_object(struct sockaddr_dn *dn, unsigned char *buf)
        int i;
 
        switch (le16_to_cpu(dn->sdn_objnamel)) {
-               case 0:
-                       sprintf(buf, "%d", dn->sdn_objnum);
-                       break;
-               default:
-                       for (i = 0; i < le16_to_cpu(dn->sdn_objnamel); i++) {
-                               buf[i] = dn->sdn_objname[i];
-                               if (IS_NOT_PRINTABLE(buf[i]))
-                                       buf[i] = '.';
-                       }
-                       buf[i] = 0;
+       case 0:
+               sprintf(buf, "%d", dn->sdn_objnum);
+               break;
+       default:
+               for (i = 0; i < le16_to_cpu(dn->sdn_objnamel); i++) {
+                       buf[i] = dn->sdn_objname[i];
+                       if (IS_NOT_PRINTABLE(buf[i]))
+                               buf[i] = '.';
+               }
+               buf[i] = 0;
        }
 }
 
 static char *dn_state2asc(unsigned char state)
 {
-       switch(state) {
-               case DN_O:
-                       return "OPEN";
-               case DN_CR:
-                       return "  CR";
-               case DN_DR:
-                       return "  DR";
-               case DN_DRC:
-                       return " DRC";
-               case DN_CC:
-                       return "  CC";
-               case DN_CI:
-                       return "  CI";
-               case DN_NR:
-                       return "  NR";
-               case DN_NC:
-                       return "  NC";
-               case DN_CD:
-                       return "  CD";
-               case DN_RJ:
-                       return "  RJ";
-               case DN_RUN:
-                       return " RUN";
-               case DN_DI:
-                       return "  DI";
-               case DN_DIC:
-                       return " DIC";
-               case DN_DN:
-                       return "  DN";
-               case DN_CL:
-                       return "  CL";
-               case DN_CN:
-                       return "  CN";
+       switch (state) {
+       case DN_O:
+               return "OPEN";
+       case DN_CR:
+               return "  CR";
+       case DN_DR:
+               return "  DR";
+       case DN_DRC:
+               return " DRC";
+       case DN_CC:
+               return "  CC";
+       case DN_CI:
+               return "  CI";
+       case DN_NR:
+               return "  NR";
+       case DN_NC:
+               return "  NC";
+       case DN_CD:
+               return "  CD";
+       case DN_RJ:
+               return "  RJ";
+       case DN_RUN:
+               return " RUN";
+       case DN_DI:
+               return "  DI";
+       case DN_DIC:
+               return " DIC";
+       case DN_DN:
+               return "  DN";
+       case DN_CL:
+               return "  CL";
+       case DN_CN:
+               return "  CN";
        }
 
        return "????";

diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c
index 48530b45439564ff5695fd9ec403d49d150191c8..ba4faceec405b45a43a6bff918f218a38717d7a3 100644 (file)
--- a/net/decnet/dn_dev.c
+++ b/net/decnet/dn_dev.c
@@ -437,17 +437,17 @@ int dn_dev_ioctl(unsigned int cmd, void __user *arg)
 
        dev_load(&init_net, ifr->ifr_name);
 
-       switch(cmd) {
-               case SIOCGIFADDR:
-                       break;
-               case SIOCSIFADDR:
-                       if (!capable(CAP_NET_ADMIN))
-                               return -EACCES;
-                       if (sdn->sdn_family != AF_DECnet)
-                               return -EINVAL;
-                       break;
-               default:
+       switch (cmd) {
+       case SIOCGIFADDR:
+               break;
+       case SIOCSIFADDR:
+               if (!capable(CAP_NET_ADMIN))
+                       return -EACCES;
+               if (sdn->sdn_family != AF_DECnet)
                        return -EINVAL;
+               break;
+       default:
+               return -EINVAL;
        }
 
        rtnl_lock();
@@ -470,27 +470,27 @@ int dn_dev_ioctl(unsigned int cmd, void __user *arg)
                goto done;
        }
 
-       switch(cmd) {
-               case SIOCGIFADDR:
-                       *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local;
-                       goto rarok;
-
-               case SIOCSIFADDR:
-                       if (!ifa) {
-                               if ((ifa = dn_dev_alloc_ifa()) == NULL) {
-                                       ret = -ENOBUFS;
-                                       break;
-                               }
-                               memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
-                       } else {
-                               if (ifa->ifa_local == dn_saddr2dn(sdn))
-                                       break;
-                               dn_dev_del_ifa(dn_db, ifap, 0);
+       switch (cmd) {
+       case SIOCGIFADDR:
+               *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local;
+               goto rarok;
+
+       case SIOCSIFADDR:
+               if (!ifa) {
+                       if ((ifa = dn_dev_alloc_ifa()) == NULL) {
+                               ret = -ENOBUFS;
+                               break;
                        }
+                       memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
+               } else {
+                       if (ifa->ifa_local == dn_saddr2dn(sdn))
+                               break;
+                       dn_dev_del_ifa(dn_db, ifap, 0);
+               }
 
-                       ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn);
+               ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn);
 
-                       ret = dn_dev_set_ifa(dev, ifa);
+               ret = dn_dev_set_ifa(dev, ifa);
        }
 done:
        rtnl_unlock();
@@ -1335,13 +1335,13 @@ static void dn_dev_seq_stop(struct seq_file *seq, void *v)
 
 static char *dn_type2asc(char type)
 {
-       switch(type) {
-               case DN_DEV_BCAST:
-                       return "B";
-               case DN_DEV_UCAST:
-                       return "U";
-               case DN_DEV_MPOINT:
-                       return "M";
+       switch (type) {
+       case DN_DEV_BCAST:
+               return "B";
+       case DN_DEV_UCAST:
+               return "U";
+       case DN_DEV_MPOINT:
+               return "M";
        }
 
        return "?";

diff --git a/net/decnet/dn_fib.c b/net/decnet/dn_fib.c
index 104324d6d5355f93dcce6a7b7b905c31d1106a63..2bd8e53d7774fa4d02a5ae36140775f6181dd3ca 100644 (file)
--- a/net/decnet/dn_fib.c
+++ b/net/decnet/dn_fib.c
@@ -414,33 +414,34 @@ int dn_fib_semantic_match(int type, struct dn_fib_info *fi, const struct flowidn
 
                res->fi = fi;
 
-               switch(type) {
-                       case RTN_NAT:
-                               DN_FIB_RES_RESET(*res);
+               switch (type) {
+               case RTN_NAT:
+                       DN_FIB_RES_RESET(*res);
+                       atomic_inc(&fi->fib_clntref);
+                       return 0;
+               case RTN_UNICAST:
+               case RTN_LOCAL:
+                       for_nexthops(fi) {
+                               if (nh->nh_flags & RTNH_F_DEAD)
+                                       continue;
+                               if (!fld->flowidn_oif ||
+                                   fld->flowidn_oif == nh->nh_oif)
+                                       break;
+                       }
+                       if (nhsel < fi->fib_nhs) {
+                               res->nh_sel = nhsel;
                                atomic_inc(&fi->fib_clntref);
                                return 0;
-                       case RTN_UNICAST:
-                       case RTN_LOCAL:
-                               for_nexthops(fi) {
-                                       if (nh->nh_flags & RTNH_F_DEAD)
-                                               continue;
-                                       if (!fld->flowidn_oif ||
-                                           fld->flowidn_oif == nh->nh_oif)
-                                               break;
-                               }
-                               if (nhsel < fi->fib_nhs) {
-                                       res->nh_sel = nhsel;
-                                       atomic_inc(&fi->fib_clntref);
-                                       return 0;
-                               }
-                               endfor_nexthops(fi);
-                               res->fi = NULL;
-                               return 1;
-                       default:
-                               if (net_ratelimit())
-                                        printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", type);
-                               res->fi = NULL;
-                               return -EINVAL;
+                       }
+                       endfor_nexthops(fi);
+                       res->fi = NULL;
+                       return 1;
+               default:
+                       if (net_ratelimit())
+                               printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n",
+                                      type);
+                       res->fi = NULL;
+                       return -EINVAL;
                }
        }
        return err;
@@ -647,20 +648,20 @@ static int dn_fib_dnaddr_event(struct notifier_block *this, unsigned long event,
 {
        struct dn_ifaddr *ifa = (struct dn_ifaddr *)ptr;
 
-       switch(event) {
-               case NETDEV_UP:
-                       dn_fib_add_ifaddr(ifa);
-                       dn_fib_sync_up(ifa->ifa_dev->dev);
+       switch (event) {
+       case NETDEV_UP:
+               dn_fib_add_ifaddr(ifa);
+               dn_fib_sync_up(ifa->ifa_dev->dev);
+               dn_rt_cache_flush(-1);
+               break;
+       case NETDEV_DOWN:
+               dn_fib_del_ifaddr(ifa);
+               if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) {
+                       dn_fib_disable_addr(ifa->ifa_dev->dev, 1);
+               } else {
                        dn_rt_cache_flush(-1);
-                       break;
-               case NETDEV_DOWN:
-                       dn_fib_del_ifaddr(ifa);
-                       if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) {
-                               dn_fib_disable_addr(ifa->ifa_dev->dev, 1);
-                       } else {
-                               dn_rt_cache_flush(-1);
-                       }
-                       break;
+               }
+               break;
        }
        return NOTIFY_DONE;
 }

diff --git a/net/decnet/dn_neigh.c b/net/decnet/dn_neigh.c
index 602dade7e9a3576905ae6f1d1dc927df7c8f8b63..03eb226118012c49730212eabf743a5c05cb71dd 100644 (file)
--- a/net/decnet/dn_neigh.c
+++ b/net/decnet/dn_neigh.c
@@ -404,13 +404,13 @@ int dn_neigh_router_hello(struct sk_buff *skb)
 
                        dn->flags &= ~DN_NDFLAG_P3;
 
-                       switch(msg->iinfo & DN_RT_INFO_TYPE) {
-                               case DN_RT_INFO_L1RT:
-                                       dn->flags &=~DN_NDFLAG_R2;
-                                       dn->flags |= DN_NDFLAG_R1;
-                                       break;
-                               case DN_RT_INFO_L2RT:
-                                       dn->flags |= DN_NDFLAG_R2;
+                       switch (msg->iinfo & DN_RT_INFO_TYPE) {
+                       case DN_RT_INFO_L1RT:
+                               dn->flags &=~DN_NDFLAG_R2;
+                               dn->flags |= DN_NDFLAG_R1;
+                               break;
+                       case DN_RT_INFO_L2RT:
+                               dn->flags |= DN_NDFLAG_R2;
                        }
                }
 

diff --git a/net/decnet/dn_nsp_in.c b/net/decnet/dn_nsp_in.c
index b430549e2b917301320b26d91fd95dacbd305fb9..73fa268fe2e8b40d977ec258a3d6b47ebf644c2c 100644 (file)
--- a/net/decnet/dn_nsp_in.c
+++ b/net/decnet/dn_nsp_in.c
@@ -101,23 +101,27 @@ static void dn_ack(struct sock *sk, struct sk_buff *skb, unsigned short ack)
        unsigned short type = ((ack >> 12) & 0x0003);
        int wakeup = 0;
 
-       switch(type) {
-               case 0: /* ACK - Data */
-                       if (dn_after(ack, scp->ackrcv_dat)) {
-                               scp->ackrcv_dat = ack & 0x0fff;
-                               wakeup |= dn_nsp_check_xmit_queue(sk, skb, &scp->data_xmit_queue, ack);
-                       }
-                       break;
-               case 1: /* NAK - Data */
-                       break;
-               case 2: /* ACK - OtherData */
-                       if (dn_after(ack, scp->ackrcv_oth)) {
-                               scp->ackrcv_oth = ack & 0x0fff;
-                               wakeup |= dn_nsp_check_xmit_queue(sk, skb, &scp->other_xmit_queue, ack);
-                       }
-                       break;
-               case 3: /* NAK - OtherData */
-                       break;
+       switch (type) {
+       case 0: /* ACK - Data */
+               if (dn_after(ack, scp->ackrcv_dat)) {
+                       scp->ackrcv_dat = ack & 0x0fff;
+                       wakeup |= dn_nsp_check_xmit_queue(sk, skb,
+                                                         &scp->data_xmit_queue,
+                                                         ack);
+               }
+               break;
+       case 1: /* NAK - Data */
+               break;
+       case 2: /* ACK - OtherData */
+               if (dn_after(ack, scp->ackrcv_oth)) {
+                       scp->ackrcv_oth = ack & 0x0fff;
+                       wakeup |= dn_nsp_check_xmit_queue(sk, skb,
+                                                         &scp->other_xmit_queue,
+                                                         ack);
+               }
+               break;
+       case 3: /* NAK - OtherData */
+               break;
        }
 
        if (wakeup && !sock_flag(sk, SOCK_DEAD))
@@ -417,19 +421,19 @@ static void dn_nsp_disc_init(struct sock *sk, struct sk_buff *skb)
        scp->addrrem = cb->src_port;
        sk->sk_state = TCP_CLOSE;
 
-       switch(scp->state) {
-               case DN_CI:
-               case DN_CD:
-                       scp->state = DN_RJ;
-                       sk->sk_err = ECONNREFUSED;
-                       break;
-               case DN_RUN:
-                       sk->sk_shutdown |= SHUTDOWN_MASK;
-                       scp->state = DN_DN;
-                       break;
-               case DN_DI:
-                       scp->state = DN_DIC;
-                       break;
+       switch (scp->state) {
+       case DN_CI:
+       case DN_CD:
+               scp->state = DN_RJ;
+               sk->sk_err = ECONNREFUSED;
+               break;
+       case DN_RUN:
+               sk->sk_shutdown |= SHUTDOWN_MASK;
+               scp->state = DN_DN;
+               break;
+       case DN_DI:
+               scp->state = DN_DIC;
+               break;
        }
 
        if (!sock_flag(sk, SOCK_DEAD)) {
@@ -470,23 +474,23 @@ static void dn_nsp_disc_conf(struct sock *sk, struct sk_buff *skb)
 
        sk->sk_state = TCP_CLOSE;
 
-       switch(scp->state) {
-               case DN_CI:
-                       scp->state = DN_NR;
-                       break;
-               case DN_DR:
-                       if (reason == NSP_REASON_DC)
-                               scp->state = DN_DRC;
-                       if (reason == NSP_REASON_NL)
-                               scp->state = DN_CN;
-                       break;
-               case DN_DI:
-                       scp->state = DN_DIC;
-                       break;
-               case DN_RUN:
-                       sk->sk_shutdown |= SHUTDOWN_MASK;
-               case DN_CC:
+       switch (scp->state) {
+       case DN_CI:
+               scp->state = DN_NR;
+               break;
+       case DN_DR:
+               if (reason == NSP_REASON_DC)
+                       scp->state = DN_DRC;
+               if (reason == NSP_REASON_NL)
                        scp->state = DN_CN;
+               break;
+       case DN_DI:
+               scp->state = DN_DIC;
+               break;
+       case DN_RUN:
+               sk->sk_shutdown |= SHUTDOWN_MASK;
+       case DN_CC:
+               scp->state = DN_CN;
        }
 
        if (!sock_flag(sk, SOCK_DEAD)) {
@@ -692,16 +696,16 @@ static int dn_nsp_no_socket(struct sk_buff *skb, unsigned short reason)
                goto out;
 
        if ((reason != NSP_REASON_OK) && ((cb->nsp_flags & 0x0c) == 0x08)) {
-               switch(cb->nsp_flags & 0x70) {
-                       case 0x10:
-                       case 0x60: /* (Retransmitted) Connect Init */
-                               dn_nsp_return_disc(skb, NSP_DISCINIT, reason);
-                               ret = NET_RX_SUCCESS;
-                               break;
-                       case 0x20: /* Connect Confirm */
-                               dn_nsp_return_disc(skb, NSP_DISCCONF, reason);
-                               ret = NET_RX_SUCCESS;
-                               break;
+               switch (cb->nsp_flags & 0x70) {
+               case 0x10:
+               case 0x60: /* (Retransmitted) Connect Init */
+                       dn_nsp_return_disc(skb, NSP_DISCINIT, reason);
+                       ret = NET_RX_SUCCESS;
+                       break;
+               case 0x20: /* Connect Confirm */
+                       dn_nsp_return_disc(skb, NSP_DISCCONF, reason);
+                       ret = NET_RX_SUCCESS;
+                       break;
                }
        }
 
@@ -733,17 +737,17 @@ static int dn_nsp_rx_packet(struct sk_buff *skb)
         * Filter out conninits and useless packet types
         */
        if ((cb->nsp_flags & 0x0c) == 0x08) {
-               switch(cb->nsp_flags & 0x70) {
-                       case 0x00: /* NOP */
-                       case 0x70: /* Reserved */
-                       case 0x50: /* Reserved, Phase II node init */
+               switch (cb->nsp_flags & 0x70) {
+               case 0x00: /* NOP */
+               case 0x70: /* Reserved */
+               case 0x50: /* Reserved, Phase II node init */
+                       goto free_out;
+               case 0x10:
+               case 0x60:
+                       if (unlikely(cb->rt_flags & DN_RT_F_RTS))
                                goto free_out;
-                       case 0x10:
-                       case 0x60:
-                               if (unlikely(cb->rt_flags & DN_RT_F_RTS))
-                                       goto free_out;
-                               sk = dn_find_listener(skb, &reason);
-                               goto got_it;
+                       sk = dn_find_listener(skb, &reason);
+                       goto got_it;
                }
        }
 
@@ -836,20 +840,20 @@ int dn_nsp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
         * Control packet.
         */
        if ((cb->nsp_flags & 0x0c) == 0x08) {
-               switch(cb->nsp_flags & 0x70) {
-                       case 0x10:
-                       case 0x60:
-                               dn_nsp_conn_init(sk, skb);
-                               break;
-                       case 0x20:
-                               dn_nsp_conn_conf(sk, skb);
-                               break;
-                       case 0x30:
-                               dn_nsp_disc_init(sk, skb);
-                               break;
-                       case 0x40:
-                               dn_nsp_disc_conf(sk, skb);
-                               break;
+               switch (cb->nsp_flags & 0x70) {
+               case 0x10:
+               case 0x60:
+                       dn_nsp_conn_init(sk, skb);
+                       break;
+               case 0x20:
+                       dn_nsp_conn_conf(sk, skb);
+                       break;
+               case 0x30:
+                       dn_nsp_disc_init(sk, skb);
+                       break;
+               case 0x40:
+                       dn_nsp_disc_conf(sk, skb);
+                       break;
                }
 
        } else if (cb->nsp_flags == 0x24) {
@@ -890,15 +894,15 @@ int dn_nsp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
                        if (scp->state != DN_RUN)
                                goto free_out;
 
-                       switch(cb->nsp_flags) {
-                               case 0x10: /* LS */
-                                       dn_nsp_linkservice(sk, skb);
-                                       break;
-                               case 0x30: /* OD */
-                                       dn_nsp_otherdata(sk, skb);
-                                       break;
-                               default:
-                                       dn_nsp_data(sk, skb);
+                       switch (cb->nsp_flags) {
+                       case 0x10: /* LS */
+                               dn_nsp_linkservice(sk, skb);
+                               break;
+                       case 0x30: /* OD */
+                               dn_nsp_otherdata(sk, skb);
+                               break;
+                       default:
+                               dn_nsp_data(sk, skb);
                        }
 
                } else { /* Ack, chuck it out here */

diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 2949ca474edebea09852fb208a560ae3537a5834..fceb86ca01168489e3720eb7fe2bbee52e259ded 100644 (file)
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -495,11 +495,11 @@ static int dn_route_rx_packet(struct sk_buff *skb)
        }
 
        if ((skb->pkt_type == PACKET_HOST) && (cb->rt_flags & DN_RT_F_RQR)) {
-               switch(cb->rt_flags & DN_RT_PKT_MSK) {
-                       case DN_RT_PKT_SHORT:
-                               return dn_return_short(skb);
-                       case DN_RT_PKT_LONG:
-                               return dn_return_long(skb);
+               switch (cb->rt_flags & DN_RT_PKT_MSK) {
+               case DN_RT_PKT_SHORT:
+                       return dn_return_short(skb);
+               case DN_RT_PKT_LONG:
+                       return dn_return_long(skb);
                }
        }
 
@@ -652,38 +652,38 @@ int dn_route_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type
                if (unlikely(skb_linearize(skb)))
                        goto dump_it;
 
-               switch(flags & DN_RT_CNTL_MSK) {
-                       case DN_RT_PKT_INIT:
-                               dn_dev_init_pkt(skb);
-                               break;
-                       case DN_RT_PKT_VERI:
-                               dn_dev_veri_pkt(skb);
-                               break;
+               switch (flags & DN_RT_CNTL_MSK) {
+               case DN_RT_PKT_INIT:
+                       dn_dev_init_pkt(skb);
+                       break;
+               case DN_RT_PKT_VERI:
+                       dn_dev_veri_pkt(skb);
+                       break;
                }
 
                if (dn->parms.state != DN_DEV_S_RU)
                        goto dump_it;
 
-               switch(flags & DN_RT_CNTL_MSK) {
-                       case DN_RT_PKT_HELO:
-                               return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
-                                              skb, skb->dev, NULL,
-                                              dn_route_ptp_hello);
-
-                       case DN_RT_PKT_L1RT:
-                       case DN_RT_PKT_L2RT:
-                               return NF_HOOK(NFPROTO_DECNET, NF_DN_ROUTE,
-                                              skb, skb->dev, NULL,
-                                              dn_route_discard);
-                       case DN_RT_PKT_ERTH:
-                               return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
-                                              skb, skb->dev, NULL,
-                                              dn_neigh_router_hello);
-
-                       case DN_RT_PKT_EEDH:
-                               return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
-                                              skb, skb->dev, NULL,
-                                              dn_neigh_endnode_hello);
+               switch (flags & DN_RT_CNTL_MSK) {
+               case DN_RT_PKT_HELO:
+                       return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
+                                      skb, skb->dev, NULL,
+                                      dn_route_ptp_hello);
+
+               case DN_RT_PKT_L1RT:
+               case DN_RT_PKT_L2RT:
+                       return NF_HOOK(NFPROTO_DECNET, NF_DN_ROUTE,
+                                      skb, skb->dev, NULL,
+                                      dn_route_discard);
+               case DN_RT_PKT_ERTH:
+                       return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
+                                      skb, skb->dev, NULL,
+                                      dn_neigh_router_hello);
+
+               case DN_RT_PKT_EEDH:
+                       return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
+                                      skb, skb->dev, NULL,
+                                      dn_neigh_endnode_hello);
                }
        } else {
                if (dn->parms.state != DN_DEV_S_RU)
@@ -691,11 +691,11 @@ int dn_route_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type
 
                skb_pull(skb, 1); /* Pull flags */
 
-               switch(flags & DN_RT_PKT_MSK) {
-                       case DN_RT_PKT_LONG:
-                               return dn_route_rx_long(skb);
-                       case DN_RT_PKT_SHORT:
-                               return dn_route_rx_short(skb);
+               switch (flags & DN_RT_PKT_MSK) {
+               case DN_RT_PKT_LONG:
+                       return dn_route_rx_long(skb);
+               case DN_RT_PKT_SHORT:
+                       return dn_route_rx_short(skb);
                }
        }
 
@@ -1419,20 +1419,20 @@ make_route:
        rt->dst.neighbour = neigh;
        rt->dst.lastuse = jiffies;
        rt->dst.output = dn_rt_bug;
-       switch(res.type) {
-               case RTN_UNICAST:
-                       rt->dst.input = dn_forward;
-                       break;
-               case RTN_LOCAL:
-                       rt->dst.output = dn_output;
-                       rt->dst.input = dn_nsp_rx;
-                       rt->dst.dev = in_dev;
-                       flags |= RTCF_LOCAL;
-                       break;
-               default:
-               case RTN_UNREACHABLE:
-               case RTN_BLACKHOLE:
-                       rt->dst.input = dst_discard;
+       switch (res.type) {
+       case RTN_UNICAST:
+               rt->dst.input = dn_forward;
+               break;
+       case RTN_LOCAL:
+               rt->dst.output = dn_output;
+               rt->dst.input = dn_nsp_rx;
+               rt->dst.dev = in_dev;
+               flags |= RTCF_LOCAL;
+               break;
+       default:
+       case RTN_UNREACHABLE:
+       case RTN_BLACKHOLE:
+               rt->dst.input = dst_discard;
        }
        rt->rt_flags = flags;
 

diff --git a/net/decnet/dn_table.c b/net/decnet/dn_table.c
index bd0a52dd1d40e65c2c6d905172cb4fc957dd3264..cd0354e9bdb37398701e95a2a3b3946503d37e71 100644 (file)
--- a/net/decnet/dn_table.c
+++ b/net/decnet/dn_table.c
@@ -147,17 +147,18 @@ static void dn_rehash_zone(struct dn_zone *dz)
 
        old_divisor = dz->dz_divisor;
 
-       switch(old_divisor) {
-               case 16:
-                       new_divisor = 256;
-                       new_hashmask = 0xFF;
-                       break;
-               default:
-                       printk(KERN_DEBUG "DECnet: dn_rehash_zone: BUG! %d\n", old_divisor);
-               case 256:
-                       new_divisor = 1024;
-                       new_hashmask = 0x3FF;
-                       break;
+       switch (old_divisor) {
+       case 16:
+               new_divisor = 256;
+               new_hashmask = 0xFF;
+               break;
+       default:
+               printk(KERN_DEBUG "DECnet: dn_rehash_zone: BUG! %d\n",
+                      old_divisor);
+       case 256:
+               new_divisor = 1024;
+               new_hashmask = 0x3FF;
+               break;
        }
 
        ht = kcalloc(new_divisor, sizeof(struct dn_fib_node*), GFP_KERNEL);

diff --git a/net/decnet/netfilter/dn_rtmsg.c b/net/decnet/netfilter/dn_rtmsg.c
index 64a7f39e069fbc82e7e4a1bf2a50981e92d30949..69975e0bcdea7a5c1655a9eb0de70011c5325d59 100644 (file)
--- a/net/decnet/netfilter/dn_rtmsg.c
+++ b/net/decnet/netfilter/dn_rtmsg.c
@@ -69,15 +69,15 @@ static void dnrmg_send_peer(struct sk_buff *skb)
        int group = 0;
        unsigned char flags = *skb->data;
 
-       switch(flags & DN_RT_CNTL_MSK) {
-               case DN_RT_PKT_L1RT:
-                       group = DNRNG_NLGRP_L1;
-                       break;
-               case DN_RT_PKT_L2RT:
-                       group = DNRNG_NLGRP_L2;
-                       break;
-               default:
-                       return;
+       switch (flags & DN_RT_CNTL_MSK) {
+       case DN_RT_PKT_L1RT:
+               group = DNRNG_NLGRP_L1;
+               break;
+       case DN_RT_PKT_L2RT:
+               group = DNRNG_NLGRP_L2;
+               break;
+       default:
+               return;
        }
 
        skb2 = dnrmg_build_message(skb, &status);

diff --git a/net/decnet/sysctl_net_decnet.c b/net/decnet/sysctl_net_decnet.c
index 28f8b5e5f73b20fcee72b7aa536f1fdd04dc95c9..02e75d11cfbb2e73a1a473e536bfa81e1429c92e 100644 (file)
--- a/net/decnet/sysctl_net_decnet.c
+++ b/net/decnet/sysctl_net_decnet.c
@@ -68,14 +68,15 @@ static struct ctl_table_header *dn_table_header = NULL;
 static void strip_it(char *str)
 {
        for(;;) {
-               switch(*str) {
-                       case ' ':
-                       case '\n':
-                       case '\r':
-                       case ':':
-                               *str = 0;
-                       case 0:
-                               return;
+               switch (*str) {
+               case ' ':
+               case '\n':
+               case '\r':
+               case ':':
+                       *str = 0;
+                       /* Fallthrough */
+               case 0:
+                       return;
                }
                str++;
        }