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 
29 unsigned int SCIPPairStorageSize(void)
30 {
31  return SCStorageGetSize(STORAGE_IPPAIR);
32 }
33 
34 void *SCIPPairGetStorageById(IPPair *h, SCIPPairStorageId id)
35 {
36  return SCStorageGetById(h->storage, STORAGE_IPPAIR, id.id);
37 }
38 
39 int SCIPPairSetStorageById(IPPair *h, SCIPPairStorageId id, void *ptr)
40 {
41  return SCStorageSetById(h->storage, STORAGE_IPPAIR, id.id, ptr);
42 }
43 
44 void SCIPPairFreeStorage(IPPair *h)
45 {
46  if (SCIPPairStorageSize() > 0)
47  SCStorageFreeAll(h->storage, STORAGE_IPPAIR);
48 }
49 
50 SCIPPairStorageId SCIPPairStorageRegister(const char *name, void (*Free)(void *))
51 {
52  int id = SCStorageRegister(STORAGE_IPPAIR, name, Free);
53  SCIPPairStorageId ippsi = { .id = id };
54  return ippsi;
55 }
56 
57 #ifdef UNITTESTS
58 
59 static void StorageTestFree(void *x)
60 {
61  if (x)
62  SCFree(x);
63 }
64 
65 static int IPPairStorageTest01(void)
66 {
67  SCStorageCleanup();
68  SCStorageInit();
69 
70  SCIPPairStorageId id1 = SCIPPairStorageRegister("test", StorageTestFree);
71  FAIL_IF(id1.id < 0);
72  SCIPPairStorageId id2 = SCIPPairStorageRegister("variable", StorageTestFree);
73  FAIL_IF(id2.id < 0);
74  SCIPPairStorageId id3 = SCIPPairStorageRegister("store", StorageTestFree);
75  FAIL_IF(id3.id < 0);
76 
77  FAIL_IF(SCStorageFinalize() < 0);
78 
79  IPPairInitConfig(1);
80 
81  Address a, b;
82  memset(&a, 0x00, sizeof(a));
83  memset(&b, 0x00, sizeof(b));
84  a.addr_data32[0] = 0x01020304;
85  b.addr_data32[0] = 0x04030201;
86  a.family = AF_INET;
87  b.family = AF_INET;
88  IPPair *h = IPPairGetIPPairFromHash(&a, &b);
89  FAIL_IF_NULL(h);
90 
91  void *ptr = SCIPPairGetStorageById(h, id1);
92  FAIL_IF_NOT_NULL(ptr);
93  ptr = SCIPPairGetStorageById(h, id2);
94  FAIL_IF_NOT_NULL(ptr);
95  ptr = SCIPPairGetStorageById(h, id3);
96  FAIL_IF_NOT_NULL(ptr);
97 
98  void *ptr1a = SCMalloc(8);
99  FAIL_IF(ptr1a == NULL);
100  FAIL_IF(SCIPPairSetStorageById(h, id1, ptr1a) != 0);
101  void *ptr2a = SCMalloc(24);
102  FAIL_IF(ptr2a == NULL);
103  FAIL_IF(SCIPPairSetStorageById(h, id2, ptr2a) != 0);
104  void *ptr3a = SCMalloc(16);
105  FAIL_IF(ptr3a == NULL);
106  FAIL_IF(SCIPPairSetStorageById(h, id3, ptr3a) != 0);
107 
108  void *ptr1b = SCIPPairGetStorageById(h, id1);
109  FAIL_IF(ptr1a != ptr1b);
110  void *ptr2b = SCIPPairGetStorageById(h, id2);
111  FAIL_IF(ptr2a != ptr2b);
112  void *ptr3b = SCIPPairGetStorageById(h, id3);
113  FAIL_IF(ptr3a != ptr3b);
114 
115  IPPairRelease(h);
116  IPPairShutdown();
117  SCStorageCleanup();
118  PASS;
119 }
120 
121 static int IPPairStorageTest02(void)
122 {
123  SCStorageCleanup();
124  SCStorageInit();
125 
126  SCIPPairStorageId id1 = SCIPPairStorageRegister("test", StorageTestFree);
127  FAIL_IF(id1.id < 0);
128 
129  FAIL_IF(SCStorageFinalize() < 0);
130 
131  IPPairInitConfig(1);
132 
133  Address a, b;
134  memset(&a, 0x00, sizeof(a));
135  memset(&b, 0x00, sizeof(b));
136  a.addr_data32[0] = 0x01020304;
137  b.addr_data32[0] = 0x04030201;
138  a.family = AF_INET;
139  b.family = AF_INET;
140  IPPair *h = IPPairGetIPPairFromHash(&a, &b);
141  FAIL_IF(h == NULL);
142 
143  void *ptr = SCIPPairGetStorageById(h, id1);
144  FAIL_IF_NOT_NULL(ptr);
145 
146  void *ptr1a = SCMalloc(128);
147  FAIL_IF(ptr1a == NULL);
148 
149  SCIPPairSetStorageById(h, id1, ptr1a);
150 
151  void *ptr1b = SCIPPairGetStorageById(h, id1);
152  FAIL_IF(ptr1a != ptr1b);
153 
154  IPPairRelease(h);
155  IPPairShutdown();
156  SCStorageCleanup();
157  PASS;
158 }
159 
160 static int IPPairStorageTest03(void)
161 {
162  SCStorageCleanup();
163  SCStorageInit();
164 
165  SCIPPairStorageId id1 = SCIPPairStorageRegister("test1", StorageTestFree);
166  FAIL_IF(id1.id < 0);
167  SCIPPairStorageId id2 = SCIPPairStorageRegister("test2", StorageTestFree);
168  FAIL_IF(id2.id < 0);
169  SCIPPairStorageId id3 = SCIPPairStorageRegister("test3", StorageTestFree);
170  FAIL_IF(id3.id < 0);
171 
172  FAIL_IF(SCStorageFinalize() < 0);
173 
174  IPPairInitConfig(1);
175 
176  Address a, b;
177  memset(&a, 0x00, sizeof(a));
178  memset(&b, 0x00, sizeof(b));
179  a.addr_data32[0] = 0x01020304;
180  b.addr_data32[0] = 0x04030201;
181  a.family = AF_INET;
182  b.family = AF_INET;
183  IPPair *h = IPPairGetIPPairFromHash(&a, &b);
184  FAIL_IF(h == NULL);
185 
186  void *ptr = SCIPPairGetStorageById(h, id1);
187  FAIL_IF_NOT_NULL(ptr);
188 
189  void *ptr1a = SCMalloc(128);
190  FAIL_IF(ptr1a == NULL);
191 
192  SCIPPairSetStorageById(h, id1, ptr1a);
193 
194  void *ptr2a = SCMalloc(256);
195  FAIL_IF(ptr2a == NULL);
196 
197  SCIPPairSetStorageById(h, id2, ptr2a);
198 
199  void *ptr3a = SCMalloc(32);
200  FAIL_IF(ptr3a == NULL);
201  SCIPPairSetStorageById(h, id3, ptr3a);
202 
203  void *ptr1b = SCIPPairGetStorageById(h, id1);
204  FAIL_IF(ptr1a != ptr1b);
205  void *ptr2b = SCIPPairGetStorageById(h, id2);
206  FAIL_IF(ptr2a != ptr2b);
207  void *ptr3b = SCIPPairGetStorageById(h, id3);
208  FAIL_IF(ptr3a != ptr3b);
209 
210  IPPairRelease(h);
211  IPPairShutdown();
212  SCStorageCleanup();
213  PASS;
214 }
215 #endif
216 
217 void SCRegisterIPPairStorageTests(void)
218 {
219 #ifdef UNITTESTS
220  UtRegisterTest("IPPairStorageTest01", IPPairStorageTest01);
221  UtRegisterTest("IPPairStorageTest02", IPPairStorageTest02);
222  UtRegisterTest("IPPairStorageTest03", IPPairStorageTest03);
223 #endif
224 }
FAIL_IF_NULL
#define FAIL_IF_NULL(expr)
Fail a test if expression evaluates to NULL.
Definition: util-unittest.h:89
SCStorageInit
void SCStorageInit(void)
Definition: util-storage.c:67
IPPairInitConfig
void IPPairInitConfig(bool quiet)
initialize the configuration
Definition: ippair.c:162
SCIPPairStorageId
Definition: ippair-storage.h:31
IPPairRelease
void IPPairRelease(IPPair *h)
Definition: ippair.c:505
UtRegisterTest
void UtRegisterTest(const char *name, int(*TestFn)(void))
Register unit test.
Definition: util-unittest.c:101
name
const char * name
Definition: detect-engine-proto.c:47
SCIPPairGetStorageById
void * SCIPPairGetStorageById(IPPair *h, SCIPPairStorageId id)
Definition: ippair-storage.c:34
SCIPPairStorageRegister
SCIPPairStorageId SCIPPairStorageRegister(const char *name, void(*Free)(void *))
Definition: ippair-storage.c:50
STORAGE_IPPAIR
@ STORAGE_IPPAIR
Definition: util-storage.h:32
Address_
Definition: decode.h:113
SCStorageSetById
int SCStorageSetById(Storage *storage, const StorageEnum type, const int id, void *ptr)
set storage for id
Definition: util-storage.c:217
SCIPPairSetStorageById
int SCIPPairSetStorageById(IPPair *h, SCIPPairStorageId id, void *ptr)
Definition: ippair-storage.c:39
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
SCRegisterIPPairStorageTests
void SCRegisterIPPairStorageTests(void)
Definition: ippair-storage.c:217
SCIPPairStorageId::id
int id
Definition: ippair-storage.h:32
SCStorageGetById
void * SCStorageGetById(const Storage *storage, const StorageEnum type, const int id)
get storage for id
Definition: util-storage.c:206
SCStorageRegister
int SCStorageRegister(const StorageEnum type, const char *name, void(*Free)(void *))
Register new storage.
Definition: util-storage.c:99
IPPairGetIPPairFromHash
IPPair * IPPairGetIPPairFromHash(Address *a, Address *b)
Definition: ippair.c:524
SCStorageGetSize
unsigned int SCStorageGetSize(StorageEnum type)
get the size of the void array used to store the pointers
Definition: util-storage.c:201
FAIL_IF
#define FAIL_IF(expr)
Fail a test if expression evaluates to true.
Definition: util-unittest.h:71
suricata-common.h
IPPair_
Definition: ippair.h:58
SCStorageFreeAll
void SCStorageFreeAll(Storage *storage, StorageEnum type)
Definition: util-storage.c:251
SCMalloc
#define SCMalloc(sz)
Definition: util-mem.h:47
SCFree
#define SCFree(p)
Definition: util-mem.h:61
SCStorageCleanup
void SCStorageCleanup(void)
Definition: util-storage.c:75
Address_::family
char family
Definition: decode.h:114
SCIPPairStorageSize
unsigned int SCIPPairStorageSize(void)
Definition: ippair-storage.c:29
ippair-storage.h
SCStorageFinalize
int SCStorageFinalize(void)
Definition: util-storage.c:134
SCIPPairFreeStorage
void SCIPPairFreeStorage(IPPair *h)
Definition: ippair-storage.c:44