tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

x25: Reduce switch/case indent

Make the case labels the same indent as the switch.

git diff -w shows 80 column line reflowing.

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

authored by

Joe Perches and committed by
David S. Miller fddc5f3e 89f0e4fe

+392 -398
+236 -239
net/x25/af_x25.c
··· 237 237 #endif 238 238 ) { 239 239 switch (event) { 240 - case NETDEV_UP: 241 - x25_link_device_up(dev); 242 - break; 243 - case NETDEV_GOING_DOWN: 244 - nb = x25_get_neigh(dev); 245 - if (nb) { 246 - x25_terminate_link(nb); 247 - x25_neigh_put(nb); 248 - } 249 - break; 250 - case NETDEV_DOWN: 251 - x25_kill_by_device(dev); 252 - x25_route_device_down(dev); 253 - x25_link_device_down(dev); 254 - break; 240 + case NETDEV_UP: 241 + x25_link_device_up(dev); 242 + break; 243 + case NETDEV_GOING_DOWN: 244 + nb = x25_get_neigh(dev); 245 + if (nb) { 246 + x25_terminate_link(nb); 247 + x25_neigh_put(nb); 248 + } 249 + break; 250 + case NETDEV_DOWN: 251 + x25_kill_by_device(dev); 252 + x25_route_device_down(dev); 253 + x25_link_device_down(dev); 254 + break; 255 255 } 256 256 } 257 257 ··· 1336 1336 int rc; 1337 1337 1338 1338 switch (cmd) { 1339 - case TIOCOUTQ: { 1340 - int amount; 1339 + case TIOCOUTQ: { 1340 + int amount; 1341 1341 1342 - amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 1343 - if (amount < 0) 1344 - amount = 0; 1345 - rc = put_user(amount, (unsigned int __user *)argp); 1346 - break; 1347 - } 1342 + amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 1343 + if (amount < 0) 1344 + amount = 0; 1345 + rc = put_user(amount, (unsigned int __user *)argp); 1346 + break; 1347 + } 1348 1348 1349 - case TIOCINQ: { 1350 - struct sk_buff *skb; 1351 - int amount = 0; 1352 - /* 1353 - * These two are safe on a single CPU system as 1354 - * only user tasks fiddle here 1355 - */ 1356 - lock_sock(sk); 1357 - if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1358 - amount = skb->len; 1359 - release_sock(sk); 1360 - rc = put_user(amount, (unsigned int __user *)argp); 1361 - break; 1362 - } 1349 + case TIOCINQ: { 1350 + struct sk_buff *skb; 1351 + int amount = 0; 1352 + /* 1353 + * These two are safe on a single CPU system as 1354 + * only user tasks fiddle here 1355 + */ 1356 + lock_sock(sk); 1357 + if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1358 + amount = skb->len; 1359 + release_sock(sk); 1360 + rc = put_user(amount, (unsigned int __user *)argp); 1361 + break; 1362 + } 1363 1363 1364 - case SIOCGSTAMP: 1365 - rc = -EINVAL; 1366 - if (sk) 1367 - rc = sock_get_timestamp(sk, 1364 + case SIOCGSTAMP: 1365 + rc = -EINVAL; 1366 + if (sk) 1367 + rc = sock_get_timestamp(sk, 1368 1368 (struct timeval __user *)argp); 1369 + break; 1370 + case SIOCGSTAMPNS: 1371 + rc = -EINVAL; 1372 + if (sk) 1373 + rc = sock_get_timestampns(sk, 1374 + (struct timespec __user *)argp); 1375 + break; 1376 + case SIOCGIFADDR: 1377 + case SIOCSIFADDR: 1378 + case SIOCGIFDSTADDR: 1379 + case SIOCSIFDSTADDR: 1380 + case SIOCGIFBRDADDR: 1381 + case SIOCSIFBRDADDR: 1382 + case SIOCGIFNETMASK: 1383 + case SIOCSIFNETMASK: 1384 + case SIOCGIFMETRIC: 1385 + case SIOCSIFMETRIC: 1386 + rc = -EINVAL; 1387 + break; 1388 + case SIOCADDRT: 1389 + case SIOCDELRT: 1390 + rc = -EPERM; 1391 + if (!capable(CAP_NET_ADMIN)) 1369 1392 break; 1370 - case SIOCGSTAMPNS: 1371 - rc = -EINVAL; 1372 - if (sk) 1373 - rc = sock_get_timestampns(sk, 1374 - (struct timespec __user *)argp); 1393 + rc = x25_route_ioctl(cmd, argp); 1394 + break; 1395 + case SIOCX25GSUBSCRIP: 1396 + rc = x25_subscr_ioctl(cmd, argp); 1397 + break; 1398 + case SIOCX25SSUBSCRIP: 1399 + rc = -EPERM; 1400 + if (!capable(CAP_NET_ADMIN)) 1375 1401 break; 1376 - case SIOCGIFADDR: 1377 - case SIOCSIFADDR: 1378 - case SIOCGIFDSTADDR: 1379 - case SIOCSIFDSTADDR: 1380 - case SIOCGIFBRDADDR: 1381 - case SIOCSIFBRDADDR: 1382 - case SIOCGIFNETMASK: 1383 - case SIOCSIFNETMASK: 1384 - case SIOCGIFMETRIC: 1385 - case SIOCSIFMETRIC: 1386 - rc = -EINVAL; 1387 - break; 1388 - case SIOCADDRT: 1389 - case SIOCDELRT: 1390 - rc = -EPERM; 1391 - if (!capable(CAP_NET_ADMIN)) 1392 - break; 1393 - rc = x25_route_ioctl(cmd, argp); 1394 - break; 1395 - case SIOCX25GSUBSCRIP: 1396 - rc = x25_subscr_ioctl(cmd, argp); 1397 - break; 1398 - case SIOCX25SSUBSCRIP: 1399 - rc = -EPERM; 1400 - if (!capable(CAP_NET_ADMIN)) 1401 - break; 1402 - rc = x25_subscr_ioctl(cmd, argp); 1403 - break; 1404 - case SIOCX25GFACILITIES: { 1405 - lock_sock(sk); 1406 - rc = copy_to_user(argp, &x25->facilities, 1407 - sizeof(x25->facilities)) 1408 - ? -EFAULT : 0; 1409 - release_sock(sk); 1410 - break; 1411 - } 1402 + rc = x25_subscr_ioctl(cmd, argp); 1403 + break; 1404 + case SIOCX25GFACILITIES: { 1405 + lock_sock(sk); 1406 + rc = copy_to_user(argp, &x25->facilities, 1407 + sizeof(x25->facilities)) 1408 + ? -EFAULT : 0; 1409 + release_sock(sk); 1410 + break; 1411 + } 1412 1412 1413 - case SIOCX25SFACILITIES: { 1414 - struct x25_facilities facilities; 1415 - rc = -EFAULT; 1416 - if (copy_from_user(&facilities, argp, 1417 - sizeof(facilities))) 1418 - break; 1419 - rc = -EINVAL; 1420 - lock_sock(sk); 1421 - if (sk->sk_state != TCP_LISTEN && 1422 - sk->sk_state != TCP_CLOSE) 1413 + case SIOCX25SFACILITIES: { 1414 + struct x25_facilities facilities; 1415 + rc = -EFAULT; 1416 + if (copy_from_user(&facilities, argp, sizeof(facilities))) 1417 + break; 1418 + rc = -EINVAL; 1419 + lock_sock(sk); 1420 + if (sk->sk_state != TCP_LISTEN && 1421 + sk->sk_state != TCP_CLOSE) 1422 + goto out_fac_release; 1423 + if (facilities.pacsize_in < X25_PS16 || 1424 + facilities.pacsize_in > X25_PS4096) 1425 + goto out_fac_release; 1426 + if (facilities.pacsize_out < X25_PS16 || 1427 + facilities.pacsize_out > X25_PS4096) 1428 + goto out_fac_release; 1429 + if (facilities.winsize_in < 1 || 1430 + facilities.winsize_in > 127) 1431 + goto out_fac_release; 1432 + if (facilities.throughput) { 1433 + int out = facilities.throughput & 0xf0; 1434 + int in = facilities.throughput & 0x0f; 1435 + if (!out) 1436 + facilities.throughput |= 1437 + X25_DEFAULT_THROUGHPUT << 4; 1438 + else if (out < 0x30 || out > 0xD0) 1423 1439 goto out_fac_release; 1424 - if (facilities.pacsize_in < X25_PS16 || 1425 - facilities.pacsize_in > X25_PS4096) 1440 + if (!in) 1441 + facilities.throughput |= 1442 + X25_DEFAULT_THROUGHPUT; 1443 + else if (in < 0x03 || in > 0x0D) 1426 1444 goto out_fac_release; 1427 - if (facilities.pacsize_out < X25_PS16 || 1428 - facilities.pacsize_out > X25_PS4096) 1429 - goto out_fac_release; 1430 - if (facilities.winsize_in < 1 || 1431 - facilities.winsize_in > 127) 1432 - goto out_fac_release; 1433 - if (facilities.throughput) { 1434 - int out = facilities.throughput & 0xf0; 1435 - int in = facilities.throughput & 0x0f; 1436 - if (!out) 1437 - facilities.throughput |= 1438 - X25_DEFAULT_THROUGHPUT << 4; 1439 - else if (out < 0x30 || out > 0xD0) 1440 - goto out_fac_release; 1441 - if (!in) 1442 - facilities.throughput |= 1443 - X25_DEFAULT_THROUGHPUT; 1444 - else if (in < 0x03 || in > 0x0D) 1445 - goto out_fac_release; 1446 - } 1447 - if (facilities.reverse && 1448 - (facilities.reverse & 0x81) != 0x81) 1449 - goto out_fac_release; 1450 - x25->facilities = facilities; 1451 - rc = 0; 1445 + } 1446 + if (facilities.reverse && 1447 + (facilities.reverse & 0x81) != 0x81) 1448 + goto out_fac_release; 1449 + x25->facilities = facilities; 1450 + rc = 0; 1452 1451 out_fac_release: 1453 - release_sock(sk); 1454 - break; 1455 - } 1452 + release_sock(sk); 1453 + break; 1454 + } 1456 1455 1457 - case SIOCX25GDTEFACILITIES: { 1458 - lock_sock(sk); 1459 - rc = copy_to_user(argp, &x25->dte_facilities, 1460 - sizeof(x25->dte_facilities)); 1461 - release_sock(sk); 1462 - if (rc) 1463 - rc = -EFAULT; 1464 - break; 1465 - } 1466 - 1467 - case SIOCX25SDTEFACILITIES: { 1468 - struct x25_dte_facilities dtefacs; 1456 + case SIOCX25GDTEFACILITIES: { 1457 + lock_sock(sk); 1458 + rc = copy_to_user(argp, &x25->dte_facilities, 1459 + sizeof(x25->dte_facilities)); 1460 + release_sock(sk); 1461 + if (rc) 1469 1462 rc = -EFAULT; 1470 - if (copy_from_user(&dtefacs, argp, sizeof(dtefacs))) 1471 - break; 1472 - rc = -EINVAL; 1473 - lock_sock(sk); 1474 - if (sk->sk_state != TCP_LISTEN && 1475 - sk->sk_state != TCP_CLOSE) 1476 - goto out_dtefac_release; 1477 - if (dtefacs.calling_len > X25_MAX_AE_LEN) 1478 - goto out_dtefac_release; 1479 - if (dtefacs.calling_ae == NULL) 1480 - goto out_dtefac_release; 1481 - if (dtefacs.called_len > X25_MAX_AE_LEN) 1482 - goto out_dtefac_release; 1483 - if (dtefacs.called_ae == NULL) 1484 - goto out_dtefac_release; 1485 - x25->dte_facilities = dtefacs; 1486 - rc = 0; 1463 + break; 1464 + } 1465 + 1466 + case SIOCX25SDTEFACILITIES: { 1467 + struct x25_dte_facilities dtefacs; 1468 + rc = -EFAULT; 1469 + if (copy_from_user(&dtefacs, argp, sizeof(dtefacs))) 1470 + break; 1471 + rc = -EINVAL; 1472 + lock_sock(sk); 1473 + if (sk->sk_state != TCP_LISTEN && 1474 + sk->sk_state != TCP_CLOSE) 1475 + goto out_dtefac_release; 1476 + if (dtefacs.calling_len > X25_MAX_AE_LEN) 1477 + goto out_dtefac_release; 1478 + if (dtefacs.calling_ae == NULL) 1479 + goto out_dtefac_release; 1480 + if (dtefacs.called_len > X25_MAX_AE_LEN) 1481 + goto out_dtefac_release; 1482 + if (dtefacs.called_ae == NULL) 1483 + goto out_dtefac_release; 1484 + x25->dte_facilities = dtefacs; 1485 + rc = 0; 1487 1486 out_dtefac_release: 1488 - release_sock(sk); 1487 + release_sock(sk); 1488 + break; 1489 + } 1490 + 1491 + case SIOCX25GCALLUSERDATA: { 1492 + lock_sock(sk); 1493 + rc = copy_to_user(argp, &x25->calluserdata, 1494 + sizeof(x25->calluserdata)) 1495 + ? -EFAULT : 0; 1496 + release_sock(sk); 1497 + break; 1498 + } 1499 + 1500 + case SIOCX25SCALLUSERDATA: { 1501 + struct x25_calluserdata calluserdata; 1502 + 1503 + rc = -EFAULT; 1504 + if (copy_from_user(&calluserdata, argp, sizeof(calluserdata))) 1489 1505 break; 1490 - } 1491 - 1492 - case SIOCX25GCALLUSERDATA: { 1493 - lock_sock(sk); 1494 - rc = copy_to_user(argp, &x25->calluserdata, 1495 - sizeof(x25->calluserdata)) 1496 - ? -EFAULT : 0; 1497 - release_sock(sk); 1506 + rc = -EINVAL; 1507 + if (calluserdata.cudlength > X25_MAX_CUD_LEN) 1498 1508 break; 1499 - } 1509 + lock_sock(sk); 1510 + x25->calluserdata = calluserdata; 1511 + release_sock(sk); 1512 + rc = 0; 1513 + break; 1514 + } 1500 1515 1501 - case SIOCX25SCALLUSERDATA: { 1502 - struct x25_calluserdata calluserdata; 1516 + case SIOCX25GCAUSEDIAG: { 1517 + lock_sock(sk); 1518 + rc = copy_to_user(argp, &x25->causediag, sizeof(x25->causediag)) 1519 + ? -EFAULT : 0; 1520 + release_sock(sk); 1521 + break; 1522 + } 1503 1523 1504 - rc = -EFAULT; 1505 - if (copy_from_user(&calluserdata, argp, 1506 - sizeof(calluserdata))) 1507 - break; 1508 - rc = -EINVAL; 1509 - if (calluserdata.cudlength > X25_MAX_CUD_LEN) 1510 - break; 1511 - lock_sock(sk); 1512 - x25->calluserdata = calluserdata; 1513 - release_sock(sk); 1514 - rc = 0; 1524 + case SIOCX25SCAUSEDIAG: { 1525 + struct x25_causediag causediag; 1526 + rc = -EFAULT; 1527 + if (copy_from_user(&causediag, argp, sizeof(causediag))) 1515 1528 break; 1516 - } 1529 + lock_sock(sk); 1530 + x25->causediag = causediag; 1531 + release_sock(sk); 1532 + rc = 0; 1533 + break; 1517 1534 1518 - case SIOCX25GCAUSEDIAG: { 1519 - lock_sock(sk); 1520 - rc = copy_to_user(argp, &x25->causediag, 1521 - sizeof(x25->causediag)) 1522 - ? -EFAULT : 0; 1523 - release_sock(sk); 1524 - break; 1525 - } 1535 + } 1526 1536 1527 - case SIOCX25SCAUSEDIAG: { 1528 - struct x25_causediag causediag; 1529 - rc = -EFAULT; 1530 - if (copy_from_user(&causediag, argp, sizeof(causediag))) 1531 - break; 1532 - lock_sock(sk); 1533 - x25->causediag = causediag; 1534 - release_sock(sk); 1535 - rc = 0; 1536 - break; 1537 - 1538 - } 1539 - 1540 - case SIOCX25SCUDMATCHLEN: { 1541 - struct x25_subaddr sub_addr; 1542 - rc = -EINVAL; 1543 - lock_sock(sk); 1544 - if(sk->sk_state != TCP_CLOSE) 1545 - goto out_cud_release; 1546 - rc = -EFAULT; 1547 - if (copy_from_user(&sub_addr, argp, 1548 - sizeof(sub_addr))) 1549 - goto out_cud_release; 1550 - rc = -EINVAL; 1551 - if(sub_addr.cudmatchlength > X25_MAX_CUD_LEN) 1552 - goto out_cud_release; 1553 - x25->cudmatchlength = sub_addr.cudmatchlength; 1554 - rc = 0; 1537 + case SIOCX25SCUDMATCHLEN: { 1538 + struct x25_subaddr sub_addr; 1539 + rc = -EINVAL; 1540 + lock_sock(sk); 1541 + if(sk->sk_state != TCP_CLOSE) 1542 + goto out_cud_release; 1543 + rc = -EFAULT; 1544 + if (copy_from_user(&sub_addr, argp, 1545 + sizeof(sub_addr))) 1546 + goto out_cud_release; 1547 + rc = -EINVAL; 1548 + if (sub_addr.cudmatchlength > X25_MAX_CUD_LEN) 1549 + goto out_cud_release; 1550 + x25->cudmatchlength = sub_addr.cudmatchlength; 1551 + rc = 0; 1555 1552 out_cud_release: 1556 - release_sock(sk); 1557 - break; 1558 - } 1553 + release_sock(sk); 1554 + break; 1555 + } 1559 1556 1560 - case SIOCX25CALLACCPTAPPRV: { 1561 - rc = -EINVAL; 1562 - lock_sock(sk); 1563 - if (sk->sk_state != TCP_CLOSE) 1564 - break; 1565 - clear_bit(X25_ACCPT_APPRV_FLAG, &x25->flags); 1566 - release_sock(sk); 1567 - rc = 0; 1557 + case SIOCX25CALLACCPTAPPRV: { 1558 + rc = -EINVAL; 1559 + lock_sock(sk); 1560 + if (sk->sk_state != TCP_CLOSE) 1568 1561 break; 1569 - } 1562 + clear_bit(X25_ACCPT_APPRV_FLAG, &x25->flags); 1563 + release_sock(sk); 1564 + rc = 0; 1565 + break; 1566 + } 1570 1567 1571 - case SIOCX25SENDCALLACCPT: { 1572 - rc = -EINVAL; 1573 - lock_sock(sk); 1574 - if (sk->sk_state != TCP_ESTABLISHED) 1575 - break; 1576 - /* must call accptapprv above */ 1577 - if (test_bit(X25_ACCPT_APPRV_FLAG, &x25->flags)) 1578 - break; 1579 - x25_write_internal(sk, X25_CALL_ACCEPTED); 1580 - x25->state = X25_STATE_3; 1581 - release_sock(sk); 1582 - rc = 0; 1568 + case SIOCX25SENDCALLACCPT: { 1569 + rc = -EINVAL; 1570 + lock_sock(sk); 1571 + if (sk->sk_state != TCP_ESTABLISHED) 1583 1572 break; 1584 - } 1573 + /* must call accptapprv above */ 1574 + if (test_bit(X25_ACCPT_APPRV_FLAG, &x25->flags)) 1575 + break; 1576 + x25_write_internal(sk, X25_CALL_ACCEPTED); 1577 + x25->state = X25_STATE_3; 1578 + release_sock(sk); 1579 + rc = 0; 1580 + break; 1581 + } 1585 1582 1586 - default: 1587 - rc = -ENOIOCTLCMD; 1588 - break; 1583 + default: 1584 + rc = -ENOIOCTLCMD; 1585 + break; 1589 1586 } 1590 1587 1591 1588 return rc;
+22 -22
net/x25/x25_dev.c
··· 146 146 unsigned char *ptr; 147 147 148 148 switch (nb->dev->type) { 149 - case ARPHRD_X25: 150 - if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) { 151 - printk(KERN_ERR "x25_dev: out of memory\n"); 152 - return; 153 - } 154 - ptr = skb_put(skb, 1); 155 - *ptr = X25_IFACE_CONNECT; 156 - break; 149 + case ARPHRD_X25: 150 + if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) { 151 + printk(KERN_ERR "x25_dev: out of memory\n"); 152 + return; 153 + } 154 + ptr = skb_put(skb, 1); 155 + *ptr = X25_IFACE_CONNECT; 156 + break; 157 157 158 158 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE) 159 - case ARPHRD_ETHER: 160 - return; 159 + case ARPHRD_ETHER: 160 + return; 161 161 #endif 162 - default: 163 - return; 162 + default: 163 + return; 164 164 } 165 165 166 166 skb->protocol = htons(ETH_P_X25); ··· 202 202 skb_reset_network_header(skb); 203 203 204 204 switch (nb->dev->type) { 205 - case ARPHRD_X25: 206 - dptr = skb_push(skb, 1); 207 - *dptr = X25_IFACE_DATA; 208 - break; 205 + case ARPHRD_X25: 206 + dptr = skb_push(skb, 1); 207 + *dptr = X25_IFACE_DATA; 208 + break; 209 209 210 210 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE) 211 - case ARPHRD_ETHER: 212 - kfree_skb(skb); 213 - return; 211 + case ARPHRD_ETHER: 212 + kfree_skb(skb); 213 + return; 214 214 #endif 215 - default: 216 - kfree_skb(skb); 217 - return; 215 + default: 216 + kfree_skb(skb); 217 + return; 218 218 } 219 219 220 220 skb->protocol = htons(ETH_P_X25);
+56 -56
net/x25/x25_in.c
··· 94 94 struct x25_sock *x25 = x25_sk(sk); 95 95 96 96 switch (frametype) { 97 - case X25_CALL_ACCEPTED: { 97 + case X25_CALL_ACCEPTED: { 98 98 99 - x25_stop_timer(sk); 100 - x25->condition = 0x00; 101 - x25->vs = 0; 102 - x25->va = 0; 103 - x25->vr = 0; 104 - x25->vl = 0; 105 - x25->state = X25_STATE_3; 106 - sk->sk_state = TCP_ESTABLISHED; 107 - /* 108 - * Parse the data in the frame. 109 - */ 110 - skb_pull(skb, X25_STD_MIN_LEN); 99 + x25_stop_timer(sk); 100 + x25->condition = 0x00; 101 + x25->vs = 0; 102 + x25->va = 0; 103 + x25->vr = 0; 104 + x25->vl = 0; 105 + x25->state = X25_STATE_3; 106 + sk->sk_state = TCP_ESTABLISHED; 107 + /* 108 + * Parse the data in the frame. 109 + */ 110 + skb_pull(skb, X25_STD_MIN_LEN); 111 111 112 - len = x25_parse_address_block(skb, &source_addr, 113 - &dest_addr); 114 - if (len > 0) 115 - skb_pull(skb, len); 116 - else if (len < 0) 117 - goto out_clear; 112 + len = x25_parse_address_block(skb, &source_addr, 113 + &dest_addr); 114 + if (len > 0) 115 + skb_pull(skb, len); 116 + else if (len < 0) 117 + goto out_clear; 118 118 119 - len = x25_parse_facilities(skb, &x25->facilities, 120 - &x25->dte_facilities, 121 - &x25->vc_facil_mask); 122 - if (len > 0) 123 - skb_pull(skb, len); 124 - else if (len < 0) 125 - goto out_clear; 126 - /* 127 - * Copy any Call User Data. 128 - */ 129 - if (skb->len > 0) { 130 - skb_copy_from_linear_data(skb, 131 - x25->calluserdata.cuddata, 132 - skb->len); 133 - x25->calluserdata.cudlength = skb->len; 134 - } 135 - if (!sock_flag(sk, SOCK_DEAD)) 136 - sk->sk_state_change(sk); 137 - break; 119 + len = x25_parse_facilities(skb, &x25->facilities, 120 + &x25->dte_facilities, 121 + &x25->vc_facil_mask); 122 + if (len > 0) 123 + skb_pull(skb, len); 124 + else if (len < 0) 125 + goto out_clear; 126 + /* 127 + * Copy any Call User Data. 128 + */ 129 + if (skb->len > 0) { 130 + skb_copy_from_linear_data(skb, 131 + x25->calluserdata.cuddata, 132 + skb->len); 133 + x25->calluserdata.cudlength = skb->len; 138 134 } 139 - case X25_CLEAR_REQUEST: 140 - x25_write_internal(sk, X25_CLEAR_CONFIRMATION); 141 - x25_disconnect(sk, ECONNREFUSED, skb->data[3], skb->data[4]); 142 - break; 135 + if (!sock_flag(sk, SOCK_DEAD)) 136 + sk->sk_state_change(sk); 137 + break; 138 + } 139 + case X25_CLEAR_REQUEST: 140 + x25_write_internal(sk, X25_CLEAR_CONFIRMATION); 141 + x25_disconnect(sk, ECONNREFUSED, skb->data[3], skb->data[4]); 142 + break; 143 143 144 - default: 145 - break; 144 + default: 145 + break; 146 146 } 147 147 148 148 return 0; ··· 354 354 frametype = x25_decode(sk, skb, &ns, &nr, &q, &d, &m); 355 355 356 356 switch (x25->state) { 357 - case X25_STATE_1: 358 - queued = x25_state1_machine(sk, skb, frametype); 359 - break; 360 - case X25_STATE_2: 361 - queued = x25_state2_machine(sk, skb, frametype); 362 - break; 363 - case X25_STATE_3: 364 - queued = x25_state3_machine(sk, skb, frametype, ns, nr, q, d, m); 365 - break; 366 - case X25_STATE_4: 367 - queued = x25_state4_machine(sk, skb, frametype); 368 - break; 357 + case X25_STATE_1: 358 + queued = x25_state1_machine(sk, skb, frametype); 359 + break; 360 + case X25_STATE_2: 361 + queued = x25_state2_machine(sk, skb, frametype); 362 + break; 363 + case X25_STATE_3: 364 + queued = x25_state3_machine(sk, skb, frametype, ns, nr, q, d, m); 365 + break; 366 + case X25_STATE_4: 367 + queued = x25_state4_machine(sk, skb, frametype); 368 + break; 369 369 } 370 370 371 371 x25_kick(sk);
+40 -41
net/x25/x25_link.c
··· 76 76 int confirm; 77 77 78 78 switch (frametype) { 79 - case X25_RESTART_REQUEST: 80 - confirm = !x25_t20timer_pending(nb); 81 - x25_stop_t20timer(nb); 82 - nb->state = X25_LINK_STATE_3; 83 - if (confirm) 84 - x25_transmit_restart_confirmation(nb); 85 - break; 79 + case X25_RESTART_REQUEST: 80 + confirm = !x25_t20timer_pending(nb); 81 + x25_stop_t20timer(nb); 82 + nb->state = X25_LINK_STATE_3; 83 + if (confirm) 84 + x25_transmit_restart_confirmation(nb); 85 + break; 86 86 87 - case X25_RESTART_CONFIRMATION: 88 - x25_stop_t20timer(nb); 89 - nb->state = X25_LINK_STATE_3; 90 - break; 87 + case X25_RESTART_CONFIRMATION: 88 + x25_stop_t20timer(nb); 89 + nb->state = X25_LINK_STATE_3; 90 + break; 91 91 92 - case X25_DIAGNOSTIC: 93 - printk(KERN_WARNING "x25: diagnostic #%d - " 94 - "%02X %02X %02X\n", 95 - skb->data[3], skb->data[4], 96 - skb->data[5], skb->data[6]); 97 - break; 92 + case X25_DIAGNOSTIC: 93 + printk(KERN_WARNING "x25: diagnostic #%d - %02X %02X %02X\n", 94 + skb->data[3], skb->data[4], 95 + skb->data[5], skb->data[6]); 96 + break; 98 97 99 - default: 100 - printk(KERN_WARNING "x25: received unknown %02X " 101 - "with LCI 000\n", frametype); 102 - break; 98 + default: 99 + printk(KERN_WARNING "x25: received unknown %02X with LCI 000\n", 100 + frametype); 101 + break; 103 102 } 104 103 105 104 if (nb->state == X25_LINK_STATE_3) ··· 192 193 void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *nb) 193 194 { 194 195 switch (nb->state) { 195 - case X25_LINK_STATE_0: 196 - skb_queue_tail(&nb->queue, skb); 197 - nb->state = X25_LINK_STATE_1; 198 - x25_establish_link(nb); 199 - break; 200 - case X25_LINK_STATE_1: 201 - case X25_LINK_STATE_2: 202 - skb_queue_tail(&nb->queue, skb); 203 - break; 204 - case X25_LINK_STATE_3: 205 - x25_send_frame(skb, nb); 206 - break; 196 + case X25_LINK_STATE_0: 197 + skb_queue_tail(&nb->queue, skb); 198 + nb->state = X25_LINK_STATE_1; 199 + x25_establish_link(nb); 200 + break; 201 + case X25_LINK_STATE_1: 202 + case X25_LINK_STATE_2: 203 + skb_queue_tail(&nb->queue, skb); 204 + break; 205 + case X25_LINK_STATE_3: 206 + x25_send_frame(skb, nb); 207 + break; 207 208 } 208 209 } 209 210 ··· 213 214 void x25_link_established(struct x25_neigh *nb) 214 215 { 215 216 switch (nb->state) { 216 - case X25_LINK_STATE_0: 217 - nb->state = X25_LINK_STATE_2; 218 - break; 219 - case X25_LINK_STATE_1: 220 - x25_transmit_restart_request(nb); 221 - nb->state = X25_LINK_STATE_2; 222 - x25_start_t20timer(nb); 223 - break; 217 + case X25_LINK_STATE_0: 218 + nb->state = X25_LINK_STATE_2; 219 + break; 220 + case X25_LINK_STATE_1: 221 + x25_transmit_restart_request(nb); 222 + nb->state = X25_LINK_STATE_2; 223 + x25_start_t20timer(nb); 224 + break; 224 225 } 225 226 } 226 227
+38 -40
net/x25/x25_subr.c
··· 126 126 * Adjust frame size. 127 127 */ 128 128 switch (frametype) { 129 - case X25_CALL_REQUEST: 130 - len += 1 + X25_ADDR_LEN + X25_MAX_FAC_LEN + 131 - X25_MAX_CUD_LEN; 132 - break; 133 - case X25_CALL_ACCEPTED: /* fast sel with no restr on resp */ 134 - if(x25->facilities.reverse & 0x80) { 135 - len += 1 + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN; 136 - } else { 137 - len += 1 + X25_MAX_FAC_LEN; 138 - } 139 - break; 140 - case X25_CLEAR_REQUEST: 141 - case X25_RESET_REQUEST: 142 - len += 2; 143 - break; 144 - case X25_RR: 145 - case X25_RNR: 146 - case X25_REJ: 147 - case X25_CLEAR_CONFIRMATION: 148 - case X25_INTERRUPT_CONFIRMATION: 149 - case X25_RESET_CONFIRMATION: 150 - break; 151 - default: 152 - printk(KERN_ERR "X.25: invalid frame type %02X\n", 153 - frametype); 154 - return; 129 + case X25_CALL_REQUEST: 130 + len += 1 + X25_ADDR_LEN + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN; 131 + break; 132 + case X25_CALL_ACCEPTED: /* fast sel with no restr on resp */ 133 + if (x25->facilities.reverse & 0x80) { 134 + len += 1 + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN; 135 + } else { 136 + len += 1 + X25_MAX_FAC_LEN; 137 + } 138 + break; 139 + case X25_CLEAR_REQUEST: 140 + case X25_RESET_REQUEST: 141 + len += 2; 142 + break; 143 + case X25_RR: 144 + case X25_RNR: 145 + case X25_REJ: 146 + case X25_CLEAR_CONFIRMATION: 147 + case X25_INTERRUPT_CONFIRMATION: 148 + case X25_RESET_CONFIRMATION: 149 + break; 150 + default: 151 + printk(KERN_ERR "X.25: invalid frame type %02X\n", frametype); 152 + return; 155 153 } 156 154 157 155 if ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL) ··· 274 276 *ns = *nr = *q = *d = *m = 0; 275 277 276 278 switch (frame[2]) { 277 - case X25_CALL_REQUEST: 278 - case X25_CALL_ACCEPTED: 279 - case X25_CLEAR_REQUEST: 280 - case X25_CLEAR_CONFIRMATION: 281 - case X25_INTERRUPT: 282 - case X25_INTERRUPT_CONFIRMATION: 283 - case X25_RESET_REQUEST: 284 - case X25_RESET_CONFIRMATION: 285 - case X25_RESTART_REQUEST: 286 - case X25_RESTART_CONFIRMATION: 287 - case X25_REGISTRATION_REQUEST: 288 - case X25_REGISTRATION_CONFIRMATION: 289 - case X25_DIAGNOSTIC: 290 - return frame[2]; 279 + case X25_CALL_REQUEST: 280 + case X25_CALL_ACCEPTED: 281 + case X25_CLEAR_REQUEST: 282 + case X25_CLEAR_CONFIRMATION: 283 + case X25_INTERRUPT: 284 + case X25_INTERRUPT_CONFIRMATION: 285 + case X25_RESET_REQUEST: 286 + case X25_RESET_CONFIRMATION: 287 + case X25_RESTART_REQUEST: 288 + case X25_RESTART_CONFIRMATION: 289 + case X25_REGISTRATION_REQUEST: 290 + case X25_REGISTRATION_CONFIRMATION: 291 + case X25_DIAGNOSTIC: 292 + return frame[2]; 291 293 } 292 294 293 295 if (x25->neighbour->extended) {