Merge branch 'for-2637/i2c/samsung' into next-i2c

[mv-sheeva.git] / net / phonet / socket.c

diff --git a/net/phonet/socket.c b/net/phonet/socket.c
index 4c29a23e900752f100bcbcbafc4764328eb0d430..25f746d20c1f2dcbf42826cf33f07a35e44ace1c 100644 (file)
--- a/net/phonet/socket.c
+++ b/net/phonet/socket.c
@@ -158,6 +158,7 @@ void pn_sock_unhash(struct sock *sk)
        spin_lock_bh(&pnsocks.lock);
        sk_del_node_init(sk);
        spin_unlock_bh(&pnsocks.lock);
+       pn_sock_unbind_all_res(sk);
 }
 EXPORT_SYMBOL(pn_sock_unhash);
 
@@ -224,6 +225,101 @@ static int pn_socket_autobind(struct socket *sock)
        return 0; /* socket was already bound */
 }
 
+#ifdef CONFIG_PHONET_PIPECTRLR
+static int pn_socket_connect(struct socket *sock, struct sockaddr *addr,
+               int len, int flags)
+{
+       struct sock *sk = sock->sk;
+       struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
+       long timeo;
+       int err;
+
+       if (len < sizeof(struct sockaddr_pn))
+               return -EINVAL;
+       if (spn->spn_family != AF_PHONET)
+               return -EAFNOSUPPORT;
+
+       lock_sock(sk);
+
+       switch (sock->state) {
+       case SS_UNCONNECTED:
+               sk->sk_state = TCP_CLOSE;
+               break;
+       case SS_CONNECTING:
+               switch (sk->sk_state) {
+               case TCP_SYN_RECV:
+                       sock->state = SS_CONNECTED;
+                       err = -EISCONN;
+                       goto out;
+               case TCP_CLOSE:
+                       err = -EALREADY;
+                       if (flags & O_NONBLOCK)
+                               goto out;
+                       goto wait_connect;
+               }
+               break;
+       case SS_CONNECTED:
+               switch (sk->sk_state) {
+               case TCP_SYN_RECV:
+                       err = -EISCONN;
+                       goto out;
+               case TCP_CLOSE:
+                       sock->state = SS_UNCONNECTED;
+                       break;
+               }
+               break;
+       case SS_DISCONNECTING:
+       case SS_FREE:
+               break;
+       }
+       sk->sk_state = TCP_CLOSE;
+       sk_stream_kill_queues(sk);
+
+       sock->state = SS_CONNECTING;
+       err = sk->sk_prot->connect(sk, addr, len);
+       if (err < 0) {
+               sock->state = SS_UNCONNECTED;
+               sk->sk_state = TCP_CLOSE;
+               goto out;
+       }
+
+       err = -EINPROGRESS;
+wait_connect:
+       if (sk->sk_state != TCP_SYN_RECV && (flags & O_NONBLOCK))
+               goto out;
+
+       timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
+       release_sock(sk);
+
+       err = -ERESTARTSYS;
+       timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
+                       sk->sk_state != TCP_CLOSE,
+                       timeo);
+
+       lock_sock(sk);
+       if (timeo < 0)
+               goto out; /* -ERESTARTSYS */
+
+       err = -ETIMEDOUT;
+       if (timeo == 0 && sk->sk_state != TCP_SYN_RECV)
+               goto out;
+
+       if (sk->sk_state != TCP_SYN_RECV) {
+               sock->state = SS_UNCONNECTED;
+               err = sock_error(sk);
+               if (!err)
+                       err = -ECONNREFUSED;
+               goto out;
+       }
+       sock->state = SS_CONNECTED;
+       err = 0;
+
+out:
+       release_sock(sk);
+       return err;
+}
+#endif
+
 static int pn_socket_accept(struct socket *sock, struct socket *newsock,
                                int flags)
 {
@@ -392,7 +488,11 @@ const struct proto_ops phonet_stream_ops = {
        .owner          = THIS_MODULE,
        .release        = pn_socket_release,
        .bind           = pn_socket_bind,
+#ifdef CONFIG_PHONET_PIPECTRLR
+       .connect        = pn_socket_connect,
+#else
        .connect        = sock_no_connect,
+#endif
        .socketpair     = sock_no_socketpair,
        .accept         = pn_socket_accept,
        .getname        = pn_socket_getname,
@@ -653,3 +753,100 @@ void pn_sock_unbind_all_res(struct sock *sk)
                match--;
        }
 }
+
+#ifdef CONFIG_PROC_FS
+static struct sock **pn_res_get_idx(struct seq_file *seq, loff_t pos)
+{
+       struct net *net = seq_file_net(seq);
+       unsigned i;
+
+       if (!net_eq(net, &init_net))
+               return NULL;
+
+       for (i = 0; i < 256; i++) {
+               if (pnres.sk[i] == NULL)
+                       continue;
+               if (!pos)
+                       return pnres.sk + i;
+               pos--;
+       }
+       return NULL;
+}
+
+static struct sock **pn_res_get_next(struct seq_file *seq, struct sock **sk)
+{
+       struct net *net = seq_file_net(seq);
+       unsigned i;
+
+       BUG_ON(!net_eq(net, &init_net));
+
+       for (i = (sk - pnres.sk) + 1; i < 256; i++)
+               if (pnres.sk[i])
+                       return pnres.sk + i;
+       return NULL;
+}
+
+static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos)
+       __acquires(resource_mutex)
+{
+       mutex_lock(&resource_mutex);
+       return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
+}
+
+static void *pn_res_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+       struct sock **sk;
+
+       if (v == SEQ_START_TOKEN)
+               sk = pn_res_get_idx(seq, 0);
+       else
+               sk = pn_res_get_next(seq, v);
+       (*pos)++;
+       return sk;
+}
+
+static void pn_res_seq_stop(struct seq_file *seq, void *v)
+       __releases(resource_mutex)
+{
+       mutex_unlock(&resource_mutex);
+}
+
+static int pn_res_seq_show(struct seq_file *seq, void *v)
+{
+       int len;
+
+       if (v == SEQ_START_TOKEN)
+               seq_printf(seq, "%s%n", "rs   uid inode", &len);
+       else {
+               struct sock **psk = v;
+               struct sock *sk = *psk;
+
+               seq_printf(seq, "%02X %5d %lu%n",
+                          (int) (psk - pnres.sk), sock_i_uid(sk),
+                          sock_i_ino(sk), &len);
+       }
+       seq_printf(seq, "%*s\n", 63 - len, "");
+       return 0;
+}
+
+static const struct seq_operations pn_res_seq_ops = {
+       .start = pn_res_seq_start,
+       .next = pn_res_seq_next,
+       .stop = pn_res_seq_stop,
+       .show = pn_res_seq_show,
+};
+
+static int pn_res_open(struct inode *inode, struct file *file)
+{
+       return seq_open_net(inode, file, &pn_res_seq_ops,
+                               sizeof(struct seq_net_private));
+}
+
+const struct file_operations pn_res_seq_fops = {
+       .owner = THIS_MODULE,
+       .open = pn_res_open,
+       .read = seq_read,
+       .llseek = seq_lseek,
+       .release = seq_release_net,
+};
+#endif