decnet: Reduce switch/case indent · tjh.dev/kernel@06f8fe1

+352 -353

net/decnet/af_decnet.c

··· 291 291 292 292 *buf++ = type; 293 293 294 - switch(type) { 295 - case 0: 296 - *buf++ = sdn->sdn_objnum; 297 - break; 298 - case 1: 299 - *buf++ = 0; 300 - *buf++ = le16_to_cpu(sdn->sdn_objnamel); 301 - memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel)); 302 - len = 3 + le16_to_cpu(sdn->sdn_objnamel); 303 - break; 304 - case 2: 305 - memset(buf, 0, 5); 306 - buf += 5; 307 - *buf++ = le16_to_cpu(sdn->sdn_objnamel); 308 - memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel)); 309 - len = 7 + le16_to_cpu(sdn->sdn_objnamel); 310 - break; 294 + switch (type) { 295 + case 0: 296 + *buf++ = sdn->sdn_objnum; 297 + break; 298 + case 1: 299 + *buf++ = 0; 300 + *buf++ = le16_to_cpu(sdn->sdn_objnamel); 301 + memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel)); 302 + len = 3 + le16_to_cpu(sdn->sdn_objnamel); 303 + break; 304 + case 2: 305 + memset(buf, 0, 5); 306 + buf += 5; 307 + *buf++ = le16_to_cpu(sdn->sdn_objnamel); 308 + memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel)); 309 + len = 7 + le16_to_cpu(sdn->sdn_objnamel); 310 + break; 311 311 } 312 312 313 313 return len; ··· 337 337 *fmt = *data++; 338 338 type = *data++; 339 339 340 - switch(*fmt) { 341 - case 0: 342 - sdn->sdn_objnum = type; 343 - return 2; 344 - case 1: 345 - namel = 16; 346 - break; 347 - case 2: 348 - len -= 4; 349 - data += 4; 350 - break; 351 - case 4: 352 - len -= 8; 353 - data += 8; 354 - break; 355 - default: 356 - return -1; 340 + switch (*fmt) { 341 + case 0: 342 + sdn->sdn_objnum = type; 343 + return 2; 344 + case 1: 345 + namel = 16; 346 + break; 347 + case 2: 348 + len -= 4; 349 + data += 4; 350 + break; 351 + case 4: 352 + len -= 8; 353 + data += 8; 354 + break; 355 + default: 356 + return -1; 357 357 } 358 358 359 359 len -= 1; ··· 575 575 576 576 scp->persist = dn_nsp_persist(sk); 577 577 578 - switch(scp->state) { 579 - case DN_DI: 580 - dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC); 581 - if (scp->nsp_rxtshift >= decnet_di_count) 582 - scp->state = DN_CN; 583 - return 0; 578 + switch (scp->state) { 579 + case DN_DI: 580 + dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC); 581 + if (scp->nsp_rxtshift >= decnet_di_count) 582 + scp->state = DN_CN; 583 + return 0; 584 584 585 - case DN_DR: 586 - dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC); 587 - if (scp->nsp_rxtshift >= decnet_dr_count) 588 - scp->state = DN_DRC; 589 - return 0; 585 + case DN_DR: 586 + dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC); 587 + if (scp->nsp_rxtshift >= decnet_dr_count) 588 + scp->state = DN_DRC; 589 + return 0; 590 590 591 - case DN_DN: 592 - if (scp->nsp_rxtshift < decnet_dn_count) { 593 - /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */ 594 - dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, GFP_ATOMIC); 595 - return 0; 596 - } 591 + case DN_DN: 592 + if (scp->nsp_rxtshift < decnet_dn_count) { 593 + /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */ 594 + dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, 595 + GFP_ATOMIC); 596 + return 0; 597 + } 597 598 } 598 599 599 600 scp->persist = (HZ * decnet_time_wait); ··· 624 623 625 624 sk->sk_state = TCP_CLOSE; 626 625 627 - switch(scp->state) { 628 - case DN_DN: 629 - dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, 630 - sk->sk_allocation); 631 - scp->persist_fxn = dn_destroy_timer; 632 - scp->persist = dn_nsp_persist(sk); 633 - break; 634 - case DN_CR: 635 - scp->state = DN_DR; 636 - goto disc_reject; 637 - case DN_RUN: 638 - scp->state = DN_DI; 639 - case DN_DI: 640 - case DN_DR: 626 + switch (scp->state) { 627 + case DN_DN: 628 + dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, 629 + sk->sk_allocation); 630 + scp->persist_fxn = dn_destroy_timer; 631 + scp->persist = dn_nsp_persist(sk); 632 + break; 633 + case DN_CR: 634 + scp->state = DN_DR; 635 + goto disc_reject; 636 + case DN_RUN: 637 + scp->state = DN_DI; 638 + case DN_DI: 639 + case DN_DR: 641 640 disc_reject: 642 - dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation); 643 - case DN_NC: 644 - case DN_NR: 645 - case DN_RJ: 646 - case DN_DIC: 647 - case DN_CN: 648 - case DN_DRC: 649 - case DN_CI: 650 - case DN_CD: 651 - scp->persist_fxn = dn_destroy_timer; 652 - scp->persist = dn_nsp_persist(sk); 653 - break; 654 - default: 655 - printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n"); 656 - case DN_O: 657 - dn_stop_slow_timer(sk); 641 + dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation); 642 + case DN_NC: 643 + case DN_NR: 644 + case DN_RJ: 645 + case DN_DIC: 646 + case DN_CN: 647 + case DN_DRC: 648 + case DN_CI: 649 + case DN_CD: 650 + scp->persist_fxn = dn_destroy_timer; 651 + scp->persist = dn_nsp_persist(sk); 652 + break; 653 + default: 654 + printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n"); 655 + case DN_O: 656 + dn_stop_slow_timer(sk); 658 657 659 - dn_unhash_sock_bh(sk); 660 - sock_put(sk); 658 + dn_unhash_sock_bh(sk); 659 + sock_put(sk); 661 660 662 - break; 661 + break; 663 662 } 664 663 } 665 664 ··· 684 683 if (!net_eq(net, &init_net)) 685 684 return -EAFNOSUPPORT; 686 685 687 - switch(sock->type) { 688 - case SOCK_SEQPACKET: 689 - if (protocol != DNPROTO_NSP) 690 - return -EPROTONOSUPPORT; 691 - break; 692 - case SOCK_STREAM: 693 - break; 694 - default: 695 - return -ESOCKTNOSUPPORT; 686 + switch (sock->type) { 687 + case SOCK_SEQPACKET: 688 + if (protocol != DNPROTO_NSP) 689 + return -EPROTONOSUPPORT; 690 + break; 691 + case SOCK_STREAM: 692 + break; 693 + default: 694 + return -ESOCKTNOSUPPORT; 696 695 } 697 696 698 697 ··· 988 987 { 989 988 struct dn_scp *scp = DN_SK(sk); 990 989 991 - switch(scp->state) { 992 - case DN_RUN: 993 - return 0; 994 - case DN_CR: 995 - return dn_confirm_accept(sk, timeo, sk->sk_allocation); 996 - case DN_CI: 997 - case DN_CC: 998 - return dn_wait_run(sk, timeo); 999 - case DN_O: 1000 - return __dn_connect(sk, addr, addrlen, timeo, flags); 990 + switch (scp->state) { 991 + case DN_RUN: 992 + return 0; 993 + case DN_CR: 994 + return dn_confirm_accept(sk, timeo, sk->sk_allocation); 995 + case DN_CI: 996 + case DN_CC: 997 + return dn_wait_run(sk, timeo); 998 + case DN_O: 999 + return __dn_connect(sk, addr, addrlen, timeo, flags); 1001 1000 } 1002 1001 1003 1002 return -EINVAL; ··· 1364 1363 if (copy_from_user(&u, optval, optlen)) 1365 1364 return -EFAULT; 1366 1365 1367 - switch(optname) { 1368 - case DSO_CONDATA: 1369 - if (sock->state == SS_CONNECTED) 1370 - return -EISCONN; 1371 - if ((scp->state != DN_O) && (scp->state != DN_CR)) 1372 - return -EINVAL; 1366 + switch (optname) { 1367 + case DSO_CONDATA: 1368 + if (sock->state == SS_CONNECTED) 1369 + return -EISCONN; 1370 + if ((scp->state != DN_O) && (scp->state != DN_CR)) 1371 + return -EINVAL; 1373 1372 1374 - if (optlen != sizeof(struct optdata_dn)) 1375 - return -EINVAL; 1373 + if (optlen != sizeof(struct optdata_dn)) 1374 + return -EINVAL; 1376 1375 1377 - if (le16_to_cpu(u.opt.opt_optl) > 16) 1378 - return -EINVAL; 1376 + if (le16_to_cpu(u.opt.opt_optl) > 16) 1377 + return -EINVAL; 1379 1378 1380 - memcpy(&scp->conndata_out, &u.opt, optlen); 1381 - break; 1379 + memcpy(&scp->conndata_out, &u.opt, optlen); 1380 + break; 1382 1381 1383 - case DSO_DISDATA: 1384 - if (sock->state != SS_CONNECTED && scp->accept_mode == ACC_IMMED) 1385 - return -ENOTCONN; 1382 + case DSO_DISDATA: 1383 + if (sock->state != SS_CONNECTED && 1384 + scp->accept_mode == ACC_IMMED) 1385 + return -ENOTCONN; 1386 1386 1387 - if (optlen != sizeof(struct optdata_dn)) 1388 - return -EINVAL; 1387 + if (optlen != sizeof(struct optdata_dn)) 1388 + return -EINVAL; 1389 1389 1390 - if (le16_to_cpu(u.opt.opt_optl) > 16) 1391 - return -EINVAL; 1390 + if (le16_to_cpu(u.opt.opt_optl) > 16) 1391 + return -EINVAL; 1392 1392 1393 - memcpy(&scp->discdata_out, &u.opt, optlen); 1394 - break; 1393 + memcpy(&scp->discdata_out, &u.opt, optlen); 1394 + break; 1395 1395 1396 - case DSO_CONACCESS: 1397 - if (sock->state == SS_CONNECTED) 1398 - return -EISCONN; 1399 - if (scp->state != DN_O) 1400 - return -EINVAL; 1396 + case DSO_CONACCESS: 1397 + if (sock->state == SS_CONNECTED) 1398 + return -EISCONN; 1399 + if (scp->state != DN_O) 1400 + return -EINVAL; 1401 1401 1402 - if (optlen != sizeof(struct accessdata_dn)) 1403 - return -EINVAL; 1402 + if (optlen != sizeof(struct accessdata_dn)) 1403 + return -EINVAL; 1404 1404 1405 - if ((u.acc.acc_accl > DN_MAXACCL) || 1406 - (u.acc.acc_passl > DN_MAXACCL) || 1407 - (u.acc.acc_userl > DN_MAXACCL)) 1408 - return -EINVAL; 1405 + if ((u.acc.acc_accl > DN_MAXACCL) || 1406 + (u.acc.acc_passl > DN_MAXACCL) || 1407 + (u.acc.acc_userl > DN_MAXACCL)) 1408 + return -EINVAL; 1409 1409 1410 - memcpy(&scp->accessdata, &u.acc, optlen); 1411 - break; 1410 + memcpy(&scp->accessdata, &u.acc, optlen); 1411 + break; 1412 1412 1413 - case DSO_ACCEPTMODE: 1414 - if (sock->state == SS_CONNECTED) 1415 - return -EISCONN; 1416 - if (scp->state != DN_O) 1417 - return -EINVAL; 1413 + case DSO_ACCEPTMODE: 1414 + if (sock->state == SS_CONNECTED) 1415 + return -EISCONN; 1416 + if (scp->state != DN_O) 1417 + return -EINVAL; 1418 1418 1419 - if (optlen != sizeof(int)) 1420 - return -EINVAL; 1419 + if (optlen != sizeof(int)) 1420 + return -EINVAL; 1421 1421 1422 - if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER)) 1423 - return -EINVAL; 1422 + if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER)) 1423 + return -EINVAL; 1424 1424 1425 - scp->accept_mode = (unsigned char)u.mode; 1426 - break; 1425 + scp->accept_mode = (unsigned char)u.mode; 1426 + break; 1427 1427 1428 - case DSO_CONACCEPT: 1428 + case DSO_CONACCEPT: 1429 + if (scp->state != DN_CR) 1430 + return -EINVAL; 1431 + timeo = sock_rcvtimeo(sk, 0); 1432 + err = dn_confirm_accept(sk, &timeo, sk->sk_allocation); 1433 + return err; 1429 1434 1430 - if (scp->state != DN_CR) 1431 - return -EINVAL; 1432 - timeo = sock_rcvtimeo(sk, 0); 1433 - err = dn_confirm_accept(sk, &timeo, sk->sk_allocation); 1434 - return err; 1435 + case DSO_CONREJECT: 1436 + if (scp->state != DN_CR) 1437 + return -EINVAL; 1435 1438 1436 - case DSO_CONREJECT: 1439 + scp->state = DN_DR; 1440 + sk->sk_shutdown = SHUTDOWN_MASK; 1441 + dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation); 1442 + break; 1437 1443 1438 - if (scp->state != DN_CR) 1439 - return -EINVAL; 1440 - 1441 - scp->state = DN_DR; 1442 - sk->sk_shutdown = SHUTDOWN_MASK; 1443 - dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation); 1444 - break; 1445 - 1446 - default: 1444 + default: 1447 1445 #ifdef CONFIG_NETFILTER 1448 1446 return nf_setsockopt(sk, PF_DECnet, optname, optval, optlen); 1449 1447 #endif 1450 - case DSO_LINKINFO: 1451 - case DSO_STREAM: 1452 - case DSO_SEQPACKET: 1453 - return -ENOPROTOOPT; 1448 + case DSO_LINKINFO: 1449 + case DSO_STREAM: 1450 + case DSO_SEQPACKET: 1451 + return -ENOPROTOOPT; 1454 1452 1455 - case DSO_MAXWINDOW: 1456 - if (optlen != sizeof(unsigned long)) 1457 - return -EINVAL; 1458 - if (u.win > NSP_MAX_WINDOW) 1459 - u.win = NSP_MAX_WINDOW; 1460 - if (u.win == 0) 1461 - return -EINVAL; 1462 - scp->max_window = u.win; 1463 - if (scp->snd_window > u.win) 1464 - scp->snd_window = u.win; 1465 - break; 1453 + case DSO_MAXWINDOW: 1454 + if (optlen != sizeof(unsigned long)) 1455 + return -EINVAL; 1456 + if (u.win > NSP_MAX_WINDOW) 1457 + u.win = NSP_MAX_WINDOW; 1458 + if (u.win == 0) 1459 + return -EINVAL; 1460 + scp->max_window = u.win; 1461 + if (scp->snd_window > u.win) 1462 + scp->snd_window = u.win; 1463 + break; 1466 1464 1467 - case DSO_NODELAY: 1468 - if (optlen != sizeof(int)) 1469 - return -EINVAL; 1470 - if (scp->nonagle == 2) 1471 - return -EINVAL; 1472 - scp->nonagle = (u.val == 0) ? 0 : 1; 1473 - /* if (scp->nonagle == 1) { Push pending frames } */ 1474 - break; 1465 + case DSO_NODELAY: 1466 + if (optlen != sizeof(int)) 1467 + return -EINVAL; 1468 + if (scp->nonagle == 2) 1469 + return -EINVAL; 1470 + scp->nonagle = (u.val == 0) ? 0 : 1; 1471 + /* if (scp->nonagle == 1) { Push pending frames } */ 1472 + break; 1475 1473 1476 - case DSO_CORK: 1477 - if (optlen != sizeof(int)) 1478 - return -EINVAL; 1479 - if (scp->nonagle == 1) 1480 - return -EINVAL; 1481 - scp->nonagle = (u.val == 0) ? 0 : 2; 1482 - /* if (scp->nonagle == 0) { Push pending frames } */ 1483 - break; 1474 + case DSO_CORK: 1475 + if (optlen != sizeof(int)) 1476 + return -EINVAL; 1477 + if (scp->nonagle == 1) 1478 + return -EINVAL; 1479 + scp->nonagle = (u.val == 0) ? 0 : 2; 1480 + /* if (scp->nonagle == 0) { Push pending frames } */ 1481 + break; 1484 1482 1485 - case DSO_SERVICES: 1486 - if (optlen != sizeof(unsigned char)) 1487 - return -EINVAL; 1488 - if ((u.services & ~NSP_FC_MASK) != 0x01) 1489 - return -EINVAL; 1490 - if ((u.services & NSP_FC_MASK) == NSP_FC_MASK) 1491 - return -EINVAL; 1492 - scp->services_loc = u.services; 1493 - break; 1483 + case DSO_SERVICES: 1484 + if (optlen != sizeof(unsigned char)) 1485 + return -EINVAL; 1486 + if ((u.services & ~NSP_FC_MASK) != 0x01) 1487 + return -EINVAL; 1488 + if ((u.services & NSP_FC_MASK) == NSP_FC_MASK) 1489 + return -EINVAL; 1490 + scp->services_loc = u.services; 1491 + break; 1494 1492 1495 - case DSO_INFO: 1496 - if (optlen != sizeof(unsigned char)) 1497 - return -EINVAL; 1498 - if (u.info & 0xfc) 1499 - return -EINVAL; 1500 - scp->info_loc = u.info; 1501 - break; 1493 + case DSO_INFO: 1494 + if (optlen != sizeof(unsigned char)) 1495 + return -EINVAL; 1496 + if (u.info & 0xfc) 1497 + return -EINVAL; 1498 + scp->info_loc = u.info; 1499 + break; 1502 1500 } 1503 1501 1504 1502 return 0; ··· 1527 1527 if(get_user(r_len , optlen)) 1528 1528 return -EFAULT; 1529 1529 1530 - switch(optname) { 1531 - case DSO_CONDATA: 1532 - if (r_len > sizeof(struct optdata_dn)) 1533 - r_len = sizeof(struct optdata_dn); 1534 - r_data = &scp->conndata_in; 1530 + switch (optname) { 1531 + case DSO_CONDATA: 1532 + if (r_len > sizeof(struct optdata_dn)) 1533 + r_len = sizeof(struct optdata_dn); 1534 + r_data = &scp->conndata_in; 1535 + break; 1536 + 1537 + case DSO_DISDATA: 1538 + if (r_len > sizeof(struct optdata_dn)) 1539 + r_len = sizeof(struct optdata_dn); 1540 + r_data = &scp->discdata_in; 1541 + break; 1542 + 1543 + case DSO_CONACCESS: 1544 + if (r_len > sizeof(struct accessdata_dn)) 1545 + r_len = sizeof(struct accessdata_dn); 1546 + r_data = &scp->accessdata; 1547 + break; 1548 + 1549 + case DSO_ACCEPTMODE: 1550 + if (r_len > sizeof(unsigned char)) 1551 + r_len = sizeof(unsigned char); 1552 + r_data = &scp->accept_mode; 1553 + break; 1554 + 1555 + case DSO_LINKINFO: 1556 + if (r_len > sizeof(struct linkinfo_dn)) 1557 + r_len = sizeof(struct linkinfo_dn); 1558 + 1559 + memset(&link, 0, sizeof(link)); 1560 + 1561 + switch (sock->state) { 1562 + case SS_CONNECTING: 1563 + link.idn_linkstate = LL_CONNECTING; 1535 1564 break; 1536 - 1537 - case DSO_DISDATA: 1538 - if (r_len > sizeof(struct optdata_dn)) 1539 - r_len = sizeof(struct optdata_dn); 1540 - r_data = &scp->discdata_in; 1565 + case SS_DISCONNECTING: 1566 + link.idn_linkstate = LL_DISCONNECTING; 1541 1567 break; 1542 - 1543 - case DSO_CONACCESS: 1544 - if (r_len > sizeof(struct accessdata_dn)) 1545 - r_len = sizeof(struct accessdata_dn); 1546 - r_data = &scp->accessdata; 1568 + case SS_CONNECTED: 1569 + link.idn_linkstate = LL_RUNNING; 1547 1570 break; 1548 - 1549 - case DSO_ACCEPTMODE: 1550 - if (r_len > sizeof(unsigned char)) 1551 - r_len = sizeof(unsigned char); 1552 - r_data = &scp->accept_mode; 1553 - break; 1554 - 1555 - case DSO_LINKINFO: 1556 - if (r_len > sizeof(struct linkinfo_dn)) 1557 - r_len = sizeof(struct linkinfo_dn); 1558 - 1559 - memset(&link, 0, sizeof(link)); 1560 - 1561 - switch(sock->state) { 1562 - case SS_CONNECTING: 1563 - link.idn_linkstate = LL_CONNECTING; 1564 - break; 1565 - case SS_DISCONNECTING: 1566 - link.idn_linkstate = LL_DISCONNECTING; 1567 - break; 1568 - case SS_CONNECTED: 1569 - link.idn_linkstate = LL_RUNNING; 1570 - break; 1571 - default: 1572 - link.idn_linkstate = LL_INACTIVE; 1573 - } 1574 - 1575 - link.idn_segsize = scp->segsize_rem; 1576 - r_data = &link; 1577 - break; 1578 - 1579 1571 default: 1580 - #ifdef CONFIG_NETFILTER 1581 - { 1582 - int ret, len; 1583 - 1584 - if(get_user(len, optlen)) 1585 - return -EFAULT; 1586 - 1587 - ret = nf_getsockopt(sk, PF_DECnet, optname, 1588 - optval, &len); 1589 - if (ret >= 0) 1590 - ret = put_user(len, optlen); 1591 - return ret; 1572 + link.idn_linkstate = LL_INACTIVE; 1592 1573 } 1574 + 1575 + link.idn_segsize = scp->segsize_rem; 1576 + r_data = &link; 1577 + break; 1578 + 1579 + default: 1580 + #ifdef CONFIG_NETFILTER 1581 + { 1582 + int ret, len; 1583 + 1584 + if (get_user(len, optlen)) 1585 + return -EFAULT; 1586 + 1587 + ret = nf_getsockopt(sk, PF_DECnet, optname, optval, &len); 1588 + if (ret >= 0) 1589 + ret = put_user(len, optlen); 1590 + return ret; 1591 + } 1593 1592 #endif 1594 - case DSO_STREAM: 1595 - case DSO_SEQPACKET: 1596 - case DSO_CONACCEPT: 1597 - case DSO_CONREJECT: 1598 - return -ENOPROTOOPT; 1593 + case DSO_STREAM: 1594 + case DSO_SEQPACKET: 1595 + case DSO_CONACCEPT: 1596 + case DSO_CONREJECT: 1597 + return -ENOPROTOOPT; 1599 1598 1600 - case DSO_MAXWINDOW: 1601 - if (r_len > sizeof(unsigned long)) 1602 - r_len = sizeof(unsigned long); 1603 - r_data = &scp->max_window; 1604 - break; 1599 + case DSO_MAXWINDOW: 1600 + if (r_len > sizeof(unsigned long)) 1601 + r_len = sizeof(unsigned long); 1602 + r_data = &scp->max_window; 1603 + break; 1605 1604 1606 - case DSO_NODELAY: 1607 - if (r_len > sizeof(int)) 1608 - r_len = sizeof(int); 1609 - val = (scp->nonagle == 1); 1610 - r_data = &val; 1611 - break; 1605 + case DSO_NODELAY: 1606 + if (r_len > sizeof(int)) 1607 + r_len = sizeof(int); 1608 + val = (scp->nonagle == 1); 1609 + r_data = &val; 1610 + break; 1612 1611 1613 - case DSO_CORK: 1614 - if (r_len > sizeof(int)) 1615 - r_len = sizeof(int); 1616 - val = (scp->nonagle == 2); 1617 - r_data = &val; 1618 - break; 1612 + case DSO_CORK: 1613 + if (r_len > sizeof(int)) 1614 + r_len = sizeof(int); 1615 + val = (scp->nonagle == 2); 1616 + r_data = &val; 1617 + break; 1619 1618 1620 - case DSO_SERVICES: 1621 - if (r_len > sizeof(unsigned char)) 1622 - r_len = sizeof(unsigned char); 1623 - r_data = &scp->services_rem; 1624 - break; 1619 + case DSO_SERVICES: 1620 + if (r_len > sizeof(unsigned char)) 1621 + r_len = sizeof(unsigned char); 1622 + r_data = &scp->services_rem; 1623 + break; 1625 1624 1626 - case DSO_INFO: 1627 - if (r_len > sizeof(unsigned char)) 1628 - r_len = sizeof(unsigned char); 1629 - r_data = &scp->info_rem; 1630 - break; 1625 + case DSO_INFO: 1626 + if (r_len > sizeof(unsigned char)) 1627 + r_len = sizeof(unsigned char); 1628 + r_data = &scp->info_rem; 1629 + break; 1631 1630 } 1632 1631 1633 1632 if (r_data) { ··· 2087 2088 if (!net_eq(dev_net(dev), &init_net)) 2088 2089 return NOTIFY_DONE; 2089 2090 2090 - switch(event) { 2091 - case NETDEV_UP: 2092 - dn_dev_up(dev); 2093 - break; 2094 - case NETDEV_DOWN: 2095 - dn_dev_down(dev); 2096 - break; 2097 - default: 2098 - break; 2091 + switch (event) { 2092 + case NETDEV_UP: 2093 + dn_dev_up(dev); 2094 + break; 2095 + case NETDEV_DOWN: 2096 + dn_dev_down(dev); 2097 + break; 2098 + default: 2099 + break; 2099 2100 } 2100 2101 2101 2102 return NOTIFY_DONE; ··· 2208 2209 int i; 2209 2210 2210 2211 switch (le16_to_cpu(dn->sdn_objnamel)) { 2211 - case 0: 2212 - sprintf(buf, "%d", dn->sdn_objnum); 2213 - break; 2214 - default: 2215 - for (i = 0; i < le16_to_cpu(dn->sdn_objnamel); i++) { 2216 - buf[i] = dn->sdn_objname[i]; 2217 - if (IS_NOT_PRINTABLE(buf[i])) 2218 - buf[i] = '.'; 2219 - } 2220 - buf[i] = 0; 2212 + case 0: 2213 + sprintf(buf, "%d", dn->sdn_objnum); 2214 + break; 2215 + default: 2216 + for (i = 0; i < le16_to_cpu(dn->sdn_objnamel); i++) { 2217 + buf[i] = dn->sdn_objname[i]; 2218 + if (IS_NOT_PRINTABLE(buf[i])) 2219 + buf[i] = '.'; 2220 + } 2221 + buf[i] = 0; 2221 2222 } 2222 2223 } 2223 2224 2224 2225 static char *dn_state2asc(unsigned char state) 2225 2226 { 2226 - switch(state) { 2227 - case DN_O: 2228 - return "OPEN"; 2229 - case DN_CR: 2230 - return " CR"; 2231 - case DN_DR: 2232 - return " DR"; 2233 - case DN_DRC: 2234 - return " DRC"; 2235 - case DN_CC: 2236 - return " CC"; 2237 - case DN_CI: 2238 - return " CI"; 2239 - case DN_NR: 2240 - return " NR"; 2241 - case DN_NC: 2242 - return " NC"; 2243 - case DN_CD: 2244 - return " CD"; 2245 - case DN_RJ: 2246 - return " RJ"; 2247 - case DN_RUN: 2248 - return " RUN"; 2249 - case DN_DI: 2250 - return " DI"; 2251 - case DN_DIC: 2252 - return " DIC"; 2253 - case DN_DN: 2254 - return " DN"; 2255 - case DN_CL: 2256 - return " CL"; 2257 - case DN_CN: 2258 - return " CN"; 2227 + switch (state) { 2228 + case DN_O: 2229 + return "OPEN"; 2230 + case DN_CR: 2231 + return " CR"; 2232 + case DN_DR: 2233 + return " DR"; 2234 + case DN_DRC: 2235 + return " DRC"; 2236 + case DN_CC: 2237 + return " CC"; 2238 + case DN_CI: 2239 + return " CI"; 2240 + case DN_NR: 2241 + return " NR"; 2242 + case DN_NC: 2243 + return " NC"; 2244 + case DN_CD: 2245 + return " CD"; 2246 + case DN_RJ: 2247 + return " RJ"; 2248 + case DN_RUN: 2249 + return " RUN"; 2250 + case DN_DI: 2251 + return " DI"; 2252 + case DN_DIC: 2253 + return " DIC"; 2254 + case DN_DN: 2255 + return " DN"; 2256 + case DN_CL: 2257 + return " CL"; 2258 + case DN_CN: 2259 + return " CN"; 2259 2260 } 2260 2261 2261 2262 return "????";

