OpenVAS Libraries  9.0.3
kb.h
Go to the documentation of this file.
1 /* OpenVAS Libraries
2  *
3  * Authors:
4  * Henri Doreau <henri.doreau@gmail.com>
5  *
6  * Copyright:
7  * Copyright (C) 2014 - Greenbone Networks GmbH.
8  *
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
23  *
24  * Knowledge base management API - Redis backend.
25  */
26 
27 #ifndef OPENVAS_KB_H
28 #define OPENVAS_KB_H
29 
30 #include <assert.h>
31 
32 #include "../base/nvti.h" /* for nvti_t */
33 
40 #define KB_PATH_DEFAULT "/tmp/redis.sock"
41 
42 
50  /* -- */
52 };
53 
57 enum kb_nvt_pos {
75 };
76 
81 struct kb_item
82 {
85  union
86  {
87  char *v_str;
88  int v_int;
89  };
91  struct kb_item *next;
93  size_t namelen;
94  char name[0];
95 };
96 
97 struct kb_operations;
98 
102 struct kb
103 {
104  const struct kb_operations *kb_ops;
105 };
106 
110 typedef struct kb *kb_t;
111 
119 {
120  /* ctor/dtor */
121  int (*kb_new) (kb_t *, const char *);
122  int (*kb_delete) (kb_t);
123  kb_t (*kb_find) (const char *, const char *);
124 
125  /* Actual kb operations */
126  struct kb_item *(*kb_get_single) (kb_t, const char *, enum kb_item_type);
127  char *(*kb_get_str) (kb_t, const char *);
128  int (*kb_get_int) (kb_t, const char *);
129  char *(*kb_get_nvt) (kb_t, const char *, enum kb_nvt_pos);
130  struct kb_item * (*kb_get_all) (kb_t, const char *);
131  struct kb_item * (*kb_get_pattern) (kb_t, const char *);
132  size_t (*kb_count) (kb_t, const char *);
133  int (*kb_add_str) (kb_t, const char *, const char *);
134  int (*kb_set_str) (kb_t, const char *, const char *);
135  int (*kb_add_int) (kb_t, const char *, int);
136  int (*kb_set_int) (kb_t, const char *, int);
137  int (*kb_add_nvt) (kb_t, const nvti_t *, const char *);
138  int (*kb_del_items) (kb_t, const char *);
139 
140  /* Utils */
141  int (*kb_lnk_reset) (kb_t);
142  int (*kb_flush) (kb_t, const char *);
143 };
144 
150 extern const struct kb_operations *KBDefaultOperations;
151 
155 void kb_item_free (struct kb_item *);
156 
157 
163 static inline int kb_new (kb_t *kb, const char *kb_path)
164 {
165  assert (kb);
166  assert (KBDefaultOperations);
167  assert (KBDefaultOperations->kb_new);
168 
169  *kb = NULL;
170 
171  return KBDefaultOperations->kb_new (kb, kb_path);
172 }
173 
180 static inline kb_t kb_find (const char *kb_path, const char *key)
181 {
182  assert (KBDefaultOperations);
183  assert (KBDefaultOperations->kb_find);
184 
185  return KBDefaultOperations->kb_find (kb_path, key);
186 }
187 
195 static inline int
196 kb_nvt_add (kb_t kb, const nvti_t *nvt, const char *filename)
197 {
198  assert (kb);
199  assert (kb->kb_ops);
200  assert (kb->kb_ops->kb_add_nvt);
201 
202  return kb->kb_ops->kb_add_nvt (kb, nvt, filename);
203 }
204 
212 static inline char *
213 kb_nvt_get (kb_t kb, const char *oid, enum kb_nvt_pos position)
214 {
215  assert (kb);
216  assert (kb->kb_ops);
217  assert (kb->kb_ops->kb_add_nvt);
218 
219  return kb->kb_ops->kb_get_nvt (kb, oid, position);
220 }
221 
227 static inline int kb_delete (kb_t kb)
228 {
229  assert (kb);
230  assert (kb->kb_ops);
231  assert (kb->kb_ops->kb_delete);
232 
233  return kb->kb_ops->kb_delete (kb);
234 }
235 
244 static inline struct kb_item *
245 kb_item_get_single (kb_t kb, const char *name, enum kb_item_type type)
246 {
247  assert (kb);
248  assert (kb->kb_ops);
249  assert (kb->kb_ops->kb_get_single);
250 
251  return kb->kb_ops->kb_get_single (kb, name, type);
252 }
253 
261 static inline char *
262 kb_item_get_str (kb_t kb, const char *name)
263 {
264  assert (kb);
265  assert (kb->kb_ops);
266  assert (kb->kb_ops->kb_get_str);
267 
268  return kb->kb_ops->kb_get_str (kb, name);
269 }
270 
278 static inline int
279 kb_item_get_int (kb_t kb, const char *name)
280 {
281  assert (kb);
282  assert (kb->kb_ops);
283  assert (kb->kb_ops->kb_get_int);
284 
285  return kb->kb_ops->kb_get_int (kb, name);
286 }
287 
295 static inline struct kb_item *
296 kb_item_get_all (kb_t kb, const char *name)
297 {
298  assert (kb);
299  assert (kb->kb_ops);
300  assert (kb->kb_ops->kb_get_all);
301 
302  return kb->kb_ops->kb_get_all (kb, name);
303 }
304 
312 static inline struct kb_item *
313 kb_item_get_pattern (kb_t kb, const char *pattern)
314 {
315  assert (kb);
316  assert (kb->kb_ops);
317  assert (kb->kb_ops->kb_get_pattern);
318 
319  return kb->kb_ops->kb_get_pattern (kb, pattern);
320 }
321 
330 static inline size_t
331 kb_item_count (kb_t kb, const char *pattern)
332 {
333  assert (kb);
334  assert (kb->kb_ops);
335  assert (kb->kb_ops->kb_count);
336 
337  return kb->kb_ops->kb_count (kb, pattern);
338 }
339 
347 static inline int
348 kb_item_add_str (kb_t kb, const char *name, const char *str)
349 {
350  assert (kb);
351  assert (kb->kb_ops);
352  assert (kb->kb_ops->kb_add_str);
353 
354  return kb->kb_ops->kb_add_str (kb, name, str);
355 }
356 
364 static inline int
365 kb_item_set_str (kb_t kb, const char *name, const char *str)
366 {
367  assert (kb);
368  assert (kb->kb_ops);
369  assert (kb->kb_ops->kb_set_str);
370 
371  return kb->kb_ops->kb_set_str (kb, name, str);
372 }
373 
381 static inline int
382 kb_item_add_int (kb_t kb, const char *name, int val)
383 {
384  assert (kb);
385  assert (kb->kb_ops);
386  assert (kb->kb_ops->kb_add_int);
387 
388  return kb->kb_ops->kb_add_int (kb, name, val);
389 }
390 
398 static inline int
399 kb_item_set_int (kb_t kb, const char *name, int val)
400 {
401  assert (kb);
402  assert (kb->kb_ops);
403  assert (kb->kb_ops->kb_set_int);
404 
405  return kb->kb_ops->kb_set_int (kb, name, val);
406 }
407 
414 static inline int
415 kb_del_items (kb_t kb, const char *name)
416 {
417  assert (kb);
418  assert (kb->kb_ops);
419  assert (kb->kb_ops->kb_del_items);
420 
421  return kb->kb_ops->kb_del_items (kb, name);
422 }
423 
430 static inline int kb_lnk_reset (kb_t kb)
431 {
432  int rc = 0;
433 
434  assert (kb);
435  assert (kb->kb_ops);
436 
437  if (kb->kb_ops->kb_lnk_reset != NULL)
438  rc = kb->kb_ops->kb_lnk_reset (kb);
439 
440  return rc;
441 }
442 
449 static inline int kb_flush (kb_t kb, const char *except)
450 {
451  int rc = 0;
452 
453  assert (kb);
454  assert (kb->kb_ops);
455 
456  if (kb->kb_ops->kb_flush != NULL)
457  rc = kb->kb_ops->kb_flush (kb, except);
458 
459  return rc;
460 }
461 
462 #endif
kb_nvt_pos
Possible positions of nvt values in cache list.
Definition: kb.h:57
const struct kb_operations * KBDefaultOperations
Default KB operations. No selection mechanism is provided yet since there&#39;s only one implementation (...
Definition: kb_redis.c:1228
struct kb_item *(* kb_get_all)(kb_t, const char *)
Definition: kb.h:130
Definition: kb.h:49
Definition: kb.h:51
void kb_item_free(struct kb_item *)
Release a KB item (or a list).
Definition: kb_redis.c:501
const char * val
Definition: nasl_init.c:525
The structure of a information record that corresponds to a NVT.
Definition: nvti.h:64
Knowledge base item (defined by name, type (int/char*) and value). Implemented as a singly linked lis...
Definition: kb.h:81
struct kb_item * next
Definition: kb.h:91
const char * oid
enum kb_item_type type
Definition: kb.h:83
KB interface. Functions provided by an implementation. All functions have to be provided, there is no default/fallback. These functions should be called via the corresponding static inline wrappers below. See the wrappers for the documentation.
Definition: kb.h:118
int(* kb_delete)(kb_t)
Definition: kb.h:122
struct kb_item *(* kb_get_single)(kb_t, const char *, enum kb_item_type)
Definition: kb.h:126
int(* kb_get_int)(kb_t, const char *)
Definition: kb.h:128
int(* kb_set_str)(kb_t, const char *, const char *)
Definition: kb.h:134
int(* kb_lnk_reset)(kb_t)
Definition: kb.h:141
int(* kb_del_items)(kb_t, const char *)
Definition: kb.h:138
int(* kb_flush)(kb_t, const char *)
Definition: kb.h:142
Definition: kb.h:48
Top-level KB. This is to be inherited by KB implementations.
Definition: kb.h:102
const struct kb_operations * kb_ops
Definition: kb.h:104
struct kb_item *(* kb_get_pattern)(kb_t, const char *)
Definition: kb.h:131
int(* kb_add_int)(kb_t, const char *, int)
Definition: kb.h:135
char *(* kb_get_nvt)(kb_t, const char *, enum kb_nvt_pos)
Definition: kb.h:129
const char * name
Definition: nasl_init.c:524
int v_int
Definition: kb.h:88
kb_item_type
Possible type of a kb_item.
Definition: kb.h:46
size_t namelen
Definition: kb.h:93
int(* kb_add_nvt)(kb_t, const nvti_t *, const char *)
Definition: kb.h:137
int(* kb_set_int)(kb_t, const char *, int)
Definition: kb.h:136
kb_t(* kb_find)(const char *, const char *)
Definition: kb.h:123
struct kb * kb_t
type abstraction to hide KB internals.
Definition: kb.h:110
char name[0]
Definition: kb.h:94
char *(* kb_get_str)(kb_t, const char *)
Definition: kb.h:127
int(* kb_add_str)(kb_t, const char *, const char *)
Definition: kb.h:133
size_t(* kb_count)(kb_t, const char *)
Definition: kb.h:132
char * v_str
Definition: kb.h:87
int(* kb_new)(kb_t *, const char *)
Definition: kb.h:121