/src/xz/src/liblzma/check/check.c

Source (jump to first uncovered line)
// SPDX-License-Identifier: 0BSD

///////////////////////////////////////////////////////////////////////////////
//
/// \file       check.c
/// \brief      Single API to access different integrity checks
//
//  Author:     Lasse Collin
//
///////////////////////////////////////////////////////////////////////////////

#include "check.h"


extern LZMA_API(lzma_bool)
lzma_check_is_supported(lzma_check type)
{
  if ((unsigned int)(type) > LZMA_CHECK_ID_MAX)
    return false;

  static const lzma_bool available_checks[LZMA_CHECK_ID_MAX + 1] = {
    true,   // LZMA_CHECK_NONE

#ifdef HAVE_CHECK_CRC32
    true,
#else
    false,
#endif

    false,  // Reserved
    false,  // Reserved

#ifdef HAVE_CHECK_CRC64
    true,
#else
    false,
#endif

    false,  // Reserved
    false,  // Reserved
    false,  // Reserved
    false,  // Reserved
    false,  // Reserved

#ifdef HAVE_CHECK_SHA256
    true,
#else
    false,
#endif

    false,  // Reserved
    false,  // Reserved
    false,  // Reserved
    false,  // Reserved
    false,  // Reserved
  };

  return available_checks[(unsigned int)(type)];
}


extern LZMA_API(uint32_t)
lzma_check_size(lzma_check type)
{
  if ((unsigned int)(type) > LZMA_CHECK_ID_MAX)
    return UINT32_MAX;

  // See file-format.txt section 2.1.1.2.
  static const uint8_t check_sizes[LZMA_CHECK_ID_MAX + 1] = {
    0,
    4, 4, 4,
    8, 8, 8,
    16, 16, 16,
    32, 32, 32,
    64, 64, 64
  };

  return check_sizes[(unsigned int)(type)];
}


extern void
lzma_check_init(lzma_check_state *check, lzma_check type)
{
  switch (type) {
  case LZMA_CHECK_NONE:
    break;

#ifdef HAVE_CHECK_CRC32
  case LZMA_CHECK_CRC32:
    check->state.crc32 = 0;
    break;
#endif

#ifdef HAVE_CHECK_CRC64
  case LZMA_CHECK_CRC64:
    check->state.crc64 = 0;
    break;
#endif

#ifdef HAVE_CHECK_SHA256
  case LZMA_CHECK_SHA256:
    lzma_sha256_init(check);
    break;
#endif

  default:
    break;
  }

  return;
}


extern void
lzma_check_update(lzma_check_state *check, lzma_check type,
    const uint8_t *buf, size_t size)
{
  switch (type) {
#ifdef HAVE_CHECK_CRC32
  case LZMA_CHECK_CRC32:
    check->state.crc32 = lzma_crc32(buf, size, check->state.crc32);
    break;
#endif

#ifdef HAVE_CHECK_CRC64
  case LZMA_CHECK_CRC64:
    check->state.crc64 = lzma_crc64(buf, size, check->state.crc64);
    break;
#endif

#ifdef HAVE_CHECK_SHA256
  case LZMA_CHECK_SHA256:
    lzma_sha256_update(buf, size, check);
    break;
#endif

  default:
    break;
  }

  return;
}


extern void
lzma_check_finish(lzma_check_state *check, lzma_check type)
{
  switch (type) {
#ifdef HAVE_CHECK_CRC32
  case LZMA_CHECK_CRC32:
    check->buffer.u32[0] = conv32le(check->state.crc32);
    break;
#endif

#ifdef HAVE_CHECK_CRC64
  case LZMA_CHECK_CRC64:
    check->buffer.u64[0] = conv64le(check->state.crc64);
    break;
#endif

#ifdef HAVE_CHECK_SHA256
  case LZMA_CHECK_SHA256:
    lzma_sha256_finish(check);
    break;
#endif

  default:
    break;
  }

  return;
}

