/src/php-src/ext/hash/hash_xxhash.c

Source (jump to first uncovered line)
/*
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Author: Anatol Belski <ab@php.net>                                   |
   +----------------------------------------------------------------------+
*/

#include "php_hash.h"
#include "php_hash_xxhash.h"

static int php_hash_xxh32_unserialize(
    php_hashcontext_object *hash, zend_long magic, const zval *zv);
static int php_hash_xxh64_unserialize(
    php_hashcontext_object *hash, zend_long magic, const zval *zv);

const php_hash_ops php_hash_xxh32_ops = {
  "xxh32",
  (php_hash_init_func_t) PHP_XXH32Init,
  (php_hash_update_func_t) PHP_XXH32Update,
  (php_hash_final_func_t) PHP_XXH32Final,
  (php_hash_copy_func_t) PHP_XXH32Copy,
  php_hash_serialize,
  php_hash_xxh32_unserialize,
  PHP_XXH32_SPEC,
  4,
  4,
  sizeof(PHP_XXH32_CTX),
  0
};

PHP_HASH_API void PHP_XXH32Init(PHP_XXH32_CTX *ctx, HashTable *args)
{
  /* XXH32_createState() is not used intentionally. */
  memset(&ctx->s, 0, sizeof ctx->s);

  if (args) {
    zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1);
    /* This might be a bit too restrictive, but thinking that a seed might be set
      once and for all, it should be done a clean way. */
    if (seed) {
      if (IS_LONG == Z_TYPE_P(seed)) {
        XXH32_reset(&ctx->s, (XXH32_hash_t)Z_LVAL_P(seed));
        return;
      } else {
        php_error_docref(NULL, E_DEPRECATED, "Passing a seed of a type other than int is deprecated because it is the same as setting the seed to 0");
      }
    }
  }

  XXH32_reset(&ctx->s, 0);
}

PHP_HASH_API void PHP_XXH32Update(PHP_XXH32_CTX *ctx, const unsigned char *in, size_t len)
{
  XXH32_update(&ctx->s, in, len);
}

PHP_HASH_API void PHP_XXH32Final(unsigned char digest[4], PHP_XXH32_CTX *ctx)
{
  XXH32_canonicalFromHash((XXH32_canonical_t*)digest, XXH32_digest(&ctx->s));
}

PHP_HASH_API zend_result PHP_XXH32Copy(const php_hash_ops *ops, const PHP_XXH32_CTX *orig_context, PHP_XXH32_CTX *copy_context)
{
  copy_context->s = orig_context->s;
  return SUCCESS;
}

static int php_hash_xxh32_unserialize(
    php_hashcontext_object *hash, zend_long magic, const zval *zv)
{
  PHP_XXH32_CTX *ctx = (PHP_XXH32_CTX *) hash->context;
  int r = FAILURE;
  if (magic == PHP_HASH_SERIALIZE_MAGIC_SPEC
    && (r = php_hash_unserialize_spec(hash, zv, PHP_XXH32_SPEC)) == SUCCESS
    && ctx->s.memsize < 16) {
    return SUCCESS;
  } else {
    return r != SUCCESS ? r : -2000;
  }
}

const php_hash_ops php_hash_xxh64_ops = {
  "xxh64",
  (php_hash_init_func_t) PHP_XXH64Init,
  (php_hash_update_func_t) PHP_XXH64Update,
  (php_hash_final_func_t) PHP_XXH64Final,
  (php_hash_copy_func_t) PHP_XXH64Copy,
  php_hash_serialize,
  php_hash_xxh64_unserialize,
  PHP_XXH64_SPEC,
  8,
  8,
  sizeof(PHP_XXH64_CTX),
  0
};

PHP_HASH_API void PHP_XXH64Init(PHP_XXH64_CTX *ctx, HashTable *args)
{
  /* XXH64_createState() is not used intentionally. */
  memset(&ctx->s, 0, sizeof ctx->s);

  if (args) {
    zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1);
    /* This might be a bit too restrictive, but thinking that a seed might be set
      once and for all, it should be done a clean way. */
    if (seed && IS_LONG == Z_TYPE_P(seed)) {
      XXH64_reset(&ctx->s, (XXH64_hash_t)Z_LVAL_P(seed));
      return;
    } else {
      php_error_docref(NULL, E_DEPRECATED, "Passing a seed of a type other than int is deprecated because it is the same as setting the seed to 0");
    }
  }

  XXH64_reset(&ctx->s, 0);
}

