Merge commit 'v2.6.28-rc2' into x86/pci-ioapic-boot-irq-quirks

1 files changed, 248 insertions, 142 deletions

diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 63f131fc42e4..3e3fde7c1d2b 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -25,7 +25,7 @@
 
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/ptrace.h>
+#include <linux/tracehook.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/security.h>
@@ -75,6 +75,7 @@
 #include <linux/string.h>
 #include <linux/selinux.h>
 #include <linux/mutex.h>
+#include <linux/posix-timers.h>
 
 #include "avc.h"
 #include "objsec.h"
@@ -291,6 +292,7 @@ static void sk_free_security(struct sock *sk)
         struct sk_security_struct *ssec = sk->sk_security;
 
         sk->sk_security = NULL;
+        selinux_netlbl_sk_security_free(ssec);
         kfree(ssec);
 }
 
@@ -324,7 +326,7 @@ enum {
         Opt_rootcontext = 4,
 };
 
-static match_table_t tokens = {
+static const match_table_t tokens = {
         {Opt_context, CONTEXT_STR "%s"},
         {Opt_fscontext, FSCONTEXT_STR "%s"},
         {Opt_defcontext, DEFCONTEXT_STR "%s"},
@@ -957,7 +959,8 @@ out_err:
         return rc;
 }
 
-void selinux_write_opts(struct seq_file *m, struct security_mnt_opts *opts)
+static void selinux_write_opts(struct seq_file *m,
+                               struct security_mnt_opts *opts)
 {
         int i;
         char *prefix;
@@ -998,8 +1001,12 @@ static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb)
         int rc;
 
         rc = selinux_get_mnt_opts(sb, &opts);
-        if (rc)
+        if (rc) {
+                /* before policy load we may get EINVAL, don't show anything */
+                if (rc == -EINVAL)
+                        rc = 0;
                 return rc;
+        }
 
         selinux_write_opts(m, &opts);
 
@@ -1286,7 +1293,7 @@ static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dent
                 /* Default to the fs superblock SID. */
                 isec->sid = sbsec->sid;
 
-                if (sbsec->proc) {
+                if (sbsec->proc && !S_ISLNK(inode->i_mode)) {
                         struct proc_inode *proci = PROC_I(inode);
                         if (proci->pde) {
                                 isec->sclass = inode_mode_to_security_class(inode->i_mode);
@@ -1734,24 +1741,34 @@ static inline u32 file_to_av(struct file *file)
 
 /* Hook functions begin here. */
 
-static int selinux_ptrace(struct task_struct *parent,
-                          struct task_struct *child,
-                          unsigned int mode)
+static int selinux_ptrace_may_access(struct task_struct *child,
+                                     unsigned int mode)
 {
         int rc;
 
-        rc = secondary_ops->ptrace(parent, child, mode);
+        rc = secondary_ops->ptrace_may_access(child, mode);
         if (rc)
                 return rc;
 
         if (mode == PTRACE_MODE_READ) {
-                struct task_security_struct *tsec = parent->security;
+                struct task_security_struct *tsec = current->security;
                 struct task_security_struct *csec = child->security;
                 return avc_has_perm(tsec->sid, csec->sid,
                                     SECCLASS_FILE, FILE__READ, NULL);
         }
 
-        return task_has_perm(parent, child, PROCESS__PTRACE);
+        return task_has_perm(current, child, PROCESS__PTRACE);
+}
+
+static int selinux_ptrace_traceme(struct task_struct *parent)
+{
+        int rc;
+
+        rc = secondary_ops->ptrace_traceme(parent);
+        if (rc)
+                return rc;
+
+        return task_has_perm(parent, current, PROCESS__PTRACE);
 }
 
 static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
@@ -1971,22 +1988,6 @@ static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
         return __vm_enough_memory(mm, pages, cap_sys_admin);
 }
 
-/**
- * task_tracer_task - return the task that is tracing the given task
- * @task:               task to consider
- *
- * Returns NULL if noone is tracing @task, or the &struct task_struct
- * pointer to its tracer.
- *
- * Must be called under rcu_read_lock().
- */
-static struct task_struct *task_tracer_task(struct task_struct *task)
-{
-        if (task->ptrace & PT_PTRACED)
-                return rcu_dereference(task->parent);
-        return NULL;
-}
-
 /* binprm security operations */
 
 static int selinux_bprm_alloc_security(struct linux_binprm *bprm)
@@ -2122,7 +2123,6 @@ static inline void flush_unauthorized_files(struct files_struct *files)
         long j = -1;
         int drop_tty = 0;
 
-        mutex_lock(&tty_mutex);
         tty = get_current_tty();
         if (tty) {
                 file_list_lock();
@@ -2140,8 +2140,8 @@ static inline void flush_unauthorized_files(struct files_struct *files)
                         }
                 }
                 file_list_unlock();
+                tty_kref_put(tty);
         }
-        mutex_unlock(&tty_mutex);
         /* Reset controlling tty. */
         if (drop_tty)
                 no_tty();
@@ -2238,7 +2238,7 @@ static void selinux_bprm_apply_creds(struct linux_binprm *bprm, int unsafe)
                         u32 ptsid = 0;
 
                         rcu_read_lock();
-                        tracer = task_tracer_task(current);
+                        tracer = tracehook_tracer_task(current);
                         if (likely(tracer != NULL)) {
                                 sec = tracer->security;
                                 ptsid = sec->sid;
@@ -2323,13 +2323,7 @@ static void selinux_bprm_post_apply_creds(struct linux_binprm *bprm)
                         initrlim = init_task.signal->rlim+i;
                         rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
                 }
-                if (current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
-                        /*
-                         * This will cause RLIMIT_CPU calculations
-                         * to be refigured.
-                         */
-                        current->it_prof_expires = jiffies_to_cputime(1);
-                }
+                update_rlimit_cpu(rlim->rlim_cur);
         }
 
         /* Wake up the parent if it is waiting so that it can
@@ -2640,12 +2634,11 @@ static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *na
         return dentry_has_perm(current, NULL, dentry, FILE__READ);
 }
 
-static int selinux_inode_permission(struct inode *inode, int mask,
-                                    struct nameidata *nd)
+static int selinux_inode_permission(struct inode *inode, int mask)
 {
         int rc;
 
-        rc = secondary_ops->inode_permission(inode, mask, nd);
+        rc = secondary_ops->inode_permission(inode, mask);
         if (rc)
                 return rc;
 
@@ -3551,38 +3544,44 @@ out:
 #endif /* IPV6 */
 
 static int selinux_parse_skb(struct sk_buff *skb, struct avc_audit_data *ad,
-                             char **addrp, int src, u8 *proto)
+                             char **_addrp, int src, u8 *proto)
 {
-        int ret = 0;
+        char *addrp;
+        int ret;
 
         switch (ad->u.net.family) {
         case PF_INET:
                 ret = selinux_parse_skb_ipv4(skb, ad, proto);
-                if (ret || !addrp)
-                        break;
-                *addrp = (char *)(src ? &ad->u.net.v4info.saddr :
-                                        &ad->u.net.v4info.daddr);
-                break;
+                if (ret)
+                        goto parse_error;
+                addrp = (char *)(src ? &ad->u.net.v4info.saddr :
+                                       &ad->u.net.v4info.daddr);
+                goto okay;
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
         case PF_INET6:
                 ret = selinux_parse_skb_ipv6(skb, ad, proto);
-                if (ret || !addrp)
-                        break;
-                *addrp = (char *)(src ? &ad->u.net.v6info.saddr :
-                                        &ad->u.net.v6info.daddr);
-                break;
+                if (ret)
+                        goto parse_error;
+                addrp = (char *)(src ? &ad->u.net.v6info.saddr :
+                                       &ad->u.net.v6info.daddr);
+                goto okay;
 #endif  /* IPV6 */
         default:
-                break;
+                addrp = NULL;
+                goto okay;
         }
 
-        if (unlikely(ret))
-                printk(KERN_WARNING
-                       "SELinux: failure in selinux_parse_skb(),"
-                       " unable to parse packet\n");
-
+parse_error:
+        printk(KERN_WARNING
+               "SELinux: failure in selinux_parse_skb(),"
+               " unable to parse packet\n");
         return ret;
+
+okay:
+        if (_addrp)
+                *_addrp = addrp;
+        return 0;
 }
 
 /**
@@ -3797,6 +3796,7 @@ out:
 
 static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
 {
+        struct sock *sk = sock->sk;
         struct inode_security_struct *isec;
         int err;
 
@@ -3810,7 +3810,6 @@ static int selinux_socket_connect(struct socket *sock, struct sockaddr *address,
         isec = SOCK_INODE(sock)->i_security;
         if (isec->sclass == SECCLASS_TCP_SOCKET ||
             isec->sclass == SECCLASS_DCCP_SOCKET) {
-                struct sock *sk = sock->sk;
                 struct avc_audit_data ad;
                 struct sockaddr_in *addr4 = NULL;
                 struct sockaddr_in6 *addr6 = NULL;
@@ -3844,6 +3843,8 @@ static int selinux_socket_connect(struct socket *sock, struct sockaddr *address,
                         goto out;
         }
 
+        err = selinux_netlbl_socket_connect(sk, address);
+
 out:
         return err;
 }
@@ -4073,20 +4074,28 @@ static int selinux_sock_rcv_skb_iptables_compat(struct sock *sk,
 }
 
 static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
-                                       struct avc_audit_data *ad,
-                                       u16 family, char *addrp)
+                                       u16 family)
 {
         int err;
         struct sk_security_struct *sksec = sk->sk_security;
         u32 peer_sid;
         u32 sk_sid = sksec->sid;
+        struct avc_audit_data ad;
+        char *addrp;
+
+        AVC_AUDIT_DATA_INIT(&ad, NET);
+        ad.u.net.netif = skb->iif;
+        ad.u.net.family = family;
+        err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
+        if (err)
+                return err;
 
         if (selinux_compat_net)
-                err = selinux_sock_rcv_skb_iptables_compat(sk, skb, ad,
+                err = selinux_sock_rcv_skb_iptables_compat(sk, skb, &ad,
                                                            family, addrp);
         else
                 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
-                                   PACKET__RECV, ad);
+                                   PACKET__RECV, &ad);
         if (err)
                 return err;
 
@@ -4095,12 +4104,14 @@ static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
                 if (err)
                         return err;
                 err = avc_has_perm(sk_sid, peer_sid,
-                                   SECCLASS_PEER, PEER__RECV, ad);
+                                   SECCLASS_PEER, PEER__RECV, &ad);
+                if (err)
+                        selinux_netlbl_err(skb, err, 0);
         } else {
-                err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, ad);
+                err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad);
                 if (err)
                         return err;
-                err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, ad);
+                err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
         }
 
         return err;
@@ -4114,6 +4125,8 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
         u32 sk_sid = sksec->sid;
         struct avc_audit_data ad;
         char *addrp;
+        u8 secmark_active;
+        u8 peerlbl_active;
 
         if (family != PF_INET && family != PF_INET6)
                 return 0;
@@ -4122,6 +4135,18 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
                 family = PF_INET;
 
+        /* If any sort of compatibility mode is enabled then handoff processing
+         * to the selinux_sock_rcv_skb_compat() function to deal with the
+         * special handling.  We do this in an attempt to keep this function
+         * as fast and as clean as possible. */
+        if (selinux_compat_net || !selinux_policycap_netpeer)
+                return selinux_sock_rcv_skb_compat(sk, skb, family);
+
+        secmark_active = selinux_secmark_enabled();
+        peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
+        if (!secmark_active && !peerlbl_active)
+                return 0;
+
         AVC_AUDIT_DATA_INIT(&ad, NET);
         ad.u.net.netif = skb->iif;
         ad.u.net.family = family;
