22553697083

Committed 01 Mar 2026 09:58PM UTC coverage: 75.673% (+2.0%) from 73.687%

Build # 22553697083

Build Type

Pull #14925

github

Committed by

web-flow

Commit Message

Merge 288827f07 into 90823fa90

Pull Request Pull Request #14925: hs: false positive coverity warning in a reference string v1

Run Details

241615 of 319288 relevant lines covered (75.67%)

1333554.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.21

/src/datasets-string.c

/* Copyright (C) 2017-2024 Open Information Security Foundation
 *
 * You can copy, redistribute or modify this Program under the terms of
 * the GNU General Public License version 2 as published by the Free
 * Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

/**
 * \file
 *
 * \author Victor Julien <victor@inliniac.net>
 */

#include "suricata-common.h"
#include "conf.h"
#include "datasets.h"
#include "datasets-string.h"
#include "util-thash.h"
#include "util-print.h"
#include "util-hash-lookup3.h"
#include "rust.h"

#if 0
static int StringAsAscii(const void *s, char *out, size_t out_size)
{
    const StringType *str = s;
    uint32_t offset = 0;
    PrintRawUriBuf(out, &offset, out_size, str->ptr, str->len);
    if (out[0] == '\0')
        return 0;
    strlcat(out, "\n", out_size);
    return strlen(out);
}
#endif

int StringAsBase64(const void *s, char *out, size_t out_size)
{
    const StringType *str = s;

    unsigned long len = SCBase64EncodeBufferSize(str->len);
    if (len + 2 > out_size) {
        // linefeed and final zero : signal we need more space
        return (int)len + 2;
    }
    if (SCBase64Encode((unsigned char *)str->ptr, str->len, (uint8_t *)out, &len) != SC_BASE64_OK)
        return 0;

    strlcat(out, "\n", out_size);
    return (int)strlen(out);
}

int StringSet(void *dst, void *src)
{
    StringType *src_s = src;
    StringType *dst_s = dst;
    SCLogDebug("dst %p src %p, src_s->ptr %p src_s->len %u", dst, src, src_s->ptr, src_s->len);

    dst_s->len = src_s->len;
    dst_s->ptr = SCMalloc(dst_s->len);
    if (dst_s->ptr == NULL) {
        SCLogError("Failed to allocate memory for string of length %u", dst_s->len);
        return -1;
    }
    memcpy(dst_s->ptr, src_s->ptr, dst_s->len);

    dst_s->rep = src_s->rep;
    SCLogDebug("dst %p src %p, dst_s->ptr %p dst_s->len %u", dst, src, dst_s->ptr, dst_s->len);
    return 0;
}

int StringJsonSet(void *dst, void *src)
{
    if (StringSet(dst, src) < 0)
        return -1;

    StringType *src_s = src;
    StringType *dst_s = dst;

    if (DatajsonCopyJson(&dst_s->json, &src_s->json) < 0) {
        SCFree(dst_s->ptr);
        return -1;
    }

    return 0;
}

bool StringCompare(void *a, void *b)
{
    const StringType *as = a;
    const StringType *bs = b;

    if (as->len != bs->len)
        return false;

    return (memcmp(as->ptr, bs->ptr, as->len) == 0);
}

uint32_t StringHash(uint32_t hash_seed, void *s)
{
    StringType *str = s;
    return hashlittle_safe(str->ptr, str->len, hash_seed);
}

uint32_t StringGetLength(void *s)
{
    StringType *str = s;
    return str->len;
}

// base data stays in hash
void StringFree(void *s)
{
    StringType *str = s;
    SCFree(str->ptr);
}

void StringJsonFree(void *s)
{
    StringType *str = s;
    SCFree(str->ptr);
    if (str->json.value) {
        SCFree(str->json.value);
    }
}

uint32_t StringJsonGetLength(void *s)
{
    StringType *str = s;
    return str->json.len + str->len;
}

