aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/feature-removal-schedule.txt12
-rw-r--r--include/net/sctp/user.h8
-rw-r--r--net/sctp/socket.c325
3 files changed, 0 insertions, 345 deletions
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index bc693fffabe0..72ae06f73acf 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -302,18 +302,6 @@ Who: ocfs2-devel@oss.oracle.com
302 302
303--------------------------- 303---------------------------
304 304
305What: SCTP_GET_PEER_ADDRS_NUM_OLD, SCTP_GET_PEER_ADDRS_OLD,
306 SCTP_GET_LOCAL_ADDRS_NUM_OLD, SCTP_GET_LOCAL_ADDRS_OLD
307When: June 2009
308Why: A newer version of the options have been introduced in 2005 that
309 removes the limitions of the old API. The sctp library has been
310 converted to use these new options at the same time. Any user
311 space app that directly uses the old options should convert to using
312 the new options.
313Who: Vlad Yasevich <vladislav.yasevich@hp.com>
314
315---------------------------
316
317What: Ability for non root users to shm_get hugetlb pages based on mlock 305What: Ability for non root users to shm_get hugetlb pages based on mlock
318 resource limits 306 resource limits
319When: 2.6.31 307When: 2.6.31
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index 50b2431405f2..fceab4d2413e 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -131,14 +131,6 @@ enum sctp_optname {
131#define SCTP_SOCKOPT_BINDX_REM SCTP_SOCKOPT_BINDX_REM 131#define SCTP_SOCKOPT_BINDX_REM SCTP_SOCKOPT_BINDX_REM
132 SCTP_SOCKOPT_PEELOFF, /* peel off association. */ 132 SCTP_SOCKOPT_PEELOFF, /* peel off association. */
133#define SCTP_SOCKOPT_PEELOFF SCTP_SOCKOPT_PEELOFF 133#define SCTP_SOCKOPT_PEELOFF SCTP_SOCKOPT_PEELOFF
134 SCTP_GET_PEER_ADDRS_NUM_OLD, /* Get number of peer addresss. */
135#define SCTP_GET_PEER_ADDRS_NUM_OLD SCTP_GET_PEER_ADDRS_NUM_OLD
136 SCTP_GET_PEER_ADDRS_OLD, /* Get all peer addresss. */
137#define SCTP_GET_PEER_ADDRS_OLD SCTP_GET_PEER_ADDRS_OLD
138 SCTP_GET_LOCAL_ADDRS_NUM_OLD, /* Get number of local addresss. */
139#define SCTP_GET_LOCAL_ADDRS_NUM_OLD SCTP_GET_LOCAL_ADDRS_NUM_OLD
140 SCTP_GET_LOCAL_ADDRS_OLD, /* Get all local addresss. */
141#define SCTP_GET_LOCAL_ADDRS_OLD SCTP_GET_LOCAL_ADDRS_OLD
142 SCTP_SOCKOPT_CONNECTX_OLD, /* CONNECTX old requests. */ 134 SCTP_SOCKOPT_CONNECTX_OLD, /* CONNECTX old requests. */
143#define SCTP_SOCKOPT_CONNECTX_OLD SCTP_SOCKOPT_CONNECTX_OLD 135#define SCTP_SOCKOPT_CONNECTX_OLD SCTP_SOCKOPT_CONNECTX_OLD
144 SCTP_GET_PEER_ADDRS, /* Get all peer addresss. */ 136 SCTP_GET_PEER_ADDRS, /* Get all peer addresss. */
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index a4577a75c6c0..d2681a6bc6fa 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -4348,90 +4348,6 @@ static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval
4348 return 0; 4348 return 0;
4349} 4349}
4350 4350
4351static int sctp_getsockopt_peer_addrs_num_old(struct sock *sk, int len,
4352 char __user *optval,
4353 int __user *optlen)
4354{
4355 sctp_assoc_t id;
4356 struct sctp_association *asoc;
4357 struct list_head *pos;
4358 int cnt = 0;
4359
4360 if (len < sizeof(sctp_assoc_t))
4361 return -EINVAL;
4362
4363 if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
4364 return -EFAULT;
4365
4366 printk(KERN_WARNING "SCTP: Use of SCTP_GET_PEER_ADDRS_NUM_OLD "
4367 "socket option deprecated\n");
4368 /* For UDP-style sockets, id specifies the association to query. */
4369 asoc = sctp_id2assoc(sk, id);
4370 if (!asoc)
4371 return -EINVAL;
4372
4373 list_for_each(pos, &asoc->peer.transport_addr_list) {
4374 cnt ++;
4375 }
4376
4377 return cnt;
4378}
4379
4380/*
4381 * Old API for getting list of peer addresses. Does not work for 32-bit
4382 * programs running on a 64-bit kernel
4383 */
4384static int sctp_getsockopt_peer_addrs_old(struct sock *sk, int len,
4385 char __user *optval,
4386 int __user *optlen)
4387{
4388 struct sctp_association *asoc;
4389 int cnt = 0;
4390 struct sctp_getaddrs_old getaddrs;
4391 struct sctp_transport *from;
4392 void __user *to;
4393 union sctp_addr temp;
4394 struct sctp_sock *sp = sctp_sk(sk);
4395 int addrlen;
4396
4397 if (len < sizeof(struct sctp_getaddrs_old))
4398 return -EINVAL;
4399
4400 len = sizeof(struct sctp_getaddrs_old);
4401
4402 if (copy_from_user(&getaddrs, optval, len))
4403 return -EFAULT;
4404
4405 if (getaddrs.addr_num <= 0) return -EINVAL;
4406
4407 printk(KERN_WARNING "SCTP: Use of SCTP_GET_PEER_ADDRS_OLD "
4408 "socket option deprecated\n");
4409
4410 /* For UDP-style sockets, id specifies the association to query. */
4411 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4412 if (!asoc)
4413 return -EINVAL;
4414
4415 to = (void __user *)getaddrs.addrs;
4416 list_for_each_entry(from, &asoc->peer.transport_addr_list,
4417 transports) {
4418 memcpy(&temp, &from->ipaddr, sizeof(temp));
4419 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
4420 addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
4421 if (copy_to_user(to, &temp, addrlen))
4422 return -EFAULT;
4423 to += addrlen ;
4424 cnt ++;
4425 if (cnt >= getaddrs.addr_num) break;
4426 }
4427 getaddrs.addr_num = cnt;
4428 if (put_user(len, optlen))
4429 return -EFAULT;
4430 if (copy_to_user(optval, &getaddrs, len))
4431 return -EFAULT;
4432
4433 return 0;
4434}
4435 4351
4436static int sctp_getsockopt_peer_addrs(struct sock *sk, int len, 4352static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
4437 char __user *optval, int __user *optlen) 4353 char __user *optval, int __user *optlen)
@@ -4484,125 +4400,6 @@ static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
4484 return 0; 4400 return 0;
4485} 4401}
4486 4402
4487static int sctp_getsockopt_local_addrs_num_old(struct sock *sk, int len,
4488 char __user *optval,
4489 int __user *optlen)
4490{
4491 sctp_assoc_t id;
4492 struct sctp_bind_addr *bp;
4493 struct sctp_association *asoc;
4494 struct sctp_sockaddr_entry *addr;
4495 int cnt = 0;
4496
4497 if (len < sizeof(sctp_assoc_t))
4498 return -EINVAL;
4499
4500 if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
4501 return -EFAULT;
4502
4503 printk(KERN_WARNING "SCTP: Use of SCTP_GET_LOCAL_ADDRS_NUM_OLD "
4504 "socket option deprecated\n");
4505
4506 /*
4507 * For UDP-style sockets, id specifies the association to query.
4508 * If the id field is set to the value '0' then the locally bound
4509 * addresses are returned without regard to any particular
4510 * association.
4511 */
4512 if (0 == id) {
4513 bp = &sctp_sk(sk)->ep->base.bind_addr;
4514 } else {
4515 asoc = sctp_id2assoc(sk, id);
4516 if (!asoc)
4517 return -EINVAL;
4518 bp = &asoc->base.bind_addr;
4519 }
4520
4521 /* If the endpoint is bound to 0.0.0.0 or ::0, count the valid
4522 * addresses from the global local address list.
4523 */
4524 if (sctp_list_single_entry(&bp->address_list)) {
4525 addr = list_entry(bp->address_list.next,
4526 struct sctp_sockaddr_entry, list);
4527 if (sctp_is_any(sk, &addr->a)) {
4528 rcu_read_lock();
4529 list_for_each_entry_rcu(addr,
4530 &sctp_local_addr_list, list) {
4531 if (!addr->valid)
4532 continue;
4533
4534 if ((PF_INET == sk->sk_family) &&
4535 (AF_INET6 == addr->a.sa.sa_family))
4536 continue;
4537
4538 if ((PF_INET6 == sk->sk_family) &&
4539 inet_v6_ipv6only(sk) &&
4540 (AF_INET == addr->a.sa.sa_family))
4541 continue;
4542
4543 cnt++;
4544 }
4545 rcu_read_unlock();
4546 } else {
4547 cnt = 1;
4548 }
4549 goto done;
4550 }
4551
4552 /* Protection on the bound address list is not needed,
4553 * since in the socket option context we hold the socket lock,
4554 * so there is no way that the bound address list can change.
4555 */
4556 list_for_each_entry(addr, &bp->address_list, list) {
4557 cnt ++;
4558 }
4559done:
4560 return cnt;
4561}
4562
4563/* Helper function that copies local addresses to user and returns the number
4564 * of addresses copied.
4565 */
4566static int sctp_copy_laddrs_old(struct sock *sk, __u16 port,
4567 int max_addrs, void *to,
4568 int *bytes_copied)
4569{
4570 struct sctp_sockaddr_entry *addr;
4571 union sctp_addr temp;
4572 int cnt = 0;
4573 int addrlen;
4574
4575 rcu_read_lock();
4576 list_for_each_entry_rcu(addr, &sctp_local_addr_list, list) {
4577 if (!addr->valid)
4578 continue;
4579
4580 if ((PF_INET == sk->sk_family) &&
4581 (AF_INET6 == addr->a.sa.sa_family))
4582 continue;
4583 if ((PF_INET6 == sk->sk_family) &&
4584 inet_v6_ipv6only(sk) &&
4585 (AF_INET == addr->a.sa.sa_family))
4586 continue;
4587 memcpy(&temp, &addr->a, sizeof(temp));
4588 if (!temp.v4.sin_port)
4589 temp.v4.sin_port = htons(port);
4590
4591 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
4592 &temp);
4593 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
4594 memcpy(to, &temp, addrlen);
4595
4596 to += addrlen;
4597 *bytes_copied += addrlen;
4598 cnt ++;
4599 if (cnt >= max_addrs) break;
4600 }
4601 rcu_read_unlock();
4602
4603 return cnt;
4604}
4605
4606static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to, 4403static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
4607 size_t space_left, int *bytes_copied) 4404 size_t space_left, int *bytes_copied)
4608{ 4405{
@@ -4646,112 +4443,6 @@ static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
4646 return cnt; 4443 return cnt;
4647} 4444}
4648 4445
4649/* Old API for getting list of local addresses. Does not work for 32-bit
4650 * programs running on a 64-bit kernel
4651 */
4652static int sctp_getsockopt_local_addrs_old(struct sock *sk, int len,
4653 char __user *optval, int __user *optlen)
4654{
4655 struct sctp_bind_addr *bp;
4656 struct sctp_association *asoc;
4657 int cnt = 0;
4658 struct sctp_getaddrs_old getaddrs;
4659 struct sctp_sockaddr_entry *addr;
4660 void __user *to;
4661 union sctp_addr temp;
4662 struct sctp_sock *sp = sctp_sk(sk);
4663 int addrlen;
4664 int err = 0;
4665 void *addrs;
4666 void *buf;
4667 int bytes_copied = 0;
4668
4669 if (len < sizeof(struct sctp_getaddrs_old))
4670 return -EINVAL;
4671
4672 len = sizeof(struct sctp_getaddrs_old);
4673 if (copy_from_user(&getaddrs, optval, len))
4674 return -EFAULT;
4675
4676 if (getaddrs.addr_num <= 0 ||
4677 getaddrs.addr_num >= (INT_MAX / sizeof(union sctp_addr)))
4678 return -EINVAL;
4679
4680 printk(KERN_WARNING "SCTP: Use of SCTP_GET_LOCAL_ADDRS_OLD "
4681 "socket option deprecated\n");
4682
4683 /*
4684 * For UDP-style sockets, id specifies the association to query.
4685 * If the id field is set to the value '0' then the locally bound
4686 * addresses are returned without regard to any particular
4687 * association.
4688 */
4689 if (0 == getaddrs.assoc_id) {
4690 bp = &sctp_sk(sk)->ep->base.bind_addr;
4691 } else {
4692 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4693 if (!asoc)
4694 return -EINVAL;
4695 bp = &asoc->base.bind_addr;
4696 }
4697
4698 to = getaddrs.addrs;
4699
4700 /* Allocate space for a local instance of packed array to hold all
4701 * the data. We store addresses here first and then put write them
4702 * to the user in one shot.
4703 */
4704 addrs = kmalloc(sizeof(union sctp_addr) * getaddrs.addr_num,
4705 GFP_KERNEL);
4706 if (!addrs)
4707 return -ENOMEM;
4708
4709 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
4710 * addresses from the global local address list.
4711 */
4712 if (sctp_list_single_entry(&bp->address_list)) {
4713 addr = list_entry(bp->address_list.next,
4714 struct sctp_sockaddr_entry, list);
4715 if (sctp_is_any(sk, &addr->a)) {
4716 cnt = sctp_copy_laddrs_old(sk, bp->port,
4717 getaddrs.addr_num,
4718 addrs, &bytes_copied);
4719 goto copy_getaddrs;
4720 }
4721 }
4722
4723 buf = addrs;
4724 /* Protection on the bound address list is not needed since
4725 * in the socket option context we hold a socket lock and
4726 * thus the bound address list can't change.
4727 */
4728 list_for_each_entry(addr, &bp->address_list, list) {
4729 memcpy(&temp, &addr->a, sizeof(temp));
4730 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
4731 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
4732 memcpy(buf, &temp, addrlen);
4733 buf += addrlen;
4734 bytes_copied += addrlen;
4735 cnt ++;
4736 if (cnt >= getaddrs.addr_num) break;
4737 }
4738
4739copy_getaddrs:
4740 /* copy the entire address list into the user provided space */
4741 if (copy_to_user(to, addrs, bytes_copied)) {
4742 err = -EFAULT;
4743 goto error;
4744 }
4745
4746 /* copy the leading structure back to user */
4747 getaddrs.addr_num = cnt;
4748 if (copy_to_user(optval, &getaddrs, len))
4749 err = -EFAULT;
4750
4751error:
4752 kfree(addrs);
4753 return err;
4754}
4755 4446
4756static int sctp_getsockopt_local_addrs(struct sock *sk, int len, 4447static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
4757 char __user *optval, int __user *optlen) 4448 char __user *optval, int __user *optlen)
@@ -5602,22 +5293,6 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
5602 case SCTP_INITMSG: 5293 case SCTP_INITMSG:
5603 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen); 5294 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
5604 break; 5295 break;
5605 case SCTP_GET_PEER_ADDRS_NUM_OLD:
5606 retval = sctp_getsockopt_peer_addrs_num_old(sk, len, optval,
5607 optlen);
5608 break;
5609 case SCTP_GET_LOCAL_ADDRS_NUM_OLD:
5610 retval = sctp_getsockopt_local_addrs_num_old(sk, len, optval,
5611 optlen);
5612 break;
5613 case SCTP_GET_PEER_ADDRS_OLD:
5614 retval = sctp_getsockopt_peer_addrs_old(sk, len, optval,
5615 optlen);
5616 break;
5617 case SCTP_GET_LOCAL_ADDRS_OLD:
5618 retval = sctp_getsockopt_local_addrs_old(sk, len, optval,
5619 optlen);
5620 break;
5621 case SCTP_GET_PEER_ADDRS: 5296 case SCTP_GET_PEER_ADDRS:
5622 retval = sctp_getsockopt_peer_addrs(sk, len, optval, 5297 retval = sctp_getsockopt_peer_addrs(sk, len, optval,
5623 optlen); 5298 optlen);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-13 02:55:27 -0500