@@ -4129,15 +4154,7 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
         if (err)
                 return err;
 
-        /* If any sort of compatibility mode is enabled then handoff processing
-         * to the selinux_sock_rcv_skb_compat() function to deal with the
-         * special handling.  We do this in an attempt to keep this function
-         * as fast and as clean as possible. */
-        if (selinux_compat_net || !selinux_policycap_netpeer)
-                return selinux_sock_rcv_skb_compat(sk, skb, &ad,
-                                                   family, addrp);
-
-        if (netlbl_enabled() || selinux_xfrm_enabled()) {
+        if (peerlbl_active) {
                 u32 peer_sid;
 
                 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
@@ -4145,13 +4162,17 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
                         return err;
                 err = selinux_inet_sys_rcv_skb(skb->iif, addrp, family,
                                                peer_sid, &ad);
-                if (err)
+                if (err) {
+                        selinux_netlbl_err(skb, err, 0);
                         return err;
+                }
                 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
                                    PEER__RECV, &ad);
+                if (err)
+                        selinux_netlbl_err(skb, err, 0);
         }
 
-        if (selinux_secmark_enabled()) {
+        if (secmark_active) {
                 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
                                    PACKET__RECV, &ad);
                 if (err)
@@ -4210,10 +4231,12 @@ static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *
         u32 peer_secid = SECSID_NULL;
         u16 family;
 
-        if (sock)
+        if (skb && skb->protocol == htons(ETH_P_IP))
+                family = PF_INET;
+        else if (skb && skb->protocol == htons(ETH_P_IPV6))
+                family = PF_INET6;
+        else if (sock)
                 family = sock->sk->sk_family;
-        else if (skb && skb->sk)
-                family = skb->sk->sk_family;
         else
                 goto out;
 
@@ -4271,8 +4294,6 @@ static void selinux_sock_graft(struct sock *sk, struct socket *parent)
             sk->sk_family == PF_UNIX)
                 isec->sid = sksec->sid;
         sksec->sclass = isec->sclass;