1	/* Copyright (C) 2017-2024 Open Information Security Foundation
2	*
3	* You can copy, redistribute or modify this Program under the terms of
4	* the GNU General Public License version 2 as published by the Free
5	* Software Foundation.
6	*
7	* This program is distributed in the hope that it will be useful,
8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10	* GNU General Public License for more details.
11	*
12	* You should have received a copy of the GNU General Public License
13	* version 2 along with this program; if not, write to the Free Software
14	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15	* 02110-1301, USA.
16	*/
17
18	/**
19	* \file
20	*
21	* \author Victor Julien <victor@inliniac.net>
22	*/
23
24	#include "suricata-common.h"
25	#include "conf.h"
26	#include "datasets.h"
27	#include "datasets-string.h"
28	#include "util-thash.h"
29	#include "util-print.h"
30	#include "util-hash-lookup3.h"
31	#include "rust.h"
32
33	#if 0
34	static int StringAsAscii(const void s, char out, size_t out_size)
35	{
36	const StringType *str = s;
37	uint32_t offset = 0;
38	PrintRawUriBuf(out, &offset, out_size, str->ptr, str->len);
39	if (out[0] == '\0')
40	return 0;
41	strlcat(out, "\n", out_size);
42	return strlen(out);
43	}
44	#endif
45
46	int StringAsBase64(const void s, char out, size_t out_size)
47	{	×
48	const StringType *str = s;	×
49
50	unsigned long len = SCBase64EncodeBufferSize(str->len);	×
51	if (len + 2 > out_size) {	×
52	// linefeed and final zero : signal we need more space
53	return (int)len + 2;	×
54	}	×
55	if (SCBase64Encode((unsigned char )str->ptr, str->len, (uint8_t )out, &len) != SC_BASE64_OK)	×
56	return 0;	×
57
58	strlcat(out, "\n", out_size);	×
59	return (int)strlen(out);	×
60	}	×
61
62	int StringSet(void dst, void src)
63	{	38✔
64	StringType *src_s = src;	38✔
65	StringType *dst_s = dst;	38✔
66	SCLogDebug("dst %p src %p, src_s->ptr %p src_s->len %u", dst, src, src_s->ptr, src_s->len);	38✔
67
68	dst_s->len = src_s->len;	38✔
69	dst_s->ptr = SCMalloc(dst_s->len);	38✔
70	if (dst_s->ptr == NULL) {	38✔
71	SCLogError("Failed to allocate memory for string of length %u", dst_s->len);	×
72	return -1;	×
73	}	×
74	memcpy(dst_s->ptr, src_s->ptr, dst_s->len);	38✔
75
76	dst_s->rep = src_s->rep;	38✔
77	SCLogDebug("dst %p src %p, dst_s->ptr %p dst_s->len %u", dst, src, dst_s->ptr, dst_s->len);	38✔
78	return 0;	38✔
79	}	38✔
80
81	int StringJsonSet(void dst, void src)
82	{	×
83	if (StringSet(dst, src) < 0)	×
84	return -1;	×
85
86	StringType *src_s = src;	×
87	StringType *dst_s = dst;	×
88
89	if (DatajsonCopyJson(&dst_s->json, &src_s->json) < 0) {	×
90	SCFree(dst_s->ptr);	×
91	return -1;	×
92	}	×
93
94	return 0;	×
95	}	×
96
97	bool StringCompare(void a, void b)
98	{	174✔
99	const StringType *as = a;	174✔
100	const StringType *bs = b;	174✔
101
102	if (as->len != bs->len)	174✔
103	return false;	×
104
105	return (memcmp(as->ptr, bs->ptr, as->len) == 0);	174✔
106	}	174✔
107
108	uint32_t StringHash(uint32_t hash_seed, void *s)
109	{	364✔
110	StringType *str = s;	364✔
111	return hashlittle_safe(str->ptr, str->len, hash_seed);	364✔
112	}	364✔
113
114	uint32_t StringGetLength(void *s)
115	{	1,204,038✔
116	StringType *str = s;	1,204,038✔
117	return str->len;	1,204,038✔
118	}	1,204,038✔
119
120	// base data stays in hash
121	void StringFree(void *s)
122	{	1,204,000✔
123	StringType *str = s;	1,204,000✔
124	SCFree(str->ptr);	1,204,000✔
125	}	1,204,000✔
126
127	void StringJsonFree(void *s)
128	{	5,000✔
129	StringType *str = s;	5,000✔
130	SCFree(str->ptr);	5,000✔
131	if (str->json.value) {	5,000✔
132	SCFree(str->json.value);	×
133	}	×
134	}	5,000✔
135
136	uint32_t StringJsonGetLength(void *s)
137	{	5,000✔
138	StringType *str = s;	5,000✔
139	return str->json.len + str->len;	5,000✔
140	}	5,000✔

OISF / suricata / 22553697083

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous