2 * algif_skcipher: User-space interface for skcipher algorithms
4 * This file provides the user-space API for symmetric key ciphers.
6 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
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)
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>
23 #include <linux/module.h>
24 #include <linux/net.h>
27 struct skcipher_sg_list
{
28 struct list_head list
;
32 struct scatterlist sg
[0];
36 struct crypto_skcipher
*skcipher
;
41 struct list_head tsgl
;
42 struct af_alg_sgl rsgl
;
46 struct af_alg_completion completion
;
56 struct skcipher_request req
;
59 struct skcipher_async_rsgl
{
60 struct af_alg_sgl sgl
;
61 struct list_head list
;
64 struct skcipher_async_req
{
66 struct skcipher_async_rsgl first_sgl
;
67 struct list_head list
;
68 struct scatterlist
*tsg
;
70 struct skcipher_request req
;
73 #define MAX_SGL_ENTS ((4096 - sizeof(struct skcipher_sg_list)) / \
74 sizeof(struct scatterlist) - 1)
76 static void skcipher_free_async_sgls(struct skcipher_async_req
*sreq
)
78 struct skcipher_async_rsgl
*rsgl
, *tmp
;
79 struct scatterlist
*sgl
;
80 struct scatterlist
*sg
;
83 list_for_each_entry_safe(rsgl
, tmp
, &sreq
->list
, list
) {
84 af_alg_free_sg(&rsgl
->sgl
);
85 if (rsgl
!= &sreq
->first_sgl
)
90 for_each_sg(sgl
, sg
, n
, i
) {
91 struct page
*page
= sg_page(sg
);
93 /* some SGs may not have a page mapped */
94 if (page
&& page_ref_count(page
))
101 static void skcipher_async_cb(struct crypto_async_request
*req
, int err
)
103 struct skcipher_async_req
*sreq
= req
->data
;
104 struct kiocb
*iocb
= sreq
->iocb
;
106 atomic_dec(sreq
->inflight
);
107 skcipher_free_async_sgls(sreq
);
109 iocb
->ki_complete(iocb
, err
, err
);
112 static inline int skcipher_sndbuf(struct sock
*sk
)
114 struct alg_sock
*ask
= alg_sk(sk
);
115 struct skcipher_ctx
*ctx
= ask
->private;
117 return max_t(int, max_t(int, sk
->sk_sndbuf
& PAGE_MASK
, PAGE_SIZE
) -
121 static inline bool skcipher_writable(struct sock
*sk
)
123 return PAGE_SIZE
<= skcipher_sndbuf(sk
);
126 static int skcipher_alloc_sgl(struct sock
*sk
)
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
;
133 sgl
= list_entry(ctx
->tsgl
.prev
, struct skcipher_sg_list
, list
);
134 if (!list_empty(&ctx
->tsgl
))
137 if (!sg
|| sgl
->cur
>= MAX_SGL_ENTS
) {
138 sgl
= sock_kmalloc(sk
, sizeof(*sgl
) +
139 sizeof(sgl
->sg
[0]) * (MAX_SGL_ENTS
+ 1),
144 sg_init_table(sgl
->sg
, MAX_SGL_ENTS
+ 1);
148 sg_chain(sg
, MAX_SGL_ENTS
+ 1, sgl
->sg
);
149 sg_unmark_end(sg
+ (MAX_SGL_ENTS
- 1));
152 list_add_tail(&sgl
->list
, &ctx
->tsgl
);
158 static void skcipher_pull_sgl(struct sock
*sk
, size_t used
, int put
)
160 struct alg_sock
*ask
= alg_sk(sk
);
161 struct skcipher_ctx
*ctx
= ask
->private;
162 struct skcipher_sg_list
*sgl
;
163 struct scatterlist
*sg
;
166 while (!list_empty(&ctx
->tsgl
)) {
167 sgl
= list_first_entry(&ctx
->tsgl
, struct skcipher_sg_list
,
171 for (i
= 0; i
< sgl
->cur
; i
++) {
172 size_t plen
= min_t(size_t, used
, sg
[i
].length
);
174 if (!sg_page(sg
+ i
))
177 sg
[i
].length
-= plen
;
178 sg
[i
].offset
+= plen
;
186 put_page(sg_page(sg
+ i
));
187 sg_assign_page(sg
+ i
, NULL
);
190 list_del(&sgl
->list
);
191 sock_kfree_s(sk
, sgl
,
192 sizeof(*sgl
) + sizeof(sgl
->sg
[0]) *
200 static void skcipher_free_sgl(struct sock
*sk
)
202 struct alg_sock
*ask
= alg_sk(sk
);
203 struct skcipher_ctx
*ctx
= ask
->private;
205 skcipher_pull_sgl(sk
, ctx
->used
, 1);
208 static int skcipher_wait_for_wmem(struct sock
*sk
, unsigned flags
)
210 DEFINE_WAIT_FUNC(wait
, woken_wake_function
);
211 int err
= -ERESTARTSYS
;
214 if (flags
& MSG_DONTWAIT
)
217 sk_set_bit(SOCKWQ_ASYNC_NOSPACE
, sk
);
219 add_wait_queue(sk_sleep(sk
), &wait
);
221 if (signal_pending(current
))
223 timeout
= MAX_SCHEDULE_TIMEOUT
;
224 if (sk_wait_event(sk
, &timeout
, skcipher_writable(sk
), &wait
)) {
229 remove_wait_queue(sk_sleep(sk
), &wait
);
234 static void skcipher_wmem_wakeup(struct sock
*sk
)
236 struct socket_wq
*wq
;
238 if (!skcipher_writable(sk
))
242 wq
= rcu_dereference(sk
->sk_wq
);
243 if (skwq_has_sleeper(wq
))
244 wake_up_interruptible_sync_poll(&wq
->wait
, POLLIN
|
247 sk_wake_async(sk
, SOCK_WAKE_WAITD
, POLL_IN
);
251 static int skcipher_wait_for_data(struct sock
*sk
, unsigned flags
)
253 DEFINE_WAIT_FUNC(wait
, woken_wake_function
);
254 struct alg_sock
*ask
= alg_sk(sk
);
255 struct skcipher_ctx
*ctx
= ask
->private;
257 int err
= -ERESTARTSYS
;
259 if (flags
& MSG_DONTWAIT
) {
263 sk_set_bit(SOCKWQ_ASYNC_WAITDATA
, sk
);
265 add_wait_queue(sk_sleep(sk
), &wait
);
267 if (signal_pending(current
))
269 timeout
= MAX_SCHEDULE_TIMEOUT
;
270 if (sk_wait_event(sk
, &timeout
, ctx
->used
, &wait
)) {
275 remove_wait_queue(sk_sleep(sk
), &wait
);
277 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA
, sk
);
282 static void skcipher_data_wakeup(struct sock
*sk
)
284 struct alg_sock
*ask
= alg_sk(sk
);
285 struct skcipher_ctx
*ctx
= ask
->private;
286 struct socket_wq
*wq
;
292 wq
= rcu_dereference(sk
->sk_wq
);
293 if (skwq_has_sleeper(wq
))
294 wake_up_interruptible_sync_poll(&wq
->wait
, POLLOUT
|
297 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
301 static int skcipher_sendmsg(struct socket
*sock
, struct msghdr
*msg
,
304 struct sock
*sk
= sock
->sk
;
305 struct alg_sock
*ask
= alg_sk(sk
);
306 struct sock
*psk
= ask
->parent
;
307 struct alg_sock
*pask
= alg_sk(psk
);
308 struct skcipher_ctx
*ctx
= ask
->private;
309 struct skcipher_tfm
*skc
= pask
->private;
310 struct crypto_skcipher
*tfm
= skc
->skcipher
;
311 unsigned ivsize
= crypto_skcipher_ivsize(tfm
);
312 struct skcipher_sg_list
*sgl
;
313 struct af_alg_control con
= {};
320 if (msg
->msg_controllen
) {
321 err
= af_alg_cmsg_send(msg
, &con
);
337 if (con
.iv
&& con
.iv
->ivlen
!= ivsize
)
344 if (!ctx
->more
&& ctx
->used
)
350 memcpy(ctx
->iv
, con
.iv
->iv
, ivsize
);
354 struct scatterlist
*sg
;
355 unsigned long len
= size
;
359 sgl
= list_entry(ctx
->tsgl
.prev
,
360 struct skcipher_sg_list
, list
);
361 sg
= sgl
->sg
+ sgl
->cur
- 1;
362 len
= min_t(unsigned long, len
,
363 PAGE_SIZE
- sg
->offset
- sg
->length
);
365 err
= memcpy_from_msg(page_address(sg_page(sg
)) +
366 sg
->offset
+ sg
->length
,
372 ctx
->merge
= (sg
->offset
+ sg
->length
) &
381 if (!skcipher_writable(sk
)) {
382 err
= skcipher_wait_for_wmem(sk
, msg
->msg_flags
);
387 len
= min_t(unsigned long, len
, skcipher_sndbuf(sk
));
389 err
= skcipher_alloc_sgl(sk
);
393 sgl
= list_entry(ctx
->tsgl
.prev
, struct skcipher_sg_list
, list
);
396 sg_unmark_end(sg
+ sgl
->cur
- 1);
399 plen
= min_t(size_t, len
, PAGE_SIZE
);
401 sg_assign_page(sg
+ i
, alloc_page(GFP_KERNEL
));
403 if (!sg_page(sg
+ i
))
406 err
= memcpy_from_msg(page_address(sg_page(sg
+ i
)),
409 __free_page(sg_page(sg
+ i
));
410 sg_assign_page(sg
+ i
, NULL
);
420 } while (len
&& sgl
->cur
< MAX_SGL_ENTS
);
423 sg_mark_end(sg
+ sgl
->cur
- 1);
425 ctx
->merge
= plen
& (PAGE_SIZE
- 1);
430 ctx
->more
= msg
->msg_flags
& MSG_MORE
;
433 skcipher_data_wakeup(sk
);
436 return copied
?: err
;
439 static ssize_t
skcipher_sendpage(struct socket
*sock
, struct page
*page
,
440 int offset
, size_t size
, int flags
)
442 struct sock
*sk
= sock
->sk
;
443 struct alg_sock
*ask
= alg_sk(sk
);
444 struct skcipher_ctx
*ctx
= ask
->private;
445 struct skcipher_sg_list
*sgl
;
448 if (flags
& MSG_SENDPAGE_NOTLAST
)
452 if (!ctx
->more
&& ctx
->used
)
458 if (!skcipher_writable(sk
)) {
459 err
= skcipher_wait_for_wmem(sk
, flags
);
464 err
= skcipher_alloc_sgl(sk
);
469 sgl
= list_entry(ctx
->tsgl
.prev
, struct skcipher_sg_list
, list
);
472 sg_unmark_end(sgl
->sg
+ sgl
->cur
- 1);
474 sg_mark_end(sgl
->sg
+ sgl
->cur
);
476 sg_set_page(sgl
->sg
+ sgl
->cur
, page
, size
, offset
);
481 ctx
->more
= flags
& MSG_MORE
;
484 skcipher_data_wakeup(sk
);
490 static int skcipher_all_sg_nents(struct skcipher_ctx
*ctx
)
492 struct skcipher_sg_list
*sgl
;
493 struct scatterlist
*sg
;
496 list_for_each_entry(sgl
, &ctx
->tsgl
, list
) {
502 nents
+= sg_nents(sg
);
507 static int skcipher_recvmsg_async(struct socket
*sock
, struct msghdr
*msg
,
510 struct sock
*sk
= sock
->sk
;
511 struct alg_sock
*ask
= alg_sk(sk
);
512 struct sock
*psk
= ask
->parent
;
513 struct alg_sock
*pask
= alg_sk(psk
);
514 struct skcipher_ctx
*ctx
= ask
->private;
515 struct skcipher_tfm
*skc
= pask
->private;
516 struct crypto_skcipher
*tfm
= skc
->skcipher
;
517 struct skcipher_sg_list
*sgl
;
518 struct scatterlist
*sg
;
519 struct skcipher_async_req
*sreq
;
520 struct skcipher_request
*req
;
521 struct skcipher_async_rsgl
*last_rsgl
= NULL
;
522 unsigned int txbufs
= 0, len
= 0, tx_nents
;
523 unsigned int reqsize
= crypto_skcipher_reqsize(tfm
);
524 unsigned int ivsize
= crypto_skcipher_ivsize(tfm
);
529 sreq
= kzalloc(sizeof(*sreq
) + reqsize
+ ivsize
, GFP_KERNEL
);
534 iv
= (char *)(req
+ 1) + reqsize
;
535 sreq
->iocb
= msg
->msg_iocb
;
536 INIT_LIST_HEAD(&sreq
->list
);
537 sreq
->inflight
= &ctx
->inflight
;
540 tx_nents
= skcipher_all_sg_nents(ctx
);
541 sreq
->tsg
= kcalloc(tx_nents
, sizeof(*sg
), GFP_KERNEL
);
542 if (unlikely(!sreq
->tsg
))
544 sg_init_table(sreq
->tsg
, tx_nents
);
545 memcpy(iv
, ctx
->iv
, ivsize
);
546 skcipher_request_set_tfm(req
, tfm
);
547 skcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_SLEEP
,
548 skcipher_async_cb
, sreq
);
550 while (iov_iter_count(&msg
->msg_iter
)) {
551 struct skcipher_async_rsgl
*rsgl
;
555 err
= skcipher_wait_for_data(sk
, flags
);
559 sgl
= list_first_entry(&ctx
->tsgl
,
560 struct skcipher_sg_list
, list
);
566 used
= min_t(unsigned long, ctx
->used
,
567 iov_iter_count(&msg
->msg_iter
));
568 used
= min_t(unsigned long, used
, sg
->length
);
570 if (txbufs
== tx_nents
) {
571 struct scatterlist
*tmp
;
573 /* Ran out of tx slots in async request
575 tmp
= kcalloc(tx_nents
* 2, sizeof(*tmp
),
582 sg_init_table(tmp
, tx_nents
* 2);
583 for (x
= 0; x
< tx_nents
; x
++)
584 sg_set_page(&tmp
[x
], sg_page(&sreq
->tsg
[x
]),
586 sreq
->tsg
[x
].offset
);
592 /* Need to take over the tx sgl from ctx
593 * to the asynch req - these sgls will be freed later */
594 sg_set_page(sreq
->tsg
+ txbufs
++, sg_page(sg
), sg
->length
,
597 if (list_empty(&sreq
->list
)) {
598 rsgl
= &sreq
->first_sgl
;
599 list_add_tail(&rsgl
->list
, &sreq
->list
);
601 rsgl
= kmalloc(sizeof(*rsgl
), GFP_KERNEL
);
606 list_add_tail(&rsgl
->list
, &sreq
->list
);
609 used
= af_alg_make_sg(&rsgl
->sgl
, &msg
->msg_iter
, used
);
614 af_alg_link_sg(&last_rsgl
->sgl
, &rsgl
->sgl
);
618 skcipher_pull_sgl(sk
, used
, 0);
619 iov_iter_advance(&msg
->msg_iter
, used
);
623 sg_mark_end(sreq
->tsg
+ txbufs
- 1);
625 skcipher_request_set_crypt(req
, sreq
->tsg
, sreq
->first_sgl
.sgl
.sg
,
627 err
= ctx
->enc
? crypto_skcipher_encrypt(req
) :
628 crypto_skcipher_decrypt(req
);
629 if (err
== -EINPROGRESS
) {
630 atomic_inc(&ctx
->inflight
);
636 skcipher_free_async_sgls(sreq
);
638 skcipher_wmem_wakeup(sk
);
645 static int skcipher_recvmsg_sync(struct socket
*sock
, struct msghdr
*msg
,
648 struct sock
*sk
= sock
->sk
;
649 struct alg_sock
*ask
= alg_sk(sk
);
650 struct sock
*psk
= ask
->parent
;
651 struct alg_sock
*pask
= alg_sk(psk
);
652 struct skcipher_ctx
*ctx
= ask
->private;
653 struct skcipher_tfm
*skc
= pask
->private;
654 struct crypto_skcipher
*tfm
= skc
->skcipher
;
655 unsigned bs
= crypto_skcipher_blocksize(tfm
);
656 struct skcipher_sg_list
*sgl
;
657 struct scatterlist
*sg
;
663 while (msg_data_left(msg
)) {
665 err
= skcipher_wait_for_data(sk
, flags
);
670 used
= min_t(unsigned long, ctx
->used
, msg_data_left(msg
));
672 used
= af_alg_make_sg(&ctx
->rsgl
, &msg
->msg_iter
, used
);
677 if (ctx
->more
|| used
< ctx
->used
)
684 sgl
= list_first_entry(&ctx
->tsgl
,
685 struct skcipher_sg_list
, list
);
691 skcipher_request_set_crypt(&ctx
->req
, sg
, ctx
->rsgl
.sg
, used
,
694 err
= af_alg_wait_for_completion(
696 crypto_skcipher_encrypt(&ctx
->req
) :
697 crypto_skcipher_decrypt(&ctx
->req
),
701 af_alg_free_sg(&ctx
->rsgl
);
707 skcipher_pull_sgl(sk
, used
, 1);
708 iov_iter_advance(&msg
->msg_iter
, used
);
714 skcipher_wmem_wakeup(sk
);
717 return copied
?: err
;
720 static int skcipher_recvmsg(struct socket
*sock
, struct msghdr
*msg
,
721 size_t ignored
, int flags
)
723 return (msg
->msg_iocb
&& !is_sync_kiocb(msg
->msg_iocb
)) ?
724 skcipher_recvmsg_async(sock
, msg
, flags
) :
725 skcipher_recvmsg_sync(sock
, msg
, flags
);
728 static unsigned int skcipher_poll(struct file
*file
, struct socket
*sock
,
731 struct sock
*sk
= sock
->sk
;
732 struct alg_sock
*ask
= alg_sk(sk
);
733 struct skcipher_ctx
*ctx
= ask
->private;
736 sock_poll_wait(file
, sk_sleep(sk
), wait
);
740 mask
|= POLLIN
| POLLRDNORM
;
742 if (skcipher_writable(sk
))
743 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
748 static struct proto_ops algif_skcipher_ops
= {
751 .connect
= sock_no_connect
,
752 .socketpair
= sock_no_socketpair
,
753 .getname
= sock_no_getname
,
754 .ioctl
= sock_no_ioctl
,
755 .listen
= sock_no_listen
,
756 .shutdown
= sock_no_shutdown
,
757 .getsockopt
= sock_no_getsockopt
,
758 .mmap
= sock_no_mmap
,
759 .bind
= sock_no_bind
,
760 .accept
= sock_no_accept
,
761 .setsockopt
= sock_no_setsockopt
,
763 .release
= af_alg_release
,
764 .sendmsg
= skcipher_sendmsg
,
765 .sendpage
= skcipher_sendpage
,
766 .recvmsg
= skcipher_recvmsg
,
767 .poll
= skcipher_poll
,
770 static int skcipher_check_key(struct socket
*sock
)
774 struct alg_sock
*pask
;
775 struct skcipher_tfm
*tfm
;
776 struct sock
*sk
= sock
->sk
;
777 struct alg_sock
*ask
= alg_sk(sk
);
784 pask
= alg_sk(ask
->parent
);
788 lock_sock_nested(psk
, SINGLE_DEPTH_NESTING
);
808 static int skcipher_sendmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
813 err
= skcipher_check_key(sock
);
817 return skcipher_sendmsg(sock
, msg
, size
);
820 static ssize_t
skcipher_sendpage_nokey(struct socket
*sock
, struct page
*page
,
821 int offset
, size_t size
, int flags
)
825 err
= skcipher_check_key(sock
);
829 return skcipher_sendpage(sock
, page
, offset
, size
, flags
);
832 static int skcipher_recvmsg_nokey(struct socket
*sock
, struct msghdr
*msg
,
833 size_t ignored
, int flags
)
837 err
= skcipher_check_key(sock
);
841 return skcipher_recvmsg(sock
, msg
, ignored
, flags
);
844 static struct proto_ops algif_skcipher_ops_nokey
= {
847 .connect
= sock_no_connect
,
848 .socketpair
= sock_no_socketpair
,
849 .getname
= sock_no_getname
,
850 .ioctl
= sock_no_ioctl
,
851 .listen
= sock_no_listen
,
852 .shutdown
= sock_no_shutdown
,
853 .getsockopt
= sock_no_getsockopt
,
854 .mmap
= sock_no_mmap
,
855 .bind
= sock_no_bind
,
856 .accept
= sock_no_accept
,
857 .setsockopt
= sock_no_setsockopt
,
859 .release
= af_alg_release
,
860 .sendmsg
= skcipher_sendmsg_nokey
,
861 .sendpage
= skcipher_sendpage_nokey
,
862 .recvmsg
= skcipher_recvmsg_nokey
,
863 .poll
= skcipher_poll
,
866 static void *skcipher_bind(const char *name
, u32 type
, u32 mask
)
868 struct skcipher_tfm
*tfm
;
869 struct crypto_skcipher
*skcipher
;
871 tfm
= kzalloc(sizeof(*tfm
), GFP_KERNEL
);
873 return ERR_PTR(-ENOMEM
);
875 skcipher
= crypto_alloc_skcipher(name
, type
, mask
);
876 if (IS_ERR(skcipher
)) {
878 return ERR_CAST(skcipher
);
881 tfm
->skcipher
= skcipher
;
886 static void skcipher_release(void *private)
888 struct skcipher_tfm
*tfm
= private;
890 crypto_free_skcipher(tfm
->skcipher
);
894 static int skcipher_setkey(void *private, const u8
*key
, unsigned int keylen
)
896 struct skcipher_tfm
*tfm
= private;
899 err
= crypto_skcipher_setkey(tfm
->skcipher
, key
, keylen
);
905 static void skcipher_wait(struct sock
*sk
)
907 struct alg_sock
*ask
= alg_sk(sk
);
908 struct skcipher_ctx
*ctx
= ask
->private;
911 while (atomic_read(&ctx
->inflight
) && ctr
++ < 100)
915 static void skcipher_sock_destruct(struct sock
*sk
)
917 struct alg_sock
*ask
= alg_sk(sk
);
918 struct skcipher_ctx
*ctx
= ask
->private;
919 struct crypto_skcipher
*tfm
= crypto_skcipher_reqtfm(&ctx
->req
);
921 if (atomic_read(&ctx
->inflight
))
924 skcipher_free_sgl(sk
);
925 sock_kzfree_s(sk
, ctx
->iv
, crypto_skcipher_ivsize(tfm
));
926 sock_kfree_s(sk
, ctx
, ctx
->len
);
927 af_alg_release_parent(sk
);
930 static int skcipher_accept_parent_nokey(void *private, struct sock
*sk
)
932 struct skcipher_ctx
*ctx
;
933 struct alg_sock
*ask
= alg_sk(sk
);
934 struct skcipher_tfm
*tfm
= private;
935 struct crypto_skcipher
*skcipher
= tfm
->skcipher
;
936 unsigned int len
= sizeof(*ctx
) + crypto_skcipher_reqsize(skcipher
);
938 ctx
= sock_kmalloc(sk
, len
, GFP_KERNEL
);
942 ctx
->iv
= sock_kmalloc(sk
, crypto_skcipher_ivsize(skcipher
),
945 sock_kfree_s(sk
, ctx
, len
);
949 memset(ctx
->iv
, 0, crypto_skcipher_ivsize(skcipher
));
951 INIT_LIST_HEAD(&ctx
->tsgl
);
957 atomic_set(&ctx
->inflight
, 0);
958 af_alg_init_completion(&ctx
->completion
);
962 skcipher_request_set_tfm(&ctx
->req
, skcipher
);
963 skcipher_request_set_callback(&ctx
->req
, CRYPTO_TFM_REQ_MAY_SLEEP
|
964 CRYPTO_TFM_REQ_MAY_BACKLOG
,
965 af_alg_complete
, &ctx
->completion
);
967 sk
->sk_destruct
= skcipher_sock_destruct
;
972 static int skcipher_accept_parent(void *private, struct sock
*sk
)
974 struct skcipher_tfm
*tfm
= private;
976 if (!tfm
->has_key
&& crypto_skcipher_has_setkey(tfm
->skcipher
))
979 return skcipher_accept_parent_nokey(private, sk
);
982 static const struct af_alg_type algif_type_skcipher
= {
983 .bind
= skcipher_bind
,
984 .release
= skcipher_release
,
985 .setkey
= skcipher_setkey
,
986 .accept
= skcipher_accept_parent
,
987 .accept_nokey
= skcipher_accept_parent_nokey
,
988 .ops
= &algif_skcipher_ops
,
989 .ops_nokey
= &algif_skcipher_ops_nokey
,
994 static int __init
algif_skcipher_init(void)
996 return af_alg_register_type(&algif_type_skcipher
);
999 static void __exit
algif_skcipher_exit(void)
1001 int err
= af_alg_unregister_type(&algif_type_skcipher
);
1005 module_init(algif_skcipher_init
);
1006 module_exit(algif_skcipher_exit
);
1007 MODULE_LICENSE("GPL");