-
-        selinux_netlbl_sock_graft(sk, parent);
 }
 
 static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
@@ -4280,10 +4301,15 @@ static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
 {
         struct sk_security_struct *sksec = sk->sk_security;
         int err;
+        u16 family = sk->sk_family;
         u32 newsid;
         u32 peersid;
 
-        err = selinux_skb_peerlbl_sid(skb, sk->sk_family, &peersid);
+        /* handle mapped IPv4 packets arriving via IPv6 sockets */
+        if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
+                family = PF_INET;
+
+        err = selinux_skb_peerlbl_sid(skb, family, &peersid);
         if (err)
                 return err;
         if (peersid == SECSID_NULL) {
@@ -4318,12 +4344,18 @@ static void selinux_inet_csk_clone(struct sock *newsk,
         selinux_netlbl_sk_security_reset(newsksec, req->rsk_ops->family);
 }
 
-static void selinux_inet_conn_established(struct sock *sk,
-                                struct sk_buff *skb)
+static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
 {
+        u16 family = sk->sk_family;
         struct sk_security_struct *sksec = sk->sk_security;
 
-        selinux_skb_peerlbl_sid(skb, sk->sk_family, &sksec->peer_sid);
+        /* handle mapped IPv4 packets arriving via IPv6 sockets */
+        if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
+                family = PF_INET;
+
+        selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid);
+
+        selinux_netlbl_inet_conn_established(sk, family);
 }
 
 static void selinux_req_classify_flow(const struct request_sock *req,
@@ -4373,39 +4405,54 @@ out:
 static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
                                        u16 family)
 {
+        int err;
         char *addrp;
         u32 peer_sid;
         struct avc_audit_data ad;
         u8 secmark_active;
+        u8 netlbl_active;
         u8 peerlbl_active;
 
         if (!selinux_policycap_netpeer)
                 return NF_ACCEPT;
 
         secmark_active = selinux_secmark_enabled();
-        peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
+        netlbl_active = netlbl_enabled();
+        peerlbl_active = netlbl_active || selinux_xfrm_enabled();
         if (!secmark_active && !peerlbl_active)
                 return NF_ACCEPT;
 
+        if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
+                return NF_DROP;
+
         AVC_AUDIT_DATA_INIT(&ad, NET);
         ad.u.net.netif = ifindex;
         ad.u.net.family = family;
         if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0)
                 return NF_DROP;
 
-        if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
-                return NF_DROP;
-
-        if (peerlbl_active)
-                if (selinux_inet_sys_rcv_skb(ifindex, addrp, family,
-                                             peer_sid, &ad) != 0)
+        if (peerlbl_active) {
+                err = selinux_inet_sys_rcv_skb(ifindex, addrp, family,
+                                               peer_sid, &ad);
+                if (err) {
+                        selinux_netlbl_err(skb, err, 1);
                         return NF_DROP;
+                }
+        }
 
         if (secmark_active)
                 if (avc_has_perm(peer_sid, skb->secmark,
                                  SECCLASS_PACKET, PACKET__FORWARD_IN, &ad))
                         return NF_DROP;
 
+        if (netlbl_active)
+                /* we do this in the FORWARD path and not the POST_ROUTING
+                 * path because we want to make sure we apply the necessary
+                 * labeling before IPsec is applied so we can leverage AH
+                 * protection */
+                if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0)
+                        return NF_DROP;
+
         return NF_ACCEPT;
 }
 
@@ -4429,6 +4476,37 @@ static unsigned int selinux_ipv6_forward(unsigned int hooknum,
 }
 #endif  /* IPV6 */
 
+static unsigned int selinux_ip_output(struct sk_buff *skb,
+                                      u16 family)
+{
+        u32 sid;
+
+        if (!netlbl_enabled())
+                return NF_ACCEPT;
+
+        /* we do this in the LOCAL_OUT path and not the POST_ROUTING path
+         * because we want to make sure we apply the necessary labeling
+         * before IPsec is applied so we can leverage AH protection */
+        if (skb->sk) {
+                struct sk_security_struct *sksec = skb->sk->sk_security;
+                sid = sksec->sid;
+        } else
+                sid = SECINITSID_KERNEL;
+        if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0)
+                return NF_DROP;
+
+        return NF_ACCEPT;
+}
+
+static unsigned int selinux_ipv4_output(unsigned int hooknum,
+                                        struct sk_buff *skb,
+                                        const struct net_device *in,
+                                        const struct net_device *out,
+                                        int (*okfn)(struct sk_buff *))
+{
+        return selinux_ip_output(skb, PF_INET);
+}
+
 static int selinux_ip_postroute_iptables_compat(struct sock *sk,
                                                 int ifindex,
                                                 struct avc_audit_data *ad,
@@ -4496,30 +4574,36 @@ static int selinux_ip_postroute_iptables_compat(struct sock *sk,
 
 static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb,
                                                 int ifindex,
-                                                struct avc_audit_data *ad,
-                                                u16 family,
-                                                char *addrp,
-                                                u8 proto)
+                                                u16 family)
 {
         struct sock *sk = skb->sk;
         struct sk_security_struct *sksec;
+        struct avc_audit_data ad;
+        char *addrp;
+        u8 proto;
 
         if (sk == NULL)
                 return NF_ACCEPT;
         sksec = sk->sk_security;
 
+        AVC_AUDIT_DATA_INIT(&ad, NET);
+        ad.u.net.netif = ifindex;
+        ad.u.net.family = family;
+        if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
+                return NF_DROP;
+
         if (selinux_compat_net) {
                 if (selinux_ip_postroute_iptables_compat(skb->sk, ifindex,
-                                                         ad, family, addrp))
+                                                         &ad, family, addrp))
                         return NF_DROP;
         } else {
                 if (avc_has_perm(sksec->sid, skb->secmark,
-                                 SECCLASS_PACKET, PACKET__SEND, ad))
+                                 SECCLASS_PACKET, PACKET__SEND, &ad))
                         return NF_DROP;
         }
 
         if (selinux_policycap_netpeer)