PHP_HASH_API void PHP_XXH64Update(PHP_XXH64_CTX *ctx, const unsigned char *in, size_t len)
{
  XXH64_update(&ctx->s, in, len);
}

PHP_HASH_API void PHP_XXH64Final(unsigned char digest[8], PHP_XXH64_CTX *ctx)
{
  XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH64_digest(&ctx->s));
}

PHP_HASH_API zend_result PHP_XXH64Copy(const php_hash_ops *ops, const PHP_XXH64_CTX *orig_context, PHP_XXH64_CTX *copy_context)
{
  copy_context->s = orig_context->s;
  return SUCCESS;
}

const php_hash_ops php_hash_xxh3_64_ops = {
  "xxh3",
  (php_hash_init_func_t) PHP_XXH3_64_Init,
  (php_hash_update_func_t) PHP_XXH3_64_Update,
  (php_hash_final_func_t) PHP_XXH3_64_Final,
  (php_hash_copy_func_t) PHP_XXH3_64_Copy,
  php_hash_serialize,
  php_hash_unserialize,
  NULL,
  8,
  8,
  sizeof(PHP_XXH3_64_CTX),
  0
};

typedef XXH_errorcode (*xxh3_reset_with_secret_func_t)(XXH3_state_t*, const void*, size_t);
typedef XXH_errorcode (*xxh3_reset_with_seed_func_t)(XXH3_state_t*, XXH64_hash_t);

static void _PHP_XXH3_Init(PHP_XXH3_64_CTX *ctx, HashTable *args,
    xxh3_reset_with_seed_func_t func_init_seed, xxh3_reset_with_secret_func_t func_init_secret, const char* algo_name)
{
  memset(&ctx->s, 0, sizeof ctx->s);

  if (args) {
    zval *_seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1);
    zval *_secret = zend_hash_str_find_deref(args, "secret", sizeof("secret") - 1);

    if (_seed && _secret) {
      zend_throw_error(NULL, "%s: Only one of seed or secret is to be passed for initialization", algo_name);
      return;
    }

    if (_seed && IS_LONG != Z_TYPE_P(_seed)) {
      php_error_docref(NULL, E_DEPRECATED, "Passing a seed of a type other than int is deprecated because it is ignored");
    }

    if (_seed && IS_LONG == Z_TYPE_P(_seed)) {
      /* This might be a bit too restrictive, but thinking that a seed might be set
        once and for all, it should be done a clean way. */
      func_init_seed(&ctx->s, (XXH64_hash_t)Z_LVAL_P(_seed));
      return;
    } else if (_secret) {
      if (IS_STRING != Z_TYPE_P(_secret)) {
        php_error_docref(NULL, E_DEPRECATED, "Passing a secret of a type other than string is deprecated because it implicitly converts to a string, potentially hiding bugs");
      }
      zend_string *secret_string = zval_try_get_string(_secret);
      if (UNEXPECTED(!secret_string)) {
        ZEND_ASSERT(EG(exception));
        return;
      }
      size_t len = ZSTR_LEN(secret_string);
      if (len < PHP_XXH3_SECRET_SIZE_MIN) {
        zend_string_release(secret_string);
        zend_throw_error(NULL, "%s: Secret length must be >= %u bytes, %zu bytes passed", algo_name, XXH3_SECRET_SIZE_MIN, len);
        return;
      }
      if (len > sizeof(ctx->secret)) {
        len = sizeof(ctx->secret);
        php_error_docref(NULL, E_WARNING, "%s: Secret content exceeding %zu bytes discarded", algo_name, sizeof(ctx->secret));
      }
      memcpy((unsigned char *)ctx->secret, ZSTR_VAL(secret_string), len);
      zend_string_release(secret_string);
      func_init_secret(&ctx->s, ctx->secret, len);
      return;
    }
  }

  func_init_seed(&ctx->s, 0);
}

