suricata
ippair-storage.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2021 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  * IPPair wrapper around storage api
24  */
25 
26 #include "suricata-common.h"
27 #include "ippair-storage.h"
28 #include "util-unittest.h"
29 
30 unsigned int IPPairStorageSize(void)
31 {
32  return StorageGetSize(STORAGE_IPPAIR);
33 }
34 
35 void *IPPairGetStorageById(IPPair *h, IPPairStorageId id)
36 {
37  return StorageGetById(h->storage, STORAGE_IPPAIR, id.id);
38 }
39 
40 int IPPairSetStorageById(IPPair *h, IPPairStorageId id, void *ptr)
41 {
42  return StorageSetById(h->storage, STORAGE_IPPAIR, id.id, ptr);
43 }
44 
45 void *IPPairAllocStorageById(IPPair *h, IPPairStorageId id)
46 {
47  return StorageAllocByIdPrealloc(h->storage, STORAGE_IPPAIR, id.id);
48 }
49 
50 void IPPairFreeStorage(IPPair *h)
51 {
52  if (IPPairStorageSize() > 0)
53  StorageFreeAll(h->storage, STORAGE_IPPAIR);
54 }
55 
56 IPPairStorageId IPPairStorageRegister(const char *name, const unsigned int size,
57  void *(*Alloc)(unsigned int), void (*Free)(void *))
58 {
59  int id = StorageRegister(STORAGE_IPPAIR, name, size, Alloc, Free);
60  IPPairStorageId ippsi = { .id = id };
61  return ippsi;
62 }
63 
64 #ifdef UNITTESTS
65 
66 static void *StorageTestAlloc(unsigned int size)
67 {
68  void *x = SCMalloc(size);
69  return x;
70 }
71 static void StorageTestFree(void *x)
72 {
73  if (x)
74  SCFree(x);
75 }
76 
77 static int IPPairStorageTest01(void)
78 {
79  StorageCleanup();
80  StorageInit();
81 
82  IPPairStorageId id1 = IPPairStorageRegister("test", 8, StorageTestAlloc, StorageTestFree);
83  FAIL_IF(id1.id < 0);
84  IPPairStorageId id2 = IPPairStorageRegister("variable", 24, StorageTestAlloc, StorageTestFree);
85  FAIL_IF(id2.id < 0);
86  IPPairStorageId id3 =
87  IPPairStorageRegister("store", sizeof(void *), StorageTestAlloc, StorageTestFree);
88  FAIL_IF(id3.id < 0);
89 
90  FAIL_IF(StorageFinalize() < 0);
91 
92  IPPairInitConfig(1);
93 
94  Address a, b;
95  memset(&a, 0x00, sizeof(a));
96  memset(&b, 0x00, sizeof(b));
97  a.addr_data32[0] = 0x01020304;
98  b.addr_data32[0] = 0x04030201;
99  a.family = AF_INET;
100  b.family = AF_INET;
101  IPPair *h = IPPairGetIPPairFromHash(&a, &b);
102  FAIL_IF_NULL(h);
103 
104  void *ptr = IPPairGetStorageById(h, id1);
105  FAIL_IF_NOT_NULL(ptr);
106  ptr = IPPairGetStorageById(h, id2);
107  FAIL_IF_NOT_NULL(ptr);
108  ptr = IPPairGetStorageById(h, id3);
109  FAIL_IF_NOT_NULL(ptr);
110 
111  void *ptr1a = IPPairAllocStorageById(h, id1);
112  FAIL_IF(ptr1a == NULL);
113  void *ptr2a = IPPairAllocStorageById(h, id2);
114  FAIL_IF(ptr2a == NULL);
115  void *ptr3a = IPPairAllocStorageById(h, id3);
116  FAIL_IF(ptr3a == NULL);
117 
118  void *ptr1b = IPPairGetStorageById(h, id1);
119  FAIL_IF(ptr1a != ptr1b);
120  void *ptr2b = IPPairGetStorageById(h, id2);
121  FAIL_IF(ptr2a != ptr2b);
122  void *ptr3b = IPPairGetStorageById(h, id3);
123  FAIL_IF(ptr3a != ptr3b);
124 
125  IPPairRelease(h);
126  IPPairShutdown();
127  StorageCleanup();
128  PASS;
129 }
130 
131 static int IPPairStorageTest02(void)
132 {
133  StorageCleanup();
134  StorageInit();
135 
136  IPPairStorageId id1 = IPPairStorageRegister("test", sizeof(void *), NULL, StorageTestFree);
137  FAIL_IF(id1.id < 0);
138 
139  FAIL_IF(StorageFinalize() < 0);
140 
141  IPPairInitConfig(1);
142 
143  Address a, b;
144  memset(&a, 0x00, sizeof(a));
145  memset(&b, 0x00, sizeof(b));
146  a.addr_data32[0] = 0x01020304;
147  b.addr_data32[0] = 0x04030201;
148  a.family = AF_INET;
149  b.family = AF_INET;
150  IPPair *h = IPPairGetIPPairFromHash(&a, &b);
151  FAIL_IF(h == NULL);
152 
153  void *ptr = IPPairGetStorageById(h, id1);
154  FAIL_IF_NOT_NULL(ptr);
155 
156  void *ptr1a = SCMalloc(128);
157  FAIL_IF(ptr1a == NULL);
158 
159  IPPairSetStorageById(h, id1, ptr1a);
160 
161  void *ptr1b = IPPairGetStorageById(h, id1);
162  FAIL_IF(ptr1a != ptr1b);
163 
164  IPPairRelease(h);
165  IPPairShutdown();
166  StorageCleanup();
167  PASS;
168 }
169 
170 static int IPPairStorageTest03(void)
171 {
172  StorageCleanup();
173  StorageInit();
174 
175  IPPairStorageId id1 = IPPairStorageRegister("test1", sizeof(void *), NULL, StorageTestFree);
176  FAIL_IF(id1.id < 0);
177  IPPairStorageId id2 = IPPairStorageRegister("test2", sizeof(void *), NULL, StorageTestFree);
178  FAIL_IF(id2.id < 0);
179  IPPairStorageId id3 = IPPairStorageRegister("test3", 32, StorageTestAlloc, StorageTestFree);
180  FAIL_IF(id3.id < 0);
181 
182  FAIL_IF(StorageFinalize() < 0);
183 
184  IPPairInitConfig(1);
185 
186  Address a, b;
187  memset(&a, 0x00, sizeof(a));
188  memset(&b, 0x00, sizeof(b));
189  a.addr_data32[0] = 0x01020304;
190  b.addr_data32[0] = 0x04030201;
191  a.family = AF_INET;
192  b.family = AF_INET;
193  IPPair *h = IPPairGetIPPairFromHash(&a, &b);
194  FAIL_IF(h == NULL);
195 
196  void *ptr = IPPairGetStorageById(h, id1);
197  FAIL_IF_NOT_NULL(ptr);
198 
199  void *ptr1a = SCMalloc(128);
200  FAIL_IF(ptr1a == NULL);
201 
202  IPPairSetStorageById(h, id1, ptr1a);
203 
204  void *ptr2a = SCMalloc(256);
205  FAIL_IF(ptr2a == NULL);
206 
207  IPPairSetStorageById(h, id2, ptr2a);
208 
209  void *ptr3a = IPPairAllocStorageById(h, id3);
210  FAIL_IF(ptr3a == NULL);
211 
212  void *ptr1b = IPPairGetStorageById(h, id1);
213  FAIL_IF(ptr1a != ptr1b);
214  void *ptr2b = IPPairGetStorageById(h, id2);
215  FAIL_IF(ptr2a != ptr2b);
216  void *ptr3b = IPPairGetStorageById(h, id3);
217  FAIL_IF(ptr3a != ptr3b);
218 
219  IPPairRelease(h);
220  IPPairShutdown();
221  StorageCleanup();
222  PASS;
223 }
224 #endif
225 
226 void RegisterIPPairStorageTests(void)
227 {
228 #ifdef UNITTESTS
229  UtRegisterTest("IPPairStorageTest01", IPPairStorageTest01);
230  UtRegisterTest("IPPairStorageTest02", IPPairStorageTest02);
231  UtRegisterTest("IPPairStorageTest03", IPPairStorageTest03);
232 #endif
233 }
IPPairStorageRegister
IPPairStorageId IPPairStorageRegister(const char *name, const unsigned int size, void *(*Alloc)(unsigned int), void(*Free)(void *))
Definition: ippair-storage.c:56
StorageFreeAll
void StorageFreeAll(Storage *storage, StorageEnum type)
Definition: util-storage.c:278
FAIL_IF_NULL
#define FAIL_IF_NULL(expr)
Fail a test if expression evaluates to NULL.
Definition: util-unittest.h:89
IPPairInitConfig
void IPPairInitConfig(bool quiet)
initialize the configuration
Definition: ippair.c:162
StorageInit
void StorageInit(void)
Definition: util-storage.c:70
IPPairRelease
void IPPairRelease(IPPair *h)
Definition: ippair.c:502
UtRegisterTest
void UtRegisterTest(const char *name, int(*TestFn)(void))
Register unit test.
Definition: util-unittest.c:103
StorageCleanup
void StorageCleanup(void)
Definition: util-storage.c:78
STORAGE_IPPAIR
@ STORAGE_IPPAIR
Definition: util-storage.h:32
Address_
Definition: decode.h:112
IPPairSetStorageById
int IPPairSetStorageById(IPPair *h, IPPairStorageId id, void *ptr)
Definition: ippair-storage.c:40
IPPairStorageId::id
int id
Definition: ippair-storage.h:32
IPPairStorageSize
unsigned int IPPairStorageSize(void)
Definition: ippair-storage.c:30
util-unittest.h
IPPairShutdown
void IPPairShutdown(void)
shutdown the flow engine
Definition: ippair.c:290
FAIL_IF_NOT_NULL
#define FAIL_IF_NOT_NULL(expr)
Fail a test if expression evaluates to non-NULL.
Definition: util-unittest.h:96
PASS
#define PASS
Pass the test.
Definition: util-unittest.h:105
IPPair_::storage
Storage storage[]
Definition: ippair.h:77
IPPairGetIPPairFromHash
IPPair * IPPairGetIPPairFromHash(Address *a, Address *b)
Definition: ippair.c:521
IPPairAllocStorageById
void * IPPairAllocStorageById(IPPair *h, IPPairStorageId id)
Definition: ippair-storage.c:45
StorageFinalize
int StorageFinalize(void)
Definition: util-storage.c:140
name
const char * name
Definition: tm-threads.c:2163
FAIL_IF
#define FAIL_IF(expr)
Fail a test if expression evaluates to true.
Definition: util-unittest.h:71
suricata-common.h
RegisterIPPairStorageTests
void RegisterIPPairStorageTests(void)
Definition: ippair-storage.c:226
IPPair_
Definition: ippair.h:58
StorageSetById
int StorageSetById(Storage *storage, const StorageEnum type, const int id, void *ptr)
set storage for id
Definition: util-storage.c:226
StorageAllocByIdPrealloc
void * StorageAllocByIdPrealloc(Storage *storage, StorageEnum type, int id)
AllocById func for prealloc'd base storage (storage ptrs are part of another memory block)
Definition: util-storage.c:238
IPPairGetStorageById
void * IPPairGetStorageById(IPPair *h, IPPairStorageId id)
Definition: ippair-storage.c:35
SCMalloc
#define SCMalloc(sz)
Definition: util-mem.h:47
SCFree
#define SCFree(p)
Definition: util-mem.h:61
Address_::family
char family
Definition: decode.h:113
IPPairFreeStorage
void IPPairFreeStorage(IPPair *h)
Definition: ippair-storage.c:50
StorageGetById
void * StorageGetById(const Storage *storage, const StorageEnum type, const int id)
get storage for id
Definition: util-storage.c:215
ippair-storage.h
IPPairStorageId
Definition: ippair-storage.h:31
StorageGetSize
unsigned int StorageGetSize(StorageEnum type)
get the size of the void array used to store the pointers
Definition: util-storage.c:210
StorageRegister
int StorageRegister(const StorageEnum type, const char *name, const unsigned int size, void *(*Alloc)(unsigned int), void(*Free)(void *))
Register new storage.
Definition: util-storage.c:102