Merge remote-tracking branch 'regulator/topic/vctrl' into regulator-next
[linux-2.6-microblaze.git] / crypto / algif_skcipher.c
1 /*
2  * algif_skcipher: User-space interface for skcipher algorithms
3  *
4  * This file provides the user-space API for symmetric key ciphers.
5  *
6  * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the Free
10  * Software Foundation; either version 2 of the License, or (at your option)
11  * any later version.
12  *
13  */
14
15 #include <crypto/scatterwalk.h>
16 #include <crypto/skcipher.h>
17 #include <crypto/if_alg.h>
18 #include <linux/init.h>
19 #include <linux/list.h>
20 #include <linux/kernel.h>
21 #include <linux/sched/signal.h>
22 #include <linux/mm.h>
23 #include <linux/module.h>
24 #include <linux/net.h>
25 #include <net/sock.h>
26
27 struct skcipher_sg_list {
28         struct list_head list;
29
30         int cur;
31
32         struct scatterlist sg[0];
33 };
34
35 struct skcipher_tfm {
36         struct crypto_skcipher *skcipher;
37         bool has_key;
38 };
39
40 struct skcipher_ctx {
41         struct list_head tsgl;
42         struct af_alg_sgl rsgl;
43
44         void *iv;
45
46         struct af_alg_completion completion;
47
48         atomic_t inflight;
49         size_t used;
50
51         unsigned int len;
52         bool more;
53         bool merge;
54         bool enc;
55
56         struct skcipher_request req;
57 };
58
59 struct skcipher_async_rsgl {
60         struct af_alg_sgl sgl;
61         struct list_head list;
62 };
63
64 struct skcipher_async_req {
65         struct kiocb *iocb;
66         struct skcipher_async_rsgl first_sgl;
67         struct list_head list;
68         struct scatterlist *tsg;
69         atomic_t *inflight;
70         struct skcipher_request req;
71 };
72
73 #define MAX_SGL_ENTS ((4096 - sizeof(struct skcipher_sg_list)) / \
74                       sizeof(struct scatterlist) - 1)
75
76 static void skcipher_free_async_sgls(struct skcipher_async_req *sreq)
77 {
78         struct skcipher_async_rsgl *rsgl, *tmp;
79         struct scatterlist *sgl;
80         struct scatterlist *sg;
81         int i, n;
82
83         list_for_each_entry_safe(rsgl, tmp, &sreq->list, list) {
84                 af_alg_free_sg(&rsgl->sgl);
85                 if (rsgl != &sreq->first_sgl)
86                         kfree(rsgl);
87         }
88         sgl = sreq->tsg;
89         n = sg_nents(sgl);
90         for_each_sg(sgl, sg, n, i)
91                 put_page(sg_page(sg));
92
93         kfree(sreq->tsg);
94 }
95
96 static void skcipher_async_cb(struct crypto_async_request *req, int err)
97 {
98         struct skcipher_async_req *sreq = req->data;
99         struct kiocb *iocb = sreq->iocb;
100
101         atomic_dec(sreq->inflight);
102         skcipher_free_async_sgls(sreq);
103         kzfree(sreq);
104         iocb->ki_complete(iocb, err, err);
105 }
106
107 static inline int skcipher_sndbuf(struct sock *sk)
108 {
109         struct alg_sock *ask = alg_sk(sk);
110         struct skcipher_ctx *ctx = ask->private;
111
112         return max_t(int, max_t(int, sk->sk_sndbuf & PAGE_MASK, PAGE_SIZE) -
113                           ctx->used, 0);
114 }
115
116 static inline bool skcipher_writable(struct sock *sk)
117 {
118         return PAGE_SIZE <= skcipher_sndbuf(sk);
119 }
120
121 static int skcipher_alloc_sgl(struct sock *sk)
122 {
123         struct alg_sock *ask = alg_sk(sk);
124         struct skcipher_ctx *ctx = ask->private;
125         struct skcipher_sg_list *sgl;
126         struct scatterlist *sg = NULL;
127
128         sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
129         if (!list_empty(&ctx->tsgl))
130                 sg = sgl->sg;
131
132         if (!sg || sgl->cur >= MAX_SGL_ENTS) {
133                 sgl = sock_kmalloc(sk, sizeof(*sgl) +
134                                        sizeof(sgl->sg[0]) * (MAX_SGL_ENTS + 1),
135                                    GFP_KERNEL);
136                 if (!sgl)
137                         return -ENOMEM;
138
139                 sg_init_table(sgl->sg, MAX_SGL_ENTS + 1);
140                 sgl->cur = 0;
141
142                 if (sg)
143                         sg_chain(sg, MAX_SGL_ENTS + 1, sgl->sg);
144
145                 list_add_tail(&sgl->list, &ctx->tsgl);
146         }
147
148         return 0;
149 }
150
151 static void skcipher_pull_sgl(struct sock *sk, size_t used, int put)
152 {
153         struct alg_sock *ask = alg_sk(sk);
154         struct skcipher_ctx *ctx = ask->private;
155         struct skcipher_sg_list *sgl;
156         struct scatterlist *sg;
157         int i;
158
159         while (!list_empty(&ctx->tsgl)) {
160                 sgl = list_first_entry(&ctx->tsgl, struct skcipher_sg_list,
161                                        list);
162                 sg = sgl->sg;
163
164                 for (i = 0; i < sgl->cur; i++) {
165                         size_t plen = min_t(size_t, used, sg[i].length);
166
167                         if (!sg_page(sg + i))
168                                 continue;
169
170                         sg[i].length -= plen;
171                         sg[i].offset += plen;
172
173                         used -= plen;
174                         ctx->used -= plen;
175
176                         if (sg[i].length)
177                                 return;
178                         if (put)
179                                 put_page(sg_page(sg + i));
180                         sg_assign_page(sg + i, NULL);
181                 }
182
183                 list_del(&sgl->list);
184                 sock_kfree_s(sk, sgl,
185                              sizeof(*sgl) + sizeof(sgl->sg[0]) *
186                                             (MAX_SGL_ENTS + 1));
187         }
188
189         if (!ctx->used)
190                 ctx->merge = 0;
191 }
192
193 static void skcipher_free_sgl(struct sock *sk)
194 {
195         struct alg_sock *ask = alg_sk(sk);
196         struct skcipher_ctx *ctx = ask->private;
197
198         skcipher_pull_sgl(sk, ctx->used, 1);
199 }
200
201 static int skcipher_wait_for_wmem(struct sock *sk, unsigned flags)
202 {
203         DEFINE_WAIT_FUNC(wait, woken_wake_function);
204         int err = -ERESTARTSYS;
205         long timeout;
206
207         if (flags & MSG_DONTWAIT)
208                 return -EAGAIN;
209
210         sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
211
212         add_wait_queue(sk_sleep(sk), &wait);
213         for (;;) {
214                 if (signal_pending(current))
215                         break;
216                 timeout = MAX_SCHEDULE_TIMEOUT;
217                 if (sk_wait_event(sk, &timeout, skcipher_writable(sk), &wait)) {
218                         err = 0;
219                         break;
220                 }
221         }
222         remove_wait_queue(sk_sleep(sk), &wait);
223
224         return err;
225 }
226
227 static void skcipher_wmem_wakeup(struct sock *sk)
228 {
229         struct socket_wq *wq;
230
231         if (!skcipher_writable(sk))
232                 return;
233
234         rcu_read_lock();
235         wq = rcu_dereference(sk->sk_wq);
236         if (skwq_has_sleeper(wq))
237                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
238                                                            POLLRDNORM |
239                                                            POLLRDBAND);
240         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
241         rcu_read_unlock();
242 }
243
244 static int skcipher_wait_for_data(struct sock *sk, unsigned flags)
245 {
246         DEFINE_WAIT_FUNC(wait, woken_wake_function);
247         struct alg_sock *ask = alg_sk(sk);
248         struct skcipher_ctx *ctx = ask->private;
249         long timeout;
250         int err = -ERESTARTSYS;
251
252         if (flags & MSG_DONTWAIT) {
253                 return -EAGAIN;
254         }
255
256         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
257
258         add_wait_queue(sk_sleep(sk), &wait);
259         for (;;) {
260                 if (signal_pending(current))
261                         break;
262                 timeout = MAX_SCHEDULE_TIMEOUT;
263                 if (sk_wait_event(sk, &timeout, ctx->used, &wait)) {
264                         err = 0;
265                         break;
266                 }
267         }
268         remove_wait_queue(sk_sleep(sk), &wait);
269
270         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
271
272         return err;
273 }
274
275 static void skcipher_data_wakeup(struct sock *sk)
276 {
277         struct alg_sock *ask = alg_sk(sk);
278         struct skcipher_ctx *ctx = ask->private;
279         struct socket_wq *wq;
280
281         if (!ctx->used)
282                 return;
283
284         rcu_read_lock();
285         wq = rcu_dereference(sk->sk_wq);
286         if (skwq_has_sleeper(wq))
287                 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
288                                                            POLLRDNORM |
289                                                            POLLRDBAND);
290         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
291         rcu_read_unlock();
292 }
293
294 static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
295                             size_t size)
296 {
297         struct sock *sk = sock->sk;
298         struct alg_sock *ask = alg_sk(sk);
299         struct sock *psk = ask->parent;
300         struct alg_sock *pask = alg_sk(psk);
301         struct skcipher_ctx *ctx = ask->private;
302         struct skcipher_tfm *skc = pask->private;
303         struct crypto_skcipher *tfm = skc->skcipher;
304         unsigned ivsize = crypto_skcipher_ivsize(tfm);
305         struct skcipher_sg_list *sgl;
306         struct af_alg_control con = {};
307         long copied = 0;
308         bool enc = 0;
309         bool init = 0;
310         int err;
311         int i;
312
313         if (msg->msg_controllen) {
314                 err = af_alg_cmsg_send(msg, &con);
315                 if (err)
316                         return err;
317
318                 init = 1;
319                 switch (con.op) {
320                 case ALG_OP_ENCRYPT:
321                         enc = 1;
322                         break;
323                 case ALG_OP_DECRYPT:
324                         enc = 0;
325                         break;
326                 default:
327                         return -EINVAL;
328                 }
329
330                 if (con.iv && con.iv->ivlen != ivsize)
331                         return -EINVAL;
332         }
333
334         err = -EINVAL;
335
336         lock_sock(sk);
337         if (!ctx->more && ctx->used)
338                 goto unlock;
339
340         if (init) {
341                 ctx->enc = enc;
342                 if (con.iv)
343                         memcpy(ctx->iv, con.iv->iv, ivsize);
344         }
345
346         while (size) {
347                 struct scatterlist *sg;
348                 unsigned long len = size;
349                 size_t plen;
350
351                 if (ctx->merge) {
352                         sgl = list_entry(ctx->tsgl.prev,
353                                          struct skcipher_sg_list, list);
354                         sg = sgl->sg + sgl->cur - 1;
355                         len = min_t(unsigned long, len,
356                                     PAGE_SIZE - sg->offset - sg->length);
357
358                         err = memcpy_from_msg(page_address(sg_page(sg)) +
359                                               sg->offset + sg->length,
360                                               msg, len);
361                         if (err)
362                                 goto unlock;
363
364                         sg->length += len;
365                         ctx->merge = (sg->offset + sg->length) &
366                                      (PAGE_SIZE - 1);
367
368                         ctx->used += len;
369                         copied += len;
370                         size -= len;
371                         continue;
372                 }
373
374                 if (!skcipher_writable(sk)) {
375                         err = skcipher_wait_for_wmem(sk, msg->msg_flags);
376                         if (err)
377                                 goto unlock;
378                 }
379
380                 len = min_t(unsigned long, len, skcipher_sndbuf(sk));
381
382                 err = skcipher_alloc_sgl(sk);
383                 if (err)
384                         goto unlock;
385
386                 sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
387                 sg = sgl->sg;
388                 if (sgl->cur)
389                         sg_unmark_end(sg + sgl->cur - 1);
390                 do {
391                         i = sgl->cur;
392                         plen = min_t(size_t, len, PAGE_SIZE);
393
394                         sg_assign_page(sg + i, alloc_page(GFP_KERNEL));
395                         err = -ENOMEM;
396                         if (!sg_page(sg + i))
397                                 goto unlock;
398
399                         err = memcpy_from_msg(page_address(sg_page(sg + i)),
400                                               msg, plen);
401                         if (err) {
402                                 __free_page(sg_page(sg + i));
403                                 sg_assign_page(sg + i, NULL);
404                                 goto unlock;
405                         }
406
407                         sg[i].length = plen;
408                         len -= plen;
409                         ctx->used += plen;
410                         copied += plen;
411                         size -= plen;
412                         sgl->cur++;
413                 } while (len && sgl->cur < MAX_SGL_ENTS);
414
415                 if (!size)
416                         sg_mark_end(sg + sgl->cur - 1);
417
418                 ctx->merge = plen & (PAGE_SIZE - 1);
419         }
420
421         err = 0;
422
423         ctx->more = msg->msg_flags & MSG_MORE;
424
425 unlock:
426         skcipher_data_wakeup(sk);
427         release_sock(sk);
428
429         return copied ?: err;
430 }
431
432 static ssize_t skcipher_sendpage(struct socket *sock, struct page *page,
433                                  int offset, size_t size, int flags)
434 {
435         struct sock *sk = sock->sk;
436         struct alg_sock *ask = alg_sk(sk);
437         struct skcipher_ctx *ctx = ask->private;
438         struct skcipher_sg_list *sgl;
439         int err = -EINVAL;
440
441         if (flags & MSG_SENDPAGE_NOTLAST)
442                 flags |= MSG_MORE;
443
444         lock_sock(sk);
445         if (!ctx->more && ctx->used)
446                 goto unlock;
447
448         if (!size)
449                 goto done;
450
451         if (!skcipher_writable(sk)) {
452                 err = skcipher_wait_for_wmem(sk, flags);
453                 if (err)
454                         goto unlock;
455         }
456
457         err = skcipher_alloc_sgl(sk);
458         if (err)
459                 goto unlock;
460
461         ctx->merge = 0;
462         sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
463
464         if (sgl->cur)
465                 sg_unmark_end(sgl->sg + sgl->cur - 1);
466
467         sg_mark_end(sgl->sg + sgl->cur);
468         get_page(page);
469         sg_set_page(sgl->sg + sgl->cur, page, size, offset);
470         sgl->cur++;
471         ctx->used += size;
472
473 done:
474         ctx->more = flags & MSG_MORE;
475
476 unlock:
477         skcipher_data_wakeup(sk);
478         release_sock(sk);
479
480         return err ?: size;
481 }
482
483 static int skcipher_all_sg_nents(struct skcipher_ctx *ctx)
484 {
485         struct skcipher_sg_list *sgl;
486         struct scatterlist *sg;
487         int nents = 0;
488
489         list_for_each_entry(sgl, &ctx->tsgl, list) {
490                 sg = sgl->sg;
491
492                 while (!sg->length)
493                         sg++;
494
495                 nents += sg_nents(sg);
496         }
497         return nents;
498 }
499
500 static int skcipher_recvmsg_async(struct socket *sock, struct msghdr *msg,
501                                   int flags)
502 {
503         struct sock *sk = sock->sk;
504         struct alg_sock *ask = alg_sk(sk);
505         struct sock *psk = ask->parent;
506         struct alg_sock *pask = alg_sk(psk);
507         struct skcipher_ctx *ctx = ask->private;
508         struct skcipher_tfm *skc = pask->private;
509         struct crypto_skcipher *tfm = skc->skcipher;
510         struct skcipher_sg_list *sgl;
511         struct scatterlist *sg;
512         struct skcipher_async_req *sreq;
513         struct skcipher_request *req;
514         struct skcipher_async_rsgl *last_rsgl = NULL;
515         unsigned int txbufs = 0, len = 0, tx_nents;
516         unsigned int reqsize = crypto_skcipher_reqsize(tfm);
517         unsigned int ivsize = crypto_skcipher_ivsize(tfm);
518         int err = -ENOMEM;
519         bool mark = false;
520         char *iv;
521
522         sreq = kzalloc(sizeof(*sreq) + reqsize + ivsize, GFP_KERNEL);
523         if (unlikely(!sreq))
524                 goto out;
525
526         req = &sreq->req;
527         iv = (char *)(req + 1) + reqsize;
528         sreq->iocb = msg->msg_iocb;
529         INIT_LIST_HEAD(&sreq->list);
530         sreq->inflight = &ctx->inflight;
531
532         lock_sock(sk);
533         tx_nents = skcipher_all_sg_nents(ctx);
534         sreq->tsg = kcalloc(tx_nents, sizeof(*sg), GFP_KERNEL);
535         if (unlikely(!sreq->tsg))
536                 goto unlock;
537         sg_init_table(sreq->tsg, tx_nents);
538         memcpy(iv, ctx->iv, ivsize);
539         skcipher_request_set_tfm(req, tfm);
540         skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
541                                       skcipher_async_cb, sreq);
542
543         while (iov_iter_count(&msg->msg_iter)) {
544                 struct skcipher_async_rsgl *rsgl;
545                 int used;
546
547                 if (!ctx->used) {
548                         err = skcipher_wait_for_data(sk, flags);
549                         if (err)
550                                 goto free;
551                 }
552                 sgl = list_first_entry(&ctx->tsgl,
553                                        struct skcipher_sg_list, list);
554                 sg = sgl->sg;
555
556                 while (!sg->length)
557                         sg++;
558
559                 used = min_t(unsigned long, ctx->used,
560                              iov_iter_count(&msg->msg_iter));
561                 used = min_t(unsigned long, used, sg->length);
562
563                 if (txbufs == tx_nents) {
564                         struct scatterlist *tmp;
565                         int x;
566                         /* Ran out of tx slots in async request
567                          * need to expand */
568                         tmp = kcalloc(tx_nents * 2, sizeof(*tmp),
569                                       GFP_KERNEL);
570                         if (!tmp) {
571                                 err = -ENOMEM;
572                                 goto free;
573                         }
574
575                         sg_init_table(tmp, tx_nents * 2);
576                         for (x = 0; x < tx_nents; x++)
577                                 sg_set_page(&tmp[x], sg_page(&sreq->tsg[x]),
578                                             sreq->tsg[x].length,
579                                             sreq->tsg[x].offset);
580                         kfree(sreq->tsg);
581                         sreq->tsg = tmp;
582                         tx_nents *= 2;
583                         mark = true;
584                 }
585                 /* Need to take over the tx sgl from ctx
586                  * to the asynch req - these sgls will be freed later */
587                 sg_set_page(sreq->tsg + txbufs++, sg_page(sg), sg->length,
588                             sg->offset);
589
590                 if (list_empty(&sreq->list)) {
591                         rsgl = &sreq->first_sgl;
592                         list_add_tail(&rsgl->list, &sreq->list);
593                 } else {
594                         rsgl = kmalloc(sizeof(*rsgl), GFP_KERNEL);
595                         if (!rsgl) {
596                                 err = -ENOMEM;
597                                 goto free;
598                         }
599                         list_add_tail(&rsgl->list, &sreq->list);
600                 }
601
602                 used = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, used);
603                 err = used;
604                 if (used < 0)
605                         goto free;
606                 if (last_rsgl)
607                         af_alg_link_sg(&last_rsgl->sgl, &rsgl->sgl);
608
609                 last_rsgl = rsgl;
610                 len += used;
611                 skcipher_pull_sgl(sk, used, 0);
612                 iov_iter_advance(&msg->msg_iter, used);
613         }
614
615         if (mark)
616                 sg_mark_end(sreq->tsg + txbufs - 1);
617
618         skcipher_request_set_crypt(req, sreq->tsg, sreq->first_sgl.sgl.sg,
619                                    len, iv);
620         err = ctx->enc ? crypto_skcipher_encrypt(req) :
621                          crypto_skcipher_decrypt(req);
622         if (err == -EINPROGRESS) {
623                 atomic_inc(&ctx->inflight);
624                 err = -EIOCBQUEUED;
625                 sreq = NULL;
626                 goto unlock;
627         }
628 free:
629         skcipher_free_async_sgls(sreq);
630 unlock:
631         skcipher_wmem_wakeup(sk);
632         release_sock(sk);
633         kzfree(sreq);
634 out:
635         return err;
636 }
637
638 static int skcipher_recvmsg_sync(struct socket *sock, struct msghdr *msg,
639                                  int flags)
640 {
641         struct sock *sk = sock->sk;
642         struct alg_sock *ask = alg_sk(sk);
643         struct sock *psk = ask->parent;
644         struct alg_sock *pask = alg_sk(psk);
645         struct skcipher_ctx *ctx = ask->private;
646         struct skcipher_tfm *skc = pask->private;
647         struct crypto_skcipher *tfm = skc->skcipher;
648         unsigned bs = crypto_skcipher_blocksize(tfm);
649         struct skcipher_sg_list *sgl;
650         struct scatterlist *sg;
651         int err = -EAGAIN;
652         int used;
653         long copied = 0;
654
655         lock_sock(sk);
656         while (msg_data_left(msg)) {
657                 if (!ctx->used) {
658                         err = skcipher_wait_for_data(sk, flags);
659                         if (err)
660                                 goto unlock;
661                 }
662
663                 used = min_t(unsigned long, ctx->used, msg_data_left(msg));
664
665                 used = af_alg_make_sg(&ctx->rsgl, &msg->msg_iter, used);
666                 err = used;
667                 if (err < 0)
668                         goto unlock;
669
670                 if (ctx->more || used < ctx->used)
671                         used -= used % bs;
672
673                 err = -EINVAL;
674                 if (!used)
675                         goto free;
676
677                 sgl = list_first_entry(&ctx->tsgl,
678                                        struct skcipher_sg_list, list);
679                 sg = sgl->sg;
680
681                 while (!sg->length)
682                         sg++;
683
684                 skcipher_request_set_crypt(&ctx->req, sg, ctx->rsgl.sg, used,
685                                            ctx->iv);
686
687                 err = af_alg_wait_for_completion(
688                                 ctx->enc ?
689                                         crypto_skcipher_encrypt(&ctx->req) :
690                                         crypto_skcipher_decrypt(&ctx->req),
691                                 &ctx->completion);
692
693 free:
694                 af_alg_free_sg(&ctx->rsgl);
695
696                 if (err)
697                         goto unlock;
698
699                 copied += used;
700                 skcipher_pull_sgl(sk, used, 1);
701                 iov_iter_advance(&msg->msg_iter, used);
702         }
703
704         err = 0;
705
706 unlock:
707         skcipher_wmem_wakeup(sk);
708         release_sock(sk);
709
710         return copied ?: err;
711 }
712
713 static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
714                             size_t ignored, int flags)
715 {
716         return (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) ?
717                 skcipher_recvmsg_async(sock, msg, flags) :
718                 skcipher_recvmsg_sync(sock, msg, flags);
719 }
720
721 static unsigned int skcipher_poll(struct file *file, struct socket *sock,
722                                   poll_table *wait)
723 {
724         struct sock *sk = sock->sk;
725         struct alg_sock *ask = alg_sk(sk);
726         struct skcipher_ctx *ctx = ask->private;
727         unsigned int mask;
728
729         sock_poll_wait(file, sk_sleep(sk), wait);
730         mask = 0;
731
732         if (ctx->used)
733                 mask |= POLLIN | POLLRDNORM;
734
735         if (skcipher_writable(sk))
736                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
737
738         return mask;
739 }
740
741 static struct proto_ops algif_skcipher_ops = {
742         .family         =       PF_ALG,
743
744         .connect        =       sock_no_connect,
745         .socketpair     =       sock_no_socketpair,
746         .getname        =       sock_no_getname,
747         .ioctl          =       sock_no_ioctl,
748         .listen         =       sock_no_listen,
749         .shutdown       =       sock_no_shutdown,
750         .getsockopt     =       sock_no_getsockopt,
751         .mmap           =       sock_no_mmap,
752         .bind           =       sock_no_bind,
753         .accept         =       sock_no_accept,
754         .setsockopt     =       sock_no_setsockopt,
755
756         .release        =       af_alg_release,
757         .sendmsg        =       skcipher_sendmsg,
758         .sendpage       =       skcipher_sendpage,
759         .recvmsg        =       skcipher_recvmsg,
760         .poll           =       skcipher_poll,
761 };
762
763 static int skcipher_check_key(struct socket *sock)
764 {
765         int err = 0;
766         struct sock *psk;
767         struct alg_sock *pask;
768         struct skcipher_tfm *tfm;
769         struct sock *sk = sock->sk;
770         struct alg_sock *ask = alg_sk(sk);
771
772         lock_sock(sk);
773         if (ask->refcnt)
774                 goto unlock_child;
775
776         psk = ask->parent;
777         pask = alg_sk(ask->parent);
778         tfm = pask->private;
779
780         err = -ENOKEY;
781         lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
782         if (!tfm->has_key)
783                 goto unlock;
784
785         if (!pask->refcnt++)
786                 sock_hold(psk);
787
788         ask->refcnt = 1;
789         sock_put(psk);
790
791         err = 0;
792
793 unlock:
794         release_sock(psk);
795 unlock_child:
796         release_sock(sk);
797
798         return err;
799 }
800
801 static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
802                                   size_t size)
803 {
804         int err;
805
806         err = skcipher_check_key(sock);
807         if (err)
808                 return err;
809
810         return skcipher_sendmsg(sock, msg, size);
811 }
812
813 static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
814                                        int offset, size_t size, int flags)
815 {
816         int err;
817
818         err = skcipher_check_key(sock);
819         if (err)
820                 return err;
821
822         return skcipher_sendpage(sock, page, offset, size, flags);
823 }
824
825 static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
826                                   size_t ignored, int flags)
827 {
828         int err;
829
830         err = skcipher_check_key(sock);
831         if (err)
832                 return err;
833
834         return skcipher_recvmsg(sock, msg, ignored, flags);
835 }
836
837 static struct proto_ops algif_skcipher_ops_nokey = {
838         .family         =       PF_ALG,
839
840         .connect        =       sock_no_connect,
841         .socketpair     =       sock_no_socketpair,
842         .getname        =       sock_no_getname,
843         .ioctl          =       sock_no_ioctl,
844         .listen         =       sock_no_listen,
845         .shutdown       =       sock_no_shutdown,
846         .getsockopt     =       sock_no_getsockopt,
847         .mmap           =       sock_no_mmap,
848         .bind           =       sock_no_bind,
849         .accept         =       sock_no_accept,
850         .setsockopt     =       sock_no_setsockopt,
851
852         .release        =       af_alg_release,
853         .sendmsg        =       skcipher_sendmsg_nokey,
854         .sendpage       =       skcipher_sendpage_nokey,
855         .recvmsg        =       skcipher_recvmsg_nokey,
856         .poll           =       skcipher_poll,
857 };
858
859 static void *skcipher_bind(const char *name, u32 type, u32 mask)
860 {
861         struct skcipher_tfm *tfm;
862         struct crypto_skcipher *skcipher;
863
864         tfm = kzalloc(sizeof(*tfm), GFP_KERNEL);
865         if (!tfm)
866                 return ERR_PTR(-ENOMEM);
867
868         skcipher = crypto_alloc_skcipher(name, type, mask);
869         if (IS_ERR(skcipher)) {
870                 kfree(tfm);
871                 return ERR_CAST(skcipher);
872         }
873
874         tfm->skcipher = skcipher;
875
876         return tfm;
877 }
878
879 static void skcipher_release(void *private)
880 {
881         struct skcipher_tfm *tfm = private;
882
883         crypto_free_skcipher(tfm->skcipher);
884         kfree(tfm);
885 }
886
887 static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
888 {
889         struct skcipher_tfm *tfm = private;
890         int err;
891
892         err = crypto_skcipher_setkey(tfm->skcipher, key, keylen);
893         tfm->has_key = !err;
894
895         return err;
896 }
897
898 static void skcipher_wait(struct sock *sk)
899 {
900         struct alg_sock *ask = alg_sk(sk);
901         struct skcipher_ctx *ctx = ask->private;
902         int ctr = 0;
903
904         while (atomic_read(&ctx->inflight) && ctr++ < 100)
905                 msleep(100);
906 }
907
908 static void skcipher_sock_destruct(struct sock *sk)
909 {
910         struct alg_sock *ask = alg_sk(sk);
911         struct skcipher_ctx *ctx = ask->private;
912         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(&ctx->req);
913
914         if (atomic_read(&ctx->inflight))
915                 skcipher_wait(sk);
916
917         skcipher_free_sgl(sk);
918         sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
919         sock_kfree_s(sk, ctx, ctx->len);
920         af_alg_release_parent(sk);
921 }
922
923 static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
924 {
925         struct skcipher_ctx *ctx;
926         struct alg_sock *ask = alg_sk(sk);
927         struct skcipher_tfm *tfm = private;
928         struct crypto_skcipher *skcipher = tfm->skcipher;
929         unsigned int len = sizeof(*ctx) + crypto_skcipher_reqsize(skcipher);
930
931         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
932         if (!ctx)
933                 return -ENOMEM;
934
935         ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher),
936                                GFP_KERNEL);
937         if (!ctx->iv) {
938                 sock_kfree_s(sk, ctx, len);
939                 return -ENOMEM;
940         }
941
942         memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher));
943
944         INIT_LIST_HEAD(&ctx->tsgl);
945         ctx->len = len;
946         ctx->used = 0;
947         ctx->more = 0;
948         ctx->merge = 0;
949         ctx->enc = 0;
950         atomic_set(&ctx->inflight, 0);
951         af_alg_init_completion(&ctx->completion);
952
953         ask->private = ctx;
954
955         skcipher_request_set_tfm(&ctx->req, skcipher);
956         skcipher_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_SLEEP |
957                                                  CRYPTO_TFM_REQ_MAY_BACKLOG,
958                                       af_alg_complete, &ctx->completion);
959
960         sk->sk_destruct = skcipher_sock_destruct;
961
962         return 0;
963 }
964
965 static int skcipher_accept_parent(void *private, struct sock *sk)
966 {
967         struct skcipher_tfm *tfm = private;
968
969         if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher))
970                 return -ENOKEY;
971
972         return skcipher_accept_parent_nokey(private, sk);
973 }
974
975 static const struct af_alg_type algif_type_skcipher = {
976         .bind           =       skcipher_bind,
977         .release        =       skcipher_release,
978         .setkey         =       skcipher_setkey,
979         .accept         =       skcipher_accept_parent,
980         .accept_nokey   =       skcipher_accept_parent_nokey,
981         .ops            =       &algif_skcipher_ops,
982         .ops_nokey      =       &algif_skcipher_ops_nokey,
983         .name           =       "skcipher",
984         .owner          =       THIS_MODULE
985 };
986
987 static int __init algif_skcipher_init(void)
988 {
989         return af_alg_register_type(&algif_type_skcipher);
990 }
991
992 static void __exit algif_skcipher_exit(void)
993 {
994         int err = af_alg_unregister_type(&algif_type_skcipher);
995         BUG_ON(err);
996 }
997
998 module_init(algif_skcipher_init);
999 module_exit(algif_skcipher_exit);
1000 MODULE_LICENSE("GPL");