+34 -34

net/decnet/dn_dev.c

··· 437 437 438 438 dev_load(&init_net, ifr->ifr_name); 439 439 440 - switch(cmd) { 441 - case SIOCGIFADDR: 442 - break; 443 - case SIOCSIFADDR: 444 - if (!capable(CAP_NET_ADMIN)) 445 - return -EACCES; 446 - if (sdn->sdn_family != AF_DECnet) 447 - return -EINVAL; 448 - break; 449 - default: 440 + switch (cmd) { 441 + case SIOCGIFADDR: 442 + break; 443 + case SIOCSIFADDR: 444 + if (!capable(CAP_NET_ADMIN)) 445 + return -EACCES; 446 + if (sdn->sdn_family != AF_DECnet) 450 447 return -EINVAL; 448 + break; 449 + default: 450 + return -EINVAL; 451 451 } 452 452 453 453 rtnl_lock(); ··· 470 470 goto done; 471 471 } 472 472 473 - switch(cmd) { 474 - case SIOCGIFADDR: 475 - *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local; 476 - goto rarok; 473 + switch (cmd) { 474 + case SIOCGIFADDR: 475 + *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local; 476 + goto rarok; 477 477 478 - case SIOCSIFADDR: 479 - if (!ifa) { 480 - if ((ifa = dn_dev_alloc_ifa()) == NULL) { 481 - ret = -ENOBUFS; 482 - break; 483 - } 484 - memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 485 - } else { 486 - if (ifa->ifa_local == dn_saddr2dn(sdn)) 487 - break; 488 - dn_dev_del_ifa(dn_db, ifap, 0); 478 + case SIOCSIFADDR: 479 + if (!ifa) { 480 + if ((ifa = dn_dev_alloc_ifa()) == NULL) { 481 + ret = -ENOBUFS; 482 + break; 489 483 } 484 + memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 485 + } else { 486 + if (ifa->ifa_local == dn_saddr2dn(sdn)) 487 + break; 488 + dn_dev_del_ifa(dn_db, ifap, 0); 489 + } 490 490 491 - ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn); 491 + ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn); 492 492 493 - ret = dn_dev_set_ifa(dev, ifa); 493 + ret = dn_dev_set_ifa(dev, ifa); 494 494 } 495 495 done: 496 496 rtnl_unlock(); ··· 1335 1335 1336 1336 static char *dn_type2asc(char type) 1337 1337 { 1338 - switch(type) { 1339 - case DN_DEV_BCAST: 1340 - return "B"; 1341 - case DN_DEV_UCAST: 1342 - return "U"; 1343 - case DN_DEV_MPOINT: 1344 - return "M"; 1338 + switch (type) { 1339 + case DN_DEV_BCAST: 1340 + return "B"; 1341 + case DN_DEV_UCAST: 1342 + return "U"; 1343 + case DN_DEV_MPOINT: 1344 + return "M"; 1345 1345 } 1346 1346 1347 1347 return "?";

+39 -38

net/decnet/dn_fib.c

··· 414 414 415 415 res->fi = fi; 416 416 417 - switch(type) { 418 - case RTN_NAT: 419 - DN_FIB_RES_RESET(*res); 417 + switch (type) { 418 + case RTN_NAT: 419 + DN_FIB_RES_RESET(*res); 420 + atomic_inc(&fi->fib_clntref); 421 + return 0; 422 + case RTN_UNICAST: 423 + case RTN_LOCAL: 424 + for_nexthops(fi) { 425 + if (nh->nh_flags & RTNH_F_DEAD) 426 + continue; 427 + if (!fld->flowidn_oif || 428 + fld->flowidn_oif == nh->nh_oif) 429 + break; 430 + } 431 + if (nhsel < fi->fib_nhs) { 432 + res->nh_sel = nhsel; 420 433 atomic_inc(&fi->fib_clntref); 421 434 return 0; 422 - case RTN_UNICAST: 423 - case RTN_LOCAL: 424 - for_nexthops(fi) { 425 - if (nh->nh_flags & RTNH_F_DEAD) 426 - continue; 427 - if (!fld->flowidn_oif || 428 - fld->flowidn_oif == nh->nh_oif) 429 - break; 430 - } 431 - if (nhsel < fi->fib_nhs) { 432 - res->nh_sel = nhsel; 433 - atomic_inc(&fi->fib_clntref); 434 - return 0; 435 - } 436 - endfor_nexthops(fi); 437 - res->fi = NULL; 438 - return 1; 439 - default: 440 - if (net_ratelimit()) 441 - printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", type); 442 - res->fi = NULL; 443 - return -EINVAL; 435 + } 436 + endfor_nexthops(fi); 437 + res->fi = NULL; 438 + return 1; 439 + default: 440 + if (net_ratelimit()) 441 + printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", 442 + type); 443 + res->fi = NULL; 444 + return -EINVAL; 444 445 } 445 446 } 446 447 return err; ··· 648 647 { 649 648 struct dn_ifaddr *ifa = (struct dn_ifaddr *)ptr; 650 649 651 - switch(event) { 652 - case NETDEV_UP: 653 - dn_fib_add_ifaddr(ifa); 654 - dn_fib_sync_up(ifa->ifa_dev->dev); 650 + switch (event) { 651 + case NETDEV_UP: 652 + dn_fib_add_ifaddr(ifa); 653 + dn_fib_sync_up(ifa->ifa_dev->dev); 654 + dn_rt_cache_flush(-1); 655 + break; 656 + case NETDEV_DOWN: 657 + dn_fib_del_ifaddr(ifa); 658 + if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) { 659 + dn_fib_disable_addr(ifa->ifa_dev->dev, 1); 660 + } else { 655 661 dn_rt_cache_flush(-1); 656 - break; 657 - case NETDEV_DOWN: 658 - dn_fib_del_ifaddr(ifa); 659 - if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) { 660 - dn_fib_disable_addr(ifa->ifa_dev->dev, 1); 661 - } else { 662 - dn_rt_cache_flush(-1); 663 - } 664 - break; 662 + } 663 + break; 665 664 } 666 665 return NOTIFY_DONE; 667 666 }

+7 -7

net/decnet/dn_neigh.c

··· 404 404 405 405 dn->flags &= ~DN_NDFLAG_P3; 406 406 407 - switch(msg->iinfo & DN_RT_INFO_TYPE) { 408 - case DN_RT_INFO_L1RT: 409 - dn->flags &=~DN_NDFLAG_R2; 410 - dn->flags |= DN_NDFLAG_R1; 411 - break; 412 - case DN_RT_INFO_L2RT: 413 - dn->flags |= DN_NDFLAG_R2; 407 + switch (msg->iinfo & DN_RT_INFO_TYPE) { 408 + case DN_RT_INFO_L1RT: 409 + dn->flags &=~DN_NDFLAG_R2; 410 + dn->flags |= DN_NDFLAG_R1; 411 + break; 412 + case DN_RT_INFO_L2RT: 413 + dn->flags |= DN_NDFLAG_R2; 414 414 } 415 415 } 416 416

+93 -89

net/decnet/dn_nsp_in.c

··· 101 101 unsigned short type = ((ack >> 12) & 0x0003); 102 102 int wakeup = 0; 103 103 104 - switch(type) { 105 - case 0: /* ACK - Data */ 106 - if (dn_after(ack, scp->ackrcv_dat)) { 107 - scp->ackrcv_dat = ack & 0x0fff; 108 - wakeup |= dn_nsp_check_xmit_queue(sk, skb, &scp->data_xmit_queue, ack); 109 - } 110 - break; 111 - case 1: /* NAK - Data */ 112 - break; 113 - case 2: /* ACK - OtherData */ 114 - if (dn_after(ack, scp->ackrcv_oth)) { 115 - scp->ackrcv_oth = ack & 0x0fff; 116 - wakeup |= dn_nsp_check_xmit_queue(sk, skb, &scp->other_xmit_queue, ack); 117 - } 118 - break; 119 - case 3: /* NAK - OtherData */ 120 - break; 104 + switch (type) { 105 + case 0: /* ACK - Data */ 106 + if (dn_after(ack, scp->ackrcv_dat)) { 107 + scp->ackrcv_dat = ack & 0x0fff; 108 + wakeup |= dn_nsp_check_xmit_queue(sk, skb, 109 + &scp->data_xmit_queue, 110 + ack); 111 + } 112 + break; 113 + case 1: /* NAK - Data */ 114 + break; 115 + case 2: /* ACK - OtherData */ 116 + if (dn_after(ack, scp->ackrcv_oth)) { 117 + scp->ackrcv_oth = ack & 0x0fff; 118 + wakeup |= dn_nsp_check_xmit_queue(sk, skb, 119 + &scp->other_xmit_queue, 120 + ack); 121 + } 122 + break; 123 + case 3: /* NAK - OtherData */ 124 + break; 121 125 } 122 126 123 127 if (wakeup && !sock_flag(sk, SOCK_DEAD)) ··· 421 417 scp->addrrem = cb->src_port; 422 418 sk->sk_state = TCP_CLOSE; 423 419 424 - switch(scp->state) { 425 - case DN_CI: 426 - case DN_CD: 427 - scp->state = DN_RJ; 428 - sk->sk_err = ECONNREFUSED; 429 - break; 430 - case DN_RUN: 431 - sk->sk_shutdown |= SHUTDOWN_MASK; 432 - scp->state = DN_DN; 433 - break; 434 - case DN_DI: 435 - scp->state = DN_DIC; 436 - break; 420 + switch (scp->state) { 421 + case DN_CI: 422 + case DN_CD: 423 + scp->state = DN_RJ; 424 + sk->sk_err = ECONNREFUSED; 425 + break; 426 + case DN_RUN: 427 + sk->sk_shutdown |= SHUTDOWN_MASK; 428 + scp->state = DN_DN; 429 + break; 430 + case DN_DI: 431 + scp->state = DN_DIC; 432 + break; 437 433 } 438 434 439 435 if (!sock_flag(sk, SOCK_DEAD)) { ··· 474 470 475 471 sk->sk_state = TCP_CLOSE; 476 472 477 - switch(scp->state) { 478 - case DN_CI: 479 - scp->state = DN_NR; 480 - break; 481 - case DN_DR: 482 - if (reason == NSP_REASON_DC) 483 - scp->state = DN_DRC; 484 - if (reason == NSP_REASON_NL) 485 - scp->state = DN_CN; 486 - break; 487 - case DN_DI: 488 - scp->state = DN_DIC; 489 - break; 490 - case DN_RUN: 491 - sk->sk_shutdown |= SHUTDOWN_MASK; 492 - case DN_CC: 473 + switch (scp->state) { 474 + case DN_CI: 475 + scp->state = DN_NR; 476 + break; 477 + case DN_DR: 478 + if (reason == NSP_REASON_DC) 479 + scp->state = DN_DRC; 480 + if (reason == NSP_REASON_NL) 493 481 scp->state = DN_CN; 482 + break; 483 + case DN_DI: 484 + scp->state = DN_DIC; 485 + break; 486 + case DN_RUN: 487 + sk->sk_shutdown |= SHUTDOWN_MASK; 488 + case DN_CC: 489 + scp->state = DN_CN; 494 490 } 495 491 496 492 if (!sock_flag(sk, SOCK_DEAD)) { ··· 696 692 goto out; 697 693 698 694 if ((reason != NSP_REASON_OK) && ((cb->nsp_flags & 0x0c) == 0x08)) { 699 - switch(cb->nsp_flags & 0x70) { 700 - case 0x10: 701 - case 0x60: /* (Retransmitted) Connect Init */ 702 - dn_nsp_return_disc(skb, NSP_DISCINIT, reason); 703 - ret = NET_RX_SUCCESS; 704 - break; 705 - case 0x20: /* Connect Confirm */ 706 - dn_nsp_return_disc(skb, NSP_DISCCONF, reason); 707 - ret = NET_RX_SUCCESS; 708 - break; 695 + switch (cb->nsp_flags & 0x70) { 696 + case 0x10: 697 + case 0x60: /* (Retransmitted) Connect Init */ 698 + dn_nsp_return_disc(skb, NSP_DISCINIT, reason); 699 + ret = NET_RX_SUCCESS; 700 + break; 701 + case 0x20: /* Connect Confirm */ 702 + dn_nsp_return_disc(skb, NSP_DISCCONF, reason); 703 + ret = NET_RX_SUCCESS; 704 + break; 709 705 } 710 706 } 711 707 ··· 737 733 * Filter out conninits and useless packet types 738 734 */ 739 735 if ((cb->nsp_flags & 0x0c) == 0x08) { 740 - switch(cb->nsp_flags & 0x70) { 741 - case 0x00: /* NOP */ 742 - case 0x70: /* Reserved */ 743 - case 0x50: /* Reserved, Phase II node init */ 736 + switch (cb->nsp_flags & 0x70) { 737 + case 0x00: /* NOP */ 738 + case 0x70: /* Reserved */ 739 + case 0x50: /* Reserved, Phase II node init */ 740 + goto free_out; 741 + case 0x10: 742 + case 0x60: 743 + if (unlikely(cb->rt_flags & DN_RT_F_RTS)) 744 744 goto free_out; 745 - case 0x10: 746 - case 0x60: 747 - if (unlikely(cb->rt_flags & DN_RT_F_RTS)) 748 - goto free_out; 749 - sk = dn_find_listener(skb, &reason); 750 - goto got_it; 745 + sk = dn_find_listener(skb, &reason); 746 + goto got_it; 751 747 } 752 748 } 753 749 ··· 840 836 * Control packet. 841 837 */ 842 838 if ((cb->nsp_flags & 0x0c) == 0x08) { 843 - switch(cb->nsp_flags & 0x70) { 844 - case 0x10: 845 - case 0x60: 846 - dn_nsp_conn_init(sk, skb); 847 - break; 848 - case 0x20: 849 - dn_nsp_conn_conf(sk, skb); 850 - break; 851 - case 0x30: 852 - dn_nsp_disc_init(sk, skb); 853 - break; 854 - case 0x40: 855 - dn_nsp_disc_conf(sk, skb); 856 - break; 839 + switch (cb->nsp_flags & 0x70) { 840 + case 0x10: 841 + case 0x60: 842 + dn_nsp_conn_init(sk, skb); 843 + break; 844 + case 0x20: 845 + dn_nsp_conn_conf(sk, skb); 846 + break; 847 + case 0x30: 848 + dn_nsp_disc_init(sk, skb); 849 + break; 850 + case 0x40: 851 + dn_nsp_disc_conf(sk, skb); 852 + break; 857 853 } 858 854 859 855 } else if (cb->nsp_flags == 0x24) { ··· 894 890 if (scp->state != DN_RUN) 895 891 goto free_out; 896 892 897 - switch(cb->nsp_flags) { 898 - case 0x10: /* LS */ 899 - dn_nsp_linkservice(sk, skb); 900 - break; 901 - case 0x30: /* OD */ 902 - dn_nsp_otherdata(sk, skb); 903 - break; 904 - default: 905 - dn_nsp_data(sk, skb); 893 + switch (cb->nsp_flags) { 894 + case 0x10: /* LS */ 895 + dn_nsp_linkservice(sk, skb); 896 + break; 897 + case 0x30: /* OD */ 898 + dn_nsp_otherdata(sk, skb); 899 + break; 900 + default: 901 + dn_nsp_data(sk, skb); 906 902 } 907 903 908 904 } else { /* Ack, chuck it out here */

+49 -49

net/decnet/dn_route.c

··· 495 495 } 496 496 497 497 if ((skb->pkt_type == PACKET_HOST) && (cb->rt_flags & DN_RT_F_RQR)) { 498 - switch(cb->rt_flags & DN_RT_PKT_MSK) { 499 - case DN_RT_PKT_SHORT: 500 - return dn_return_short(skb); 501 - case DN_RT_PKT_LONG: 502 - return dn_return_long(skb); 498 + switch (cb->rt_flags & DN_RT_PKT_MSK) { 499 + case DN_RT_PKT_SHORT: 500 + return dn_return_short(skb); 501 + case DN_RT_PKT_LONG: 502 + return dn_return_long(skb); 503 503 } 504 504 } 505 505 ··· 652 652 if (unlikely(skb_linearize(skb))) 653 653 goto dump_it; 654 654 655 - switch(flags & DN_RT_CNTL_MSK) { 656 - case DN_RT_PKT_INIT: 657 - dn_dev_init_pkt(skb); 658 - break; 659 - case DN_RT_PKT_VERI: 660 - dn_dev_veri_pkt(skb); 661 - break; 655 + switch (flags & DN_RT_CNTL_MSK) { 656 + case DN_RT_PKT_INIT: 657 + dn_dev_init_pkt(skb); 658 + break; 659 + case DN_RT_PKT_VERI: 660 + dn_dev_veri_pkt(skb); 661 + break; 662 662 } 663 663 664 664 if (dn->parms.state != DN_DEV_S_RU) 665 665 goto dump_it; 666 666 667 - switch(flags & DN_RT_CNTL_MSK) { 668 - case DN_RT_PKT_HELO: 669 - return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO, 670 - skb, skb->dev, NULL, 671 - dn_route_ptp_hello); 667 + switch (flags & DN_RT_CNTL_MSK) { 668 + case DN_RT_PKT_HELO: 669 + return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO, 670 + skb, skb->dev, NULL, 671 + dn_route_ptp_hello); 672 672 673 - case DN_RT_PKT_L1RT: 674 - case DN_RT_PKT_L2RT: 675 - return NF_HOOK(NFPROTO_DECNET, NF_DN_ROUTE, 676 - skb, skb->dev, NULL, 677 - dn_route_discard); 678 - case DN_RT_PKT_ERTH: 679 - return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO, 680 - skb, skb->dev, NULL, 681 - dn_neigh_router_hello); 673 + case DN_RT_PKT_L1RT: 674 + case DN_RT_PKT_L2RT: 675 + return NF_HOOK(NFPROTO_DECNET, NF_DN_ROUTE, 676 + skb, skb->dev, NULL, 677 + dn_route_discard); 678 + case DN_RT_PKT_ERTH: 679 + return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO, 680 + skb, skb->dev, NULL, 681 + dn_neigh_router_hello); 682 682 683 - case DN_RT_PKT_EEDH: 684 - return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO, 685 - skb, skb->dev, NULL, 686 - dn_neigh_endnode_hello); 683 + case DN_RT_PKT_EEDH: 684 + return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO, 685 + skb, skb->dev, NULL, 686 + dn_neigh_endnode_hello); 687 687 } 688 688 } else { 689 689 if (dn->parms.state != DN_DEV_S_RU) ··· 691 691 692 692 skb_pull(skb, 1); /* Pull flags */ 693 693 694 - switch(flags & DN_RT_PKT_MSK) { 695 - case DN_RT_PKT_LONG: 696 - return dn_route_rx_long(skb); 697 - case DN_RT_PKT_SHORT: 698 - return dn_route_rx_short(skb); 694 + switch (flags & DN_RT_PKT_MSK) { 695 + case DN_RT_PKT_LONG: 696 + return dn_route_rx_long(skb); 697 + case DN_RT_PKT_SHORT: 698 + return dn_route_rx_short(skb); 699 699 } 700 700 } 701 701 ··· 1419 1419 rt->dst.neighbour = neigh; 1420 1420 rt->dst.lastuse = jiffies; 1421 1421 rt->dst.output = dn_rt_bug; 1422 - switch(res.type) { 1423 - case RTN_UNICAST: 1424 - rt->dst.input = dn_forward; 1425 - break; 1426 - case RTN_LOCAL: 1427 - rt->dst.output = dn_output; 1428 - rt->dst.input = dn_nsp_rx; 1429 - rt->dst.dev = in_dev; 1430 - flags |= RTCF_LOCAL; 1431 - break; 1432 - default: 1433 - case RTN_UNREACHABLE: 1434 - case RTN_BLACKHOLE: 1435 - rt->dst.input = dst_discard; 1422 + switch (res.type) { 1423 + case RTN_UNICAST: 1424 + rt->dst.input = dn_forward; 1425 + break; 1426 + case RTN_LOCAL: 1427 + rt->dst.output = dn_output; 1428 + rt->dst.input = dn_nsp_rx; 1429 + rt->dst.dev = in_dev; 1430 + flags |= RTCF_LOCAL; 1431 + break; 1432 + default: 1433 + case RTN_UNREACHABLE: 1434 + case RTN_BLACKHOLE: 1435 + rt->dst.input = dst_discard; 1436 1436 } 1437 1437 rt->rt_flags = flags; 1438 1438

+12 -11

net/decnet/dn_table.c

··· 147 147 148 148 old_divisor = dz->dz_divisor; 149 149 150 - switch(old_divisor) { 151 - case 16: 152 - new_divisor = 256; 153 - new_hashmask = 0xFF; 154 - break; 155 - default: 156 - printk(KERN_DEBUG "DECnet: dn_rehash_zone: BUG! %d\n", old_divisor); 157 - case 256: 158 - new_divisor = 1024; 159 - new_hashmask = 0x3FF; 160 - break; 150 + switch (old_divisor) { 151 + case 16: 152 + new_divisor = 256; 153 + new_hashmask = 0xFF; 154 + break; 155 + default: 156 + printk(KERN_DEBUG "DECnet: dn_rehash_zone: BUG! %d\n", 157 + old_divisor); 158 + case 256: 159 + new_divisor = 1024; 160 + new_hashmask = 0x3FF; 161 + break; 161 162 } 162 163 163 164 ht = kcalloc(new_divisor, sizeof(struct dn_fib_node*), GFP_KERNEL);

+9 -9

net/decnet/netfilter/dn_rtmsg.c

··· 69 69 int group = 0; 70 70 unsigned char flags = *skb->data; 71 71 72 - switch(flags & DN_RT_CNTL_MSK) { 73 - case DN_RT_PKT_L1RT: 74 - group = DNRNG_NLGRP_L1; 75 - break; 76 - case DN_RT_PKT_L2RT: 77 - group = DNRNG_NLGRP_L2; 78 - break; 79 - default: 80 - return; 72 + switch (flags & DN_RT_CNTL_MSK) { 73 + case DN_RT_PKT_L1RT: 74 + group = DNRNG_NLGRP_L1; 75 + break; 76 + case DN_RT_PKT_L2RT: 77 + group = DNRNG_NLGRP_L2; 78 + break; 79 + default: 80 + return; 81 81 } 82 82 83 83 skb2 = dnrmg_build_message(skb, &status);

+9 -8

net/decnet/sysctl_net_decnet.c

··· 68 68 static void strip_it(char *str) 69 69 { 70 70 for(;;) { 71 - switch(*str) { 72 - case ' ': 73 - case '\n': 74 - case '\r': 75 - case ':': 76 - *str = 0; 77 - case 0: 78 - return; 71 + switch (*str) { 72 + case ' ': 73 + case '\n': 74 + case '\r': 75 + case ':': 76 + *str = 0; 77 + /* Fallthrough */ 78 + case 0: 79 + return; 79 80 } 80 81 str++; 81 82 }