PHP_HASH_API void PHP_XXH3_64_Init(PHP_XXH3_64_CTX *ctx, HashTable *args)
{
  _PHP_XXH3_Init(ctx, args, XXH3_64bits_reset_withSeed, XXH3_64bits_reset_withSecret, "xxh3");
}

PHP_HASH_API void PHP_XXH3_64_Update(PHP_XXH3_64_CTX *ctx, const unsigned char *in, size_t len)
{
  XXH3_64bits_update(&ctx->s, in, len);
}

PHP_HASH_API void PHP_XXH3_64_Final(unsigned char digest[8], PHP_XXH3_64_CTX *ctx)
{
  XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH3_64bits_digest(&ctx->s));
}

PHP_HASH_API zend_result PHP_XXH3_64_Copy(const php_hash_ops *ops, const PHP_XXH3_64_CTX *orig_context, PHP_XXH3_64_CTX *copy_context)
{
  copy_context->s = orig_context->s;
  return SUCCESS;
}

static int php_hash_xxh64_unserialize(
    php_hashcontext_object *hash, zend_long magic, const zval *zv)
{
  PHP_XXH64_CTX *ctx = (PHP_XXH64_CTX *) hash->context;
  int r = FAILURE;
  if (magic == PHP_HASH_SERIALIZE_MAGIC_SPEC
    && (r = php_hash_unserialize_spec(hash, zv, PHP_XXH64_SPEC)) == SUCCESS
    && ctx->s.memsize < 32) {
    return SUCCESS;
  } else {
    return r != SUCCESS ? r : -2000;
  }
}

const php_hash_ops php_hash_xxh3_128_ops = {
  "xxh128",
  (php_hash_init_func_t) PHP_XXH3_128_Init,
  (php_hash_update_func_t) PHP_XXH3_128_Update,
  (php_hash_final_func_t) PHP_XXH3_128_Final,
  (php_hash_copy_func_t) PHP_XXH3_128_Copy,
  php_hash_serialize,
  php_hash_unserialize,
  NULL,
  16,
  8,
  sizeof(PHP_XXH3_128_CTX),
  0
};

PHP_HASH_API void PHP_XXH3_128_Init(PHP_XXH3_128_CTX *ctx, HashTable *args)
{
  _PHP_XXH3_Init(ctx, args, XXH3_128bits_reset_withSeed, XXH3_128bits_reset_withSecret, "xxh128");
}

PHP_HASH_API void PHP_XXH3_128_Update(PHP_XXH3_128_CTX *ctx, const unsigned char *in, size_t len)
{
  XXH3_128bits_update(&ctx->s, in, len);
}

PHP_HASH_API void PHP_XXH3_128_Final(unsigned char digest[16], PHP_XXH3_128_CTX *ctx)
{
  XXH128_canonicalFromHash((XXH128_canonical_t*)digest, XXH3_128bits_digest(&ctx->s));
}

PHP_HASH_API zend_result PHP_XXH3_128_Copy(const php_hash_ops *ops, const PHP_XXH3_128_CTX *orig_context, PHP_XXH3_128_CTX *copy_context)
{
  copy_context->s = orig_context->s;
  return SUCCESS;
}


Coverage Report

Created: 2025-06-13 06:43

