Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[firefly-linux-kernel-4.4.55.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/mm.h>
22 #include <linux/module.h>
23 #include <linux/net.h>
24 #include <net/sock.h>
25
26 struct skcipher_sg_list {
27         struct list_head list;
28
29         int cur;
30
31         struct scatterlist sg[0];
32 };
33
34 struct skcipher_ctx {
35         struct list_head tsgl;
36         struct af_alg_sgl rsgl;
37
38         void *iv;
39
40         struct af_alg_completion completion;
41
42         atomic_t inflight;
43         unsigned used;
44
45         unsigned int len;
46         bool more;
47         bool merge;
48         bool enc;
49
50         struct ablkcipher_request req;
51 };
52
53 struct skcipher_async_rsgl {
54         struct af_alg_sgl sgl;
55         struct list_head list;
56 };
57
58 struct skcipher_async_req {
59         struct kiocb *iocb;
60         struct skcipher_async_rsgl first_sgl;
61         struct list_head list;
62         struct scatterlist *tsg;
63         char iv[];
64 };
65
66 #define GET_SREQ(areq, ctx) (struct skcipher_async_req *)((char *)areq + \
67         crypto_ablkcipher_reqsize(crypto_ablkcipher_reqtfm(&ctx->req)))
68
69 #define GET_REQ_SIZE(ctx) \
70         crypto_ablkcipher_reqsize(crypto_ablkcipher_reqtfm(&ctx->req))
71
72 #define GET_IV_SIZE(ctx) \
73         crypto_ablkcipher_ivsize(crypto_ablkcipher_reqtfm(&ctx->req))
74
75 #define MAX_SGL_ENTS ((4096 - sizeof(struct skcipher_sg_list)) / \
76                       sizeof(struct scatterlist) - 1)
77
78 static void skcipher_free_async_sgls(struct skcipher_async_req *sreq)
79 {
80         struct skcipher_async_rsgl *rsgl, *tmp;
81         struct scatterlist *sgl;
82         struct scatterlist *sg;
83         int i, n;
84
85         list_for_each_entry_safe(rsgl, tmp, &sreq->list, list) {
86                 af_alg_free_sg(&rsgl->sgl);
87                 if (rsgl != &sreq->first_sgl)
88                         kfree(rsgl);
89         }
90         sgl = sreq->tsg;
91         n = sg_nents(sgl);
92         for_each_sg(sgl, sg, n, i)
93                 put_page(sg_page(sg));
94
95         kfree(sreq->tsg);
96 }
97
98 static void skcipher_async_cb(struct crypto_async_request *req, int err)
99 {
100         struct sock *sk = req->data;
101         struct alg_sock *ask = alg_sk(sk);
102         struct skcipher_ctx *ctx = ask->private;
103         struct skcipher_async_req *sreq = GET_SREQ(req, ctx);
104         struct kiocb *iocb = sreq->iocb;
105
106         atomic_dec(&ctx->inflight);
107         skcipher_free_async_sgls(sreq);
108         kfree(req);
109         iocb->ki_complete(iocb, err, err);
110 }
111
112 static inline int skcipher_sndbuf(struct sock *sk)
113 {
114         struct alg_sock *ask = alg_sk(sk);
115         struct skcipher_ctx *ctx = ask->private;
116
117         return max_t(int, max_t(int, sk->sk_sndbuf & PAGE_MASK, PAGE_SIZE) -
118                           ctx->used, 0);
119 }
120
121 static inline bool skcipher_writable(struct sock *sk)
122 {
123         return PAGE_SIZE <= skcipher_sndbuf(sk);
124 }
125
126 static int skcipher_alloc_sgl(struct sock *sk)
127 {
128         struct alg_sock *ask = alg_sk(sk);
129         struct skcipher_ctx *ctx = ask->private;
130         struct skcipher_sg_list *sgl;
131         struct scatterlist *sg = NULL;
132
133         sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
134         if (!list_empty(&ctx->tsgl))
135                 sg = sgl->sg;
136
137         if (!sg || sgl->cur >= MAX_SGL_ENTS) {
138                 sgl = sock_kmalloc(sk, sizeof(*sgl) +
139                                        sizeof(sgl->sg[0]) * (MAX_SGL_ENTS + 1),
140                                    GFP_KERNEL);
141                 if (!sgl)
142                         return -ENOMEM;
143
144                 sg_init_table(sgl->sg, MAX_SGL_ENTS + 1);
145                 sgl->cur = 0;
146
147                 if (sg)
148                         sg_chain(sg, MAX_SGL_ENTS + 1, sgl->sg);
149
150                 list_add_tail(&sgl->list, &ctx->tsgl);
151         }
152
153         return 0;
154 }
155
156 static void skcipher_pull_sgl(struct sock *sk, int used, int put)
157 {
158         struct alg_sock *ask = alg_sk(sk);
159         struct skcipher_ctx *ctx = ask->private;
160         struct skcipher_sg_list *sgl;
161         struct scatterlist *sg;
162         int i;
163
164         while (!list_empty(&ctx->tsgl)) {
165                 sgl = list_first_entry(&ctx->tsgl, struct skcipher_sg_list,
166                                        list);
167                 sg = sgl->sg;
168
169                 for (i = 0; i < sgl->cur; i++) {
170                         int plen = min_t(int, used, sg[i].length);
171
172                         if (!sg_page(sg + i))
173                                 continue;
174
175                         sg[i].length -= plen;
176                         sg[i].offset += plen;
177
178                         used -= plen;
179                         ctx->used -= plen;
180
181                         if (sg[i].length)
182                                 return;
183                         if (put)
184                                 put_page(sg_page(sg + i));
185                         sg_assign_page(sg + i, NULL);
186                 }
187
188                 list_del(&sgl->list);
189                 sock_kfree_s(sk, sgl,
190                              sizeof(*sgl) + sizeof(sgl->sg[0]) *
191                                             (MAX_SGL_ENTS + 1));
192         }
193
194         if (!ctx->used)
195                 ctx->merge = 0;
196 }
197
198 static void skcipher_free_sgl(struct sock *sk)
199 {
200         struct alg_sock *ask = alg_sk(sk);
201         struct skcipher_ctx *ctx = ask->private;
202
203         skcipher_pull_sgl(sk, ctx->used, 1);
204 }
205
206 static int skcipher_wait_for_wmem(struct sock *sk, unsigned flags)
207 {
208         long timeout;
209         DEFINE_WAIT(wait);
210         int err = -ERESTARTSYS;
211
212         if (flags & MSG_DONTWAIT)
213                 return -EAGAIN;
214
215         set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
216
217         for (;;) {
218                 if (signal_pending(current))
219                         break;
220                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
221                 timeout = MAX_SCHEDULE_TIMEOUT;
222                 if (sk_wait_event(sk, &timeout, skcipher_writable(sk))) {
223                         err = 0;
224                         break;
225                 }
226         }
227         finish_wait(sk_sleep(sk), &wait);
228
229         return err;
230 }
231
232 static void skcipher_wmem_wakeup(struct sock *sk)
233 {
234         struct socket_wq *wq;
235
236         if (!skcipher_writable(sk))
237                 return;
238
239         rcu_read_lock();
240         wq = rcu_dereference(sk->sk_wq);
241         if (wq_has_sleeper(wq))
242                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
243                                                            POLLRDNORM |
244                                                            POLLRDBAND);
245         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
246         rcu_read_unlock();
247 }
248
249 static int skcipher_wait_for_data(struct sock *sk, unsigned flags)
250 {
251         struct alg_sock *ask = alg_sk(sk);
252         struct skcipher_ctx *ctx = ask->private;
253         long timeout;
254         DEFINE_WAIT(wait);
255         int err = -ERESTARTSYS;
256
257         if (flags & MSG_DONTWAIT) {
258                 return -EAGAIN;
259         }
260
261         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
262
263         for (;;) {
264                 if (signal_pending(current))
265                         break;
266                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
267                 timeout = MAX_SCHEDULE_TIMEOUT;
268                 if (sk_wait_event(sk, &timeout, ctx->used)) {
269                         err = 0;
270                         break;
271                 }
272         }
273         finish_wait(sk_sleep(sk), &wait);
274
275         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
276
277         return err;
278 }
279
280 static void skcipher_data_wakeup(struct sock *sk)
281 {
282         struct alg_sock *ask = alg_sk(sk);
283         struct skcipher_ctx *ctx = ask->private;
284         struct socket_wq *wq;
285
286         if (!ctx->used)
287                 return;
288
289         rcu_read_lock();
290         wq = rcu_dereference(sk->sk_wq);
291         if (wq_has_sleeper(wq))
292                 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
293                                                            POLLRDNORM |
294                                                            POLLRDBAND);
295         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
296         rcu_read_unlock();
297 }
298
299 static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
300                             size_t size)
301 {
302         struct sock *sk = sock->sk;
303         struct alg_sock *ask = alg_sk(sk);
304         struct skcipher_ctx *ctx = ask->private;
305         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(&ctx->req);
306         unsigned ivsize = crypto_ablkcipher_ivsize(tfm);
307         struct skcipher_sg_list *sgl;
308         struct af_alg_control con = {};
309         long copied = 0;
310         bool enc = 0;
311         bool init = 0;
312         int err;
313         int i;
314
315         if (msg->msg_controllen) {
316                 err = af_alg_cmsg_send(msg, &con);
317                 if (err)
318                         return err;
319
320                 init = 1;
321                 switch (con.op) {
322                 case ALG_OP_ENCRYPT:
323                         enc = 1;
324                         break;
325                 case ALG_OP_DECRYPT:
326                         enc = 0;
327                         break;
328                 default:
329                         return -EINVAL;
330                 }
331
332                 if (con.iv && con.iv->ivlen != ivsize)
333                         return -EINVAL;
334         }
335
336         err = -EINVAL;
337
338         lock_sock(sk);
339         if (!ctx->more && ctx->used)
340                 goto unlock;
341
342         if (init) {
343                 ctx->enc = enc;
344                 if (con.iv)
345                         memcpy(ctx->iv, con.iv->iv, ivsize);
346         }
347
348         while (size) {
349                 struct scatterlist *sg;
350                 unsigned long len = size;
351                 int plen;
352
353                 if (ctx->merge) {
354                         sgl = list_entry(ctx->tsgl.prev,
355                                          struct skcipher_sg_list, list);
356                         sg = sgl->sg + sgl->cur - 1;
357                         len = min_t(unsigned long, len,
358                                     PAGE_SIZE - sg->offset - sg->length);
359
360                         err = memcpy_from_msg(page_address(sg_page(sg)) +
361                                               sg->offset + sg->length,
362                                               msg, len);
363                         if (err)
364                                 goto unlock;
365
366                         sg->length += len;
367                         ctx->merge = (sg->offset + sg->length) &
368                                      (PAGE_SIZE - 1);
369
370                         ctx->used += len;
371                         copied += len;
372                         size -= len;
373                         continue;
374                 }
375
376                 if (!skcipher_writable(sk)) {
377                         err = skcipher_wait_for_wmem(sk, msg->msg_flags);
378                         if (err)
379                                 goto unlock;
380                 }
381
382                 len = min_t(unsigned long, len, skcipher_sndbuf(sk));
383
384                 err = skcipher_alloc_sgl(sk);
385                 if (err)
386                         goto unlock;
387
388                 sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
389                 sg = sgl->sg;
390                 sg_unmark_end(sg + sgl->cur);
391                 do {
392                         i = sgl->cur;
393                         plen = min_t(int, len, PAGE_SIZE);
394
395                         sg_assign_page(sg + i, alloc_page(GFP_KERNEL));
396                         err = -ENOMEM;
397                         if (!sg_page(sg + i))
398                                 goto unlock;
399
400                         err = memcpy_from_msg(page_address(sg_page(sg + i)),
401                                               msg, plen);
402                         if (err) {
403                                 __free_page(sg_page(sg + i));
404                                 sg_assign_page(sg + i, NULL);
405                                 goto unlock;
406                         }
407
408                         sg[i].length = plen;
409                         len -= plen;
410                         ctx->used += plen;
411                         copied += plen;
412                         size -= plen;
413                         sgl->cur++;
414                 } while (len && sgl->cur < MAX_SGL_ENTS);
415
416                 if (!size)
417                         sg_mark_end(sg + sgl->cur - 1);
418
419                 ctx->merge = plen & (PAGE_SIZE - 1);
420         }
421
422         err = 0;
423
424         ctx->more = msg->msg_flags & MSG_MORE;
425
426 unlock:
427         skcipher_data_wakeup(sk);
428         release_sock(sk);
429
430         return copied ?: err;
431 }
432
433 static ssize_t skcipher_sendpage(struct socket *sock, struct page *page,
434                                  int offset, size_t size, int flags)
435 {
436         struct sock *sk = sock->sk;
437         struct alg_sock *ask = alg_sk(sk);
438         struct skcipher_ctx *ctx = ask->private;
439         struct skcipher_sg_list *sgl;
440         int err = -EINVAL;
441
442         if (flags & MSG_SENDPAGE_NOTLAST)
443                 flags |= MSG_MORE;
444
445         lock_sock(sk);
446         if (!ctx->more && ctx->used)
447                 goto unlock;
448
449         if (!size)
450                 goto done;
451
452         if (!skcipher_writable(sk)) {
453                 err = skcipher_wait_for_wmem(sk, flags);
454                 if (err)
455                         goto unlock;
456         }
457
458         err = skcipher_alloc_sgl(sk);
459         if (err)
460                 goto unlock;
461
462         ctx->merge = 0;
463         sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
464
465         if (sgl->cur)
466                 sg_unmark_end(sgl->sg + sgl->cur - 1);
467
468         sg_mark_end(sgl->sg + sgl->cur);
469         get_page(page);
470         sg_set_page(sgl->sg + sgl->cur, page, size, offset);
471         sgl->cur++;
472         ctx->used += size;
473
474 done:
475         ctx->more = flags & MSG_MORE;
476
477 unlock:
478         skcipher_data_wakeup(sk);
479         release_sock(sk);
480
481         return err ?: size;
482 }
483
484 static int skcipher_all_sg_nents(struct skcipher_ctx *ctx)
485 {
486         struct skcipher_sg_list *sgl;
487         struct scatterlist *sg;
488         int nents = 0;
489
490         list_for_each_entry(sgl, &ctx->tsgl, list) {
491                 sg = sgl->sg;
492
493                 while (!sg->length)
494                         sg++;
495
496                 nents += sg_nents(sg);
497         }
498         return nents;
499 }
500
501 static int skcipher_recvmsg_async(struct socket *sock, struct msghdr *msg,
502                                   int flags)
503 {
504         struct sock *sk = sock->sk;
505         struct alg_sock *ask = alg_sk(sk);
506         struct skcipher_ctx *ctx = ask->private;
507         struct skcipher_sg_list *sgl;
508         struct scatterlist *sg;
509         struct skcipher_async_req *sreq;
510         struct ablkcipher_request *req;
511         struct skcipher_async_rsgl *last_rsgl = NULL;
512         unsigned int txbufs = 0, len = 0, tx_nents = skcipher_all_sg_nents(ctx);
513         unsigned int reqlen = sizeof(struct skcipher_async_req) +
514                                 GET_REQ_SIZE(ctx) + GET_IV_SIZE(ctx);
515         int err = -ENOMEM;
516         bool mark = false;
517
518         lock_sock(sk);
519         req = kmalloc(reqlen, GFP_KERNEL);
520         if (unlikely(!req))
521                 goto unlock;
522
523         sreq = GET_SREQ(req, ctx);
524         sreq->iocb = msg->msg_iocb;
525         memset(&sreq->first_sgl, '\0', sizeof(struct skcipher_async_rsgl));
526         INIT_LIST_HEAD(&sreq->list);
527         sreq->tsg = kcalloc(tx_nents, sizeof(*sg), GFP_KERNEL);
528         if (unlikely(!sreq->tsg)) {
529                 kfree(req);
530                 goto unlock;
531         }
532         sg_init_table(sreq->tsg, tx_nents);
533         memcpy(sreq->iv, ctx->iv, GET_IV_SIZE(ctx));
534         ablkcipher_request_set_tfm(req, crypto_ablkcipher_reqtfm(&ctx->req));
535         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
536                                         skcipher_async_cb, sk);
537
538         while (iov_iter_count(&msg->msg_iter)) {
539                 struct skcipher_async_rsgl *rsgl;
540                 int used;
541
542                 if (!ctx->used) {
543                         err = skcipher_wait_for_data(sk, flags);
544                         if (err)
545                                 goto free;
546                 }
547                 sgl = list_first_entry(&ctx->tsgl,
548                                        struct skcipher_sg_list, list);
549                 sg = sgl->sg;
550
551                 while (!sg->length)
552                         sg++;
553
554                 used = min_t(unsigned long, ctx->used,
555                              iov_iter_count(&msg->msg_iter));
556                 used = min_t(unsigned long, used, sg->length);
557
558                 if (txbufs == tx_nents) {
559                         struct scatterlist *tmp;
560                         int x;
561                         /* Ran out of tx slots in async request
562                          * need to expand */
563                         tmp = kcalloc(tx_nents * 2, sizeof(*tmp),
564                                       GFP_KERNEL);
565                         if (!tmp)
566                                 goto free;
567
568                         sg_init_table(tmp, tx_nents * 2);
569                         for (x = 0; x < tx_nents; x++)
570                                 sg_set_page(&tmp[x], sg_page(&sreq->tsg[x]),
571                                             sreq->tsg[x].length,
572                                             sreq->tsg[x].offset);
573                         kfree(sreq->tsg);
574                         sreq->tsg = tmp;
575                         tx_nents *= 2;
576                         mark = true;
577                 }
578                 /* Need to take over the tx sgl from ctx
579                  * to the asynch req - these sgls will be freed later */
580                 sg_set_page(sreq->tsg + txbufs++, sg_page(sg), sg->length,
581                             sg->offset);
582
583                 if (list_empty(&sreq->list)) {
584                         rsgl = &sreq->first_sgl;
585                         list_add_tail(&rsgl->list, &sreq->list);
586                 } else {
587                         rsgl = kmalloc(sizeof(*rsgl), GFP_KERNEL);
588                         if (!rsgl) {
589                                 err = -ENOMEM;
590                                 goto free;
591                         }
592                         list_add_tail(&rsgl->list, &sreq->list);
593                 }
594
595                 used = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, used);
596                 err = used;
597                 if (used < 0)
598                         goto free;
599                 if (last_rsgl)
600                         af_alg_link_sg(&last_rsgl->sgl, &rsgl->sgl);
601
602                 last_rsgl = rsgl;
603                 len += used;
604                 skcipher_pull_sgl(sk, used, 0);
605                 iov_iter_advance(&msg->msg_iter, used);
606         }
607
608         if (mark)
609                 sg_mark_end(sreq->tsg + txbufs - 1);
610
611         ablkcipher_request_set_crypt(req, sreq->tsg, sreq->first_sgl.sgl.sg,
612                                      len, sreq->iv);
613         err = ctx->enc ? crypto_ablkcipher_encrypt(req) :
614                          crypto_ablkcipher_decrypt(req);
615         if (err == -EINPROGRESS) {
616                 atomic_inc(&ctx->inflight);
617                 err = -EIOCBQUEUED;
618                 goto unlock;
619         }
620 free:
621         skcipher_free_async_sgls(sreq);
622         kfree(req);
623 unlock:
624         skcipher_wmem_wakeup(sk);
625         release_sock(sk);
626         return err;
627 }
628
629 static int skcipher_recvmsg_sync(struct socket *sock, struct msghdr *msg,
630                                  int flags)
631 {
632         struct sock *sk = sock->sk;
633         struct alg_sock *ask = alg_sk(sk);
634         struct skcipher_ctx *ctx = ask->private;
635         unsigned bs = crypto_ablkcipher_blocksize(crypto_ablkcipher_reqtfm(
636                 &ctx->req));
637         struct skcipher_sg_list *sgl;
638         struct scatterlist *sg;
639         int err = -EAGAIN;
640         int used;
641         long copied = 0;
642
643         lock_sock(sk);
644         while (msg_data_left(msg)) {
645                 sgl = list_first_entry(&ctx->tsgl,
646                                        struct skcipher_sg_list, list);
647                 sg = sgl->sg;
648
649                 while (!sg->length)
650                         sg++;
651
652                 if (!ctx->used) {
653                         err = skcipher_wait_for_data(sk, flags);
654                         if (err)
655                                 goto unlock;
656                 }
657
658                 used = min_t(unsigned long, ctx->used, msg_data_left(msg));
659
660                 used = af_alg_make_sg(&ctx->rsgl, &msg->msg_iter, used);
661                 err = used;
662                 if (err < 0)
663                         goto unlock;
664
665                 if (ctx->more || used < ctx->used)
666                         used -= used % bs;
667
668                 err = -EINVAL;
669                 if (!used)
670                         goto free;
671
672                 ablkcipher_request_set_crypt(&ctx->req, sg,
673                                              ctx->rsgl.sg, used,
674                                              ctx->iv);
675
676                 err = af_alg_wait_for_completion(
677                                 ctx->enc ?
678                                         crypto_ablkcipher_encrypt(&ctx->req) :
679                                         crypto_ablkcipher_decrypt(&ctx->req),
680                                 &ctx->completion);
681
682 free:
683                 af_alg_free_sg(&ctx->rsgl);
684
685                 if (err)
686                         goto unlock;
687
688                 copied += used;
689                 skcipher_pull_sgl(sk, used, 1);
690                 iov_iter_advance(&msg->msg_iter, used);
691         }
692
693         err = 0;
694
695 unlock:
696         skcipher_wmem_wakeup(sk);
697         release_sock(sk);
698
699         return copied ?: err;
700 }
701
702 static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
703                             size_t ignored, int flags)
704 {
705         return (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) ?
706                 skcipher_recvmsg_async(sock, msg, flags) :
707                 skcipher_recvmsg_sync(sock, msg, flags);
708 }
709
710 static unsigned int skcipher_poll(struct file *file, struct socket *sock,
711                                   poll_table *wait)
712 {
713         struct sock *sk = sock->sk;
714         struct alg_sock *ask = alg_sk(sk);
715         struct skcipher_ctx *ctx = ask->private;
716         unsigned int mask;
717
718         sock_poll_wait(file, sk_sleep(sk), wait);
719         mask = 0;
720
721         if (ctx->used)
722                 mask |= POLLIN | POLLRDNORM;
723
724         if (skcipher_writable(sk))
725                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
726
727         return mask;
728 }
729
730 static struct proto_ops algif_skcipher_ops = {
731         .family         =       PF_ALG,
732
733         .connect        =       sock_no_connect,
734         .socketpair     =       sock_no_socketpair,
735         .getname        =       sock_no_getname,
736         .ioctl          =       sock_no_ioctl,
737         .listen         =       sock_no_listen,
738         .shutdown       =       sock_no_shutdown,
739         .getsockopt     =       sock_no_getsockopt,
740         .mmap           =       sock_no_mmap,
741         .bind           =       sock_no_bind,
742         .accept         =       sock_no_accept,
743         .setsockopt     =       sock_no_setsockopt,
744
745         .release        =       af_alg_release,
746         .sendmsg        =       skcipher_sendmsg,
747         .sendpage       =       skcipher_sendpage,
748         .recvmsg        =       skcipher_recvmsg,
749         .poll           =       skcipher_poll,
750 };
751
752 static void *skcipher_bind(const char *name, u32 type, u32 mask)
753 {
754         return crypto_alloc_ablkcipher(name, type, mask);
755 }
756
757 static void skcipher_release(void *private)
758 {
759         crypto_free_ablkcipher(private);
760 }
761
762 static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
763 {
764         return crypto_ablkcipher_setkey(private, key, keylen);
765 }
766
767 static void skcipher_wait(struct sock *sk)
768 {
769         struct alg_sock *ask = alg_sk(sk);
770         struct skcipher_ctx *ctx = ask->private;
771         int ctr = 0;
772
773         while (atomic_read(&ctx->inflight) && ctr++ < 100)
774                 msleep(100);
775 }
776
777 static void skcipher_sock_destruct(struct sock *sk)
778 {
779         struct alg_sock *ask = alg_sk(sk);
780         struct skcipher_ctx *ctx = ask->private;
781         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(&ctx->req);
782
783         if (atomic_read(&ctx->inflight))
784                 skcipher_wait(sk);
785
786         skcipher_free_sgl(sk);
787         sock_kzfree_s(sk, ctx->iv, crypto_ablkcipher_ivsize(tfm));
788         sock_kfree_s(sk, ctx, ctx->len);
789         af_alg_release_parent(sk);
790 }
791
792 static int skcipher_accept_parent(void *private, struct sock *sk)
793 {
794         struct skcipher_ctx *ctx;
795         struct alg_sock *ask = alg_sk(sk);
796         unsigned int len = sizeof(*ctx) + crypto_ablkcipher_reqsize(private);
797
798         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
799         if (!ctx)
800                 return -ENOMEM;
801
802         ctx->iv = sock_kmalloc(sk, crypto_ablkcipher_ivsize(private),
803                                GFP_KERNEL);
804         if (!ctx->iv) {
805                 sock_kfree_s(sk, ctx, len);
806                 return -ENOMEM;
807         }
808
809         memset(ctx->iv, 0, crypto_ablkcipher_ivsize(private));
810
811         INIT_LIST_HEAD(&ctx->tsgl);
812         ctx->len = len;
813         ctx->used = 0;
814         ctx->more = 0;
815         ctx->merge = 0;
816         ctx->enc = 0;
817         atomic_set(&ctx->inflight, 0);
818         af_alg_init_completion(&ctx->completion);
819
820         ask->private = ctx;
821
822         ablkcipher_request_set_tfm(&ctx->req, private);
823         ablkcipher_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG,
824                                         af_alg_complete, &ctx->completion);
825
826         sk->sk_destruct = skcipher_sock_destruct;
827
828         return 0;
829 }
830
831 static const struct af_alg_type algif_type_skcipher = {
832         .bind           =       skcipher_bind,
833         .release        =       skcipher_release,
834         .setkey         =       skcipher_setkey,
835         .accept         =       skcipher_accept_parent,
836         .ops            =       &algif_skcipher_ops,
837         .name           =       "skcipher",
838         .owner          =       THIS_MODULE
839 };
840
841 static int __init algif_skcipher_init(void)
842 {
843         return af_alg_register_type(&algif_type_skcipher);
844 }
845
846 static void __exit algif_skcipher_exit(void)
847 {
848         int err = af_alg_unregister_type(&algif_type_skcipher);
849         BUG_ON(err);
850 }
851
852 module_init(algif_skcipher_init);
853 module_exit(algif_skcipher_exit);
854 MODULE_LICENSE("GPL");