Greenbone Vulnerability Management Libraries 22.17.0
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 if ((curl = curl_easy_init ()) == NULL)
425 {
426 *err =
427 g_strdup ("{\"error\": \"Not possible to initialize curl library\"}");
428 g_warning ("%s: Not possible to initialize curl library", __func__);
429 return NULL;
430 }
431
432 url = g_string_new (g_strdup (conn->server));
433
434 if (conn->port > 0 && conn->port < 65535)
435 {
436 char buf[6];
437 g_snprintf (buf, sizeof (buf), ":%d", conn->port);
438 g_string_append (url, buf);
439 }
440
441 if (path != NULL && path[0] != '\0')
442 g_string_append (url, path);
443
444 // Set URL
445 g_debug ("%s: URL: %s", __func__, url->str);
446 if (curl_easy_setopt (curl, CURLOPT_URL, url->str) != CURLE_OK)
447 {
448 g_string_free (url, TRUE);
449 g_warning ("%s: Not possible to set the URL", __func__);
450 curl_easy_cleanup (curl);
451 *err = g_strdup ("{\"error\": \"Not possible to set URL\"}");
452 return NULL;
453 }
454 g_string_free (url, TRUE);
455
456 // Server verification
457 if (conn->ca_cert != NULL)
458 {
459 struct curl_blob blob;
460 blob.data = conn->ca_cert;
461 blob.len = strlen (conn->ca_cert);
462 blob.flags = CURL_BLOB_COPY;
463
464 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 1L);
465 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 1L);
466 if (curl_easy_setopt (curl, CURLOPT_CAINFO_BLOB, &blob) != CURLE_OK)
467 {
468 g_warning ("%s: Not possible to set the CA certificate", __func__);
469 curl_easy_cleanup (curl);
470 *err =
471 g_strdup ("{\"error\": \"Not possible to set CA certificate\"}");
472 return NULL;
473 }
474 }
475 else
476 {
477 // Accept an insecure connection. Don't verify the server certificate
478 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0L);
479 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0L);
480 curl_easy_setopt (curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2);
481 g_debug ("%s: Server certificate verification disabled.", __func__);
482 }
483
484 // Client certificate
485 if (conn->cert != NULL && conn->key != NULL)
486 {
487 struct curl_blob blob;
488 blob.data = conn->cert;
489 blob.len = strlen (conn->cert);
490 blob.flags = CURL_BLOB_COPY;
491
492 if (curl_easy_setopt (curl, CURLOPT_SSLCERT_BLOB, &blob) != CURLE_OK)
493 {
494 g_warning ("%s: Not possible to set the Client certificate",
495 __func__);
496 curl_easy_cleanup (curl);
497 *err = g_strdup (
498 "{\"error\": \"Not possible to set Client certificate\"}");
499 return NULL;
500 }
501 blob.data = conn->key;
502 blob.len = strlen (conn->key);
503 blob.flags = CURL_BLOB_COPY;
504
505 if (curl_easy_setopt (curl, CURLOPT_SSLKEY_BLOB, &blob) != CURLE_OK)
506 {
507 g_warning ("%s: Not possible to set the Client private key",
508 __func__);
509 curl_easy_cleanup (curl);
510 *err = g_strdup (
511 "{\"error\": \"Not possible to set Client private key\"}");
512 return NULL;
513 }
514 }
515
516 switch (method)
517 {
518 case POST:
519 if (data != NULL && data[0] != '\0')
520 {
521 // Set body
522 curl_easy_setopt (curl, CURLOPT_POSTFIELDS, data);
523 curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen (data));
524 }
525 break;
526 case GET:
527 curl_easy_setopt (curl, CURLOPT_HTTPGET, 1L);
528 break;
529 case DELETE:
530 curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, "DELETE");
531 break;
532 default:
533 curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, "HEAD");
534 break;
535 };
536
537 if (customheader != NULL)
538 curl_easy_setopt (curl, CURLOPT_HTTPHEADER, customheader);
539
540 // Init the struct where the response is stored and set the callback function
541 curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, response_callback_fn);
542 curl_easy_setopt (curl, CURLOPT_WRITEDATA, conn->stream_resp);
543
544 return curl;
545}
546
560static openvasd_resp_t
561openvasd_send_request (CURL *curl, const gchar *header_name,
562 openvasd_resp_t response)
563{
564 long http_code = RESP_CODE_ERR;
565
566 int ret = CURLE_OK;
567 if ((ret = curl_easy_perform (curl)) != CURLE_OK)
568 {
569 g_warning ("%s: Error sending request: %d", __func__, ret);
570 curl_easy_cleanup (curl);
571 response->code = http_code;
572 response->body = g_strdup ("{\"error\": \"Error sending request\"}");
573 return response;
574 }
575
576 curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
577 if (header_name)
578 {
579 struct curl_header *hname;
580 curl_easy_header (curl, header_name, 0, CURLH_HEADER, -1, &hname);
581 response->header = g_strdup (hname->value);
582 }
583 curl_easy_cleanup (curl);
584 response->code = http_code;
585
586 return response;
587}
588
598{
599 gchar *err = NULL;
600 CURL *hnd = NULL;
601 openvasd_resp_t response = NULL;
602 struct curl_slist *customheader = NULL;
603
604 response = g_malloc0 (sizeof (struct openvasd_response));
605
606 customheader = init_customheader (conn->apikey, FALSE);
607 hnd = handler (conn, HEAD, "/", NULL, customheader, &err);
608 if (hnd == NULL)
609 {
610 curl_slist_free_all (customheader);
611 response->code = RESP_CODE_ERR;
612 response->body = err;
614 return response;
615 }
616
617 openvasd_send_request (hnd, NULL, response);
618 curl_slist_free_all (customheader);
619 if (response->code != RESP_CODE_ERR)
620 response->body = g_strdup (openvasd_vt_stream_str (conn));
621
623 return response;
624}
625
640{
641 GString *path;
642 openvasd_resp_t response = NULL;
643 gchar *err = NULL;
644 CURL *hnd = NULL;
645 CURLM *h = NULL;
646 struct curl_slist *customheader = NULL;
647
648 response = g_malloc0 (sizeof (struct openvasd_response));
649
650 path = g_string_new ("/vts?information=1");
651 customheader = init_customheader (conn->apikey, FALSE);
652 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
653 if (hnd == NULL)
654 {
655 curl_slist_free_all (customheader);
656 g_string_free (path, TRUE);
657 response->code = RESP_CODE_ERR;
658 response->body = err;
659 return response;
660 }
661 g_string_free (path, TRUE);
662
663 h = curl_multi_init ();
664 curl_multi_add_handle (h, hnd);
665
666 conn->stream_resp->curl_hnd->h = h;
667 conn->stream_resp->curl_hnd->customheader = customheader;
668
669 response->code = RESP_CODE_OK;
670 return response;
671}
672
673void
678
679gchar *
681{
682 return conn->stream_resp->ptr;
683}
684
685size_t
687{
688 return conn->stream_resp->len;
689}
690
702int
704{
705 static int running = 0;
706 CURLM *h = conn->stream_resp->curl_hnd->h;
707 if (!(h))
708 {
709 return -1;
710 }
711
712 CURLMcode mc = curl_multi_perform (h, &running);
713 if (!mc && running)
714 /* wait for activity, timeout or "nothing" */
715 mc = curl_multi_poll (h, NULL, 0, 5000, NULL);
716 if (mc != CURLM_OK)
717 {
718 g_warning ("%s: error on curl_multi_poll(): %d\n", __func__, mc);
719 return -1;
720 }
721
722 return running;
723}
724
735{
736 GString *path;
737 openvasd_resp_t response = NULL;
738 gchar *err = NULL;
739 CURL *hnd = NULL;
740 struct curl_slist *customheader = NULL;
741
742 response = g_malloc0 (sizeof (struct openvasd_response));
743
744 path = g_string_new ("/vts?information=1");
745 customheader = init_customheader (conn->apikey, FALSE);
746 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
747 if (hnd == NULL)
748 {
749 curl_slist_free_all (customheader);
750 g_string_free (path, TRUE);
751 response->code = RESP_CODE_ERR;
752 response->body = err;
753 return response;
754 }
755 g_string_free (path, TRUE);
756
757 openvasd_send_request (hnd, NULL, response);
758 curl_slist_free_all (customheader);
759 if (response->code != RESP_CODE_ERR)
760 response->body = g_strdup (openvasd_vt_stream_str (conn));
761
763 return response;
764}
765
776{
777 openvasd_resp_t response = NULL;
778 cJSON *parser = NULL;
779 GString *path;
780 gchar *err = NULL;
781 CURL *hnd = NULL;
782 struct curl_slist *customheader = NULL;
783
784 response = g_malloc0 (sizeof (struct openvasd_response));
785
786 customheader = init_customheader (conn->apikey, TRUE);
787 hnd = handler (conn, POST, "/scans", data, customheader, &err);
788 if (hnd == NULL)
789 {
790 curl_slist_free_all (customheader);
791 response->code = RESP_CODE_ERR;
792 response->body = err;
793 return response;
794 }
795
796 openvasd_send_request (hnd, NULL, response);
797 curl_slist_free_all (customheader);
798 if (response->code == RESP_CODE_ERR)
799 {
800 response->code = RESP_CODE_ERR;
801 if (response->body == NULL)
802 response->body =
803 g_strdup ("{\"error\": \"Storing scan configuration\"}");
804 g_warning ("%s: Error storing scan configuration ", __func__);
806 return response;
807 }
808
809 // Get the Scan ID
810 parser = cJSON_Parse (openvasd_vt_stream_str (conn));
811 if (!parser)
812 {
813 const gchar *error_ptr = cJSON_GetErrorPtr ();
814 g_warning ("%s: Error parsing json string to get the scan ID", __func__);
815 if (error_ptr != NULL)
816 {
817 response->body = g_strdup_printf ("{\"error\": \"%s\"}", error_ptr);
818 g_warning ("%s: %s", __func__, error_ptr);
819 }
820 else
821 {
822 response->body = g_strdup (
823 "{\"error\": \"Parsing json string to get the scan ID\"}");
824 }
825 response->code = RESP_CODE_ERR;
826 cJSON_Delete (parser);
828 return response;
829 }
830
831 conn->scan_id = g_strdup (cJSON_GetStringValue (parser));
832
833 // Start the scan
834 path = g_string_new ("/scans");
835 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
836 {
837 g_string_append (path, "/");
838 g_string_append (path, conn->scan_id);
839 }
840 else
841 {
842 response->code = RESP_CODE_ERR;
843 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
844 g_string_free (path, TRUE);
845 g_warning ("%s: Missing scan ID", __func__);
846 cJSON_Delete (parser);
847 return response;
848 }
849
851 customheader = init_customheader (conn->apikey, TRUE);
852 hnd = handler (conn, POST, path->str, "{\"action\": \"start\"}", customheader,
853 &err);
854 if (hnd == NULL)
855 {
856 curl_slist_free_all (customheader);
857 g_string_free (path, TRUE);
858 response->code = RESP_CODE_ERR;
859 response->body = err;
860 return response;
861 }
862 g_string_free (path, TRUE);
863
864 openvasd_send_request (hnd, NULL, response);
865 curl_slist_free_all (customheader);
866 if (response->code == RESP_CODE_ERR)
867 {
868 response->code = RESP_CODE_ERR;
869 if (response->body == NULL)
870 response->body = g_strdup ("{\"error\": \"Starting the scan.\"}");
871 g_warning ("%s: Error starting the scan.", __func__);
872 return response;
873 }
874
875 cJSON_Delete (parser);
876 response->body = g_strdup (openvasd_vt_stream_str (conn));
878 return response;
879}
880
883{
884 openvasd_resp_t response = NULL;
885 GString *path;
886 gchar *err = NULL;
887 CURL *hnd = NULL;
888 struct curl_slist *customheader = NULL;
889
890 response = g_malloc0 (sizeof (struct openvasd_response));
891
892 // Stop the scan
893 path = g_string_new ("/scans");
894 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
895 {
896 g_string_append (path, "/");
897 g_string_append (path, conn->scan_id);
898 }
899 else
900 {
901 response->code = RESP_CODE_ERR;
902 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
903 g_string_free (path, TRUE);
904 g_warning ("%s: Missing scan ID", __func__);
905 return response;
906 }
907
908 customheader = init_customheader (conn->apikey, TRUE);
909 hnd = handler (conn, POST, path->str, "{\"action\": \"stop\"}", customheader,
910 &err);
911 if (hnd == NULL)
912 {
913 curl_slist_free_all (customheader);
914 g_string_free (path, TRUE);
915 response->code = RESP_CODE_ERR;
916 response->body = err;
917 return response;
918 }
919 g_string_free (path, TRUE);
920
921 openvasd_send_request (hnd, NULL, response);
922 curl_slist_free_all (customheader);
923 if (response->code != RESP_CODE_ERR)
924 response->body = g_strdup (openvasd_vt_stream_str (conn));
925
927 return response;
928}
929
932{
933 openvasd_resp_t response = NULL;
934 GString *path = NULL;
935 gchar *err = NULL;
936 CURL *hnd = NULL;
937 struct curl_slist *customheader = NULL;
938
939 response = g_malloc0 (sizeof (struct openvasd_response));
940
941 path = g_string_new ("/scans");
942 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
943 {
944 g_string_append (path, "/");
945 g_string_append (path, conn->scan_id);
946 if (last > first)
947 g_string_append_printf (path, "/results?range%ld-%ld", first, last);
948 else if (last < first)
949 g_string_append_printf (path, "/results?range=%ld", first);
950 else
951 g_string_append (path, "/results");
952 }
953 else
954 {
955 response->code = RESP_CODE_ERR;
956 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
957 g_string_free (path, TRUE);
958 g_warning ("%s: Missing scan ID", __func__);
959 return response;
960 }
961
962 customheader = init_customheader (conn->apikey, FALSE);
963 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
964 if (hnd == NULL)
965 {
966 curl_slist_free_all (customheader);
967 g_string_free (path, TRUE);
968 response->code = RESP_CODE_ERR;
969 response->body = err;
970 return response;
971 }
972 g_string_free (path, TRUE);
973
974 openvasd_send_request (hnd, NULL, response);
975 curl_slist_free_all (customheader);
976 if (response->code != RESP_CODE_ERR)
977 response->body = g_strdup (openvasd_vt_stream_str (conn));
978 else if (response->code == RESP_CODE_ERR)
979 {
980 g_warning ("%s: Not possible to get scan results", __func__);
981 response->body =
982 g_strdup ("{\"error\": \"Not possible to get scan results\"}");
983 }
984
986 return response;
987}
988
990openvasd_result_new (unsigned long id, gchar *type, gchar *ip_address,
991 gchar *hostname, gchar *oid, int port, gchar *protocol,
992 gchar *message, gchar *detail_name, gchar *detail_value,
993 gchar *detail_source_type, gchar *detail_source_name,
994 gchar *detail_source_description)
995{
996 openvasd_result_t result = g_malloc0 (sizeof (struct openvasd_result));
997
998 result->id = id;
999 result->type = g_strdup (type);
1000 result->ip_address = g_strdup (ip_address);
1001 result->hostname = g_strdup (hostname);
1002 result->oid = g_strdup (oid);
1003 result->port = port;
1004 result->protocol = g_strdup (protocol);
1005 result->message = g_strdup (message);
1006 result->detail_name = g_strdup (detail_name);
1007 result->detail_value = g_strdup (detail_value);
1008 result->detail_source_name = g_strdup (detail_source_name);
1009 result->detail_source_type = g_strdup (detail_source_type);
1010 result->detail_source_description = g_strdup (detail_source_description);
1011
1012 return result;
1013}
1014
1015char *
1018{
1019 if (!result)
1020 return NULL;
1021 switch (member)
1022 {
1023 case TYPE:
1024 return result->type;
1025
1026 case IP_ADDRESS:
1027 return result->ip_address;
1028 case HOSTNAME:
1029 return result->hostname;
1030 case OID:
1031 return result->oid;
1032 case PROTOCOL:
1033 return result->protocol;
1034 case MESSAGE:
1035 return result->message;
1036 case DETAIL_NAME:
1037 return result->detail_name;
1038 case DETAIL_VALUE:
1039 return result->detail_value;
1040 case DETAIL_SOURCE_NAME:
1041 return result->detail_source_name;
1042 case DETAIL_SOURCE_TYPE:
1043 return result->detail_source_type;
1045 return result->detail_source_description;
1046 default:
1047 return NULL;
1048 }
1049}
1050
1051int
1054{
1055 if (!result)
1056 return -1;
1057
1058 switch (member)
1059 {
1060 case ID:
1061 return result->id;
1062 case PORT:
1063 return result->port;
1064 default:
1065 return -1;
1066 }
1067}
1068
1069void
1071{
1072 if (result == NULL)
1073 return;
1074
1075 g_free (result->type);
1076 g_free (result->ip_address);
1077 g_free (result->hostname);
1078 g_free (result->oid);
1079 g_free (result->protocol);
1080 g_free (result->message);
1081 g_free (result->detail_name);
1082 g_free (result->detail_value);
1083 g_free (result->detail_source_name);
1084 g_free (result->detail_source_type);
1085 g_free (result->detail_source_description);
1086 g_free (result);
1087 result = NULL;
1088}
1089
1090static int
1091parse_results (const gchar *body, GSList **results)
1092{
1093 cJSON *parser = NULL;
1094 cJSON *result_obj = NULL;
1095 const gchar *err = NULL;
1096 openvasd_result_t result = NULL;
1097 int port = 0;
1098 gchar *detail_name = NULL;
1099 gchar *detail_value = NULL;
1100 gchar *detail_source_type = NULL;
1101 gchar *detail_source_name = NULL;
1102 gchar *detail_source_description = NULL;
1103 int ret = -1;
1104
1105 if ((parser = cJSON_Parse (body)) == NULL)
1106 {
1107 err = cJSON_GetErrorPtr ();
1108 goto res_cleanup;
1109 }
1110 if (!cJSON_IsArray (parser))
1111 {
1112 // No results. No information.
1113 goto res_cleanup;
1114 }
1115
1116 cJSON_ArrayForEach (result_obj, parser)
1117 {
1118 cJSON *item = NULL;
1119 if (!cJSON_IsObject (result_obj))
1120 // error
1121 goto res_cleanup;
1122
1123 if ((item = cJSON_GetObjectItem (result_obj, "port")) != NULL
1124 && cJSON_IsNumber (item))
1125 port = item->valueint;
1126
1127 if ((item = cJSON_GetObjectItem (result_obj, "detail")) != NULL
1128 && cJSON_IsObject (item))
1129 {
1130 cJSON *detail_obj = NULL;
1131
1132 if ((detail_obj = cJSON_GetObjectItem (item, "name")) != NULL
1133 && cJSON_IsString (detail_obj))
1134 detail_name = g_strdup (detail_obj->valuestring);
1135
1136 if ((detail_obj = cJSON_GetObjectItem (item, "value")) != NULL
1137 && cJSON_IsString (detail_obj))
1138 detail_value = g_strdup (detail_obj->valuestring);
1139
1140 detail_obj = cJSON_GetObjectItem (item, "source");
1141 if (detail_obj && cJSON_IsObject (detail_obj))
1142 {
1143 cJSON *source_obj;
1144
1145 if ((source_obj = cJSON_GetObjectItem (detail_obj, "type")) != NULL
1146 && cJSON_IsString (source_obj))
1147 detail_source_type = g_strdup (source_obj->valuestring);
1148
1149 if ((source_obj = cJSON_GetObjectItem (detail_obj, "name")) != NULL
1150 && cJSON_IsString (source_obj))
1151 detail_source_name = g_strdup (source_obj->valuestring);
1152
1153 if ((source_obj = cJSON_GetObjectItem (detail_obj, "description"))
1154 != NULL
1155 && cJSON_IsString (source_obj))
1156 detail_source_description = g_strdup (source_obj->valuestring);
1157 }
1158 }
1159
1160 result = openvasd_result_new (gvm_json_obj_double (result_obj, "id"),
1161 gvm_json_obj_str (result_obj, "type"),
1162 gvm_json_obj_str (result_obj, "ip_address"),
1163 gvm_json_obj_str (result_obj, "hostname"),
1164 gvm_json_obj_str (result_obj, "oid"),
1165 port,
1166 gvm_json_obj_str (result_obj, "protocol"),
1167 gvm_json_obj_str (result_obj, "message"),
1168 detail_name, detail_value,
1169 detail_source_type, detail_source_name,
1170 detail_source_description);
1171
1172 *results = g_slist_append (*results, result);
1173 ret = 200;
1174 }
1175
1176res_cleanup:
1177 if (err != NULL)
1178 {
1179 g_warning ("%s: Unable to parse scan results. Reason: %s", __func__, err);
1180 }
1181 cJSON_Delete (parser);
1182
1183 return ret;
1184}
1185
1186int
1188 unsigned long last, GSList **results)
1189{
1190 int ret;
1191 openvasd_resp_t resp;
1192
1193 resp = openvasd_get_scan_results (conn, first, last);
1194 if (resp->code == 200)
1195 ret = parse_results (resp->body, results);
1196 else
1197 ret = resp->code;
1198
1200
1201 return ret;
1202}
1203
1206{
1207 openvasd_resp_t response = NULL;
1208 GString *path = NULL;
1209 gchar *err = NULL;
1210 CURL *hnd = NULL;
1211 struct curl_slist *customheader = NULL;
1212
1213 response = g_malloc0 (sizeof (struct openvasd_response));
1214
1215 path = g_string_new ("/scans");
1216 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1217 {
1218 g_string_append (path, "/");
1219 g_string_append (path, conn->scan_id);
1220 g_string_append (path, "/status");
1221 }
1222 else
1223 {
1224 response->code = RESP_CODE_ERR;
1225 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1226 g_string_free (path, TRUE);
1227 g_warning ("%s: Missing scan ID", __func__);
1228 return response;
1229 }
1230
1231 customheader = init_customheader (conn->apikey, FALSE);
1232 hnd = handler (conn, GET, path->str, NULL, customheader, &err);
1233 if (hnd == NULL)
1234 {
1235 curl_slist_free_all (customheader);
1236 g_string_free (path, TRUE);
1237 response->code = RESP_CODE_ERR;
1238 response->body = err;
1239 return response;
1240 }
1241 g_string_free (path, TRUE);
1242
1243 openvasd_send_request (hnd, NULL, response);
1244 curl_slist_free_all (customheader);
1245 if (response->code != RESP_CODE_ERR)
1246 response->body = g_strdup (openvasd_vt_stream_str (conn));
1247 else if (response->code == RESP_CODE_ERR)
1248 {
1249 response->body =
1250 g_strdup ("{\"error\": \"Not possible to get scan status\"}");
1251 g_warning ("%s: Not possible to get scan status", __func__);
1252 }
1253
1255 return response;
1256}
1257
1262static int
1263get_member_value_or_fail (cJSON *reader, const gchar *member)
1264{
1265 cJSON *item = NULL;
1266 if ((item = cJSON_GetObjectItem (reader, member)) == NULL
1267 && cJSON_IsNumber (item))
1268 return -1;
1269
1270 return item->valueint;
1271}
1272
1273static int
1275 openvasd_resp_t response)
1276{
1277 cJSON *parser;
1278 cJSON *reader = NULL;
1279 const gchar *err = NULL;
1280 int all = 0, excluded = 0, dead = 0, alive = 0, queued = 0, finished = 0;
1281 int running_hosts_progress_sum = 0;
1282
1283 openvasd_resp_t resp;
1284 int progress = -1;
1285
1286 if (!response && !conn)
1287 return -1;
1288
1289 if (response == NULL)
1290 resp = openvasd_get_scan_status (conn);
1291 else
1292 resp = response;
1293
1294 if (resp->code == 404)
1295 return -2;
1296 else if (resp->code != 200)
1297 return -1;
1298
1299 parser = cJSON_Parse (resp->body);
1300 if (!parser)
1301 {
1302 err = cJSON_GetErrorPtr ();
1303 goto cleanup;
1304 }
1305
1306 if ((reader = cJSON_GetObjectItem (parser, "host_info")) == NULL)
1307 {
1308 goto cleanup;
1309 }
1310 if (!cJSON_IsObject (reader))
1311 {
1312 // Scan still not started. No information.
1313 progress = 0;
1314 goto cleanup;
1315 }
1316
1317 // read general hosts count
1318 all = get_member_value_or_fail (reader, "all");
1319 excluded = get_member_value_or_fail (reader, "excluded");
1320 dead = get_member_value_or_fail (reader, "dead");
1321 alive = get_member_value_or_fail (reader, "alive");
1322 queued = get_member_value_or_fail (reader, "queued");
1323 finished = get_member_value_or_fail (reader, "finished");
1324
1325 // read progress of single running hosts
1326 cJSON *scanning = NULL;
1327 if ((scanning = cJSON_GetObjectItem (reader, "scanning")) != NULL
1328 && cJSON_IsObject (scanning))
1329 {
1330 cJSON *host = scanning->child;
1331 while (host)
1332 {
1333 running_hosts_progress_sum += cJSON_GetNumberValue (host);
1334 host = host->next;
1335 }
1336
1337 } // end scanning
1338 // end host_info
1339
1340 if (all < 0 || excluded < 0 || dead < 0 || alive < 0 || queued < 0
1341 || finished < 0)
1342 {
1343 goto cleanup;
1344 }
1345
1346 if ((all + finished - dead) > 0)
1347 progress = (running_hosts_progress_sum + 100 * (alive + finished))
1348 / (all + finished - dead);
1349 else
1350 progress = 100;
1351
1352cleanup:
1353 if (err != NULL)
1354 g_warning ("%s: Unable to parse scan status. Reason: %s", __func__, err);
1355 cJSON_Delete (parser);
1356
1357 return progress;
1358}
1359
1360int
1365
1366static openvasd_status_t
1367get_status_code_from_openvas (const gchar *status_val)
1368{
1370
1371 if (g_strcmp0 (status_val, "stored") == 0)
1372 status_code = OPENVASD_SCAN_STATUS_STORED;
1373 else if (g_strcmp0 (status_val, "requested") == 0)
1374 status_code = OPENVASD_SCAN_STATUS_REQUESTED;
1375 else if (g_strcmp0 (status_val, "running") == 0)
1376 status_code = OPENVASD_SCAN_STATUS_RUNNING;
1377 else if (g_strcmp0 (status_val, "stopped") == 0)
1378 status_code = OPENVASD_SCAN_STATUS_STOPPED;
1379 else if (g_strcmp0 (status_val, "succeeded") == 0)
1380 status_code = OPENVASD_SCAN_STATUS_SUCCEEDED;
1381 else if (g_strcmp0 (status_val, "interrupted") == 0)
1382 status_code = OPENVASD_SCAN_STATUS_FAILED;
1383
1384 return status_code;
1385}
1386
1387static int
1388parse_status (const gchar *body, openvasd_scan_status_t status_info)
1389{
1390 cJSON *parser = NULL;
1391 cJSON *status = NULL;
1392 gchar *status_val = NULL;
1394
1395 if (!status_info)
1396 return -1;
1397
1398 if ((parser = cJSON_Parse (body)) == NULL)
1399 return -1;
1400
1401 if ((status = cJSON_GetObjectItem (parser, "status")) == NULL
1402 || !cJSON_IsString (status))
1403 {
1404 cJSON_Delete (parser);
1405 return -1;
1406 }
1407
1408 status_val = g_strdup (status->valuestring);
1409 status_code = get_status_code_from_openvas (status_val);
1410 g_free (status_val);
1411
1412 status_info->status = status_code;
1413 status_info->end_time = gvm_json_obj_double (parser, "end_time");
1414 status_info->start_time = gvm_json_obj_double (parser, "start_time");
1415 cJSON_Delete (parser);
1416
1417 return 0;
1418}
1419
1429{
1430 openvasd_resp_t resp = NULL;
1431 int progress = -1;
1433 openvasd_scan_status_t status_info = NULL;
1434
1435 resp = openvasd_get_scan_status (conn);
1436
1437 status_info = g_malloc0 (sizeof (struct openvasd_scan_status));
1438 if (resp->code != 200 || parse_status (resp->body, status_info) == -1)
1439 {
1440 status_info->status = status_code;
1441 status_info->response_code = resp->code;
1443 return status_info;
1444 }
1445
1446 progress = openvasd_get_scan_progress_ext (NULL, resp);
1448 status_info->progress = progress;
1449
1450 return status_info;
1451}
1452
1455{
1456 openvasd_resp_t response = NULL;
1457 GString *path;
1458 gchar *err = NULL;
1459 CURL *hnd = NULL;
1460 struct curl_slist *customheader = NULL;
1461
1462 response = g_malloc0 (sizeof (struct openvasd_response));
1463
1464 // Stop the scan
1465 path = g_string_new ("/scans");
1466 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1467 {
1468 g_string_append (path, "/");
1469 g_string_append (path, conn->scan_id);
1470 }
1471 else
1472 {
1473 response->code = RESP_CODE_ERR;
1474 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1475 g_string_free (path, TRUE);
1476 g_warning ("%s: Missing scan ID", __func__);
1477 return response;
1478 }
1479
1480 customheader = init_customheader (conn->apikey, FALSE);
1481 hnd = handler (conn, DELETE, path->str, NULL, customheader, &err);
1482 if (hnd == NULL)
1483 {
1484 curl_slist_free_all (customheader);
1485 g_string_free (path, TRUE);
1486 response->code = RESP_CODE_ERR;
1487 response->body = err;
1488 return response;
1489 }
1490 g_string_free (path, TRUE);
1491
1492 openvasd_send_request (hnd, NULL, response);
1493 curl_slist_free_all (customheader);
1494 if (response->code != RESP_CODE_ERR)
1495 response->body = g_strdup (openvasd_vt_stream_str (conn));
1496 else if (response->code == RESP_CODE_ERR)
1497 {
1498 response->body =
1499 g_strdup ("{\"error\": \"Not possible to delete scan.\"}");
1500 g_warning ("%s: Not possible to delete scan", __func__);
1501 }
1502
1504 return response;
1505}
1506
1509{
1510 openvasd_resp_t response = NULL;
1511 gchar *err = NULL;
1512 CURL *hnd = NULL;
1513 struct curl_slist *customheader = NULL;
1514
1515 response = g_malloc0 (sizeof (struct openvasd_response));
1516
1517 customheader = init_customheader (conn->apikey, FALSE);
1518 hnd = handler (conn, GET, "/health/alive", NULL, customheader, &err);
1519 if (hnd == NULL)
1520 {
1521 curl_slist_free_all (customheader);
1522 response->code = RESP_CODE_ERR;
1523 response->body = err;
1524 return response;
1525 }
1526
1527 openvasd_send_request (hnd, NULL, response);
1528 curl_slist_free_all (customheader);
1529 if (response->code != RESP_CODE_ERR)
1530 response->body = g_strdup (openvasd_vt_stream_str (conn));
1531 else if (response->code == RESP_CODE_ERR)
1532 {
1533 response->body =
1534 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1535 g_warning ("%s: Not possible to get health information", __func__);
1536 }
1537
1539 return response;
1540}
1541
1544{
1545 openvasd_resp_t response = NULL;
1546 gchar *err = NULL;
1547 CURL *hnd = NULL;
1548 struct curl_slist *customheader = NULL;
1549
1550 response = g_malloc0 (sizeof (struct openvasd_response));
1551
1552 customheader = init_customheader (conn->apikey, FALSE);
1553 hnd = handler (conn, GET, "/health/ready", NULL, customheader, &err);
1554 if (hnd == NULL)
1555 {
1556 response->code = RESP_CODE_ERR;
1557 response->body = err;
1558 return response;
1559 }
1560
1561 openvasd_send_request (hnd, "feed-version", response);
1562 curl_slist_free_all (customheader);
1563 if (response->code != RESP_CODE_ERR)
1564 response->body = g_strdup (openvasd_vt_stream_str (conn));
1565 else if (response->code == RESP_CODE_ERR)
1566 {
1567 response->body =
1568 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1569 g_warning ("%s: Not possible to get health information", __func__);
1570 }
1571
1573 return response;
1574}
1575
1578{
1579 openvasd_resp_t response = NULL;
1580 gchar *err = NULL;
1581 CURL *hnd = NULL;
1582 struct curl_slist *customheader = NULL;
1583
1584 response = g_malloc0 (sizeof (struct openvasd_response));
1585
1586 customheader = init_customheader (conn->apikey, FALSE);
1587 hnd = handler (conn, GET, "/health/started", NULL, customheader, &err);
1588 if (hnd == NULL)
1589 {
1590 curl_slist_free_all (customheader);
1591 response->code = RESP_CODE_ERR;
1592 response->body = err;
1593 return response;
1594 }
1595
1596 openvasd_send_request (hnd, NULL, response);
1597 curl_slist_free_all (customheader);
1598 if (response->code != RESP_CODE_ERR)
1599 response->body = g_strdup (openvasd_vt_stream_str (conn));
1600 else if (response->code == RESP_CODE_ERR)
1601 {
1602 response->body =
1603 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1604 g_warning ("%s: Not possible to get health information", __func__);
1605 }
1606
1608 return response;
1609}
1610
1613{
1614 openvasd_resp_t response = NULL;
1615 gchar *err = NULL;
1616 CURL *hnd = NULL;
1617 struct curl_slist *customheader = NULL;
1618
1619 response = g_malloc0 (sizeof (struct openvasd_response));
1620
1621 customheader = init_customheader (conn->apikey, FALSE);
1622 if ((hnd =
1623 handler (conn, GET, "/scans/preferences", NULL, customheader, &err))
1624 == NULL)
1625 {
1626 curl_slist_free_all (customheader);
1627 response->code = RESP_CODE_ERR;
1628 response->body = err;
1629 return response;
1630 }
1631
1632 openvasd_send_request (hnd, NULL, response);
1633 curl_slist_free_all (customheader);
1634 if (response->code != RESP_CODE_ERR)
1635 response->body = g_strdup (openvasd_vt_stream_str (conn));
1636 else if (response->code == RESP_CODE_ERR)
1637 {
1638 response->body =
1639 g_strdup ("{\"error\": \"Not possible to get scans preferences.\"}");
1640 g_warning ("%s: Not possible to get scans_preferences", __func__);
1641 }
1642
1644 return response;
1645}
1646
1652static openvasd_param_t *
1653openvasd_param_new (char *id, gchar *name, gchar *defval, gchar *description,
1654 gchar *type, int mandatory)
1655{
1656 openvasd_param_t *param = g_malloc0 (sizeof (openvasd_param_t));
1657
1658 param->id = id;
1659 param->defval = defval;
1660 param->description = description;
1661 param->name = name;
1662 param->mandatory = mandatory;
1663 param->type = type;
1664 return param;
1665}
1666
1672void
1674{
1675 if (!param)
1676 return;
1677 g_free (param->id);
1678 g_free (param->name);
1679 g_free (param->defval);
1680 g_free (param->description);
1681 g_free (param->type);
1682}
1683
1689char *
1691{
1692 if (!param)
1693 return NULL;
1694
1695 return param->id;
1696}
1697
1703char *
1705{
1706 if (!param)
1707 return NULL;
1708
1709 return param->defval;
1710}
1711
1717char *
1719{
1720 if (!param)
1721 return NULL;
1722
1723 return param->description;
1724}
1725
1731char *
1733{
1734 if (!param)
1735 return NULL;
1736
1737 return param->type;
1738}
1739
1745char *
1747{
1748 if (!param)
1749 return NULL;
1750
1751 return param->defval;
1752}
1753
1759int
1761{
1762 if (!param)
1763 return 0;
1764
1765 return param->mandatory;
1766}
1767
1768int
1770{
1771 openvasd_resp_t resp = NULL;
1772 cJSON *parser;
1773 cJSON *param_obj = NULL;
1774 int err = 0;
1775
1776 resp = openvasd_get_scan_preferences (conn);
1777
1778 if (resp->code != 200)
1779 return -1;
1780
1781 // No results. No information.
1782 if ((parser = cJSON_Parse (resp->body)) == NULL || !cJSON_IsArray (parser))
1783 {
1784 err = 1;
1785 goto prefs_cleanup;
1786 }
1787
1788 cJSON_ArrayForEach (param_obj, parser)
1789 {
1790 gchar *defval = NULL, *param_type = NULL;
1791 openvasd_param_t *param = NULL;
1792 int val, mandatory = 0;
1793 char buf[6];
1794 cJSON *item = NULL;
1795
1796 if ((item = cJSON_GetObjectItem (param_obj, "default")) != NULL)
1797 {
1798 if (cJSON_IsNumber (item))
1799 {
1800 val = item->valueint;
1801 g_snprintf (buf, sizeof (buf), "%d", val);
1802 defval = g_strdup (buf);
1803 param_type = g_strdup ("integer");
1804 }
1805 else if (cJSON_IsString (item))
1806 {
1807 defval = g_strdup (item->valuestring);
1808 param_type = g_strdup ("string");
1809 }
1810 else if (cJSON_IsBool (item))
1811 {
1812 if (cJSON_IsTrue (item))
1813 defval = g_strdup ("yes");
1814 else
1815 defval = g_strdup ("no");
1816 param_type = g_strdup ("boolean");
1817 }
1818 else
1819 {
1820 g_warning ("%s: Unable to parse scan preferences.", __func__);
1821 g_free (defval);
1822 g_free (param_type);
1823 continue;
1824 }
1825 }
1826
1827 param =
1828 openvasd_param_new (g_strdup (gvm_json_obj_str (param_obj, "id")),
1829 g_strdup (gvm_json_obj_str (param_obj, "name")),
1830 g_strdup (defval),
1831 g_strdup (gvm_json_obj_str (param_obj, "description")),
1832 g_strdup (param_type), mandatory);
1833 g_free (defval);
1834 g_free (param_type);
1835 *params = g_slist_append (*params, param);
1836 }
1837
1838prefs_cleanup:
1840 cJSON_Delete (parser);
1841 if (err)
1842 {
1843 g_warning ("%s: Unable to parse scan preferences.", __func__);
1844 return -1;
1845 }
1846
1847 return 0;
1848}
1849
1850// Scan config builder
1851static void
1852add_port_to_scan_json (gpointer range, gpointer p_array)
1853{
1854 range_t *ports = range;
1855
1856 cJSON *port = cJSON_CreateObject ();
1857 if (ports->type == 1)
1858 cJSON_AddStringToObject (port, "protocol", "udp");
1859 else
1860 cJSON_AddStringToObject (port, "protocol", "tcp");
1861
1862 cJSON *ranges_array = cJSON_CreateArray ();
1863 cJSON *range_obj = cJSON_CreateObject ();
1864 cJSON_AddNumberToObject (range_obj, "start", ports->start);
1865
1866 if (ports->end > ports->start && ports->end < 65535)
1867 cJSON_AddNumberToObject (range_obj, "end", ports->end);
1868 else
1869 cJSON_AddNumberToObject (range_obj, "end", ports->start);
1870 cJSON_AddItemToArray (ranges_array, range_obj);
1871 cJSON_AddItemToObject (port, "range", ranges_array);
1872 cJSON_AddItemToArray ((cJSON *) p_array, port);
1873}
1874
1875static void
1876add_credential_to_scan_json (gpointer credentials, gpointer cred_array)
1877{
1878 GHashTableIter auth_data_iter;
1879 gchar *auth_data_name, *auth_data_value;
1880 cJSON *cred_obj = NULL;
1881
1882 openvasd_credential_t *cred = credentials;
1883
1884 cred_obj = cJSON_CreateObject ();
1885 cJSON_AddStringToObject (cred_obj, "service", cred->service);
1886
1887 if (cred->port)
1888 {
1889 cJSON_AddNumberToObject (cred_obj, "port", atoi (cred->port));
1890 }
1891
1892 cJSON *cred_type_obj = cJSON_CreateObject ();
1893 g_hash_table_iter_init (&auth_data_iter, cred->auth_data);
1894 while (g_hash_table_iter_next (&auth_data_iter, (gpointer *) &auth_data_name,
1895 (gpointer *) &auth_data_value))
1896 cJSON_AddStringToObject (cred_type_obj, auth_data_name, auth_data_value);
1897 cJSON_AddItemToObject (cred_obj, cred->type, cred_type_obj);
1898
1899 cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
1900}
1901
1902static void
1903add_scan_preferences_to_scan_json (gpointer key, gpointer val,
1904 gpointer scan_prefs_array)
1905{
1906 cJSON *pref_obj = cJSON_CreateObject ();
1907 cJSON_AddStringToObject (pref_obj, "id", key);
1908 cJSON_AddStringToObject (pref_obj, "value", val);
1909 cJSON_AddItemToArray (scan_prefs_array, pref_obj);
1910}
1911
1912static void
1913add_vts_to_scan_json (gpointer single_vt, gpointer vts_array)
1914{
1915 GHashTableIter vt_data_iter;
1916 gchar *vt_param_id, *vt_param_value;
1917
1918 openvasd_vt_single_t *vt = single_vt;
1919
1920 cJSON *vt_obj = cJSON_CreateObject ();
1921
1922 cJSON_AddStringToObject (vt_obj, "oid", vt->vt_id);
1923
1924 if (g_hash_table_size (vt->vt_values))
1925 {
1926 cJSON *params_array = cJSON_CreateArray ();
1927
1928 g_hash_table_iter_init (&vt_data_iter, vt->vt_values);
1929 while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
1930 (gpointer *) &vt_param_value))
1931 {
1932 cJSON *param_obj = cJSON_CreateObject ();
1933 cJSON_AddNumberToObject (param_obj, "id", atoi (vt_param_id));
1934 cJSON_AddStringToObject (param_obj, "value", vt_param_value);
1935 cJSON_AddItemToArray (params_array, param_obj);
1936 }
1937 cJSON_AddItemToObject (vt_obj, "parameters", params_array);
1938 }
1939 cJSON_AddItemToArray (vts_array, vt_obj);
1940}
1941
1954char *
1956 GHashTable *scan_preferences, GSList *vts)
1957{
1958 cJSON *scan_obj = NULL;
1959 cJSON *target_obj = NULL;
1960 cJSON *hosts_array = NULL;
1961 cJSON *exclude_hosts_array = NULL;
1962 cJSON *finished_hosts_array = NULL;
1963 gchar *json_str = NULL;
1964
1965 /* Build the message in json format to be published. */
1966 scan_obj = cJSON_CreateObject ();
1967
1968 if (target->scan_id && target->scan_id[0] != '\0')
1969 cJSON_AddStringToObject (scan_obj, "scan_id", target->scan_id);
1970
1971 // begin target
1972 target_obj = cJSON_CreateObject ();
1973
1974 // hosts
1975 hosts_array = cJSON_CreateArray ();
1976 gchar **hosts_list = g_strsplit (target->hosts, ",", 0);
1977 for (int i = 0; hosts_list[i] != NULL; i++)
1978 {
1979 cJSON *host_item = NULL;
1980 host_item = cJSON_CreateString (hosts_list[i]);
1981 cJSON_AddItemToArray (hosts_array, host_item);
1982 }
1983 g_strfreev (hosts_list);
1984 cJSON_AddItemToObject (target_obj, "hosts", hosts_array);
1985
1986 // exclude hosts
1987 if (target->exclude_hosts && target->exclude_hosts[0] != '\0')
1988 {
1989 exclude_hosts_array = cJSON_CreateArray ();
1990 gchar **exclude_hosts_list = g_strsplit (target->exclude_hosts, ",", 0);
1991 for (int i = 0; exclude_hosts_list[i] != NULL; i++)
1992 {
1993 cJSON *exclude_host_item = NULL;
1994 exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
1995 cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
1996 }
1997 g_strfreev (exclude_hosts_list);
1998 cJSON_AddItemToObject (target_obj, "excluded_hosts", exclude_hosts_array);
1999 }
2000
2001 // finished hosts
2002 if (target->finished_hosts && target->finished_hosts[0] != '\0')
2003 {
2004 finished_hosts_array = cJSON_CreateArray ();
2005 gchar **finished_hosts_list = g_strsplit (target->finished_hosts, ",", 0);
2006 for (int i = 0; finished_hosts_list[i] != NULL; i++)
2007 {
2008 cJSON *finished_host_item = NULL;
2009 finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
2010 cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
2011 }
2012 g_strfreev (hosts_list);
2013 cJSON_AddItemToObject (target_obj, "finished_hosts",
2014 finished_hosts_array);
2015 }
2016
2017 // ports
2018 if (target->ports && target->ports[0] != '\0')
2019 {
2020 cJSON *ports_array = cJSON_CreateArray ();
2021 array_t *ports = port_range_ranges (target->ports);
2022 g_ptr_array_foreach (ports, add_port_to_scan_json, ports_array);
2023 array_free (ports);
2024 cJSON_AddItemToObject (target_obj, "ports", ports_array);
2025 }
2026
2027 // credentials
2028 cJSON *credentials = cJSON_CreateArray ();
2029 g_slist_foreach (target->credentials, add_credential_to_scan_json,
2030 credentials);
2031 cJSON_AddItemToObject (target_obj, "credentials", credentials);
2032
2033 // reverse lookup
2034 if (target->reverse_lookup_unify)
2035 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_True);
2036 else
2037 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_False);
2038
2039 if (target->reverse_lookup_only)
2040 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_True);
2041 else
2042 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_False);
2043
2044 // alive test methods
2045 cJSON *alive_test_methods = cJSON_CreateArray ();
2046 if (target->arp)
2047 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("arp"));
2048 if (target->tcp_ack)
2049 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_ack"));
2050 if (target->tcp_syn)
2051 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_syn"));
2052 if (target->consider_alive)
2053 cJSON_AddItemToArray (alive_test_methods,
2054 cJSON_CreateString ("consider_alive"));
2055 if (target->icmp)
2056 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("icmp"));
2057 cJSON_AddItemToObject (target_obj, "alive_test_methods", alive_test_methods);
2058
2059 cJSON_AddItemToObject (scan_obj, "target", target_obj);
2060
2061 // Begin Scan Preferences
2062 cJSON *scan_prefs_array = cJSON_CreateArray ();
2063 g_hash_table_foreach (scan_preferences, add_scan_preferences_to_scan_json,
2064 scan_prefs_array);
2065 cJSON_AddItemToObject (scan_obj, "scan_preferences", scan_prefs_array);
2066
2067 // Begin VTs
2068 cJSON *vts_array = cJSON_CreateArray ();
2069 g_slist_foreach (vts, add_vts_to_scan_json, vts_array);
2070 cJSON_AddItemToObject (scan_obj, "vts", vts_array);
2071
2072 json_str = cJSON_Print (scan_obj);
2073 cJSON_Delete (scan_obj);
2074 if (json_str == NULL)
2075 g_warning ("%s: Error while creating JSON.", __func__);
2076
2077 return json_str;
2078}
2079
2090openvasd_credential_new (const gchar *type, const gchar *service,
2091 const gchar *port)
2092{
2093 openvasd_credential_t *new_credential;
2094
2095 new_credential = g_malloc0 (sizeof (openvasd_credential_t));
2096
2097 new_credential->type = type ? g_strdup (type) : NULL;
2098 new_credential->service = service ? g_strdup (service) : NULL;
2099 new_credential->port = port ? g_strdup (port) : NULL;
2100 new_credential->auth_data =
2101 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
2102
2103 return new_credential;
2104}
2105
2111void
2113{
2114 if (!credential)
2115 return;
2116
2117 g_free (credential->type);
2118 g_free (credential->service);
2119 g_free (credential->port);
2120 g_hash_table_destroy (credential->auth_data);
2121 g_free (credential);
2122}
2123
2131void
2133 const gchar *name, const gchar *value)
2134{
2135 if (credential == NULL || name == NULL)
2136 return;
2137
2138 if (g_regex_match_simple ("^[[:alpha:]][[:alnum:]_]*$", name, 0, 0))
2139 {
2140 if (value)
2141 g_hash_table_replace (credential->auth_data, g_strdup (name),
2142 g_strdup (value));
2143 else
2144 g_hash_table_remove (credential->auth_data, name);
2145 }
2146 else
2147 {
2148 g_warning ("%s: Invalid auth data name: %s", __func__, name);
2149 }
2150}
2151
2165openvasd_target_new (const gchar *scanid, const gchar *hosts,
2166 const gchar *ports, const gchar *exclude_hosts,
2167 int reverse_lookup_unify, int reverse_lookup_only)
2168{
2169 openvasd_target_t *new_target;
2170 new_target = g_malloc0 (sizeof (openvasd_target_t));
2171
2172 if (scanid && *scanid)
2173 new_target->scan_id = g_strdup (scanid);
2174
2175 new_target->exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
2176 new_target->finished_hosts = NULL;
2177 new_target->hosts = hosts ? g_strdup (hosts) : NULL;
2178 new_target->ports = ports ? g_strdup (ports) : NULL;
2179 new_target->reverse_lookup_unify =
2180 reverse_lookup_unify ? reverse_lookup_unify : 0;
2181 new_target->reverse_lookup_only =
2182 reverse_lookup_only ? reverse_lookup_only : 0;
2183
2184 return new_target;
2185}
2186
2193void
2195 const gchar *finished_hosts)
2196{
2197 g_free (target->finished_hosts);
2198 target->finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
2199}
2200
2206void
2208{
2209 if (!target)
2210 return;
2211
2212 g_slist_free_full (target->credentials,
2213 (GDestroyNotify) openvasd_credential_free);
2214 g_free (target->exclude_hosts);
2215 g_free (target->finished_hosts);
2216 g_free (target->scan_id);
2217 g_free (target->hosts);
2218 g_free (target->ports);
2219 g_free (target);
2220 target = NULL;
2221}
2222
2233void
2235 gboolean icmp, gboolean tcp_syn,
2236 gboolean tcp_ack, gboolean arp,
2237 gboolean consider_alive)
2238{
2239 if (!target)
2240 return;
2241
2242 target->icmp = icmp;
2243 target->tcp_syn = tcp_syn;
2244 target->tcp_ack = tcp_ack;
2245 target->arp = arp;
2246 target->consider_alive = consider_alive;
2247}
2248
2255void
2257 openvasd_credential_t *credential)
2258{
2259 if (!target || !credential)
2260 return;
2261
2262 target->credentials = g_slist_prepend (target->credentials, credential);
2263}
2264
2273openvasd_vt_single_new (const gchar *vt_id)
2274{
2275 openvasd_vt_single_t *new_vt_single;
2276 new_vt_single = g_malloc0 (sizeof (openvasd_vt_single_t));
2277
2278 new_vt_single->vt_id = vt_id ? g_strdup (vt_id) : NULL;
2279 new_vt_single->vt_values =
2280 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
2281
2282 return new_vt_single;
2283}
2284
2290void
2292{
2293 if (!vt_single)
2294 return;
2295
2296 g_hash_table_destroy (vt_single->vt_values);
2297
2298 g_free (vt_single->vt_id);
2299 g_free (vt_single);
2300}
2301
2311void
2313 const gchar *name, const gchar *value)
2314{
2315 g_hash_table_replace (vt_single->vt_values, g_strdup (name),
2316 g_strdup (value));
2317}
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
gchar * gvm_json_obj_str(cJSON *obj, const gchar *key)
Get a string field from a JSON object.
Definition json.c:95
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:2256
void openvasd_param_free(openvasd_param_t *param)
Free an Openvasd parameter.
Definition openvasd.c:1673
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:2132
int openvasd_get_result_member_int(openvasd_result_t result, openvasd_result_member_int_t member)
Definition openvasd.c:1052
void openvasd_target_free(openvasd_target_t *target)
Free an Openvasd target, including all added credentials.
Definition openvasd.c:2207
openvasd_scan_status_t openvasd_parsed_scan_status(openvasd_connector_t conn)
Return a struct with the general scan status.
Definition openvasd.c:1428
char * openvasd_param_desc(openvasd_param_t *param)
Get the parameter description.
Definition openvasd.c:1718
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:990
void openvasd_reset_vt_stream(openvasd_connector_t conn)
Definition openvasd.c:674
void openvasd_credential_free(openvasd_credential_t *credential)
Free an Openvasd credential.
Definition openvasd.c:2112
size_t openvasd_vt_stream_len(openvasd_connector_t conn)
Definition openvasd.c:686
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:2090
openvasd_resp_t openvasd_get_scan_results(openvasd_connector_t conn, long first, long last)
Definition openvasd.c:931
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:1955
char * openvasd_param_name(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1704
static void add_credential_to_scan_json(gpointer credentials, gpointer cred_array)
Definition openvasd.c:1876
openvasd_resp_t openvasd_get_scan_preferences(openvasd_connector_t conn)
Definition openvasd.c:1612
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:1187
int openvasd_param_mandatory(openvasd_param_t *param)
If the parameter is mandatory.
Definition openvasd.c:1760
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:639
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:2165
void openvasd_result_free(openvasd_result_t result)
Definition openvasd.c:1070
char * openvasd_get_result_member_str(openvasd_result_t result, openvasd_result_member_string_t member)
Definition openvasd.c:1016
#define RESP_CODE_OK
Definition openvasd.c:34
int openvasd_get_scan_progress(openvasd_connector_t conn)
Definition openvasd.c:1361
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:1852
static openvasd_status_t get_status_code_from_openvas(const gchar *status_val)
Definition openvasd.c:1367
char * openvasd_param_type(openvasd_param_t *param)
Get the parameter type.
Definition openvasd.c:1732
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:1508
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:2194
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:1263
void openvasd_vt_single_free(openvasd_vt_single_t *vt_single)
Free a single Openvasd VT, including all preference values.
Definition openvasd.c:2291
openvasd_resp_t openvasd_get_version(openvasd_connector_t conn)
Request HEAD.
Definition openvasd.c:597
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:1746
static void add_scan_preferences_to_scan_json(gpointer key, gpointer val, gpointer scan_prefs_array)
Definition openvasd.c:1903
openvasd_resp_t openvasd_get_vts(openvasd_connector_t conn)
Get VT's metadata.
Definition openvasd.c:734
int openvasd_get_vt_stream(openvasd_connector_t conn)
Get a new feed metadata chunk.
Definition openvasd.c:703
openvasd_resp_t openvasd_start_scan(openvasd_connector_t conn, gchar *data)
Definition openvasd.c:775
static void add_vts_to_scan_json(gpointer single_vt, gpointer vts_array)
Definition openvasd.c:1913
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:2312
static int parse_status(const gchar *body, openvasd_scan_status_t status_info)
Definition openvasd.c:1388
openvasd_resp_t openvasd_get_health_started(openvasd_connector_t conn)
Definition openvasd.c:1577
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:1454
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:1274
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:2234
gchar * openvasd_vt_stream_str(openvasd_connector_t conn)
Definition openvasd.c:680
openvasd_resp_t openvasd_stop_scan(openvasd_connector_t conn)
Definition openvasd.c:882
openvasd_resp_t openvasd_get_health_ready(openvasd_connector_t conn)
Definition openvasd.c:1543
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:1690
static int parse_results(const gchar *body, GSList **results)
Definition openvasd.c:1091
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:1653
static openvasd_resp_t openvasd_send_request(CURL *curl, const gchar *header_name, openvasd_resp_t response)
Send request.
Definition openvasd.c:561
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:1769
openvasd_vt_single_t * openvasd_vt_single_new(const gchar *vt_id)
Create a new single Openvasd VT.
Definition openvasd.c:2273
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:1205
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