Add ENET device to i.MX6 SOC.
[qemu.git] / include / crypto / hash.h
1 /*
2 * QEMU Crypto hash algorithms
3 *
4 * Copyright (c) 2015 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #ifndef QCRYPTO_HASH_H__
22 #define QCRYPTO_HASH_H__
23
24 #include "qapi-types.h"
25
26 /* See also "QCryptoHashAlgorithm" defined in qapi/crypto.json */
27
28 /**
29 * qcrypto_hash_supports:
30 * @alg: the hash algorithm
31 *
32 * Determine if @alg hash algorithm is supported by the
33 * current configured build.
34 *
35 * Returns: true if the algorithm is supported, false otherwise
36 */
37 gboolean qcrypto_hash_supports(QCryptoHashAlgorithm alg);
38
39
40 /**
41 * qcrypto_hash_digest_len:
42 * @alg: the hash algorithm
43 *
44 * Determine the size of the hash digest in bytes
45 *
46 * Returns: the digest length in bytes
47 */
48 size_t qcrypto_hash_digest_len(QCryptoHashAlgorithm alg);
49
50 /**
51 * qcrypto_hash_bytesv:
52 * @alg: the hash algorithm
53 * @iov: the array of memory regions to hash
54 * @niov: the length of @iov
55 * @result: pointer to hold output hash
56 * @resultlen: pointer to hold length of @result
57 * @errp: pointer to a NULL-initialized error object
58 *
59 * Computes the hash across all the memory regions
60 * present in @iov. The @result pointer will be
61 * filled with raw bytes representing the computed
62 * hash, which will have length @resultlen. The
63 * memory pointer in @result must be released
64 * with a call to g_free() when no longer required.
65 *
66 * Returns: 0 on success, -1 on error
67 */
68 int qcrypto_hash_bytesv(QCryptoHashAlgorithm alg,
69 const struct iovec *iov,
70 size_t niov,
71 uint8_t **result,
72 size_t *resultlen,
73 Error **errp);
74
75 /**
76 * qcrypto_hash_bytes:
77 * @alg: the hash algorithm
78 * @buf: the memory region to hash
79 * @len: the length of @buf
80 * @result: pointer to hold output hash
81 * @resultlen: pointer to hold length of @result
82 * @errp: pointer to a NULL-initialized error object
83 *
84 * Computes the hash across all the memory region
85 * @buf of length @len. The @result pointer will be
86 * filled with raw bytes representing the computed
87 * hash, which will have length @resultlen. The
88 * memory pointer in @result must be released
89 * with a call to g_free() when no longer required.
90 *
91 * Returns: 0 on success, -1 on error
92 */
93 int qcrypto_hash_bytes(QCryptoHashAlgorithm alg,
94 const char *buf,
95 size_t len,
96 uint8_t **result,
97 size_t *resultlen,
98 Error **errp);
99
100 /**
101 * qcrypto_hash_digestv:
102 * @alg: the hash algorithm
103 * @iov: the array of memory regions to hash
104 * @niov: the length of @iov
105 * @digest: pointer to hold output hash
106 * @errp: pointer to a NULL-initialized error object
107 *
108 * Computes the hash across all the memory regions
109 * present in @iov. The @digest pointer will be
110 * filled with the printable hex digest of the computed
111 * hash, which will be terminated by '\0'. The
112 * memory pointer in @digest must be released
113 * with a call to g_free() when no longer required.
114 *
115 * Returns: 0 on success, -1 on error
116 */
117 int qcrypto_hash_digestv(QCryptoHashAlgorithm alg,
118 const struct iovec *iov,
119 size_t niov,
120 char **digest,
121 Error **errp);
122
123 /**
124 * qcrypto_hash_digest:
125 * @alg: the hash algorithm
126 * @buf: the memory region to hash
127 * @len: the length of @buf
128 * @digest: pointer to hold output hash
129 * @errp: pointer to a NULL-initialized error object
130 *
131 * Computes the hash across all the memory region
132 * @buf of length @len. The @digest pointer will be
133 * filled with the printable hex digest of the computed
134 * hash, which will be terminated by '\0'. The
135 * memory pointer in @digest must be released
136 * with a call to g_free() when no longer required.
137 *
138 * Returns: 0 on success, -1 on error
139 */
140 int qcrypto_hash_digest(QCryptoHashAlgorithm alg,
141 const char *buf,
142 size_t len,
143 char **digest,
144 Error **errp);
145
146 /**
147 * qcrypto_hash_base64v:
148 * @alg: the hash algorithm
149 * @iov: the array of memory regions to hash
150 * @niov: the length of @iov
151 * @base64: pointer to hold output hash
152 * @errp: pointer to a NULL-initialized error object
153 *
154 * Computes the hash across all the memory regions
155 * present in @iov. The @base64 pointer will be
156 * filled with the base64 encoding of the computed
157 * hash, which will be terminated by '\0'. The
158 * memory pointer in @base64 must be released
159 * with a call to g_free() when no longer required.
160 *
161 * Returns: 0 on success, -1 on error
162 */
163 int qcrypto_hash_base64v(QCryptoHashAlgorithm alg,
164 const struct iovec *iov,
165 size_t niov,
166 char **base64,
167 Error **errp);
168
169 /**
170 * qcrypto_hash_base64:
171 * @alg: the hash algorithm
172 * @buf: the memory region to hash
173 * @len: the length of @buf
174 * @base64: pointer to hold output hash
175 * @errp: pointer to a NULL-initialized error object
176 *
177 * Computes the hash across all the memory region
178 * @buf of length @len. The @base64 pointer will be
179 * filled with the base64 encoding of the computed
180 * hash, which will be terminated by '\0'. The
181 * memory pointer in @base64 must be released
182 * with a call to g_free() when no longer required.
183 *
184 * Returns: 0 on success, -1 on error
185 */
186 int qcrypto_hash_base64(QCryptoHashAlgorithm alg,
187 const char *buf,
188 size_t len,
189 char **base64,
190 Error **errp);
191
192 #endif /* QCRYPTO_HASH_H__ */