1 files changed, 483 insertions, 0 deletions

diff --git a/crypto/af_alg.c b/crypto/af_alg.c
new file mode 100644
index 000000000000..940d70cb5c25
--- /dev/null
+++ b/crypto/af_alg.c
@@ -0,0 +1,483 @@
+/*
+ * af_alg: User-space algorithm interface
+ *
+ * This file provides the user-space API for algorithms.
+ *
+ * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ */
+
+#include <asm/atomic.h>
+#include <crypto/if_alg.h>
+#include <linux/crypto.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/net.h>
+#include <linux/rwsem.h>
+
+struct alg_type_list {
+        const struct af_alg_type *type;
+        struct list_head list;
+};
+
+static atomic_long_t alg_memory_allocated;
+
+static struct proto alg_proto = {
+        .name                   = "ALG",
+        .owner                  = THIS_MODULE,
+        .memory_allocated       = &alg_memory_allocated,
+        .obj_size               = sizeof(struct alg_sock),
+};
+
+static LIST_HEAD(alg_types);
+static DECLARE_RWSEM(alg_types_sem);
+
+static const struct af_alg_type *alg_get_type(const char *name)
+{
+        const struct af_alg_type *type = ERR_PTR(-ENOENT);
+        struct alg_type_list *node;
+
+        down_read(&alg_types_sem);
+        list_for_each_entry(node, &alg_types, list) {
+                if (strcmp(node->type->name, name))
+                        continue;
+
+                if (try_module_get(node->type->owner))
+                        type = node->type;
+                break;
+        }
+        up_read(&alg_types_sem);
+
+        return type;
+}
+
+int af_alg_register_type(const struct af_alg_type *type)
+{
+        struct alg_type_list *node;
+        int err = -EEXIST;
+
+        down_write(&alg_types_sem);
+        list_for_each_entry(node, &alg_types, list) {
+                if (!strcmp(node->type->name, type->name))
+                        goto unlock;
+        }
+
+        node = kmalloc(sizeof(*node), GFP_KERNEL);
+        err = -ENOMEM;
+        if (!node)
+                goto unlock;
+
+        type->ops->owner = THIS_MODULE;
+        node->type = type;
+        list_add(&node->list, &alg_types);
+        err = 0;
+
+unlock:
+        up_write(&alg_types_sem);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(af_alg_register_type);
+
+int af_alg_unregister_type(const struct af_alg_type *type)
+{
+        struct alg_type_list *node;
+        int err = -ENOENT;
+
+        down_write(&alg_types_sem);
+        list_for_each_entry(node, &alg_types, list) {
+                if (strcmp(node->type->name, type->name))
+                        continue;
+
+                list_del(&node->list);
+                kfree(node);
+                err = 0;
+                break;
+        }
+        up_write(&alg_types_sem);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(af_alg_unregister_type);
+
+static void alg_do_release(const struct af_alg_type *type, void *private)
+{
+        if (!type)
+                return;
+
+        type->release(private);
+        module_put(type->owner);
+}
+
+int af_alg_release(struct socket *sock)
+{
+        if (sock->sk)
+                sock_put(sock->sk);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(af_alg_release);
+
+static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
+{
+        struct sock *sk = sock->sk;
+        struct alg_sock *ask = alg_sk(sk);
+        struct sockaddr_alg *sa = (void *)uaddr;
+        const struct af_alg_type *type;
+        void *private;
+
+        if (sock->state == SS_CONNECTED)
+                return -EINVAL;
+
+        if (addr_len != sizeof(*sa))
+                return -EINVAL;
+
+        sa->salg_type[sizeof(sa->salg_type) - 1] = 0;
+        sa->salg_name[sizeof(sa->salg_name) - 1] = 0;
+
+        type = alg_get_type(sa->salg_type);
+        if (IS_ERR(type) && PTR_ERR(type) == -ENOENT) {
+                request_module("algif-%s", sa->salg_type);
+                type = alg_get_type(sa->salg_type);
+        }
+
+        if (IS_ERR(type))
+                return PTR_ERR(type);
+
+        private = type->bind(sa->salg_name, sa->salg_feat, sa->salg_mask);
+        if (IS_ERR(private)) {
+                module_put(type->owner);
+                return PTR_ERR(private);
+        }
+
+        lock_sock(sk);
+
+        swap(ask->type, type);
+        swap(ask->private, private);
+
+        release_sock(sk);
+
+        alg_do_release(type, private);
+
+        return 0;
+}
+
+static int alg_setkey(struct sock *sk, char __user *ukey,
+                      unsigned int keylen)
+{
+        struct alg_sock *ask = alg_sk(sk);
+        const struct af_alg_type *type = ask->type;
+        u8 *key;
+        int err;
+
+        key = sock_kmalloc(sk, keylen, GFP_KERNEL);
+        if (!key)
+                return -ENOMEM;
+
+        err = -EFAULT;
+        if (copy_from_user(key, ukey, keylen))
+                goto out;
+
+        err = type->setkey(ask->private, key, keylen);
+
+out:
+        sock_kfree_s(sk, key, keylen);
+
+        return err;
+}
+
+static int alg_setsockopt(struct socket *sock, int level, int optname,
+                          char __user *optval, unsigned int optlen)
+{
+        struct sock *sk = sock->sk;
+        struct alg_sock *ask = alg_sk(sk);
+        const struct af_alg_type *type;
+        int err = -ENOPROTOOPT;
+
+        lock_sock(sk);
+        type = ask->type;
+
+        if (level != SOL_ALG || !type)
+                goto unlock;
+
+        switch (optname) {
+        case ALG_SET_KEY:
+                if (sock->state == SS_CONNECTED)
+                        goto unlock;
+                if (!type->setkey)
+                        goto unlock;
+
+                err = alg_setkey(sk, optval, optlen);
+        }
+
+unlock:
+        release_sock(sk);
+
+        return err;
+}
+
+int af_alg_accept(struct sock *sk, struct socket *newsock)
+{
+        struct alg_sock *ask = alg_sk(sk);
+        const struct af_alg_type *type;
+        struct sock *sk2;
+        int err;
+
+        lock_sock(sk);
+        type = ask->type;
+
+        err = -EINVAL;
+        if (!type)
+                goto unlock;
+
+        sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto);
+        err = -ENOMEM;
+        if (!sk2)
+                goto unlock;
+
+        sock_init_data(newsock, sk2);
+        sock_graft(sk2, newsock);
+
+        err = type->accept(ask->private, sk2);
+        if (err) {
+                sk_free(sk2);
+                goto unlock;
+        }
+
+        sk2->sk_family = PF_ALG;
+
+        sock_hold(sk);
+        alg_sk(sk2)->parent = sk;
+        alg_sk(sk2)->type = type;
+
+        newsock->ops = type->ops;
+        newsock->state = SS_CONNECTED;
+
+        err = 0;
+
+unlock:
+        release_sock(sk);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(af_alg_accept);
+
+static int alg_accept(struct socket *sock, struct socket *newsock, int flags)
+{
+        return af_alg_accept(sock->sk, newsock);
+}
+
+static const struct proto_ops alg_proto_ops = {
+        .family         =       PF_ALG,
+        .owner          =       THIS_MODULE,
+
+        .connect        =       sock_no_connect,
+        .socketpair     =       sock_no_socketpair,
+        .getname        =       sock_no_getname,
+        .ioctl          =       sock_no_ioctl,
+        .listen         =       sock_no_listen,
+        .shutdown       =       sock_no_shutdown,
+        .getsockopt     =       sock_no_getsockopt,
+        .mmap           =       sock_no_mmap,
+        .sendpage       =       sock_no_sendpage,
+        .sendmsg        =       sock_no_sendmsg,
+        .recvmsg        =       sock_no_recvmsg,
+        .poll           =       sock_no_poll,
+
+        .bind           =       alg_bind,
+        .release        =       af_alg_release,
+        .setsockopt     =       alg_setsockopt,
+        .accept         =       alg_accept,
+};
+
+static void alg_sock_destruct(struct sock *sk)
+{
+        struct alg_sock *ask = alg_sk(sk);
+
+        alg_do_release(ask->type, ask->private);
+}
+
+static int alg_create(struct net *net, struct socket *sock, int protocol,
+                      int kern)
+{
+        struct sock *sk;
+        int err;
+
+        if (sock->type != SOCK_SEQPACKET)
+                return -ESOCKTNOSUPPORT;
+        if (protocol != 0)
+                return -EPROTONOSUPPORT;
+
+        err = -ENOMEM;
+        sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto);
+        if (!sk)
+                goto out;
+
+        sock->ops = &alg_proto_ops;
+        sock_init_data(sock, sk);
+
+        sk->sk_family = PF_ALG;
+        sk->sk_destruct = alg_sock_destruct;
+
+        return 0;
+out:
+        return err;
+}
+
+static const struct net_proto_family alg_family = {
+        .family =       PF_ALG,
+        .create =       alg_create,
+        .owner  =       THIS_MODULE,
+};
+
+int af_alg_make_sg(struct af_alg_sgl *sgl, void __user *addr, int len,
+                   int write)
+{
+        unsigned long from = (unsigned long)addr;
+        unsigned long npages;
+        unsigned off;
+        int err;
+        int i;
+
+        err = -EFAULT;
+        if (!access_ok(write ? VERIFY_READ : VERIFY_WRITE, addr, len))
+                goto out;
+
+        off = from & ~PAGE_MASK;
+        npages = (off + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        if (npages > ALG_MAX_PAGES)
+                npages = ALG_MAX_PAGES;
+
+        err = get_user_pages_fast(from, npages, write, sgl->pages);
+        if (err < 0)
+                goto out;
+
+        npages = err;
+        err = -EINVAL;
+        if (WARN_ON(npages == 0))
+                goto out;
+
+        err = 0;
+
+        sg_init_table(sgl->sg, npages);
+
+        for (i = 0; i < npages; i++) {
+                int plen = min_t(int, len, PAGE_SIZE - off);
+
+                sg_set_page(sgl->sg + i, sgl->pages[i], plen, off);
+
+                off = 0;
+                len -= plen;
+                err += plen;
+        }
+
+out:
+        return err;
+}
+EXPORT_SYMBOL_GPL(af_alg_make_sg);
+
+void af_alg_free_sg(struct af_alg_sgl *sgl)
+{
+        int i;
+
+        i = 0;
+        do {
+                put_page(sgl->pages[i]);
+        } while (!sg_is_last(sgl->sg + (i++)));
+}
+EXPORT_SYMBOL_GPL(af_alg_free_sg);
+
+int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
+{
+        struct cmsghdr *cmsg;
+
+        for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
+                if (!CMSG_OK(msg, cmsg))
+                        return -EINVAL;
+                if (cmsg->cmsg_level != SOL_ALG)
+                        continue;
+
+                switch(cmsg->cmsg_type) {
+                case ALG_SET_IV:
+                        if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv)))
+                                return -EINVAL;
+                        con->iv = (void *)CMSG_DATA(cmsg);
+                        if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen +
+                                                      sizeof(*con->iv)))
+                                return -EINVAL;
+                        break;
+
+                case ALG_SET_OP:
+                        if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
+                                return -EINVAL;
+                        con->op = *(u32 *)CMSG_DATA(cmsg);
+                        break;
+
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
+
+int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
+{
+        switch (err) {
+        case -EINPROGRESS:
+        case -EBUSY:
+                wait_for_completion(&completion->completion);
+                INIT_COMPLETION(completion->completion);
+                err = completion->err;
+                break;
+        };
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
+
+void af_alg_complete(struct crypto_async_request *req, int err)
+{
+        struct af_alg_completion *completion = req->data;
+
+        completion->err = err;
+        complete(&completion->completion);
+}
+EXPORT_SYMBOL_GPL(af_alg_complete);
+
+static int __init af_alg_init(void)
+{
+        int err = proto_register(&alg_proto, 0);
+
+        if (err)
+                goto out;
+
+        err = sock_register(&alg_family);
+        if (err != 0)
+                goto out_unregister_proto;
+
+out:
+        return err;
+
+out_unregister_proto:
+        proto_unregister(&alg_proto);
+        goto out;
+}
+
+static void __exit af_alg_exit(void)
+{
+        sock_unregister(PF_ALG);
+        proto_unregister(&alg_proto);
+}
+
+module_init(af_alg_init);
+module_exit(af_alg_exit);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_NETPROTO(AF_ALG);