-                if (selinux_xfrm_postroute_last(sksec->sid, skb, ad, proto))
+                if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto))
                         return NF_DROP;
 
         return NF_ACCEPT;
@@ -4533,23 +4617,15 @@ static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
         struct sock *sk;
         struct avc_audit_data ad;
         char *addrp;
-        u8 proto;
         u8 secmark_active;
         u8 peerlbl_active;
 
-        AVC_AUDIT_DATA_INIT(&ad, NET);
-        ad.u.net.netif = ifindex;
-        ad.u.net.family = family;
-        if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
-                return NF_DROP;
-
         /* If any sort of compatibility mode is enabled then handoff processing
          * to the selinux_ip_postroute_compat() function to deal with the
          * special handling.  We do this in an attempt to keep this function
          * as fast and as clean as possible. */
         if (selinux_compat_net || !selinux_policycap_netpeer)
-                return selinux_ip_postroute_compat(skb, ifindex, &ad,
-                                                   family, addrp, proto);
+                return selinux_ip_postroute_compat(skb, ifindex, family);
 
         /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec
          * packet transformation so allow the packet to pass without any checks
@@ -4565,21 +4641,45 @@ static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
         if (!secmark_active && !peerlbl_active)
                 return NF_ACCEPT;
 
-        /* if the packet is locally generated (skb->sk != NULL) then use the
-         * socket's label as the peer label, otherwise the packet is being
-         * forwarded through this system and we need to fetch the peer label
-         * directly from the packet */
+        /* if the packet is being forwarded then get the peer label from the
+         * packet itself; otherwise check to see if it is from a local
+         * application or the kernel, if from an application get the peer label
+         * from the sending socket, otherwise use the kernel's sid */
         sk = skb->sk;