Line	Count	Source (jump to first uncovered line)
1		// SPDX-License-Identifier: 0BSD
2
3		///////////////////////////////////////////////////////////////////////////////
4		//
5		/// \file check.c
6		/// \brief Single API to access different integrity checks
7		//
8		// Author: Lasse Collin
9		//
10		///////////////////////////////////////////////////////////////////////////////
11
12		#include "check.h"
13
14
15		extern LZMA_API(lzma_bool)
16		lzma_check_is_supported(lzma_check type)
17	2.89k	{
18	2.89k	if ((unsigned int)(type) > LZMA_CHECK_ID_MAX)
19	0	return false;
20
21	2.89k	static const lzma_bool available_checks[LZMA_CHECK_ID_MAX + 1] = {
22	2.89k	true, // LZMA_CHECK_NONE
23
24	2.89k	#ifdef HAVE_CHECK_CRC32
25	2.89k	true,
26		#else
27		false,
28		#endif
29
30	2.89k	false, // Reserved
31	2.89k	false, // Reserved
32
33	2.89k	#ifdef HAVE_CHECK_CRC64
34	2.89k	true,
35		#else
36		false,
37		#endif
38
39	2.89k	false, // Reserved
40	2.89k	false, // Reserved
41	2.89k	false, // Reserved
42	2.89k	false, // Reserved
43	2.89k	false, // Reserved
44
45	2.89k	#ifdef HAVE_CHECK_SHA256
46	2.89k	true,
47		#else
48		false,
49		#endif
50
51	2.89k	false, // Reserved
52	2.89k	false, // Reserved
53	2.89k	false, // Reserved
54	2.89k	false, // Reserved
55	2.89k	false, // Reserved
56	2.89k	};
57
58	2.89k	return available_checks[(unsigned int)(type)];
59	2.89k	}
60
61
62		extern LZMA_API(uint32_t)
63		lzma_check_size(lzma_check type)
64	42.5k	{
65	42.5k	if ((unsigned int)(type) > LZMA_CHECK_ID_MAX)
66	0	return UINT32_MAX;
67
68		// See file-format.txt section 2.1.1.2.
69	42.5k	static const uint8_t check_sizes[LZMA_CHECK_ID_MAX + 1] = {
70	42.5k	0,
71	42.5k	4, 4, 4,
72	42.5k	8, 8, 8,
73	42.5k	16, 16, 16,
74	42.5k	32, 32, 32,
75	42.5k	64, 64, 64
76	42.5k	};
77
78	42.5k	return check_sizes[(unsigned int)(type)];
79	42.5k	}
80
81
82		extern void
83		lzma_check_init(lzma_check_state *check, lzma_check type)
84	92.8k	{
85	92.8k	switch (type) {
86	5.48k	case LZMA_CHECK_NONE:
87	5.48k	break;
88
89	0	#ifdef HAVE_CHECK_CRC32
90	7.29k	case LZMA_CHECK_CRC32:
91	7.29k	check->state.crc32 = 0;
92	7.29k	break;
93	0	#endif
94
95	0	#ifdef HAVE_CHECK_CRC64
96	5.03k	case LZMA_CHECK_CRC64:
97	5.03k	check->state.crc64 = 0;
98	5.03k	break;
99	0	#endif
100
101	0	#ifdef HAVE_CHECK_SHA256
102	67.7k	case LZMA_CHECK_SHA256:
103	67.7k	lzma_sha256_init(check);
104	67.7k	break;
105	0	#endif
106
107	7.21k	default:
108	7.21k	break;
109	92.8k	}
110
111	92.8k	return;
112	92.8k	}
113
114
115		extern void
116		lzma_check_update(lzma_check_state *check, lzma_check type,
117		const uint8_t *buf, size_t size)
118	290k	{
119	290k	switch (type) {
120	0	#ifdef HAVE_CHECK_CRC32
121	21.9k	case LZMA_CHECK_CRC32:
122	21.9k	check->state.crc32 = lzma_crc32(buf, size, check->state.crc32);
123	21.9k	break;
124	0	#endif
125
126	0	#ifdef HAVE_CHECK_CRC64
127	13.3k	case LZMA_CHECK_CRC64:
128	13.3k	check->state.crc64 = lzma_crc64(buf, size, check->state.crc64);
129	13.3k	break;
130	0	#endif
131
132	0	#ifdef HAVE_CHECK_SHA256
133	19.3k	case LZMA_CHECK_SHA256:
134	19.3k	lzma_sha256_update(buf, size, check);
135	19.3k	break;
136	0	#endif
137
138	235k	default:
139	235k	break;
140	290k	}
141
142	290k	return;
143	290k	}
144
145
146		extern void
147		lzma_check_finish(lzma_check_state *check, lzma_check type)
148	3.86k	{
149	3.86k	switch (type) {
150	0	#ifdef HAVE_CHECK_CRC32
151	277	case LZMA_CHECK_CRC32:
152	277	check->buffer.u32[0] = conv32le(check->state.crc32);
153	277	break;
154	0	#endif
155
156	0	#ifdef HAVE_CHECK_CRC64
157	141	case LZMA_CHECK_CRC64:
158	141	check->buffer.u64[0] = conv64le(check->state.crc64);
159	141	break;
160	0	#endif
161
162	0	#ifdef HAVE_CHECK_SHA256
163	1.03k	case LZMA_CHECK_SHA256:
164	1.03k	lzma_sha256_finish(check);
165	1.03k	break;
166	0	#endif
167
168	2.41k	default:
169	2.41k	break;
170	3.86k	}
171
172	3.86k	return;
173	3.86k	}

Coverage Report

Created: 2025-08-12 07:37