Greenbone Vulnerability Management Libraries 22.18.1
openvasd.c
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Greenbone AG
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 */
5
10
11#include "openvasd.h"
12
13#include "../base/array.h"
14#include "../base/networking.h"
15#include "../util/json.h"
16
17#include <cjson/cJSON.h>
18#include <curl/curl.h>
19#include <curl/easy.h>
20#include <curl/multi.h>
21#include <netinet/in.h>
22#include <stddef.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <unistd.h>
26
27#undef G_LOG_DOMAIN
31#define G_LOG_DOMAIN "libgvm ovd"
32
33#define RESP_CODE_ERR -1
34#define RESP_CODE_OK 0
35
39typedef struct openvasd_curlm
40{
41 CURLM *h;
42 struct curl_slist *customheader;
44
49{
50 gchar *ptr;
51 size_t len;
53};
54
56
61{
62 gchar *ca_cert;
63 gchar *cert;
64 gchar *key;
65 gchar *apikey;
66 gchar *server;
67 gchar *host;
68 gchar *scan_id;
69 int port;
71};
72
77{
78 gchar *id;
79 gchar *name;
80 gchar *defval;
81 gchar *description;
82 gchar *type;
84};
85
90{
91 gchar *type;
92 gchar *service;
93 gchar *port;
94 GHashTable *auth_data;
95};
96
101{
102 gchar *scan_id;
103 GSList *credentials;
105 gchar *hosts;
106 gchar *ports;
108 gboolean icmp;
109 gboolean tcp_syn;
110 gboolean tcp_ack;
111 gboolean arp;
112 gboolean consider_alive;
115};
116
121{
122 gchar *vt_id;
123 GHashTable *vt_values;
124};
125
136
138
144static openvasd_curlm_t *
146{
147 return (openvasd_curlm_t *) g_malloc0 (sizeof (struct openvasd_curlm));
148}
149
155static void
157{
158 int queued = 0;
159
160 /* when an easy handle has completed, remove it */
161 CURLMsg *msg = curl_multi_info_read (h->h, &queued);
162 if (msg)
163 {
164 if (msg->msg == CURLMSG_DONE)
165 {
166 curl_multi_remove_handle (h->h, msg->easy_handle);
167 curl_easy_cleanup (msg->easy_handle);
168 curl_slist_free_all (h->customheader);
169 curl_multi_cleanup (h->h);
170 return;
171 }
172 g_warning ("%s: Not possible to clean up the curl handler", __func__);
173 }
174}
175
183{
185 s = g_malloc0 (sizeof (struct openvasd_string));
186 s->len = 0;
187 s->ptr = g_malloc0 (s->len + 1);
189 return s;
190}
191
197static void
199{
200 if (s == NULL)
201 return;
202
203 g_free (s->ptr);
204 if (s->curl_hnd)
206
207 g_free (s);
208}
209
214static void
216{
217 if (s)
218 {
219 g_free (s->ptr);
220 s->len = 0;
221 s->ptr = g_malloc0 (s->len + 1);
222 }
223}
224
232{
233 openvasd_connector_t connector;
235
236 connector = g_malloc0 (sizeof (struct openvasd_connector));
237 stream = openvasd_vt_stream_new ();
238 connector->stream_resp = stream;
239
240 return connector;
241}
242
255 const void *val)
256{
257 if (conn == NULL)
258 conn = openvasd_connector_new ();
259
260 if (opt < OPENVASD_CA_CERT || opt > OPENVASD_PORT)
262
263 if (val == NULL)
265
266 switch (opt)
267 {
268 case OPENVASD_CA_CERT:
269 conn->ca_cert = g_strdup ((char *) val);
270 break;
271 case OPENVASD_CERT:
272 conn->cert = g_strdup ((char *) val);
273 break;
274 case OPENVASD_KEY:
275 conn->key = g_strdup ((char *) val);
276 break;
277 case OPENVASD_API_KEY:
278 conn->apikey = g_strdup ((char *) val);
279 break;
280 case OPENVASD_SERVER:
281 conn->server = g_strdup ((char *) val);
282 break;
283 case OPENVASD_HOST:
284 conn->host = g_strdup ((char *) val);
285 break;
286 case OPENVASD_SCAN_ID:
287 conn->scan_id = g_strdup ((const gchar *) val);
288 break;
289 case OPENVASD_PORT:
290 default:
291 conn->port = *((int *) val);
292 break;
293 };
294
295 return OPENVASD_OK;
296}
297
308{
309 if (conn == NULL)
310 return OPENVASD_OK;
311
312 g_free (conn->ca_cert);
313 g_free (conn->cert);
314 g_free (conn->key);
315 g_free (conn->apikey);
316 g_free (conn->server);
317 g_free (conn->host);
318 g_free (conn->scan_id);
320 g_free (conn);
321 conn = NULL;
322
323 return OPENVASD_OK;
324}
325
331void
333{
334 if (resp == NULL)
335 return;
336
337 g_free (resp->body);
338 g_free (resp->header);
339 g_free (resp);
340 resp = NULL;
341}
342
348static size_t
349response_callback_fn (void *ptr, size_t size, size_t nmemb, void *struct_string)
350{
351 openvasd_vt_stream_t s = struct_string;
352 size_t new_len = s->len + size * nmemb;
353 gchar *ptr_aux = g_realloc (s->ptr, new_len + 1);
354 s->ptr = ptr_aux;
355 memcpy (s->ptr + s->len, ptr, size * nmemb);
356 s->ptr[new_len] = '\0';
357 s->len = new_len;
358
359 return size * nmemb;
360}
361
362static struct curl_slist *
363init_customheader (const gchar *apikey, gboolean contenttype)
364{
365 struct curl_slist *customheader = NULL;
366 struct curl_slist *temp = NULL;
367
368 // Set API KEY
369 if (apikey)
370 {
371 GString *xapikey;
372 xapikey = g_string_new ("X-API-KEY: ");
373 g_string_append (xapikey, apikey);
374 temp = curl_slist_append (customheader, xapikey->str);
375 if (!temp)
376 g_warning ("%s: Not possible to set API-KEY", __func__);
377 else
378 customheader = temp;
379 g_string_free (xapikey, TRUE);
380 }
381 // SET Content type
382 if (contenttype)
383 {
384 temp = curl_slist_append (customheader, "Content-Type: application/json");
385 if (!temp)
386 g_warning ("%s: Not possible to set Content-Type", __func__);
387 else
388 customheader = temp;
389 }
390
391 return customheader;
392}
393
410static CURL *
412 gchar *data, struct curl_slist *customheader, gchar **err)
413{
414 CURL *curl;
415 GString *url = NULL;
416
417 if (!conn)
418 {
419 *err = g_strdup ("{\"error\": \"Missing openvasd connector\"}");
420 g_warning ("%s: Missing openvasd connector", __func__);
421 return NULL;
422 }
423
424 curl = curl_easy_init ();
425 if (curl == NULL)
426 {
427 *err =
428 g_strdup ("{\"error\": \"Not possible to initialize curl library\"}");
429 g_warning ("%s: Not possible to initialize curl library", __func__);
430 return NULL;
431 }
432
433 url = g_string_new (g_strdup (conn->server));
434
435 if (conn->port > 0 && conn->port < 65535)
436 {
437 char buf[6];
438 g_snprintf (buf, sizeof (buf), ":%d", conn->port);
439 g_string_append (url, buf);
440 }
441
442 if (path != NULL && path[0] != '\0')
443 g_string_append (url, path);
444
445 // Set URL
446 g_debug ("%s: URL: %s", __func__, url->str);
447 if (curl_easy_setopt (curl, CURLOPT_URL, url->str) != CURLE_OK)
448 {
449 g_string_free (url, TRUE);
450 g_warning ("%s: Not possible to set the URL", __func__);
451 curl_easy_cleanup (curl);
452 *err = g_strdup ("{\"error\": \"Not possible to set URL\"}");
453 return NULL;
454 }
455 g_string_free (url, TRUE);
456
457 // Server verification
458 if (conn->ca_cert != NULL)
459 {
460 struct curl_blob blob;
461 blob.data = conn->ca_cert;
462 blob.len = strlen (conn->ca_cert);
463 blob.flags = CURL_BLOB_COPY;
464
465 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 1L);
466 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 1L);
467 if (curl_easy_setopt (curl, CURLOPT_CAINFO_BLOB, &blob) != CURLE_OK)
468 {
469 g_warning ("%s: Not possible to set the CA certificate", __func__);
470 curl_easy_cleanup (curl);
471 *err =
472 g_strdup ("{\"error\": \"Not possible to set CA certificate\"}");
473 return NULL;
474 }
475 }
476 else
477 {
478 // Accept an insecure connection. Don't verify the server certificate
479 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0L);
480 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0L);
481 curl_easy_setopt (curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2);
482 g_debug ("%s: Server certificate verification disabled.", __func__);
483 }
484
485 // Client certificate
486 if (conn->cert != NULL && conn->key != NULL)
487 {
488 struct curl_blob blob;
489 blob.data = conn->cert;
490 blob.len = strlen (conn->cert);
491 blob.flags = CURL_BLOB_COPY;
492
493 if (curl_easy_setopt (curl, CURLOPT_SSLCERT_BLOB, &blob) != CURLE_OK)
494 {
495 g_warning ("%s: Not possible to set the Client certificate",
496 __func__);
497 curl_easy_cleanup (curl);
498 *err = g_strdup (
499 "{\"error\": \"Not possible to set Client certificate\"}");
500 return NULL;
501 }
502 blob.data = conn->key;
503 blob.len = strlen (conn->key);
504 blob.flags = CURL_BLOB_COPY;
505
506 if (curl_easy_setopt (curl, CURLOPT_SSLKEY_BLOB, &blob) != CURLE_OK)
507 {
508 g_warning ("%s: Not possible to set the Client private key",
509 __func__);
510 curl_easy_cleanup (curl);
511 *err = g_strdup (
512 "{\"error\": \"Not possible to set Client private key\"}");
513 return NULL;
514 }
515 }
516
517 switch (method)
518 {
519 case POST:
520 if (data != NULL && data[0] != '\0')
521 {
522 // Set body
523 curl_easy_setopt (curl, CURLOPT_POSTFIELDS, data);
524 curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen (data));
525 }
526 break;
527 case GET:
528 curl_easy_setopt (curl, CURLOPT_HTTPGET, 1L);
529 break;
530 case DELETE:
531 curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, "DELETE");
532 break;
533 default:
534 curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, "HEAD");
535 break;
536 };
537
538 if (customheader != NULL)
539 curl_easy_setopt (curl, CURLOPT_HTTPHEADER, customheader);
540
541 // Init the struct where the response is stored and set the callback function
542 curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, response_callback_fn);
543 curl_easy_setopt (curl, CURLOPT_WRITEDATA, conn->stream_resp);
544
545 return curl;
546}
547
561static openvasd_resp_t
562openvasd_send_request (CURL *curl, const gchar *header_name,
563 openvasd_resp_t response)
564{
565 long http_code = RESP_CODE_ERR;
566 int ret;
567
568 ret = curl_easy_perform (curl);
569 if (ret != CURLE_OK)
570 {
571 g_warning ("%s: Error sending request: %d", __func__, ret);
572 curl_easy_cleanup (curl);
573 response->code = http_code;
574 response->body = g_strdup ("{\"error\": \"Error sending request\"}");
575 return response;
576 }
577
578 curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
579 if (header_name)
580 {
581 struct curl_header *hname;
582 curl_easy_header (curl, header_name, 0, CURLH_HEADER, -1, &hname);
583 response->header = g_strdup (hname->value);
584 }
585 curl_easy_cleanup (curl);
586 response->code = http_code;
587
588 return response;
589}
590
600{
601 gchar *err = NULL;
602 CURL *hnd = NULL;
603 openvasd_resp_t response = NULL;
604 struct curl_slist *customheader = NULL;
605
606 response = g_malloc0 (sizeof (struct openvasd_response));
607
608 customheader = init_customheader (conn->apikey, FALSE);
609 hnd = handler (conn, HEAD, "/", NULL, customheader, &err);
610 if (hnd == NULL)
611 {
612 curl_slist_free_all (customheader);
613 response->code = RESP_CODE_ERR;
614 response->body = err;
616 return response;
617 }
618
619 openvasd_send_request (hnd, NULL, response);
620 curl_slist_free_all (customheader);
621 if (response->code != RESP_CODE_ERR)
622 response->body = g_strdup (openvasd_vt_stream_str (conn));
623
625 return response;
626}
627
642{
643 GString *path;
644 openvasd_resp_t response = NULL;
645 gchar *err = NULL;
646 CURL *hnd = NULL;
647 CURLM *h = NULL;
648 struct curl_slist *customheader = NULL;
649
650 response = g_malloc0 (sizeof (struct openvasd_response));
651
652 path = g_string_new ("/vts?information=1");
653 customheader = init_customheader (conn->apikey, FALSE);
654 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
655 if (hnd == NULL)
656 {
657 curl_slist_free_all (customheader);
658 g_string_free (path, TRUE);
659 response->code = RESP_CODE_ERR;
660 response->body = err;
661 return response;
662 }
663 g_string_free (path, TRUE);
664
665 h = curl_multi_init ();
666 curl_multi_add_handle (h, hnd);
667
668 conn->stream_resp->curl_hnd->h = h;
669 conn->stream_resp->curl_hnd->customheader = customheader;
670
671 response->code = RESP_CODE_OK;
672 return response;
673}
674
675void
680
681gchar *
683{
684 return conn->stream_resp->ptr;
685}
686
687size_t
689{
690 return conn->stream_resp->len;
691}
692
704int
706{
707 static int running = 0;
708 CURLM *h = conn->stream_resp->curl_hnd->h;
709 if (!(h))
710 {
711 return -1;
712 }
713
714 CURLMcode mc = curl_multi_perform (h, &running);
715 if (!mc && running)
716 /* wait for activity, timeout or "nothing" */
717 mc = curl_multi_poll (h, NULL, 0, 5000, NULL);
718 if (mc != CURLM_OK)
719 {
720 g_warning ("%s: error on curl_multi_poll(): %d\n", __func__, mc);
721 return -1;
722 }
723
724 return running;
725}
726
737{
738 GString *path;
739 openvasd_resp_t response = NULL;
740 gchar *err = NULL;
741 CURL *hnd = NULL;
742 struct curl_slist *customheader = NULL;
743
744 response = g_malloc0 (sizeof (struct openvasd_response));
745
746 path = g_string_new ("/vts?information=1");
747 customheader = init_customheader (conn->apikey, FALSE);
748 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
749 if (hnd == NULL)
750 {
751 curl_slist_free_all (customheader);
752 g_string_free (path, TRUE);
753 response->code = RESP_CODE_ERR;
754 response->body = err;
755 return response;
756 }
757 g_string_free (path, TRUE);
758
759 openvasd_send_request (hnd, NULL, response);
760 curl_slist_free_all (customheader);
761 if (response->code != RESP_CODE_ERR)
762 response->body = g_strdup (openvasd_vt_stream_str (conn));
763
765 return response;
766}
767
778{
779 openvasd_resp_t response = NULL;
780 cJSON *parser = NULL;
781 GString *path;
782 gchar *err = NULL;
783 CURL *hnd = NULL;
784 struct curl_slist *customheader = NULL;
785
786 response = g_malloc0 (sizeof (struct openvasd_response));
787
788 customheader = init_customheader (conn->apikey, TRUE);
789 hnd = handler (conn, POST, "/scans", data, customheader, &err);
790 if (hnd == NULL)
791 {
792 curl_slist_free_all (customheader);
793 response->code = RESP_CODE_ERR;
794 response->body = err;
795 return response;
796 }
797
798 openvasd_send_request (hnd, NULL, response);
799 curl_slist_free_all (customheader);
800 if (response->code == RESP_CODE_ERR)
801 {
802 response->code = RESP_CODE_ERR;
803 if (response->body == NULL)
804 response->body =
805 g_strdup ("{\"error\": \"Storing scan configuration\"}");
806 g_warning ("%s: Error storing scan configuration ", __func__);
808 return response;
809 }
810
811 // Get the Scan ID
812 parser = cJSON_Parse (openvasd_vt_stream_str (conn));
813 if (!parser)
814 {
815 const gchar *error_ptr = cJSON_GetErrorPtr ();
816 g_warning ("%s: Error parsing json string to get the scan ID", __func__);
817 if (error_ptr != NULL)
818 {
819 response->body = g_strdup_printf ("{\"error\": \"%s\"}", error_ptr);
820 g_warning ("%s: %s", __func__, error_ptr);
821 }
822 else
823 {
824 response->body = g_strdup (
825 "{\"error\": \"Parsing json string to get the scan ID\"}");
826 }
827 response->code = RESP_CODE_ERR;
828 cJSON_Delete (parser);
830 return response;
831 }
832
833 conn->scan_id = g_strdup (cJSON_GetStringValue (parser));
834
835 // Start the scan
836 path = g_string_new ("/scans");
837 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
838 {
839 g_string_append (path, "/");
840 g_string_append (path, conn->scan_id);
841 }
842 else
843 {
844 response->code = RESP_CODE_ERR;
845 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
846 g_string_free (path, TRUE);
847 g_warning ("%s: Missing scan ID", __func__);
848 cJSON_Delete (parser);
849 return response;
850 }
851
853 customheader = init_customheader (conn->apikey, TRUE);
854 hnd = handler (conn, POST, path->str, "{\"action\": \"start\"}", customheader,
855 &err);
856 if (hnd == NULL)
857 {
858 curl_slist_free_all (customheader);
859 g_string_free (path, TRUE);
860 response->code = RESP_CODE_ERR;
861 response->body = err;
862 return response;
863 }
864 g_string_free (path, TRUE);
865
866 openvasd_send_request (hnd, NULL, response);
867 curl_slist_free_all (customheader);
868 if (response->code == RESP_CODE_ERR)
869 {
870 response->code = RESP_CODE_ERR;
871 if (response->body == NULL)
872 response->body = g_strdup ("{\"error\": \"Starting the scan.\"}");
873 g_warning ("%s: Error starting the scan.", __func__);
874 return response;
875 }
876
877 cJSON_Delete (parser);
878 response->body = g_strdup (openvasd_vt_stream_str (conn));
880 return response;
881}
882
885{
886 openvasd_resp_t response = NULL;
887 GString *path;
888 gchar *err = NULL;
889 CURL *hnd = NULL;
890 struct curl_slist *customheader = NULL;
891
892 response = g_malloc0 (sizeof (struct openvasd_response));
893
894 // Stop the scan
895 path = g_string_new ("/scans");
896 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
897 {
898 g_string_append (path, "/");
899 g_string_append (path, conn->scan_id);
900 }
901 else
902 {
903 response->code = RESP_CODE_ERR;
904 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
905 g_string_free (path, TRUE);
906 g_warning ("%s: Missing scan ID", __func__);
907 return response;
908 }
909
910 customheader = init_customheader (conn->apikey, TRUE);
911 hnd = handler (conn, POST, path->str, "{\"action\": \"stop\"}", customheader,
912 &err);
913 if (hnd == NULL)
914 {
915 curl_slist_free_all (customheader);
916 g_string_free (path, TRUE);
917 response->code = RESP_CODE_ERR;
918 response->body = err;
919 return response;
920 }
921 g_string_free (path, TRUE);
922
923 openvasd_send_request (hnd, NULL, response);
924 curl_slist_free_all (customheader);
925 if (response->code != RESP_CODE_ERR)
926 response->body = g_strdup (openvasd_vt_stream_str (conn));
927
929 return response;
930}
931
934{
935 openvasd_resp_t response = NULL;
936 GString *path = NULL;
937 gchar *err = NULL;
938 CURL *hnd = NULL;
939 struct curl_slist *customheader = NULL;
940
941 response = g_malloc0 (sizeof (struct openvasd_response));
942
943 path = g_string_new ("/scans");
944 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
945 {
946 g_string_append (path, "/");
947 g_string_append (path, conn->scan_id);
948 if (last > first)
949 g_string_append_printf (path, "/results?range%ld-%ld", first, last);
950 else if (last < first)
951 g_string_append_printf (path, "/results?range=%ld", first);
952 else
953 g_string_append (path, "/results");
954 }
955 else
956 {
957 response->code = RESP_CODE_ERR;
958 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
959 g_string_free (path, TRUE);
960 g_warning ("%s: Missing scan ID", __func__);
961 return response;
962 }
963
964 customheader = init_customheader (conn->apikey, FALSE);
965 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
966 if (hnd == NULL)
967 {
968 curl_slist_free_all (customheader);
969 g_string_free (path, TRUE);
970 response->code = RESP_CODE_ERR;
971 response->body = err;
972 return response;
973 }
974 g_string_free (path, TRUE);
975
976 openvasd_send_request (hnd, NULL, response);
977 curl_slist_free_all (customheader);
978 if (response->code != RESP_CODE_ERR)
979 response->body = g_strdup (openvasd_vt_stream_str (conn));
980 else if (response->code == RESP_CODE_ERR)
981 {
982 g_warning ("%s: Not possible to get scan results", __func__);
983 response->body =
984 g_strdup ("{\"error\": \"Not possible to get scan results\"}");
985 }
986
988 return response;
989}
990
992openvasd_result_new (unsigned long id, gchar *type, gchar *ip_address,
993 gchar *hostname, gchar *oid, int port, gchar *protocol,
994 gchar *message, gchar *detail_name, gchar *detail_value,
995 gchar *detail_source_type, gchar *detail_source_name,
996 gchar *detail_source_description)
997{
998 openvasd_result_t result = g_malloc0 (sizeof (struct openvasd_result));
999
1000 result->id = id;
1001 result->type = g_strdup (type);
1002 result->ip_address = g_strdup (ip_address);
1003 result->hostname = g_strdup (hostname);
1004 result->oid = g_strdup (oid);
1005 result->port = port;
1006 result->protocol = g_strdup (protocol);
1007 result->message = g_strdup (message);
1008 result->detail_name = g_strdup (detail_name);
1009 result->detail_value = g_strdup (detail_value);
1010 result->detail_source_name = g_strdup (detail_source_name);
1011 result->detail_source_type = g_strdup (detail_source_type);
1012 result->detail_source_description = g_strdup (detail_source_description);
1013
1014 return result;
1015}
1016
1017char *
1020{
1021 if (!result)
1022 return NULL;
1023 switch (member)
1024 {
1025 case TYPE:
1026 return result->type;
1027
1028 case IP_ADDRESS:
1029 return result->ip_address;
1030 case HOSTNAME:
1031 return result->hostname;
1032 case OID:
1033 return result->oid;
1034 case PROTOCOL:
1035 return result->protocol;
1036 case MESSAGE:
1037 return result->message;
1038 case DETAIL_NAME:
1039 return result->detail_name;
1040 case DETAIL_VALUE:
1041 return result->detail_value;
1042 case DETAIL_SOURCE_NAME:
1043 return result->detail_source_name;
1044 case DETAIL_SOURCE_TYPE:
1045 return result->detail_source_type;
1047 return result->detail_source_description;
1048 default:
1049 return NULL;
1050 }
1051}
1052
1053int
1056{
1057 if (!result)
1058 return -1;
1059
1060 switch (member)
1061 {
1062 case ID:
1063 return result->id;
1064 case PORT:
1065 return result->port;
1066 default:
1067 return -1;
1068 }
1069}
1070
1071void
1073{
1074 if (result == NULL)
1075 return;
1076
1077 g_free (result->type);
1078 g_free (result->ip_address);
1079 g_free (result->hostname);
1080 g_free (result->oid);
1081 g_free (result->protocol);
1082 g_free (result->message);
1083 g_free (result->detail_name);
1084 g_free (result->detail_value);
1085 g_free (result->detail_source_name);
1086 g_free (result->detail_source_type);
1087 g_free (result->detail_source_description);
1088 g_free (result);
1089 result = NULL;
1090}
1091
1092static int
1093parse_results (const gchar *body, GSList **results)
1094{
1095 cJSON *parser;
1096 cJSON *result_obj = NULL;
1097 const gchar *err = NULL;
1098 openvasd_result_t result = NULL;
1099 int ret = -1;
1100
1101 parser = cJSON_Parse (body);
1102 if (parser == NULL)
1103 {
1104 err = cJSON_GetErrorPtr ();
1105 goto res_cleanup;
1106 }
1107 if (!cJSON_IsArray (parser))
1108 {
1109 // No results. No information.
1110 goto res_cleanup;
1111 }
1112
1113 cJSON_ArrayForEach (result_obj, parser)
1114 {
1115 cJSON *item;
1116 gchar *detail_name = NULL;
1117 gchar *detail_value = NULL;
1118 gchar *detail_source_type = NULL;
1119 gchar *detail_source_name = NULL;
1120 gchar *detail_source_description = NULL;
1121
1122 if (!cJSON_IsObject (result_obj))
1123 // error
1124 goto res_cleanup;
1125
1126 item = cJSON_GetObjectItem (result_obj, "detail");
1127 if (item != NULL
1128 && cJSON_IsObject (item))
1129 {
1130 cJSON *detail_obj = NULL;
1131
1132 detail_name = gvm_json_obj_str (item, "name");
1133 detail_value = gvm_json_obj_str (item, "value");
1134
1135 detail_obj = cJSON_GetObjectItem (item, "source");
1136 if (detail_obj && cJSON_IsObject (detail_obj))
1137 {
1138 detail_source_type = gvm_json_obj_str (detail_obj, "type");
1139 detail_source_name = gvm_json_obj_str (detail_obj, "name");
1140 detail_source_description = gvm_json_obj_str (detail_obj, "description");
1141 }
1142 }
1143
1144 result = openvasd_result_new (gvm_json_obj_double (result_obj, "id"),
1145 gvm_json_obj_str (result_obj, "type"),
1146 gvm_json_obj_str (result_obj, "ip_address"),
1147 gvm_json_obj_str (result_obj, "hostname"),
1148 gvm_json_obj_str (result_obj, "oid"),
1149 gvm_json_obj_int (result_obj, "port"),
1150 gvm_json_obj_str (result_obj, "protocol"),
1151 gvm_json_obj_str (result_obj, "message"),
1152 detail_name, detail_value,
1153 detail_source_type, detail_source_name,
1154 detail_source_description);
1155
1156 *results = g_slist_append (*results, result);
1157 ret = 200;
1158 }
1159
1160res_cleanup:
1161 if (err != NULL)
1162 {
1163 g_warning ("%s: Unable to parse scan results. Reason: %s", __func__, err);
1164 }
1165 cJSON_Delete (parser);
1166
1167 return ret;
1168}
1169
1170int
1172 unsigned long last, GSList **results)
1173{
1174 int ret;
1175 openvasd_resp_t resp;
1176
1177 resp = openvasd_get_scan_results (conn, first, last);
1178 if (resp->code == 200)
1179 ret = parse_results (resp->body, results);
1180 else
1181 ret = resp->code;
1182
1184
1185 return ret;
1186}
1187
1190{
1191 openvasd_resp_t response = NULL;
1192 GString *path = NULL;
1193 gchar *err = NULL;
1194 CURL *hnd = NULL;
1195 struct curl_slist *customheader = NULL;
1196
1197 response = g_malloc0 (sizeof (struct openvasd_response));
1198
1199 path = g_string_new ("/scans");
1200 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1201 {
1202 g_string_append (path, "/");
1203 g_string_append (path, conn->scan_id);
1204 g_string_append (path, "/status");
1205 }
1206 else
1207 {
1208 response->code = RESP_CODE_ERR;
1209 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1210 g_string_free (path, TRUE);
1211 g_warning ("%s: Missing scan ID", __func__);
1212 return response;
1213 }
1214
1215 customheader = init_customheader (conn->apikey, FALSE);
1216 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
1217 if (hnd == NULL)
1218 {
1219 curl_slist_free_all (customheader);
1220 g_string_free (path, TRUE);
1221 response->code = RESP_CODE_ERR;
1222 response->body = err;
1223 return response;
1224 }
1225 g_string_free (path, TRUE);
1226
1227 openvasd_send_request (hnd, NULL, response);
1228 curl_slist_free_all (customheader);
1229 if (response->code != RESP_CODE_ERR)
1230 response->body = g_strdup (openvasd_vt_stream_str (conn));
1231 else if (response->code == RESP_CODE_ERR)
1232 {
1233 response->body =
1234 g_strdup ("{\"error\": \"Not possible to get scan status\"}");
1235 g_warning ("%s: Not possible to get scan status", __func__);
1236 }
1237
1239 return response;
1240}
1241
1246static int
1247get_member_value_or_fail (cJSON *reader, const gchar *member)
1248{
1249 int ret;
1250
1251 if (gvm_json_obj_check_int (reader, member, &ret))
1252 return -1;
1253
1254 return ret;
1255}
1256
1257static int
1259 openvasd_resp_t response)
1260{
1261 cJSON *parser;
1262 cJSON *reader = NULL;
1263 const gchar *err = NULL;
1264 int all = 0, excluded = 0, dead = 0, alive = 0, queued = 0, finished = 0;
1265 int running_hosts_progress_sum = 0;
1266
1267 openvasd_resp_t resp;
1268 int progress = -1;
1269
1270 if (!response && !conn)
1271 return -1;
1272
1273 if (response == NULL)
1274 resp = openvasd_get_scan_status (conn);
1275 else
1276 resp = response;
1277
1278 if (resp->code == 404)
1279 return -2;
1280 else if (resp->code != 200)
1281 return -1;
1282
1283 parser = cJSON_Parse (resp->body);
1284 if (!parser)
1285 {
1286 err = cJSON_GetErrorPtr ();
1287 goto cleanup;
1288 }
1289
1290 reader = cJSON_GetObjectItem (parser, "host_info");
1291 if (reader == NULL)
1292 {
1293 goto cleanup;
1294 }
1295 if (!cJSON_IsObject (reader))
1296 {
1297 // Scan still not started. No information.
1298 progress = 0;
1299 goto cleanup;
1300 }
1301
1302 // read general hosts count
1303 all = get_member_value_or_fail (reader, "all");
1304 excluded = get_member_value_or_fail (reader, "excluded");
1305 dead = get_member_value_or_fail (reader, "dead");
1306 alive = get_member_value_or_fail (reader, "alive");
1307 queued = get_member_value_or_fail (reader, "queued");
1308 finished = get_member_value_or_fail (reader, "finished");
1309
1310 // read progress of single running hosts
1311 cJSON *scanning;
1312 scanning = cJSON_GetObjectItem (reader, "scanning");
1313 if (scanning != NULL
1314 && cJSON_IsObject (scanning))
1315 {
1316 cJSON *host = scanning->child;
1317 while (host)
1318 {
1319 running_hosts_progress_sum += cJSON_GetNumberValue (host);
1320 host = host->next;
1321 }
1322
1323 } // end scanning
1324 // end host_info
1325
1326 if (all < 0 || excluded < 0 || dead < 0 || alive < 0 || queued < 0
1327 || finished < 0)
1328 {
1329 goto cleanup;
1330 }
1331
1332 if ((all + finished - dead) > 0)
1333 progress = (running_hosts_progress_sum + 100 * (alive + finished))
1334 / (all + finished - dead);
1335 else
1336 progress = 100;
1337
1338cleanup:
1339 if (err != NULL)
1340 g_warning ("%s: Unable to parse scan status. Reason: %s", __func__, err);
1341 cJSON_Delete (parser);
1342
1343 return progress;
1344}
1345
1346int
1351
1352static openvasd_status_t
1353get_status_code_from_openvas (const gchar *status_val)
1354{
1356
1357 if (g_strcmp0 (status_val, "stored") == 0)
1358 status_code = OPENVASD_SCAN_STATUS_STORED;
1359 else if (g_strcmp0 (status_val, "requested") == 0)
1360 status_code = OPENVASD_SCAN_STATUS_REQUESTED;
1361 else if (g_strcmp0 (status_val, "running") == 0)
1362 status_code = OPENVASD_SCAN_STATUS_RUNNING;
1363 else if (g_strcmp0 (status_val, "stopped") == 0)
1364 status_code = OPENVASD_SCAN_STATUS_STOPPED;
1365 else if (g_strcmp0 (status_val, "succeeded") == 0)
1366 status_code = OPENVASD_SCAN_STATUS_SUCCEEDED;
1367 else if (g_strcmp0 (status_val, "interrupted") == 0)
1368 status_code = OPENVASD_SCAN_STATUS_FAILED;
1369
1370 return status_code;
1371}
1372
1373static int
1374parse_status (const gchar *body, openvasd_scan_status_t status_info)
1375{
1376 cJSON *parser;
1377 gchar *status_val = NULL;
1379
1380 if (!status_info)
1381 return -1;
1382
1383 parser = cJSON_Parse (body);
1384 if (parser == NULL)
1385 return -1;
1386
1387 if (gvm_json_obj_check_str (parser, "status", &status_val))
1388 {
1389 cJSON_Delete (parser);
1390 return -1;
1391 }
1392
1393 status_code = get_status_code_from_openvas (status_val);
1394
1395 status_info->status = status_code;
1396 status_info->end_time = gvm_json_obj_double (parser, "end_time");
1397 status_info->start_time = gvm_json_obj_double (parser, "start_time");
1398 cJSON_Delete (parser);
1399
1400 return 0;
1401}
1402
1412{
1413 openvasd_resp_t resp = NULL;
1414 int progress = -1;
1416 openvasd_scan_status_t status_info = NULL;
1417
1418 resp = openvasd_get_scan_status (conn);
1419
1420 status_info = g_malloc0 (sizeof (struct openvasd_scan_status));
1421 if (resp->code != 200 || parse_status (resp->body, status_info) == -1)
1422 {
1423 status_info->status = status_code;
1424 status_info->response_code = resp->code;
1426 return status_info;
1427 }
1428
1429 progress = openvasd_get_scan_progress_ext (NULL, resp);
1431 status_info->progress = progress;
1432
1433 return status_info;
1434}
1435
1438{
1439 openvasd_resp_t response = NULL;
1440 GString *path;
1441 gchar *err = NULL;
1442 CURL *hnd = NULL;
1443 struct curl_slist *customheader = NULL;
1444
1445 response = g_malloc0 (sizeof (struct openvasd_response));
1446
1447 // Stop the scan
1448 path = g_string_new ("/scans");
1449 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1450 {
1451 g_string_append (path, "/");
1452 g_string_append (path, conn->scan_id);
1453 }
1454 else
1455 {
1456 response->code = RESP_CODE_ERR;
1457 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1458 g_string_free (path, TRUE);
1459 g_warning ("%s: Missing scan ID", __func__);
1460 return response;
1461 }
1462
1463 customheader = init_customheader (conn->apikey, FALSE);
1464 hnd = handler (conn, DELETE, path->str, NULL, customheader, &err);
1465 if (hnd == NULL)
1466 {
1467 curl_slist_free_all (customheader);
1468 g_string_free (path, TRUE);
1469 response->code = RESP_CODE_ERR;
1470 response->body = err;
1471 return response;
1472 }
1473 g_string_free (path, TRUE);
1474
1475 openvasd_send_request (hnd, NULL, response);
1476 curl_slist_free_all (customheader);
1477 if (response->code != RESP_CODE_ERR)
1478 response->body = g_strdup (openvasd_vt_stream_str (conn));
1479 else if (response->code == RESP_CODE_ERR)
1480 {
1481 response->body =
1482 g_strdup ("{\"error\": \"Not possible to delete scan.\"}");
1483 g_warning ("%s: Not possible to delete scan", __func__);
1484 }
1485
1487 return response;
1488}
1489
1492{
1493 openvasd_resp_t response = NULL;
1494 gchar *err = NULL;
1495 CURL *hnd = NULL;
1496 struct curl_slist *customheader = NULL;
1497
1498 response = g_malloc0 (sizeof (struct openvasd_response));
1499
1500 customheader = init_customheader (conn->apikey, FALSE);
1501 hnd = handler (conn, GET, "/health/alive", NULL, customheader, &err);
1502 if (hnd == NULL)
1503 {
1504 curl_slist_free_all (customheader);
1505 response->code = RESP_CODE_ERR;
1506 response->body = err;
1507 return response;
1508 }
1509
1510 openvasd_send_request (hnd, NULL, response);
1511 curl_slist_free_all (customheader);
1512 if (response->code != RESP_CODE_ERR)
1513 response->body = g_strdup (openvasd_vt_stream_str (conn));
1514 else if (response->code == RESP_CODE_ERR)
1515 {
1516 response->body =
1517 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1518 g_warning ("%s: Not possible to get health information", __func__);
1519 }
1520
1522 return response;
1523}
1524
1527{
1528 openvasd_resp_t response = NULL;
1529 gchar *err = NULL;
1530 CURL *hnd = NULL;
1531 struct curl_slist *customheader = NULL;
1532
1533 response = g_malloc0 (sizeof (struct openvasd_response));
1534
1535 customheader = init_customheader (conn->apikey, FALSE);
1536 hnd = handler (conn, GET, "/health/ready", NULL, customheader, &err);
1537 if (hnd == NULL)
1538 {
1539 response->code = RESP_CODE_ERR;
1540 response->body = err;
1541 return response;
1542 }
1543
1544 openvasd_send_request (hnd, "feed-version", response);
1545 curl_slist_free_all (customheader);
1546 if (response->code != RESP_CODE_ERR)
1547 response->body = g_strdup (openvasd_vt_stream_str (conn));
1548 else if (response->code == RESP_CODE_ERR)
1549 {
1550 response->body =
1551 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1552 g_warning ("%s: Not possible to get health information", __func__);
1553 }
1554
1556 return response;
1557}
1558
1561{
1562 openvasd_resp_t response = NULL;
1563 gchar *err = NULL;
1564 CURL *hnd = NULL;
1565 struct curl_slist *customheader = NULL;
1566
1567 response = g_malloc0 (sizeof (struct openvasd_response));
1568
1569 customheader = init_customheader (conn->apikey, FALSE);
1570 hnd = handler (conn, GET, "/health/started", NULL, customheader, &err);
1571 if (hnd == NULL)
1572 {
1573 curl_slist_free_all (customheader);
1574 response->code = RESP_CODE_ERR;
1575 response->body = err;
1576 return response;
1577 }
1578
1579 openvasd_send_request (hnd, NULL, response);
1580 curl_slist_free_all (customheader);
1581 if (response->code != RESP_CODE_ERR)
1582 response->body = g_strdup (openvasd_vt_stream_str (conn));
1583 else if (response->code == RESP_CODE_ERR)
1584 {
1585 response->body =
1586 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1587 g_warning ("%s: Not possible to get health information", __func__);
1588 }
1589
1591 return response;
1592}
1593
1596{
1597 openvasd_resp_t response = NULL;
1598 gchar *err = NULL;
1599 CURL *hnd = NULL;
1600 struct curl_slist *customheader = NULL;
1601
1602 response = g_malloc0 (sizeof (struct openvasd_response));
1603
1604 customheader = init_customheader (conn->apikey, FALSE);
1605 if ((hnd =
1606 handler (conn, GET, "/scans/preferences", NULL, customheader, &err))
1607 == NULL)
1608 {
1609 curl_slist_free_all (customheader);
1610 response->code = RESP_CODE_ERR;
1611 response->body = err;
1612 return response;
1613 }
1614
1615 openvasd_send_request (hnd, NULL, response);
1616 curl_slist_free_all (customheader);
1617 if (response->code != RESP_CODE_ERR)
1618 response->body = g_strdup (openvasd_vt_stream_str (conn));
1619 else if (response->code == RESP_CODE_ERR)
1620 {
1621 response->body =
1622 g_strdup ("{\"error\": \"Not possible to get scans preferences.\"}");
1623 g_warning ("%s: Not possible to get scans_preferences", __func__);
1624 }
1625
1627 return response;
1628}
1629
1635static openvasd_param_t *
1636openvasd_param_new (char *id, gchar *name, gchar *defval, gchar *description,
1637 gchar *type, int mandatory)
1638{
1639 openvasd_param_t *param = g_malloc0 (sizeof (openvasd_param_t));
1640
1641 param->id = id;
1642 param->defval = defval;
1643 param->description = description;
1644 param->name = name;
1645 param->mandatory = mandatory;
1646 param->type = type;
1647 return param;
1648}
1649
1655void
1657{
1658 if (!param)
1659 return;
1660 g_free (param->id);
1661 g_free (param->name);
1662 g_free (param->defval);
1663 g_free (param->description);
1664 g_free (param->type);
1665}
1666
1672char *
1674{
1675 if (!param)
1676 return NULL;
1677
1678 return param->id;
1679}
1680
1686char *
1688{
1689 if (!param)
1690 return NULL;
1691
1692 return param->defval;
1693}
1694
1700char *
1702{
1703 if (!param)
1704 return NULL;
1705
1706 return param->description;
1707}
1708
1714char *
1716{
1717 if (!param)
1718 return NULL;
1719
1720 return param->type;
1721}
1722
1728char *
1730{
1731 if (!param)
1732 return NULL;
1733
1734 return param->defval;
1735}
1736
1742int
1744{
1745 if (!param)
1746 return 0;
1747
1748 return param->mandatory;
1749}
1750
1751int
1753{
1754 openvasd_resp_t resp = NULL;
1755 cJSON *parser;
1756 cJSON *param_obj = NULL;
1757 int err = 0;
1758
1759 resp = openvasd_get_scan_preferences (conn);
1760
1761 if (resp->code != 200)
1762 return -1;
1763
1764 // No results. No information.
1765 parser = cJSON_Parse (resp->body);
1766 if (parser == NULL || !cJSON_IsArray (parser))
1767 {
1768 err = 1;
1769 goto prefs_cleanup;
1770 }
1771
1772 cJSON_ArrayForEach (param_obj, parser)
1773 {
1774 gchar *defval = NULL, *param_type = NULL;
1775 openvasd_param_t *param = NULL;
1776 int val, mandatory = 0;
1777 char buf[6];
1778 cJSON *item = NULL;
1779
1780 item = cJSON_GetObjectItem (param_obj, "default");
1781 if (item != NULL)
1782 {
1783 if (cJSON_IsNumber (item))
1784 {
1785 val = item->valueint;
1786 g_snprintf (buf, sizeof (buf), "%d", val);
1787 defval = g_strdup (buf);
1788 param_type = g_strdup ("integer");
1789 }
1790 else if (cJSON_IsString (item))
1791 {
1792 defval = g_strdup (item->valuestring);
1793 param_type = g_strdup ("string");
1794 }
1795 else if (cJSON_IsBool (item))
1796 {
1797 if (cJSON_IsTrue (item))
1798 defval = g_strdup ("yes");
1799 else
1800 defval = g_strdup ("no");
1801 param_type = g_strdup ("boolean");
1802 }
1803 else
1804 {
1805 g_warning ("%s: Unable to parse scan preferences.", __func__);
1806 g_free (defval);
1807 g_free (param_type);
1808 continue;
1809 }
1810 }
1811
1812 param =
1813 openvasd_param_new (g_strdup (gvm_json_obj_str (param_obj, "id")),
1814 g_strdup (gvm_json_obj_str (param_obj, "name")),
1815 g_strdup (defval),
1816 g_strdup (gvm_json_obj_str (param_obj, "description")),
1817 g_strdup (param_type), mandatory);
1818 g_free (defval);
1819 g_free (param_type);
1820 *params = g_slist_append (*params, param);
1821 }
1822
1823prefs_cleanup:
1825 cJSON_Delete (parser);
1826 if (err)
1827 {
1828 g_warning ("%s: Unable to parse scan preferences.", __func__);
1829 return -1;
1830 }
1831
1832 return 0;
1833}
1834
1835// Scan config builder
1836static void
1837add_port_to_scan_json (gpointer range, gpointer p_array)
1838{
1839 range_t *ports = range;
1840
1841 cJSON *port = cJSON_CreateObject ();
1842 if (ports->type == 1)
1843 cJSON_AddStringToObject (port, "protocol", "udp");
1844 else
1845 cJSON_AddStringToObject (port, "protocol", "tcp");
1846
1847 cJSON *ranges_array = cJSON_CreateArray ();
1848 cJSON *range_obj = cJSON_CreateObject ();
1849 cJSON_AddNumberToObject (range_obj, "start", ports->start);
1850
1851 if (ports->end > ports->start && ports->end < 65535)
1852 cJSON_AddNumberToObject (range_obj, "end", ports->end);
1853 else
1854 cJSON_AddNumberToObject (range_obj, "end", ports->start);
1855 cJSON_AddItemToArray (ranges_array, range_obj);
1856 cJSON_AddItemToObject (port, "range", ranges_array);
1857 cJSON_AddItemToArray ((cJSON *) p_array, port);
1858}
1859
1860static void
1861add_credential_to_scan_json (gpointer credentials, gpointer cred_array)
1862{
1863 GHashTableIter auth_data_iter;
1864 gchar *auth_data_name, *auth_data_value;
1865 cJSON *cred_obj = NULL;
1866
1867 openvasd_credential_t *cred = credentials;
1868
1869 cred_obj = cJSON_CreateObject ();
1870 cJSON_AddStringToObject (cred_obj, "service", cred->service);
1871
1872 if (cred->port)
1873 {
1874 cJSON_AddNumberToObject (cred_obj, "port", atoi (cred->port));
1875 }
1876
1877 cJSON *cred_type_obj = cJSON_CreateObject ();
1878 g_hash_table_iter_init (&auth_data_iter, cred->auth_data);
1879 while (g_hash_table_iter_next (&auth_data_iter, (gpointer *) &auth_data_name,
1880 (gpointer *) &auth_data_value))
1881 cJSON_AddStringToObject (cred_type_obj, auth_data_name, auth_data_value);
1882 cJSON_AddItemToObject (cred_obj, cred->type, cred_type_obj);
1883
1884 cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
1885}
1886
1887static void
1888add_scan_preferences_to_scan_json (gpointer key, gpointer val,
1889 gpointer scan_prefs_array)
1890{
1891 cJSON *pref_obj = cJSON_CreateObject ();
1892 cJSON_AddStringToObject (pref_obj, "id", key);
1893 cJSON_AddStringToObject (pref_obj, "value", val);
1894 cJSON_AddItemToArray (scan_prefs_array, pref_obj);
1895}
1896
1897static void
1898add_vts_to_scan_json (gpointer single_vt, gpointer vts_array)
1899{
1900 GHashTableIter vt_data_iter;
1901 gchar *vt_param_id, *vt_param_value;
1902
1903 openvasd_vt_single_t *vt = single_vt;
1904
1905 cJSON *vt_obj = cJSON_CreateObject ();
1906
1907 cJSON_AddStringToObject (vt_obj, "oid", vt->vt_id);
1908
1909 if (g_hash_table_size (vt->vt_values))
1910 {
1911 cJSON *params_array = cJSON_CreateArray ();
1912
1913 g_hash_table_iter_init (&vt_data_iter, vt->vt_values);
1914 while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
1915 (gpointer *) &vt_param_value))
1916 {
1917 cJSON *param_obj = cJSON_CreateObject ();
1918 cJSON_AddNumberToObject (param_obj, "id", atoi (vt_param_id));
1919 cJSON_AddStringToObject (param_obj, "value", vt_param_value);
1920 cJSON_AddItemToArray (params_array, param_obj);
1921 }
1922 cJSON_AddItemToObject (vt_obj, "parameters", params_array);
1923 }
1924 cJSON_AddItemToArray (vts_array, vt_obj);
1925}
1926
1939char *
1941 GHashTable *scan_preferences, GSList *vts)
1942{
1943 cJSON *scan_obj = NULL;
1944 cJSON *target_obj = NULL;
1945 cJSON *hosts_array = NULL;
1946 cJSON *exclude_hosts_array = NULL;
1947 cJSON *finished_hosts_array = NULL;
1948 gchar *json_str = NULL;
1949
1950 /* Build the message in json format to be published. */
1951 scan_obj = cJSON_CreateObject ();
1952
1953 if (target->scan_id && target->scan_id[0] != '\0')
1954 cJSON_AddStringToObject (scan_obj, "scan_id", target->scan_id);
1955
1956 // begin target
1957 target_obj = cJSON_CreateObject ();
1958
1959 // hosts
1960 hosts_array = cJSON_CreateArray ();
1961 gchar **hosts_list = g_strsplit (target->hosts, ",", 0);
1962 for (int i = 0; hosts_list[i] != NULL; i++)
1963 {
1964 cJSON *host_item = NULL;
1965 host_item = cJSON_CreateString (hosts_list[i]);
1966 cJSON_AddItemToArray (hosts_array, host_item);
1967 }
1968 g_strfreev (hosts_list);
1969 cJSON_AddItemToObject (target_obj, "hosts", hosts_array);
1970
1971 // exclude hosts
1972 if (target->exclude_hosts && target->exclude_hosts[0] != '\0')
1973 {
1974 exclude_hosts_array = cJSON_CreateArray ();
1975 gchar **exclude_hosts_list = g_strsplit (target->exclude_hosts, ",", 0);
1976 for (int i = 0; exclude_hosts_list[i] != NULL; i++)
1977 {
1978 cJSON *exclude_host_item = NULL;
1979 exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
1980 cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
1981 }
1982 g_strfreev (exclude_hosts_list);
1983 cJSON_AddItemToObject (target_obj, "excluded_hosts", exclude_hosts_array);
1984 }
1985
1986 // finished hosts
1987 if (target->finished_hosts && target->finished_hosts[0] != '\0')
1988 {
1989 finished_hosts_array = cJSON_CreateArray ();
1990 gchar **finished_hosts_list = g_strsplit (target->finished_hosts, ",", 0);
1991 for (int i = 0; finished_hosts_list[i] != NULL; i++)
1992 {
1993 cJSON *finished_host_item = NULL;
1994 finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
1995 cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
1996 }
1997 g_strfreev (hosts_list);
1998 cJSON_AddItemToObject (target_obj, "finished_hosts",
1999 finished_hosts_array);
2000 }
2001
2002 // ports
2003 if (target->ports && target->ports[0] != '\0')
2004 {
2005 cJSON *ports_array = cJSON_CreateArray ();
2006 array_t *ports = port_range_ranges (target->ports);
2007 g_ptr_array_foreach (ports, add_port_to_scan_json, ports_array);
2008 array_free (ports);
2009 cJSON_AddItemToObject (target_obj, "ports", ports_array);
2010 }
2011
2012 // credentials
2013 cJSON *credentials = cJSON_CreateArray ();
2014 g_slist_foreach (target->credentials, add_credential_to_scan_json,
2015 credentials);
2016 cJSON_AddItemToObject (target_obj, "credentials", credentials);
2017
2018 // reverse lookup
2019 if (target->reverse_lookup_unify)
2020 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_True);
2021 else
2022 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_False);
2023
2024 if (target->reverse_lookup_only)
2025 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_True);
2026 else
2027 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_False);
2028
2029 // alive test methods
2030 cJSON *alive_test_methods = cJSON_CreateArray ();
2031 if (target->arp)
2032 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("arp"));
2033 if (target->tcp_ack)
2034 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_ack"));
2035 if (target->tcp_syn)
2036 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_syn"));
2037 if (target->consider_alive)
2038 cJSON_AddItemToArray (alive_test_methods,
2039 cJSON_CreateString ("consider_alive"));
2040 if (target->icmp)
2041 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("icmp"));
2042 cJSON_AddItemToObject (target_obj, "alive_test_methods", alive_test_methods);
2043
2044 cJSON_AddItemToObject (scan_obj, "target", target_obj);
2045
2046 // Begin Scan Preferences
2047 cJSON *scan_prefs_array = cJSON_CreateArray ();
2048 g_hash_table_foreach (scan_preferences, add_scan_preferences_to_scan_json,
2049 scan_prefs_array);
2050 cJSON_AddItemToObject (scan_obj, "scan_preferences", scan_prefs_array);
2051
2052 // Begin VTs
2053 cJSON *vts_array = cJSON_CreateArray ();
2054 g_slist_foreach (vts, add_vts_to_scan_json, vts_array);
2055 cJSON_AddItemToObject (scan_obj, "vts", vts_array);
2056
2057 json_str = cJSON_Print (scan_obj);
2058 cJSON_Delete (scan_obj);
2059 if (json_str == NULL)
2060 g_warning ("%s: Error while creating JSON.", __func__);
2061
2062 return json_str;
2063}
2064
2075openvasd_credential_new (const gchar *type, const gchar *service,
2076 const gchar *port)
2077{
2078 openvasd_credential_t *new_credential;
2079
2080 new_credential = g_malloc0 (sizeof (openvasd_credential_t));
2081
2082 new_credential->type = type ? g_strdup (type) : NULL;
2083 new_credential->service = service ? g_strdup (service) : NULL;
2084 new_credential->port = port ? g_strdup (port) : NULL;
2085 new_credential->auth_data =
2086 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
2087
2088 return new_credential;
2089}
2090
2096void
2098{
2099 if (!credential)
2100 return;
2101
2102 g_free (credential->type);
2103 g_free (credential->service);
2104 g_free (credential->port);
2105 g_hash_table_destroy (credential->auth_data);
2106 g_free (credential);
2107}
2108
2116void
2118 const gchar *name, const gchar *value)
2119{
2120 if (credential == NULL || name == NULL)
2121 return;
2122
2123 if (g_regex_match_simple ("^[[:alpha:]][[:alnum:]_]*$", name, 0, 0))
2124 {
2125 if (value)
2126 g_hash_table_replace (credential->auth_data, g_strdup (name),
2127 g_strdup (value));
2128 else
2129 g_hash_table_remove (credential->auth_data, name);
2130 }
2131 else
2132 {
2133 g_warning ("%s: Invalid auth data name: %s", __func__, name);
2134 }
2135}
2136
2150openvasd_target_new (const gchar *scanid, const gchar *hosts,
2151 const gchar *ports, const gchar *exclude_hosts,
2152 int reverse_lookup_unify, int reverse_lookup_only)
2153{
2154 openvasd_target_t *new_target;
2155 new_target = g_malloc0 (sizeof (openvasd_target_t));
2156
2157 if (scanid && *scanid)
2158 new_target->scan_id = g_strdup (scanid);
2159
2160 new_target->exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
2161 new_target->finished_hosts = NULL;
2162 new_target->hosts = hosts ? g_strdup (hosts) : NULL;
2163 new_target->ports = ports ? g_strdup (ports) : NULL;
2164 new_target->reverse_lookup_unify =
2165 reverse_lookup_unify ? reverse_lookup_unify : 0;
2166 new_target->reverse_lookup_only =
2167 reverse_lookup_only ? reverse_lookup_only : 0;
2168
2169 return new_target;
2170}
2171
2178void
2180 const gchar *finished_hosts)
2181{
2182 g_free (target->finished_hosts);
2183 target->finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
2184}
2185
2191void
2193{
2194 if (!target)
2195 return;
2196
2197 g_slist_free_full (target->credentials,
2198 (GDestroyNotify) openvasd_credential_free);
2199 g_free (target->exclude_hosts);
2200 g_free (target->finished_hosts);
2201 g_free (target->scan_id);
2202 g_free (target->hosts);
2203 g_free (target->ports);
2204 g_free (target);
2205 target = NULL;
2206}
2207
2218void
2220 gboolean icmp, gboolean tcp_syn,
2221 gboolean tcp_ack, gboolean arp,
2222 gboolean consider_alive)
2223{
2224 if (!target)
2225 return;
2226
2227 target->icmp = icmp;
2228 target->tcp_syn = tcp_syn;
2229 target->tcp_ack = tcp_ack;
2230 target->arp = arp;
2231 target->consider_alive = consider_alive;
2232}
2233
2240void
2242 openvasd_credential_t *credential)
2243{
2244 if (!target || !credential)
2245 return;
2246
2247 target->credentials = g_slist_prepend (target->credentials, credential);
2248}
2249
2258openvasd_vt_single_new (const gchar *vt_id)
2259{
2260 openvasd_vt_single_t *new_vt_single;
2261 new_vt_single = g_malloc0 (sizeof (openvasd_vt_single_t));
2262
2263 new_vt_single->vt_id = vt_id ? g_strdup (vt_id) : NULL;
2264 new_vt_single->vt_values =
2265 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
2266
2267 return new_vt_single;
2268}
2269
2275void
2277{
2278 if (!vt_single)
2279 return;
2280
2281 g_hash_table_destroy (vt_single->vt_values);
2282
2283 g_free (vt_single->vt_id);
2284 g_free (vt_single);
2285}
2286
2296void
2298 const gchar *name, const gchar *value)
2299{
2300 g_hash_table_replace (vt_single->vt_values, g_strdup (name),
2301 g_strdup (value));
2302}
void array_free(GPtrArray *array)
Free global array value.
Definition array.c:50
Array utilities.
GPtrArray array_t
Definition array.h:16
double gvm_json_obj_double(cJSON *obj, const gchar *key)
Get a double field from a JSON object.
Definition json.c:75
int gvm_json_obj_check_int(cJSON *obj, const gchar *key, int *val)
Get an int field from a JSON object.
Definition json.c:97
int gvm_json_obj_int(cJSON *obj, const gchar *key)
Get an int field from a JSON object.
Definition json.c:120
gchar * gvm_json_obj_str(cJSON *obj, const gchar *key)
Get a string field from a JSON object.
Definition json.c:165
int gvm_json_obj_check_str(cJSON *obj, const gchar *key, gchar **val)
Get a string field from a JSON object.
Definition json.c:142
array_t * port_range_ranges(const char *port_range)
Create a range array from a port_range string.
Definition networking.c:601
GVM Networking related API.
struct range range_t
Definition networking.h:43
void openvasd_target_add_credential(openvasd_target_t *target, openvasd_credential_t *credential)
Add a credential to an Openvasd target.
Definition openvasd.c:2241
void openvasd_param_free(openvasd_param_t *param)
Free an Openvasd parameter.
Definition openvasd.c:1656
static CURL * handler(openvasd_connector_t conn, openvasd_req_method_t method, gchar *path, gchar *data, struct curl_slist *customheader, gchar **err)
Create a CURL handler.
Definition openvasd.c:411
#define RESP_CODE_ERR
Definition openvasd.c:33
void openvasd_credential_set_auth_data(openvasd_credential_t *credential, const gchar *name, const gchar *value)
Get authentication data from an Openvasd credential.
Definition openvasd.c:2117
int openvasd_get_result_member_int(openvasd_result_t result, openvasd_result_member_int_t member)
Definition openvasd.c:1054
void openvasd_target_free(openvasd_target_t *target)
Free an Openvasd target, including all added credentials.
Definition openvasd.c:2192
openvasd_scan_status_t openvasd_parsed_scan_status(openvasd_connector_t conn)
Return a struct with the general scan status.
Definition openvasd.c:1411
char * openvasd_param_desc(openvasd_param_t *param)
Get the parameter description.
Definition openvasd.c:1701
openvasd_result_t openvasd_result_new(unsigned long id, gchar *type, gchar *ip_address, gchar *hostname, gchar *oid, int port, gchar *protocol, gchar *message, gchar *detail_name, gchar *detail_value, gchar *detail_source_type, gchar *detail_source_name, gchar *detail_source_description)
Definition openvasd.c:992
void openvasd_reset_vt_stream(openvasd_connector_t conn)
Definition openvasd.c:676
void openvasd_credential_free(openvasd_credential_t *credential)
Free an Openvasd credential.
Definition openvasd.c:2097
size_t openvasd_vt_stream_len(openvasd_connector_t conn)
Definition openvasd.c:688
openvasd_credential_t * openvasd_credential_new(const gchar *type, const gchar *service, const gchar *port)
Allocate and initialize a new Openvasd credential.
Definition openvasd.c:2075
openvasd_resp_t openvasd_get_scan_results(openvasd_connector_t conn, long first, long last)
Definition openvasd.c:933
char * openvasd_build_scan_config_json(openvasd_target_t *target, GHashTable *scan_preferences, GSList *vts)
Build a json object with data necessary to start a scan.
Definition openvasd.c:1940
char * openvasd_param_name(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1687
static void add_credential_to_scan_json(gpointer credentials, gpointer cred_array)
Definition openvasd.c:1861
openvasd_resp_t openvasd_get_scan_preferences(openvasd_connector_t conn)
Definition openvasd.c:1595
static void openvasd_curlm_handler_close(openvasd_curlm_t *h)
Cleanup an openvasd curl handler.
Definition openvasd.c:156
int openvasd_parsed_results(openvasd_connector_t conn, unsigned long first, unsigned long last, GSList **results)
Definition openvasd.c:1171
int openvasd_param_mandatory(openvasd_param_t *param)
If the parameter is mandatory.
Definition openvasd.c:1743
openvasd_resp_t openvasd_get_vt_stream_init(openvasd_connector_t conn)
Initialized an curl multiperform handler which allows fetch feed metadata chunk by chunk.
Definition openvasd.c:641
openvasd_target_t * openvasd_target_new(const gchar *scanid, const gchar *hosts, const gchar *ports, const gchar *exclude_hosts, int reverse_lookup_unify, int reverse_lookup_only)
Create a new Openvasd target.
Definition openvasd.c:2150
void openvasd_result_free(openvasd_result_t result)
Definition openvasd.c:1072
char * openvasd_get_result_member_str(openvasd_result_t result, openvasd_result_member_string_t member)
Definition openvasd.c:1018
#define RESP_CODE_OK
Definition openvasd.c:34
int openvasd_get_scan_progress(openvasd_connector_t conn)
Definition openvasd.c:1347
enum openvas_request_method openvasd_req_method_t
Definition openvasd.c:137
static struct curl_slist * init_customheader(const gchar *apikey, gboolean contenttype)
Definition openvasd.c:363
static void add_port_to_scan_json(gpointer range, gpointer p_array)
Definition openvasd.c:1837
static openvasd_status_t get_status_code_from_openvas(const gchar *status_val)
Definition openvasd.c:1353
char * openvasd_param_type(openvasd_param_t *param)
Get the parameter type.
Definition openvasd.c:1715
openvasd_connector_t openvasd_connector_new(void)
Initialize an openvasd connector.
Definition openvasd.c:231
struct openvasd_curlm openvasd_curlm_t
Wrapps a CURLM * handler and the custom header.
openvasd_resp_t openvasd_get_health_alive(openvasd_connector_t conn)
Definition openvasd.c:1491
void openvasd_target_set_finished_hosts(openvasd_target_t *target, const gchar *finished_hosts)
Set the finished hosts of an Openvasd target.
Definition openvasd.c:2179
struct openvasd_string * openvasd_vt_stream_t
Definition openvasd.c:55
static int get_member_value_or_fail(cJSON *reader, const gchar *member)
Get the value from an object or error.
Definition openvasd.c:1247
void openvasd_vt_single_free(openvasd_vt_single_t *vt_single)
Free a single Openvasd VT, including all preference values.
Definition openvasd.c:2276
openvasd_resp_t openvasd_get_version(openvasd_connector_t conn)
Request HEAD.
Definition openvasd.c:599
static size_t response_callback_fn(void *ptr, size_t size, size_t nmemb, void *struct_string)
Call back function to stored the response.
Definition openvasd.c:349
char * openvasd_param_default(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1729
static void add_scan_preferences_to_scan_json(gpointer key, gpointer val, gpointer scan_prefs_array)
Definition openvasd.c:1888
openvasd_resp_t openvasd_get_vts(openvasd_connector_t conn)
Get VT's metadata.
Definition openvasd.c:736
int openvasd_get_vt_stream(openvasd_connector_t conn)
Get a new feed metadata chunk.
Definition openvasd.c:705
openvasd_resp_t openvasd_start_scan(openvasd_connector_t conn, gchar *data)
Definition openvasd.c:777
static void add_vts_to_scan_json(gpointer single_vt, gpointer vts_array)
Definition openvasd.c:1898
void openvasd_vt_single_add_value(openvasd_vt_single_t *vt_single, const gchar *name, const gchar *value)
Add a preference value to an Openvasd VT.
Definition openvasd.c:2297
static int parse_status(const gchar *body, openvasd_scan_status_t status_info)
Definition openvasd.c:1374
openvasd_resp_t openvasd_get_health_started(openvasd_connector_t conn)
Definition openvasd.c:1560
openvasd_error_t openvasd_connector_free(openvasd_connector_t conn)
Build a openvasd connector.
Definition openvasd.c:307
static openvasd_vt_stream_t openvasd_vt_stream_new(void)
Allocate the vt stream struct to hold the response and the curlm handler.
Definition openvasd.c:182
static void openvasd_vt_stream_reset(openvasd_vt_stream_t s)
Reinitialize the string struct to hold the response.
Definition openvasd.c:215
openvasd_resp_t openvasd_delete_scan(openvasd_connector_t conn)
Definition openvasd.c:1437
void openvasd_response_cleanup(openvasd_resp_t resp)
Free an openvasd response struct.
Definition openvasd.c:332
static int openvasd_get_scan_progress_ext(openvasd_connector_t conn, openvasd_resp_t response)
Definition openvasd.c:1258
void openvasd_target_add_alive_test_methods(openvasd_target_t *target, gboolean icmp, gboolean tcp_syn, gboolean tcp_ack, gboolean arp, gboolean consider_alive)
Add alive test methods to Openvasd target.
Definition openvasd.c:2219
gchar * openvasd_vt_stream_str(openvasd_connector_t conn)
Definition openvasd.c:682
openvasd_resp_t openvasd_stop_scan(openvasd_connector_t conn)
Definition openvasd.c:884
openvasd_resp_t openvasd_get_health_ready(openvasd_connector_t conn)
Definition openvasd.c:1526
openvas_request_method
Request methods.
Definition openvasd.c:130
@ HEAD
Definition openvasd.c:133
@ GET
Definition openvasd.c:132
@ POST
Definition openvasd.c:131
@ DELETE
Definition openvasd.c:134
char * openvasd_param_id(openvasd_param_t *param)
Get the parameter id.
Definition openvasd.c:1673
static int parse_results(const gchar *body, GSList **results)
Definition openvasd.c:1093
static openvasd_param_t * openvasd_param_new(char *id, gchar *name, gchar *defval, gchar *description, gchar *type, int mandatory)
Create a new Openvasd parameter.
Definition openvasd.c:1636
static openvasd_resp_t openvasd_send_request(CURL *curl, const gchar *header_name, openvasd_resp_t response)
Send request.
Definition openvasd.c:562
static openvasd_curlm_t * openvasd_curlm_handler_new(void)
Allocate openvasd curl handler.
Definition openvasd.c:145
int openvasd_parsed_scans_preferences(openvasd_connector_t conn, GSList **params)
Definition openvasd.c:1752
openvasd_vt_single_t * openvasd_vt_single_new(const gchar *vt_id)
Create a new single Openvasd VT.
Definition openvasd.c:2258
static void openvasd_vt_stream_free(openvasd_vt_stream_t s)
Cleanup the string struct to hold the response and the curl multiperform handler.
Definition openvasd.c:198
openvasd_error_t openvasd_connector_builder(openvasd_connector_t conn, openvasd_conn_opt_t opt, const void *val)
Build a openvasd connector.
Definition openvasd.c:254
openvasd_resp_t openvasd_get_scan_status(openvasd_connector_t conn)
Definition openvasd.c:1189
API for Openvas Daemon communication.
@ ID
Definition openvasd.h:79
@ PORT
Definition openvasd.h:80
enum OPENVASD_RESULT_MEMBER_STRING openvasd_result_member_string_t
Definition openvasd.h:117
struct openvasd_credential openvasd_credential_t
Definition openvasd.h:220
@ OPENVASD_INVALID_OPT
Definition openvasd.h:42
@ OPENVASD_INVALID_VALUE
Definition openvasd.h:44
@ OPENVASD_OK
Definition openvasd.h:46
struct openvasd_vt_single openvasd_vt_single_t
Definition openvasd.h:218
struct openvasd_connector * openvasd_connector_t
Definition openvasd.h:125
struct openvasd_target openvasd_target_t
Definition openvasd.h:216
@ OPENVASD_API_KEY
Definition openvasd.h:55
@ OPENVASD_SERVER
Definition openvasd.h:56
@ OPENVASD_CA_CERT
Definition openvasd.h:52
@ OPENVASD_KEY
Definition openvasd.h:54
@ OPENVASD_SCAN_ID
Definition openvasd.h:58
@ OPENVASD_CERT
Definition openvasd.h:53
@ OPENVASD_PORT
Definition openvasd.h:59
@ OPENVASD_HOST
Definition openvasd.h:57
struct openvasd_param openvasd_param_t
Definition openvasd.h:187
openvasd_status_t
Openvasd scan status.
Definition openvasd.h:87
@ OPENVASD_SCAN_STATUS_SUCCEEDED
Definition openvasd.h:94
@ OPENVASD_SCAN_STATUS_RUNNING
Definition openvasd.h:92
@ OPENVASD_SCAN_STATUS_STOPPED
Definition openvasd.h:93
@ OPENVASD_SCAN_STATUS_STORED
Definition openvasd.h:90
@ OPENVASD_SCAN_STATUS_REQUESTED
Definition openvasd.h:91
@ OPENVASD_SCAN_STATUS_ERROR
Definition openvasd.h:88
@ OPENVASD_SCAN_STATUS_FAILED
Definition openvasd.h:89
struct openvasd_result * openvasd_result_t
Definition openvasd.h:123
enum OPENVASD_CONNECTOR_OPTS openvasd_conn_opt_t
Definition openvasd.h:119
enum OPENVASD_RESULT_MEMBER_INT openvasd_result_member_int_t
Definition openvasd.h:115
struct openvasd_scan_status * openvasd_scan_status_t
Definition openvasd.h:127
struct openvasd_response * openvasd_resp_t
Definition openvasd.h:113
enum OPENVASD_ERROR openvasd_error_t
Definition openvasd.h:121
@ DETAIL_NAME
Definition openvasd.h:70
@ DETAIL_VALUE
Definition openvasd.h:71
@ DETAIL_SOURCE_DESCRIPTION
Definition openvasd.h:74
@ PROTOCOL
Definition openvasd.h:68
@ DETAIL_SOURCE_NAME
Definition openvasd.h:72
@ DETAIL_SOURCE_TYPE
Definition openvasd.h:73
@ HOSTNAME
Definition openvasd.h:66
@ MESSAGE
Definition openvasd.h:69
@ TYPE
Definition openvasd.h:64
@ IP_ADDRESS
Definition openvasd.h:65
@ OID
Definition openvasd.h:67
Struct holding the data for connecting with Openvasd.
Definition openvasd.c:61
openvasd_vt_stream_t stream_resp
Definition openvasd.c:70
gchar * apikey
Definition openvasd.c:65
gchar * server
Definition openvasd.c:66
gchar * key
Definition openvasd.c:64
gchar * cert
Definition openvasd.c:63
int port
Definition openvasd.c:69
gchar * ca_cert
Definition openvasd.c:62
gchar * scan_id
Definition openvasd.c:68
gchar * host
Definition openvasd.c:67
Struct credential information for Openvasd.
Definition openvasd.c:90
gchar * type
Definition openvasd.c:91
gchar * port
Definition openvasd.c:93
gchar * service
Definition openvasd.c:92
GHashTable * auth_data
Definition openvasd.c:94
Wrapps a CURLM * handler and the custom header.
Definition openvasd.c:40
CURLM * h
Definition openvasd.c:41
struct curl_slist * customheader
Definition openvasd.c:42
Struct holding options for Openvasd parameters.
Definition openvasd.c:77
gchar * id
Definition openvasd.c:78
gchar * description
Definition openvasd.c:81
gchar * defval
Definition openvasd.c:80
gchar * name
Definition openvasd.c:79
int mandatory
Definition openvasd.c:83
gchar * type
Definition openvasd.c:82
Definition openvasd.h:98
gchar * header
Definition openvasd.h:101
gchar * body
Definition openvasd.h:100
long code
Definition openvasd.h:99
Struct to hold an scan result.
Definition openvasd.h:23
int port
Definition openvasd.h:29
gchar * ip_address
Definition openvasd.h:26
gchar * oid
Definition openvasd.h:28
gchar * protocol
Definition openvasd.h:30
gchar * detail_source_name
Definition openvasd.h:35
gchar * message
Definition openvasd.h:31
gchar * type
Definition openvasd.h:25
gchar * detail_source_description
Definition openvasd.h:36
gchar * hostname
Definition openvasd.h:27
gchar * detail_name
Definition openvasd.h:32
unsigned long id
Definition openvasd.h:24
gchar * detail_value
Definition openvasd.h:33
gchar * detail_source_type
Definition openvasd.h:34
Definition openvasd.h:105
int progress
Definition openvasd.h:108
time_t start_time
Definition openvasd.h:106
long response_code
Definition openvasd.h:110
time_t end_time
Definition openvasd.h:107
openvasd_status_t status
Definition openvasd.h:109
Define a string struct for storing the response and the curl handler.
Definition openvasd.c:49
openvasd_curlm_t * curl_hnd
Definition openvasd.c:52
gchar * ptr
Definition openvasd.c:50
size_t len
Definition openvasd.c:51
Struct holding target information.
Definition openvasd.c:101
int reverse_lookup_only
Definition openvasd.c:114
gboolean icmp
Definition openvasd.c:108
gchar * ports
Definition openvasd.c:106
gboolean tcp_ack
Definition openvasd.c:110
gchar * exclude_hosts
Definition openvasd.c:104
int reverse_lookup_unify
Definition openvasd.c:113
gboolean arp
Definition openvasd.c:111
GSList * credentials
Definition openvasd.c:103
gboolean tcp_syn
Definition openvasd.c:109
gboolean consider_alive
Definition openvasd.c:112
gchar * finished_hosts
Definition openvasd.c:107
gchar * hosts
Definition openvasd.c:105
gchar * scan_id
Definition openvasd.c:102
Struct holding vt information.
Definition openvasd.c:121
gchar * vt_id
Definition openvasd.c:122
GHashTable * vt_values
Definition openvasd.c:123
A port range.
Definition networking.h:35
int start
Definition networking.h:40
port_protocol_t type
Definition networking.h:41
int end
Definition networking.h:38