-        if (sk) {
+        if (sk == NULL) {
+                switch (family) {
+                case PF_INET:
+                        if (IPCB(skb)->flags & IPSKB_FORWARDED)
+                                secmark_perm = PACKET__FORWARD_OUT;
+                        else
+                                secmark_perm = PACKET__SEND;
+                        break;
+                case PF_INET6:
+                        if (IP6CB(skb)->flags & IP6SKB_FORWARDED)
+                                secmark_perm = PACKET__FORWARD_OUT;
+                        else
+                                secmark_perm = PACKET__SEND;
+                        break;
+                default:
+                        return NF_DROP;
+                }
+                if (secmark_perm == PACKET__FORWARD_OUT) {
+                        if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
+                                return NF_DROP;
+                } else
+                        peer_sid = SECINITSID_KERNEL;
+        } else {
                 struct sk_security_struct *sksec = sk->sk_security;
                 peer_sid = sksec->sid;
                 secmark_perm = PACKET__SEND;
-        } else {
-                if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
-                                return NF_DROP;
-                secmark_perm = PACKET__FORWARD_OUT;
         }
 
+        AVC_AUDIT_DATA_INIT(&ad, NET);
+        ad.u.net.netif = ifindex;
+        ad.u.net.family = family;
+        if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL))
+                return NF_DROP;
+
         if (secmark_active)
                 if (avc_has_perm(peer_sid, skb->secmark,
                                  SECCLASS_PACKET, secmark_perm, &ad))
