Whamcloud - gitweb
LU-6765 obdecho: don't copy lu_site
[fs/lustre-release.git] / libcfs / libcfs / linux / linux-crypto-adler.c
1 /* GPL HEADER START
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 only,
7  * as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License version 2 for more details (a copy is included
13  * in the LICENSE file that accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License
16  * version 2 along with this program; If not, see http://www.gnu.org/licenses
17  *
18  * Please  visit http://www.xyratex.com/contact if you need additional
19  * information or have any questions.
20  *
21  * GPL HEADER END
22  */
23
24 /*
25  * Copyright 2012 Xyratex Technology Limited
26  */
27
28 /*
29  * This is crypto api shash wrappers to zlib_adler32.
30  */
31
32 #include <linux/module.h>
33 #include <linux/zutil.h>
34 #include <libcfs/linux/linux-crypto.h>
35 #include <crypto/internal/hash.h>
36
37
38 #define CHKSUM_BLOCK_SIZE       1
39 #define CHKSUM_DIGEST_SIZE      4
40
41
42 static u32 __adler32(u32 cksum, unsigned char const *p, size_t len)
43 {
44         return zlib_adler32(cksum, p, len);
45 }
46
47 static int adler32_cra_init(struct crypto_tfm *tfm)
48 {
49         u32 *key = crypto_tfm_ctx(tfm);
50
51         *key = 1;
52
53         return 0;
54 }
55
56 static int adler32_setkey(struct crypto_shash *hash, const u8 *key,
57                           unsigned int keylen)
58 {
59         u32 *mctx = crypto_shash_ctx(hash);
60
61         if (keylen != sizeof(u32)) {
62                 crypto_shash_set_flags(hash, CRYPTO_TFM_RES_BAD_KEY_LEN);
63                 return -EINVAL;
64         }
65         *mctx = *(u32 *)key;
66         return 0;
67 }
68
69 static int adler32_init(struct shash_desc *desc)
70 {
71         u32 *mctx = crypto_shash_ctx(desc->tfm);
72         u32 *cksump = shash_desc_ctx(desc);
73
74         *cksump = *mctx;
75
76         return 0;
77 }
78
79 static int adler32_update(struct shash_desc *desc, const u8 *data,
80                           unsigned int len)
81 {
82         u32 *cksump = shash_desc_ctx(desc);
83
84         *cksump = __adler32(*cksump, data, len);
85         return 0;
86 }
87 static int __adler32_finup(u32 *cksump, const u8 *data, unsigned int len,
88                            u8 *out)
89 {
90         *(u32 *)out = __adler32(*cksump, data, len);
91         return 0;
92 }
93
94 static int adler32_finup(struct shash_desc *desc, const u8 *data,
95                          unsigned int len, u8 *out)
96 {
97         return __adler32_finup(shash_desc_ctx(desc), data, len, out);
98 }
99
100 static int adler32_final(struct shash_desc *desc, u8 *out)
101 {
102         u32 *cksump = shash_desc_ctx(desc);
103
104         *(u32 *)out = *cksump;
105         return 0;
106 }
107
108 static int adler32_digest(struct shash_desc *desc, const u8 *data,
109                           unsigned int len, u8 *out)
110 {
111         return __adler32_finup(crypto_shash_ctx(desc->tfm), data, len,
112                                     out);
113 }
114 static struct shash_alg alg = {
115         .setkey         = adler32_setkey,
116         .init           = adler32_init,
117         .update         = adler32_update,
118         .final          = adler32_final,
119         .finup          = adler32_finup,
120         .digest         = adler32_digest,
121         .descsize       = sizeof(u32),
122         .digestsize     = CHKSUM_DIGEST_SIZE,
123         .base           = {
124                 .cra_name               = "adler32",
125                 .cra_driver_name        = "adler32-zlib",
126                 .cra_priority           = 100,
127                 .cra_blocksize          = CHKSUM_BLOCK_SIZE,
128                 .cra_ctxsize            = sizeof(u32),
129                 .cra_module             = THIS_MODULE,
130                 .cra_init               = adler32_cra_init,
131         }
132 };
133
134 int cfs_crypto_adler32_register(void)
135 {
136         return crypto_register_shash(&alg);
137 }
138
139 void cfs_crypto_adler32_unregister(void)
140 {
141         crypto_unregister_shash(&alg);
142 }