Line	Count	Source (jump to first uncovered line)
1		/*
2		+----------------------------------------------------------------------+
3		\| Copyright (c) The PHP Group \|
4		+----------------------------------------------------------------------+
5		\| This source file is subject to version 3.01 of the PHP license, \|
6		\| that is bundled with this package in the file LICENSE, and is \|
7		\| available through the world-wide-web at the following url: \|
8		\| https://www.php.net/license/3_01.txt \|
9		\| If you did not receive a copy of the PHP license and are unable to \|
10		\| obtain it through the world-wide-web, please send a note to \|
11		\| license@php.net so we can mail you a copy immediately. \|
12		+----------------------------------------------------------------------+
13		\| Author: Anatol Belski <ab@php.net> \|
14		+----------------------------------------------------------------------+
15		*/
16
17		#include "php_hash.h"
18		#include "php_hash_xxhash.h"
19
20		static int php_hash_xxh32_unserialize(
21		php_hashcontext_object hash, zend_long magic, const zval zv);
22		static int php_hash_xxh64_unserialize(
23		php_hashcontext_object hash, zend_long magic, const zval zv);
24
25		const php_hash_ops php_hash_xxh32_ops = {
26		"xxh32",
27		(php_hash_init_func_t) PHP_XXH32Init,
28		(php_hash_update_func_t) PHP_XXH32Update,
29		(php_hash_final_func_t) PHP_XXH32Final,
30		(php_hash_copy_func_t) PHP_XXH32Copy,
31		php_hash_serialize,
32		php_hash_xxh32_unserialize,
33		PHP_XXH32_SPEC,
34		4,
35		4,
36		sizeof(PHP_XXH32_CTX),
37		0
38		};
39
40		PHP_HASH_API void PHP_XXH32Init(PHP_XXH32_CTX ctx, HashTable args)
41	108	{
42		/* XXH32_createState() is not used intentionally. */
43	108	memset(&ctx->s, 0, sizeof ctx->s);
44
45	108	if (args) {
46	0	zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1);
47		/* This might be a bit too restrictive, but thinking that a seed might be set
48		once and for all, it should be done a clean way. */
49	0	if (seed) {
50	0	if (IS_LONG == Z_TYPE_P(seed)) {
51	0	XXH32_reset(&ctx->s, (XXH32_hash_t)Z_LVAL_P(seed));
52	0	return;
53	0	} else {
54	0	php_error_docref(NULL, E_DEPRECATED, "Passing a seed of a type other than int is deprecated because it is the same as setting the seed to 0");
55	0	}
56	0	}
57	0	}
58
59	108	XXH32_reset(&ctx->s, 0);
60	108	}
61
62		PHP_HASH_API void PHP_XXH32Update(PHP_XXH32_CTX ctx, const unsigned char in, size_t len)
63	82	{
64	82	XXH32_update(&ctx->s, in, len);
65	82	}
66
67		PHP_HASH_API void PHP_XXH32Final(unsigned char digest[4], PHP_XXH32_CTX *ctx)
68	82	{
69	82	XXH32_canonicalFromHash((XXH32_canonical_t*)digest, XXH32_digest(&ctx->s));
70	82	}
71
72		PHP_HASH_API zend_result PHP_XXH32Copy(const php_hash_ops ops, const PHP_XXH32_CTX orig_context, PHP_XXH32_CTX *copy_context)
73	0	{
74	0	copy_context->s = orig_context->s;
75	0	return SUCCESS;
76	0	}
77
78		static int php_hash_xxh32_unserialize(
79		php_hashcontext_object hash, zend_long magic, const zval zv)
80	108	{
81	108	PHP_XXH32_CTX ctx = (PHP_XXH32_CTX ) hash->context;
82	108	int r = FAILURE;
83	108	if (magic == PHP_HASH_SERIALIZE_MAGIC_SPEC
84	108	&& (r = php_hash_unserialize_spec(hash, zv, PHP_XXH32_SPEC)) == SUCCESS
85	108	&& ctx->s.memsize < 16) {
86	82	return SUCCESS;
87	82	} else {
88	26	return r != SUCCESS ? r : -2000;
89	26	}
90	108	}
91
92		const php_hash_ops php_hash_xxh64_ops = {
93		"xxh64",
94		(php_hash_init_func_t) PHP_XXH64Init,
95		(php_hash_update_func_t) PHP_XXH64Update,
96		(php_hash_final_func_t) PHP_XXH64Final,
97		(php_hash_copy_func_t) PHP_XXH64Copy,
98		php_hash_serialize,
99		php_hash_xxh64_unserialize,
100		PHP_XXH64_SPEC,
101		8,
102		8,
103		sizeof(PHP_XXH64_CTX),
104		0
105		};
106
107		PHP_HASH_API void PHP_XXH64Init(PHP_XXH64_CTX ctx, HashTable args)
108	70	{
109		/* XXH64_createState() is not used intentionally. */
110	70	memset(&ctx->s, 0, sizeof ctx->s);
111
112	70	if (args) {
113	0	zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1);
114		/* This might be a bit too restrictive, but thinking that a seed might be set
115		once and for all, it should be done a clean way. */
116	0	if (seed && IS_LONG == Z_TYPE_P(seed)) {
117	0	XXH64_reset(&ctx->s, (XXH64_hash_t)Z_LVAL_P(seed));
118	0	return;
119	0	} else {
120	0	php_error_docref(NULL, E_DEPRECATED, "Passing a seed of a type other than int is deprecated because it is the same as setting the seed to 0");
121	0	}
122	0	}
123
124	70	XXH64_reset(&ctx->s, 0);
125	70	}
126
127		PHP_HASH_API void PHP_XXH64Update(PHP_XXH64_CTX ctx, const unsigned char in, size_t len)
128	58	{
129	58	XXH64_update(&ctx->s, in, len);
130	58	}
131
132		PHP_HASH_API void PHP_XXH64Final(unsigned char digest[8], PHP_XXH64_CTX *ctx)
133	58	{
134	58	XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH64_digest(&ctx->s));
135	58	}
136
137		PHP_HASH_API zend_result PHP_XXH64Copy(const php_hash_ops ops, const PHP_XXH64_CTX orig_context, PHP_XXH64_CTX *copy_context)
138	0	{
139	0	copy_context->s = orig_context->s;
140	0	return SUCCESS;
141	0	}
142
143		const php_hash_ops php_hash_xxh3_64_ops = {
144		"xxh3",
145		(php_hash_init_func_t) PHP_XXH3_64_Init,
146		(php_hash_update_func_t) PHP_XXH3_64_Update,
147		(php_hash_final_func_t) PHP_XXH3_64_Final,
148		(php_hash_copy_func_t) PHP_XXH3_64_Copy,
149		php_hash_serialize,
150		php_hash_unserialize,
151		NULL,
152		8,
153		8,
154		sizeof(PHP_XXH3_64_CTX),
155		0
156		};
157
158		typedef XXH_errorcode (xxh3_reset_with_secret_func_t)(XXH3_state_t, const void*, size_t);
159		typedef XXH_errorcode (xxh3_reset_with_seed_func_t)(XXH3_state_t, XXH64_hash_t);
160
161		static void _PHP_XXH3_Init(PHP_XXH3_64_CTX ctx, HashTable args,
162		xxh3_reset_with_seed_func_t func_init_seed, xxh3_reset_with_secret_func_t func_init_secret, const char* algo_name)
163	0	{
164	0	memset(&ctx->s, 0, sizeof ctx->s);
165
166	0	if (args) {
167	0	zval *_seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1);
168	0	zval *_secret = zend_hash_str_find_deref(args, "secret", sizeof("secret") - 1);
169
170	0	if (_seed && _secret) {
171	0	zend_throw_error(NULL, "%s: Only one of seed or secret is to be passed for initialization", algo_name);
172	0	return;
173	0	}
174
175	0	if (_seed && IS_LONG != Z_TYPE_P(_seed)) {
176	0	php_error_docref(NULL, E_DEPRECATED, "Passing a seed of a type other than int is deprecated because it is ignored");
177	0	}
178
179	0	if (_seed && IS_LONG == Z_TYPE_P(_seed)) {
180		/* This might be a bit too restrictive, but thinking that a seed might be set
181		once and for all, it should be done a clean way. */
182	0	func_init_seed(&ctx->s, (XXH64_hash_t)Z_LVAL_P(_seed));
183	0	return;
184	0	} else if (_secret) {
185	0	if (IS_STRING != Z_TYPE_P(_secret)) {
186	0	php_error_docref(NULL, E_DEPRECATED, "Passing a secret of a type other than string is deprecated because it implicitly converts to a string, potentially hiding bugs");
187	0	}
188	0	zend_string *secret_string = zval_try_get_string(_secret);
189	0	if (UNEXPECTED(!secret_string)) {
190	0	ZEND_ASSERT(EG(exception));
191	0	return;
192	0	}
193	0	size_t len = ZSTR_LEN(secret_string);
194	0	if (len < PHP_XXH3_SECRET_SIZE_MIN) {
195	0	zend_string_release(secret_string);
196	0	zend_throw_error(NULL, "%s: Secret length must be >= %u bytes, %zu bytes passed", algo_name, XXH3_SECRET_SIZE_MIN, len);
197	0	return;
198	0	}
199	0	if (len > sizeof(ctx->secret)) {
200	0	len = sizeof(ctx->secret);
201	0	php_error_docref(NULL, E_WARNING, "%s: Secret content exceeding %zu bytes discarded", algo_name, sizeof(ctx->secret));
202	0	}
203	0	memcpy((unsigned char *)ctx->secret, ZSTR_VAL(secret_string), len);
204	0	zend_string_release(secret_string);
205	0	func_init_secret(&ctx->s, ctx->secret, len);
206	0	return;
207	0	}
208	0	}
209
210	0	func_init_seed(&ctx->s, 0);
211	0	}
212
213		PHP_HASH_API void PHP_XXH3_64_Init(PHP_XXH3_64_CTX ctx, HashTable args)
214	0	{
215	0	_PHP_XXH3_Init(ctx, args, XXH3_64bits_reset_withSeed, XXH3_64bits_reset_withSecret, "xxh3");
216	0	}
217
218		PHP_HASH_API void PHP_XXH3_64_Update(PHP_XXH3_64_CTX ctx, const unsigned char in, size_t len)
219	0	{
220	0	XXH3_64bits_update(&ctx->s, in, len);
221	0	}
222
223		PHP_HASH_API void PHP_XXH3_64_Final(unsigned char digest[8], PHP_XXH3_64_CTX *ctx)
224	0	{
225	0	XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH3_64bits_digest(&ctx->s));
226	0	}
227
228		PHP_HASH_API zend_result PHP_XXH3_64_Copy(const php_hash_ops ops, const PHP_XXH3_64_CTX orig_context, PHP_XXH3_64_CTX *copy_context)
229	0	{
230	0	copy_context->s = orig_context->s;
231	0	return SUCCESS;
232	0	}
233
234		static int php_hash_xxh64_unserialize(
235		php_hashcontext_object hash, zend_long magic, const zval zv)
236	70	{
237	70	PHP_XXH64_CTX ctx = (PHP_XXH64_CTX ) hash->context;
238	70	int r = FAILURE;
239	70	if (magic == PHP_HASH_SERIALIZE_MAGIC_SPEC
240	70	&& (r = php_hash_unserialize_spec(hash, zv, PHP_XXH64_SPEC)) == SUCCESS
241	70	&& ctx->s.memsize < 32) {
242	58	return SUCCESS;
243	58	} else {
244	12	return r != SUCCESS ? r : -2000;
245	12	}
246	70	}
247
248		const php_hash_ops php_hash_xxh3_128_ops = {
249		"xxh128",
250		(php_hash_init_func_t) PHP_XXH3_128_Init,
251		(php_hash_update_func_t) PHP_XXH3_128_Update,
252		(php_hash_final_func_t) PHP_XXH3_128_Final,
253		(php_hash_copy_func_t) PHP_XXH3_128_Copy,
254		php_hash_serialize,
255		php_hash_unserialize,
256		NULL,
257		16,
258		8,
259		sizeof(PHP_XXH3_128_CTX),
260		0
261		};
262
263		PHP_HASH_API void PHP_XXH3_128_Init(PHP_XXH3_128_CTX ctx, HashTable args)
264	0	{
265	0	_PHP_XXH3_Init(ctx, args, XXH3_128bits_reset_withSeed, XXH3_128bits_reset_withSecret, "xxh128");
266	0	}
267
268		PHP_HASH_API void PHP_XXH3_128_Update(PHP_XXH3_128_CTX ctx, const unsigned char in, size_t len)
269	0	{
270	0	XXH3_128bits_update(&ctx->s, in, len);
271	0	}
272
273		PHP_HASH_API void PHP_XXH3_128_Final(unsigned char digest[16], PHP_XXH3_128_CTX *ctx)
274	0	{
275	0	XXH128_canonicalFromHash((XXH128_canonical_t*)digest, XXH3_128bits_digest(&ctx->s));
276	0	}
277
278		PHP_HASH_API zend_result PHP_XXH3_128_Copy(const php_hash_ops ops, const PHP_XXH3_128_CTX orig_context, PHP_XXH3_128_CTX *copy_context)
279	0	{
280	0	copy_context->s = orig_context->s;
281	0	return SUCCESS;
282	0	}
283