@@ -5222,8 +5322,12 @@ static int selinux_setprocattr(struct task_struct *p,
 
                 if (sid == 0)
                         return -EINVAL;
-
-                /* Only allow single threaded processes to change context */
+                /*
+                 * SELinux allows to change context in the following case only.
+                 *  - Single threaded processes.
+                 *  - Multi threaded processes intend to change its context into
+                 *    more restricted domain (defined by TYPEBOUNDS statement).
+                 */
                 if (atomic_read(&p->mm->mm_users) != 1) {
                         struct task_struct *g, *t;
                         struct mm_struct *mm = p->mm;
@@ -5231,11 +5335,16 @@ static int selinux_setprocattr(struct task_struct *p,
                         do_each_thread(g, t) {
                                 if (t->mm == mm && t != p) {
                                         read_unlock(&tasklist_lock);
-                                        return -EPERM;
+                                        error = security_bounded_transition(tsec->sid, sid);
+                                        if (!error)
+                                                goto boundary_ok;
+
+                                        return error;
                                 }
                         } while_each_thread(g, t);
                         read_unlock(&tasklist_lock);
                 }
+boundary_ok:
 
                 /* Check permissions for the transition. */
                 error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
@@ -5247,7 +5356,7 @@ static int selinux_setprocattr(struct task_struct *p,
                    Otherwise, leave SID unchanged and fail. */
                 task_lock(p);
                 rcu_read_lock();
-                tracer = task_tracer_task(p);
+                tracer = tracehook_tracer_task(p);
                 if (tracer != NULL) {
                         struct task_security_struct *ptsec = tracer->security;
                         u32 ptsid = ptsec->sid;
@@ -5359,7 +5468,8 @@ static int selinux_key_getsecurity(struct key *key, char **_buffer)
 static struct security_operations selinux_ops = {
         .name =                         "selinux",
 
-        .ptrace =                       selinux_ptrace,
+        .ptrace_may_access =            selinux_ptrace_may_access,
+        .ptrace_traceme =               selinux_ptrace_traceme,
         .capget =                       selinux_capget,
         .capset_check =                 selinux_capset_check,
         .capset_set =                   selinux_capset_set,
@@ -5643,6 +5753,13 @@ static struct nf_hook_ops selinux_ipv4_ops[] = {
                 .pf =           PF_INET,
                 .hooknum =      NF_INET_FORWARD,
                 .priority =     NF_IP_PRI_SELINUX_FIRST,
+        },
+        {
+                .hook =         selinux_ipv4_output,
+                .owner =        THIS_MODULE,
+                .pf =           PF_INET,
+                .hooknum =      NF_INET_LOCAL_OUT,
+                .priority =     NF_IP_PRI_SELINUX_FIRST,
         }
 };
 
@@ -5670,27 +5787,20 @@ static struct nf_hook_ops selinux_ipv6_ops[] = {
 static int __init selinux_nf_ip_init(void)
 {
         int err = 0;
-        u32 iter;
 
         if (!selinux_enabled)
                 goto out;
 
         printk(KERN_DEBUG "SELinux:  Registering netfilter hooks\n");
 
-        for (iter = 0; iter < ARRAY_SIZE(selinux_ipv4_ops); iter++) {
-                err = nf_register_hook(&selinux_ipv4_ops[iter]);
-                if (err)
-                        panic("SELinux: nf_register_hook for IPv4: error %d\n",
-                              err);
-        }
+        err = nf_register_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
+        if (err)
+                panic("SELinux: nf_register_hooks for IPv4: error %d\n", err);
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-        for (iter = 0; iter < ARRAY_SIZE(selinux_ipv6_ops); iter++) {
-                err = nf_register_hook(&selinux_ipv6_ops[iter]);
-                if (err)
-                        panic("SELinux: nf_register_hook for IPv6: error %d\n",
-                              err);
-        }
+        err = nf_register_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
+        if (err)
+                panic("SELinux: nf_register_hooks for IPv6: error %d\n", err);
 #endif  /* IPV6 */
 
 out:
@@ -5702,15 +5812,11 @@ __initcall(selinux_nf_ip_init);
 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
 static void selinux_nf_ip_exit(void)
 {
-        u32 iter;
-
         printk(KERN_DEBUG "SELinux:  Unregistering netfilter hooks\n");
 
-        for (iter = 0; iter < ARRAY_SIZE(selinux_ipv4_ops); iter++)
-                nf_unregister_hook(&selinux_ipv4_ops[iter]);
+        nf_unregister_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-        for (iter = 0; iter < ARRAY_SIZE(selinux_ipv6_ops); iter++)
-                nf_unregister_hook(&selinux_ipv6_ops[iter]);
+        nf_unregister_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
 #endif  /* IPV6 */
 }
 #endif