OpenVAS Manager  7.0.3~git
omp.c
Go to the documentation of this file.
1 /* OpenVAS Manager
2  * $Id$
3  * Description: Module for OpenVAS Manager: the OMP library.
4  *
5  * Authors:
6  * Matthew Mundell <matthew.mundell@greenbone.net>
7  * Timo Pollmeier <timo.pollmeier@greenbone.net>
8  *
9  * Copyright:
10  * Copyright (C) 2009-2013 Greenbone Networks GmbH
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
25  */
26 
93 #include "omp.h"
94 #include "manage.h"
95 #include "manage_acl.h"
97 #include "otp.h"
98 
99 #include <arpa/inet.h>
100 #include <assert.h>
101 #include <ctype.h>
102 #include <errno.h>
103 #include <fcntl.h>
104 #include <glib/gstdio.h>
105 #include <math.h>
106 #include <netinet/in.h>
107 #include <string.h>
108 #include <stdlib.h>
109 #include <sys/socket.h>
110 #include <sys/stat.h>
111 #include <sys/types.h>
112 #include <sys/wait.h>
113 
114 #include <gnutls/x509.h>
115 
116 #include <openvas/base/nvti.h>
117 #include <openvas/osp/osp.h>
118 #include <openvas/base/openvas_string.h>
119 #include <openvas/base/openvas_file.h>
120 #include <openvas/base/pwpolicy.h>
121 #include <openvas/misc/openvas_auth.h>
122 #include <openvas/misc/openvas_logging.h>
123 #include <openvas/misc/openvas_ssh.h>
124 #include <openvas/omp/xml.h>
125 
126 #undef G_LOG_DOMAIN
127 
130 #define G_LOG_DOMAIN "md omp"
131 
132 
133 /* Static headers. */
134 
136 void
137 buffer_results_xml (GString *, iterator_t *, task_t, int, int, int, int, int,
138  int, int, const char *, iterator_t *, int);
139 
140 static void
141 buffer_xml_append_printf (GString*, const char*, ...);
142 
143 
144 /* Helper functions. */
145 
153 static int
154 is_uuid (const char *uuid)
155 {
156  while (*uuid) if (isxdigit (*uuid) || (*uuid == '-')) uuid++; else return 0;
157  return 1;
158 }
159 
175 static time_t
176 time_from_strings (const char *hour, const char *minute,
177  const char *day_of_month, const char *month,
178  const char *year, const char *timezone)
179 {
180  struct tm given_broken, *now_broken;
181  time_t now, ret;
182  gchar *tz;
183 
184  tz = NULL;
185  if (timezone)
186  {
187  /* Store current TZ. */
188  tz = getenv ("TZ") ? g_strdup (getenv ("TZ")) : NULL;
189 
190  if (setenv ("TZ", timezone, 1) == -1)
191  {
192  g_free (tz);
193  return -2;
194  }
195  tzset ();
196  }
197 
198  time (&now);
199  now_broken = localtime (&now);
200 
201  given_broken.tm_sec = 0;
202  given_broken.tm_min = (minute ? atoi (minute) : now_broken->tm_min);
203  given_broken.tm_hour = (hour ? atoi (hour) : now_broken->tm_hour);
204  given_broken.tm_mday = (day_of_month
205  ? atoi (day_of_month)
206  : now_broken->tm_mday);
207  given_broken.tm_mon = (month ? (atoi (month) - 1) : now_broken->tm_mon);
208  given_broken.tm_year = (year ? (atoi (year) - 1900) : now_broken->tm_year);
209  given_broken.tm_isdst = now_broken->tm_isdst;
210 
211  ret = mktime (&given_broken);
212 
213  if (timezone)
214  {
215  /* Revert to stored TZ. */
216  if (tz)
217  setenv ("TZ", tz, 1);
218  else
219  unsetenv ("TZ");
220  g_free (tz);
221  tzset ();
222  }
223 
224  return ret;
225 }
226 
238 static time_t
239 interval_from_strings (const char *value, const char *unit, time_t *months)
240 {
241  if (value == NULL)
242  return -1;
243 
244  if ((unit == NULL) || (strcasecmp (unit, "second") == 0))
245  {
246  long int val;
247  val = strtol (value, NULL, 10);
248  if ((val >= INT_MAX) || (val < 0))
249  return -3;
250  return val;
251  }
252 
253  if (strcasecmp (unit, "minute") == 0)
254  {
255  long int val;
256  val = strtol (value, NULL, 10);
257  if ((val >= (INT_MAX / 60)) || (val < 0))
258  return -3;
259  return val * 60;
260  }
261 
262  if (strcasecmp (unit, "hour") == 0)
263  {
264  long int val;
265  val = strtol (value, NULL, 10);
266  if ((val >= (INT_MAX / (60 * 60))) || (val < 0))
267  return -3;
268  return val * 60 * 60;
269  }
270 
271  if (strcasecmp (unit, "day") == 0)
272  {
273  long int val;
274  val = strtol (value, NULL, 10);
275  if ((val >= (INT_MAX / (60 * 60 * 24))) || (val < 0))
276  return -3;
277  return val * 60 * 60 * 24;
278  }
279 
280  if (strcasecmp (unit, "week") == 0)
281  {
282  long int val;
283  val = strtol (value, NULL, 10);
284  if ((val >= (INT_MAX / (60 * 60 * 24 * 7))) || (val < 0))
285  return -3;
286  return val * 60 * 60 * 24 * 7;
287  }
288 
289  if (months)
290  {
291  if (strcasecmp (unit, "month") == 0)
292  {
293  *months = atoi (value);
294  if ((*months >= INT_MAX) || (*months < 0))
295  return -3;
296  return 0;
297  }
298 
299  if (strcasecmp (unit, "year") == 0)
300  {
301  *months = atoi (value);
302  if ((*months >= (INT_MAX / 12)) || (*months < 0))
303  return -3;
304  *months = *months * 12;
305  return 0;
306  }
307 
308  if (strcasecmp (unit, "decade") == 0)
309  {
310  *months = atoi (value);
311  if ((*months >= (INT_MAX / (12 * 10))) || (*months < 0))
312  return -3;
313  *months = *months * 12 * 10;
314  return 0;
315  }
316  }
317 
318  return -2;
319 }
320 
331 int
332 find_attribute (const gchar **attribute_names,
333  const gchar **attribute_values,
334  const char *attribute_name,
335  const gchar **attribute_value)
336 {
337  while (*attribute_names && *attribute_values)
338  if (strcmp (*attribute_names, attribute_name))
339  attribute_names++, attribute_values++;
340  else
341  {
342  *attribute_value = *attribute_values;
343  return 1;
344  }
345  return 0;
346 }
347 
360 int
361 append_attribute (const gchar **attribute_names,
362  const gchar **attribute_values,
363  const char *attribute_name,
364  gchar **string)
365 {
366  const gchar* attribute;
367  if (find_attribute (attribute_names, attribute_values, attribute_name,
368  &attribute))
369  {
370  openvas_append_string (string, attribute);
371  return 1;
372  }
373  return 0;
374 }
375 
379 typedef struct
380 {
381  gchar *key;
382  gchar *value;
384 
395 int
396 init_get (gchar *command, get_data_t * get, const gchar *setting_name,
397  int *first)
398 {
399  gchar *filter, *replacement;
400 
401  if (acl_user_may (command) == 0)
402  return 99;
403 
404  /* Get any replacement out of get->filter, before it changes. Used to add
405  * task_id to the filter for GET_REPORTS. */
406 
407  if (get->filter_replace && strlen (get->filter_replace) && get->filter)
408  replacement = filter_term_value (get->filter, get->filter_replace);
409  else
410  replacement = NULL;
411 
412  /* Switch to the default filter from the setting, if required. */
413 
414  if (get->filt_id && strcmp (get->filt_id, "-2") == 0)
415  {
416  char *user_filter = setting_filter (setting_name);
417 
418  if (user_filter && strlen (user_filter))
419  {
420  get->filt_id = user_filter;
421  get->filter = filter_term (user_filter);
422  }
423  else
424  {
425  free (user_filter);
426  get->filt_id = g_strdup ("0");
427  }
428  }
429 
430  /* Get the actual filter string. */
431 
432  if (get->filt_id && strcmp (get->filt_id, "0"))
433  {
434  filter = filter_term (get->filt_id);
435  if (filter == NULL)
436  {
437  char *user_filter;
438 
439  /* Probably the user deleted the filter, switch to default. */
440 
441  g_free (get->filt_id);
442 
443  user_filter = setting_filter (setting_name);
444  if (user_filter && strlen (user_filter))
445  {
446  get->filt_id = user_filter;
447  get->filter = filter_term (user_filter);
448  filter = filter_term (get->filt_id);
449  }
450  else
451  get->filt_id = g_strdup ("0");
452  }
453  }
454  else
455  filter = NULL;
456 
457  if (replacement)
458  {
459  const gchar *term;
460 
461  /* Replace the term in filter. Used to add task_id to the filter
462  * for GET_REPORTS. */
463 
464  term = filter ? filter : get->filter;
465 
466  if (term)
467  {
468  gchar *new_filter, *clean;
469 
470  clean = manage_clean_filter_remove (term, get->filter_replace);
471  new_filter = g_strdup_printf
472  ("%s=%s %s",
473  get->filter_replace,
474  replacement,
475  clean);
476  g_free (clean);
477  if (get->filter)
478  {
479  g_free (get->filter);
480  get->filter = new_filter;
481  }
482  else
483  {
484  g_free (filter);
485  filter = new_filter;
486  }
487  get->filter_replacement = g_strdup (new_filter);
488  }
489 
490  g_free (replacement);
491  }
492 
493  /* Get the value of "first" from the filter string.
494  *
495  * This is used by get_next when the result set is empty, to determine if
496  * the query should be rerun with first 1.
497  */
498  manage_filter_controls (filter ? filter : get->filter, first, NULL, NULL,
499  NULL);
500 
501  g_free (filter);
502 
503  return 0;
504 }
505 
513 static int
514 check_certificate (const char *cert_str)
515 {
516  gnutls_x509_crt_t crt;
517  gnutls_datum_t data;
518  int ret = 0;
519 
520  assert (cert_str);
521  if (gnutls_x509_crt_init (&crt))
522  return 1;
523  data.size = strlen (cert_str);
524  data.data = (void *) g_strdup (cert_str);
525  if (gnutls_x509_crt_import (crt, &data, GNUTLS_X509_FMT_PEM))
526  {
527  gnutls_x509_crt_deinit (crt);
528  g_free (data.data);
529  return 1;
530  }
531 
532  if (time (NULL) > gnutls_x509_crt_get_expiration_time (crt))
533  {
534  g_warning ("Certificate expiration time passed");
535  ret = 1;
536  }
537  if (time (NULL) < gnutls_x509_crt_get_activation_time (crt))
538  {
539  g_warning ("Certificate activation time in the future");
540  ret = 1;
541  }
542  g_free (data.data);
543  gnutls_x509_crt_deinit (crt);
544  return ret;
545 }
546 
554 static int
555 check_private_key (const char *key_str)
556 {
557  gnutls_x509_privkey_t key;
558  gnutls_datum_t data;
559 
560  assert (key_str);
561  if (gnutls_x509_privkey_init (&key))
562  return 1;
563  data.size = strlen (key_str);
564  data.data = (void *) g_strdup (key_str);
565  if (gnutls_x509_privkey_import (key, &data, GNUTLS_X509_FMT_PEM))
566  {
567  gnutls_x509_privkey_deinit (key);
568  g_free (data.data);
569  return 1;
570  }
571  g_free (data.data);
572  gnutls_x509_privkey_deinit (key);
573  return 0;
574 }
575 
576 
577 /* Status codes. */
578 
579 /* HTTP status codes used:
580  *
581  * 200 OK
582  * 201 Created
583  * 202 Accepted
584  * 400 Bad request
585  * 401 Must auth
586  * 404 Missing
587  */
588 
592 #define STATUS_ERROR_SYNTAX "400"
593 
597 #define STATUS_ERROR_MUST_AUTH "401"
598 
602 #define STATUS_ERROR_MUST_AUTH_TEXT "Authenticate first"
603 
607 #define STATUS_ERROR_ACCESS "403"
608 
612 #define STATUS_ERROR_ACCESS_TEXT "Access to resource forbidden"
613 
617 #define STATUS_ERROR_MISSING "404"
618 
622 #define STATUS_ERROR_MISSING_TEXT "Resource missing"
623 
627 #define STATUS_ERROR_BUSY "409"
628 
632 #define STATUS_ERROR_BUSY_TEXT "Resource busy"
633 
637 #define STATUS_ERROR_AUTH_FAILED "400"
638 
642 #define STATUS_ERROR_AUTH_FAILED_TEXT "Authentication failed"
643 
647 #define STATUS_OK "200"
648 
652 #define STATUS_OK_TEXT "OK"
653 
657 #define STATUS_OK_CREATED "201"
658 
662 #define STATUS_OK_CREATED_TEXT "OK, resource created"
663 
667 #define STATUS_OK_REQUESTED "202"
668 
672 #define STATUS_OK_REQUESTED_TEXT "OK, request submitted"
673 
677 #define STATUS_INTERNAL_ERROR "500"
678 
682 #define STATUS_INTERNAL_ERROR_TEXT "Internal error"
683 
687 #define STATUS_SERVICE_UNAVAILABLE "503"
688 
692 #define STATUS_SERVICE_DOWN "503"
693 
697 #define STATUS_SERVICE_DOWN_TEXT "Service temporarily down"
698 
699 
700 /* OMP parser. */
701 
705 typedef struct
706 {
707  int (*client_writer) (const char*, void*);
709  int importing;
710  int read_over;
713 } omp_parser_t;
714 
715 static int
716 process_omp (omp_parser_t *, const gchar *, gchar **);
717 
728 omp_parser_t *
729 omp_parser_new (int (*write_to_client) (const char*, void*), void* write_to_client_data,
730  gchar **disable)
731 {
732  omp_parser_t *omp_parser = (omp_parser_t*) g_malloc0 (sizeof (omp_parser_t));
733  omp_parser->client_writer = write_to_client;
734  omp_parser->client_writer_data = write_to_client_data;
735  omp_parser->read_over = 0;
736  omp_parser->disabled_commands = g_strdupv (disable);
737  return omp_parser;
738 }
739 
747 void
749 {
750  g_strfreev (omp_parser->disabled_commands);
751  g_free (omp_parser);
752 }
753 
762 static int
763 command_disabled (omp_parser_t *omp_parser, const gchar *name)
764 {
765  gchar **disabled;
766  disabled = omp_parser->disabled_commands;
767  if (disabled)
768  while (*disabled)
769  {
770  if (strcasecmp (*disabled, name) == 0)
771  return 1;
772  disabled++;
773  }
774  return 0;
775 }
776 
777 
778 /* Command data passed between parser callbacks. */
779 
794 static gpointer
795 preference_new (char *name, char *type, char *value, char *nvt_name,
796  char *nvt_oid, array_t *alts, char* default_value,
797  char *hr_name)
798 {
799  preference_t *preference;
800 
801  preference = (preference_t*) g_malloc0 (sizeof (preference_t));
802  preference->name = name;
803  preference->type = type;
804  preference->value = value;
805  preference->nvt_name = nvt_name;
806  preference->nvt_oid = nvt_oid;
807  preference->alts = alts;
808  preference->default_value = default_value;
809  preference->hr_name = hr_name;
810 
811  return preference;
812 }
813 
824 static gpointer
825 nvt_selector_new (char *name, char *type, int include, char *family_or_nvt)
826 {
827  nvt_selector_t *selector;
828 
829  selector = (nvt_selector_t*) g_malloc0 (sizeof (nvt_selector_t));
830  selector->name = name;
831  selector->type = type;
832  selector->include = include;
833  selector->family_or_nvt = family_or_nvt;
834 
835  return selector;
836 }
837 
841 typedef struct
842 {
843  char *comment;
844  char *copy;
846  char *howto_use;
847  char *installer;
850  char *name;
852 
856 static void
857 create_agent_data_reset (create_agent_data_t *data)
858 {
859  free (data->comment);
860  free (data->copy);
861  free (data->howto_install);
862  free (data->howto_use);
863  free (data->installer);
864  free (data->installer_filename);
865  free (data->installer_signature);
866  free (data->name);
867 
868  memset (data, 0, sizeof (create_agent_data_t));
869 }
870 
874 typedef struct
875 {
876  char *name;
877  char *comment;
878  char *filter_term;
879  char *report_id;
880  char *type;
882 
886 static void
887 create_asset_data_reset (create_asset_data_t *data)
888 {
889  free (data->comment);
890  free (data->filter_term);
891  free (data->report_id);
892  free (data->type);
893  free (data->name);
894 
895  memset (data, 0, sizeof (create_asset_data_t));
896 }
897 
901 typedef struct
902 {
903  int import;
904  char *comment;
905  char *name;
906  array_t *nvt_selectors;
911  array_t *preferences;
912  array_t *preference_alts;
921  char *type;
923 
927 typedef struct
928 {
929  char *comment;
930  char *scanner;
931  char *copy;
933  char *name;
935 
941 static void
942 create_config_data_reset (create_config_data_t *data)
943 {
945 
946  g_free (data->comment);
947  g_free (data->copy);
948  g_free (data->scanner);
949 
950  g_free (import->comment);
951  g_free (import->name);
952  array_free (import->nvt_selectors);
953  g_free (import->nvt_selector_name);
954  g_free (import->nvt_selector_type);
955  g_free (import->nvt_selector_family_or_nvt);
956 
957  if (import->preferences)
958  {
959  guint index = import->preferences->len;
960  while (index--)
961  {
962  const preference_t *preference;
963  preference = (preference_t*) g_ptr_array_index (import->preferences,
964  index);
965  if (preference)
966  array_free (preference->alts);
967  }
968  array_free (import->preferences);
969  }
970 
971  g_free (import->preference_alt);
972  g_free (import->preference_name);
973  g_free (import->preference_name);
974  g_free (import->preference_nvt_name);
975  g_free (import->preference_nvt_oid);
976  g_free (import->preference_type);
977  g_free (import->preference_value);
978  g_free (import->type);
979 
980  g_free (data->name);
981 
982  memset (data, 0, sizeof (create_config_data_t));
983 }
984 
993 typedef struct
994 {
995  char *comment;
996  char *copy;
997  char *condition;
998  array_t *condition_data;
999  char *event;
1000  array_t *event_data;
1001  char *filter_id;
1002  char *method;
1003  array_t *method_data;
1004  char *name;
1005  char *part_data;
1006  char *part_name;
1008 
1014 static void
1015 create_alert_data_reset (create_alert_data_t *data)
1016 {
1017  free (data->comment);
1018  free (data->copy);
1019  free (data->condition);
1020  array_free (data->condition_data);
1021  free (data->event);
1022  array_free (data->event_data);
1023  free (data->filter_id);
1024  free (data->method);
1025  array_free (data->method_data);
1026  free (data->name);
1027  free (data->part_data);
1028  free (data->part_name);
1029 
1030  memset (data, 0, sizeof (create_alert_data_t));
1031 }
1032 
1036 typedef struct
1037 {
1039  char *certificate;
1040  char *comment;
1041  char *copy;
1042  int key;
1043  char *key_phrase;
1044  char *key_private;
1045  char *login;
1046  char *name;
1047  char *password;
1048  char *community;
1052  char *type;
1054 
1060 static void
1061 create_credential_data_reset (create_credential_data_t *data)
1062 {
1063  free (data->allow_insecure);
1064  free (data->certificate);
1065  free (data->comment);
1066  free (data->copy);
1067  free (data->key_phrase);
1068  free (data->key_private);
1069  free (data->login);
1070  free (data->name);
1071  free (data->password);
1072  free (data->community);
1073  free (data->auth_algorithm);
1074  free (data->privacy_password);
1075  free (data->privacy_algorithm);
1076  free (data->type);
1077 
1078  memset (data, 0, sizeof (create_credential_data_t));
1079 }
1080 
1084 typedef struct
1085 {
1086  char *comment;
1087  char *copy;
1089  char *name;
1090  char *term;
1091  char *type;
1093 
1099 static void
1100 create_filter_data_reset (create_filter_data_t *data)
1101 {
1102  free (data->comment);
1103  free (data->copy);
1104  free (data->make_name_unique);
1105  free (data->name);
1106  free (data->term);
1107  free (data->type);
1108 
1109  memset (data, 0, sizeof (create_filter_data_t));
1110 }
1111 
1115 typedef struct
1116 {
1117  char *comment;
1118  char *copy;
1119  char *name;
1120  char *users;
1123 
1129 static void
1130 create_group_data_reset (create_group_data_t *data)
1131 {
1132  free (data->comment);
1133  free (data->copy);
1134  free (data->name);
1135  free (data->users);
1136 
1137  memset (data, 0, sizeof (create_group_data_t));
1138 }
1139 
1143 typedef struct
1144 {
1145  char *active;
1146  char *copy;
1147  char *hosts;
1148  char *nvt_oid;
1149  char *port;
1150  char *result_id;
1151  char *severity;
1152  char *task_id;
1153  char *text;
1154  char *threat;
1156 
1162 static void
1163 create_note_data_reset (create_note_data_t *data)
1164 {
1165  free (data->active);
1166  free (data->copy);
1167  free (data->hosts);
1168  free (data->nvt_oid);
1169  free (data->port);
1170  free (data->result_id);
1171  free (data->severity);
1172  free (data->task_id);
1173  free (data->text);
1174  free (data->threat);
1175 
1176  memset (data, 0, sizeof (create_note_data_t));
1177 }
1178 
1182 typedef struct
1183 {
1184  char *active;
1185  char *copy;
1186  char *hosts;
1187  char *new_threat;
1189  char *nvt_oid;
1190  char *port;
1191  char *result_id;
1192  char *severity;
1193  char *task_id;
1194  char *text;
1195  char *threat;
1197 
1203 static void
1204 create_override_data_reset (create_override_data_t *data)
1205 {
1206  free (data->active);
1207  free (data->copy);
1208  free (data->hosts);
1209  free (data->new_threat);
1210  free (data->new_severity);
1211  free (data->nvt_oid);
1212  free (data->port);
1213  free (data->result_id);
1214  free (data->task_id);
1215  free (data->text);
1216  free (data->threat);
1217  free (data->severity);
1218 
1219  memset (data, 0, sizeof (create_override_data_t));
1220 }
1221 
1225 typedef struct
1226 {
1227  char *comment;
1228  char *copy;
1229  char *name;
1231  char *resource_id;
1233  char *subject_id;
1235 
1241 static void
1242 create_permission_data_reset (create_permission_data_t *data)
1243 {
1244  free (data->comment);
1245  free (data->copy);
1246  free (data->name);
1247  free (data->resource_type);
1248  free (data->resource_id);
1249  free (data->subject_type);
1250  free (data->subject_id);
1251 
1252  memset (data, 0, sizeof (create_permission_data_t));
1253 }
1254 
1259 {
1260  char *comment;
1261  char *end;
1262  char *id;
1263  char *start;
1264  char *type;
1265 };
1266 
1271 
1275 typedef struct
1276 {
1277  char *comment;
1278  char *id;
1279  char *copy;
1280  int import;
1281  char *name;
1282  char *port_range;
1284  array_t *ranges;
1286 
1292 static void
1293 create_port_list_data_reset (create_port_list_data_t *data)
1294 {
1295  free (data->comment);
1296  free (data->copy);
1297  free (data->name);
1298  free (data->port_range);
1299 
1300  if (data->ranges)
1301  {
1302  guint index;
1303 
1304  index = data->ranges->len;
1305  while (index--)
1306  {
1307  create_port_list_range_t *range;
1308  range = (create_port_list_range_t*) g_ptr_array_index (data->ranges,
1309  index);
1310  if (range)
1311  {
1312  free (range->comment);
1313  free (range->end);
1314  free (range->id);
1315  free (range->start);
1316  free (range->type);
1317  }
1318  }
1319  array_free (data->ranges);
1320  }
1321 
1322  memset (data, 0, sizeof (create_port_list_data_t));
1323 }
1324 
1328 typedef struct
1329 {
1330  char *comment;
1331  char *end;
1333  char *start;
1334  char *type;
1336 
1342 static void
1343 create_port_range_data_reset (create_port_range_data_t *data)
1344 {
1345  free (data->comment);
1346  free (data->end);
1347  free (data->port_list_id);
1348  free (data->start);
1349  free (data->type);
1350 
1351  memset (data, 0, sizeof (create_port_range_data_t));
1352 }
1353 
1357 typedef struct
1358 {
1359  char *detail_name;
1364  array_t *details;
1365  char *host_end;
1367  array_t *host_ends;
1368  char *host_start;
1370  array_t *host_starts;
1371  char *in_assets;
1372  char *ip;
1374  char *result_host;
1376  char *result_port;
1377  char *result_qod;
1382  array_t *results;
1383  char *scan_end;
1384  char *scan_start;
1386  char *task_id;
1387  char *task_name;
1388  char *type;
1389  int wrapper;
1391 
1397 static void
1398 create_report_data_reset (create_report_data_t *data)
1399 {
1400  if (data->details)
1401  {
1402  guint index = data->details->len;
1403  while (index--)
1404  {
1405  host_detail_t *detail;
1406  detail = (host_detail_t*) g_ptr_array_index (data->details, index);
1407  if (detail)
1408  host_detail_free (detail);
1409  }
1410  array_free (data->details);
1411  }
1412  free (data->host_end);
1413  free (data->host_start);
1414  free (data->in_assets);
1415  free (data->ip);
1416  free (data->result_description);
1417  free (data->result_host);
1418  free (data->result_nvt_oid);
1419  free (data->result_port);
1420  free (data->result_threat);
1421  if (data->results)
1422  {
1423  guint index = data->results->len;
1424  while (index--)
1425  {
1426  create_report_result_t *result;
1427  result = (create_report_result_t*) g_ptr_array_index (data->results,
1428  index);
1429  if (result)
1430  {
1431  free (result->host);
1432  free (result->description);
1433  free (result->nvt_oid);
1434  free (result->port);
1435  free (result->qod);
1436  free (result->qod_type);
1437  free (result->scan_nvt_version);
1438  free (result->severity);
1439  }
1440  }
1441  array_free (data->results);
1442  }
1443  free (data->scan_end);
1444  free (data->scan_start);
1445  free (data->task_comment);
1446  free (data->task_id);
1447  free (data->task_name);
1448  free (data->type);
1449 
1450  memset (data, 0, sizeof (create_report_data_t));
1451 }
1452 
1456 typedef struct
1457 {
1459  char *description;
1460  char *extension;
1461  char *file;
1462  char *file_name;
1463  array_t *files;
1464  char *id;
1465  int import;
1466  char *name;
1467  char *param_value;
1469  char *param_name;
1471  array_t *param_options;
1472  array_t *params_options;
1473  char *param_type;
1476  array_t *params;
1477  char *signature;
1478  char *summary;
1479  char *copy;
1481 
1487 static void
1488 create_report_format_data_reset (create_report_format_data_t *data)
1489 {
1490  free (data->content_type);
1491  free (data->description);
1492  free (data->extension);
1493  free (data->file);
1494  free (data->file_name);
1495  array_free (data->files);
1496  free (data->id);
1497  free (data->name);
1498  free (data->copy);
1499  free (data->param_default);
1500  free (data->param_name);
1501 
1502  if (data->params_options)
1503  {
1504  guint index = data->params_options->len;
1505  while (index--)
1506  {
1507  array_t *options;
1508  options = (array_t*) g_ptr_array_index (data->params_options, index);
1509  if (options)
1510  array_free (options);
1511  }
1512  g_ptr_array_free (data->params_options, TRUE);
1513  }
1514 
1515  free (data->param_type);
1516  free (data->param_type_min);
1517  free (data->param_type_max);
1518  free (data->param_value);
1519  array_free (data->params);
1520  free (data->summary);
1521 
1522  memset (data, 0, sizeof (create_report_format_data_t));
1523 }
1524 
1528 typedef struct
1529 {
1530  char *comment;
1531  char *copy;
1532  char *name;
1533  char *users;
1535 
1541 static void
1542 create_role_data_reset (create_role_data_t *data)
1543 {
1544  free (data->comment);
1545  free (data->copy);
1546  free (data->name);
1547  free (data->users);
1548 
1549  memset (data, 0, sizeof (create_role_data_t));
1550 }
1551 
1555 typedef struct
1556 {
1557  char *name;
1558  char *copy;
1559  char *comment;
1560  char *host;
1561  char *port;
1562  char *type;
1563  char *ca_pub;
1566 
1572 static void
1573 create_scanner_data_reset (create_scanner_data_t *data)
1574 {
1575  free (data->name);
1576  free (data->copy);
1577  free (data->comment);
1578  free (data->host);
1579  free (data->port);
1580  free (data->type);
1581  free (data->ca_pub);
1582  free (data->credential_id);
1583 
1584  memset (data, 0, sizeof (create_scanner_data_t));
1585 }
1586 
1590 typedef struct
1591 {
1592  char *name;
1593  char *comment;
1594  char *copy;
1600  char *period;
1601  char *period_unit;
1602  char *duration;
1604  char *timezone;
1606 
1612 static void
1613 create_schedule_data_reset (create_schedule_data_t *data)
1614 {
1615  free (data->name);
1616  free (data->copy);
1617  free (data->comment);
1618  free (data->first_time_day_of_month);
1619  free (data->first_time_hour);
1620  free (data->first_time_minute);
1621  free (data->first_time_month);
1622  free (data->first_time_year);
1623  free (data->period);
1624  free (data->period_unit);
1625  free (data->duration);
1626  free (data->duration_unit);
1627  free (data->timezone);
1628 
1629  memset (data, 0, sizeof (create_schedule_data_t));
1630 }
1631 
1635 typedef struct
1636 {
1637  char *alive_tests;
1639  char *comment;
1643  char *copy;
1644  char *hosts;
1646  char *port_range;
1649  char *ssh_port;
1657  char *name;
1659 
1665 static void
1666 create_target_data_reset (create_target_data_t *data)
1667 {
1668  free (data->alive_tests);
1669  free (data->asset_hosts_filter);
1670  free (data->comment);
1671  free (data->exclude_hosts);
1672  free (data->reverse_lookup_only);
1673  free (data->reverse_lookup_unify);
1674  free (data->copy);
1675  free (data->hosts);
1676  free (data->port_list_id);
1677  free (data->port_range);
1678  free (data->ssh_credential_id);
1679  free (data->ssh_lsc_credential_id);
1680  free (data->ssh_port);
1681  free (data->ssh_lsc_port);
1682  free (data->smb_credential_id);
1683  free (data->smb_lsc_credential_id);
1684  free (data->esxi_credential_id);
1685  free (data->esxi_lsc_credential_id);
1686  free (data->snmp_credential_id);
1687  free (data->make_name_unique);
1688  free (data->name);
1689 
1690  memset (data, 0, sizeof (create_target_data_t));
1691 }
1692 
1696 typedef struct
1697 {
1698  char *active;
1699  char *resource_id;
1701  char *comment;
1702  char *name;
1703  char *value;
1704  char *copy;
1706 
1712 static void
1713 create_tag_data_reset (create_tag_data_t *data)
1714 {
1715  free (data->active);
1716  free (data->resource_type);
1717  free (data->resource_id);
1718  free (data->comment);
1719  free (data->name);
1720  free (data->value);
1721  free (data->copy);
1722  memset (data, 0, sizeof (create_tag_data_t));
1723 }
1724 
1728 typedef struct
1729 {
1730  char *alterable;
1731  char *config_id;
1733  char *scanner_id;
1734  array_t *alerts;
1735  char *copy;
1736  array_t *groups;
1737  char *observers;
1739  array_t *preferences;
1740  char *schedule_id;
1742  char *target_id;
1745 
1751 static void
1752 create_task_data_reset (create_task_data_t *data)
1753 {
1754  free (data->alterable);
1755  free (data->config_id);
1756  free (data->hosts_ordering);
1757  free (data->scanner_id);
1758  free (data->copy);
1759  array_free (data->alerts);
1760  array_free (data->groups);
1761  free (data->observers);
1762  if (data->preferences)
1763  {
1764  guint index = data->preferences->len;
1765  while (index--)
1766  {
1767  name_value_t *pair;
1768  pair = (name_value_t*) g_ptr_array_index (data->preferences, index);
1769  if (pair)
1770  {
1771  g_free (pair->name);
1772  g_free (pair->value);
1773  }
1774  }
1775  }
1776  array_free (data->preferences);
1777  free (data->schedule_id);
1778  free (data->schedule_periods);
1779  free (data->target_id);
1780 
1781  memset (data, 0, sizeof (create_task_data_t));
1782 }
1783 
1784 /* Command data passed between parser callbacks. */
1785 
1786 typedef struct
1787 {
1788  char *copy;
1790  array_t *groups;
1791  char *hosts;
1793  char *ifaces;
1795  char *name;
1796  char *password;
1797  array_t *roles;
1799  array_t *sources;
1801 
1807 static void
1808 create_user_data_reset (create_user_data_t * data)
1809 {
1810  g_free (data->copy);
1811  array_free (data->groups);
1812  g_free (data->name);
1813  g_free (data->password);
1814  g_free (data->hosts);
1815  g_free (data->ifaces);
1816  array_free (data->roles);
1817  if (data->sources)
1818  {
1819  array_free (data->sources);
1820  }
1821  g_free (data->current_source);
1822  memset (data, 0, sizeof (create_user_data_t));
1823 }
1824 
1828 typedef struct
1829 {
1830  char *agent_id;
1831  int ultimate;
1833 
1839 static void
1840 delete_agent_data_reset (delete_agent_data_t *data)
1841 {
1842  free (data->agent_id);
1843 
1844  memset (data, 0, sizeof (delete_agent_data_t));
1845 }
1846 
1850 typedef struct
1851 {
1852  char *asset_id;
1853  char *report_id;
1854  int ultimate;
1856 
1862 static void
1863 delete_asset_data_reset (delete_asset_data_t *data)
1864 {
1865  free (data->asset_id);
1866  free (data->report_id);
1867 
1868  memset (data, 0, sizeof (delete_asset_data_t));
1869 }
1870 
1874 typedef struct
1875 {
1876  char *config_id;
1877  int ultimate;
1879 
1885 static void
1886 delete_config_data_reset (delete_config_data_t *data)
1887 {
1888  free (data->config_id);
1889 
1890  memset (data, 0, sizeof (delete_config_data_t));
1891 }
1892 
1896 typedef struct
1897 {
1898  char *alert_id;
1899  int ultimate;
1901 
1907 static void
1908 delete_alert_data_reset (delete_alert_data_t *data)
1909 {
1910  free (data->alert_id);
1911 
1912  memset (data, 0, sizeof (delete_alert_data_t));
1913 }
1914 
1918 typedef struct
1919 {
1921  int ultimate;
1923 
1929 static void
1930 delete_credential_data_reset (delete_credential_data_t *data)
1931 {
1932  free (data->credential_id);
1933 
1934  memset (data, 0, sizeof (delete_credential_data_t));
1935 }
1936 
1940 typedef struct
1941 {
1942  char *filter_id;
1943  int ultimate;
1945 
1951 static void
1952 delete_filter_data_reset (delete_filter_data_t *data)
1953 {
1954  free (data->filter_id);
1955 
1956  memset (data, 0, sizeof (delete_filter_data_t));
1957 }
1958 
1962 typedef struct
1963 {
1964  char *group_id;
1965  int ultimate;
1967 
1973 static void
1974 delete_group_data_reset (delete_group_data_t *data)
1975 {
1976  free (data->group_id);
1977 
1978  memset (data, 0, sizeof (delete_group_data_t));
1979 }
1980 
1984 typedef struct
1985 {
1986  char *note_id;
1987  int ultimate;
1989 
1995 static void
1996 delete_note_data_reset (delete_note_data_t *data)
1997 {
1998  free (data->note_id);
1999 
2000  memset (data, 0, sizeof (delete_note_data_t));
2001 }
2002 
2006 typedef struct
2007 {
2008  char *override_id;
2009  int ultimate;
2011 
2015 typedef struct
2016 {
2018  int ultimate;
2020 
2026 static void
2027 delete_permission_data_reset (delete_permission_data_t *data)
2028 {
2029  free (data->permission_id);
2030 
2031  memset (data, 0, sizeof (delete_permission_data_t));
2032 }
2033 
2037 typedef struct
2038 {
2040  int ultimate;
2042 
2048 static void
2049 delete_port_list_data_reset (delete_port_list_data_t *data)
2050 {
2051  free (data->port_list_id);
2052 
2053  memset (data, 0, sizeof (delete_port_list_data_t));
2054 }
2055 
2059 typedef struct
2060 {
2062  int ultimate;
2064 
2070 static void
2071 delete_port_range_data_reset (delete_port_range_data_t *data)
2072 {
2073  free (data->port_range_id);
2074 
2075  memset (data, 0, sizeof (delete_port_range_data_t));
2076 }
2077 
2083 static void
2084 delete_override_data_reset (delete_override_data_t *data)
2085 {
2086  free (data->override_id);
2087 
2088  memset (data, 0, sizeof (delete_override_data_t));
2089 }
2090 
2094 typedef struct
2095 {
2096  char *report_id;
2097  int ultimate;
2099 
2105 static void
2106 delete_report_data_reset (delete_report_data_t *data)
2107 {
2108  free (data->report_id);
2109 
2110  memset (data, 0, sizeof (delete_report_data_t));
2111 }
2112 
2116 typedef struct
2117 {
2119  int ultimate;
2121 
2127 static void
2128 delete_report_format_data_reset (delete_report_format_data_t *data)
2129 {
2130  free (data->report_format_id);
2131 
2132  memset (data, 0, sizeof (delete_report_format_data_t));
2133 }
2134 
2138 typedef struct
2139 {
2140  char *role_id;
2141  int ultimate;
2143 
2149 static void
2150 delete_role_data_reset (delete_role_data_t *data)
2151 {
2152  free (data->role_id);
2153 
2154  memset (data, 0, sizeof (delete_role_data_t));
2155 }
2156 
2160 typedef struct
2161 {
2162  char *schedule_id;
2163  int ultimate;
2165 
2169 typedef struct
2170 {
2171  char *scanner_id;
2172  int ultimate;
2174 
2180 static void
2181 delete_scanner_data_reset (delete_scanner_data_t *data)
2182 {
2183  g_free (data->scanner_id);
2184 
2185  memset (data, 0, sizeof (delete_scanner_data_t));
2186 }
2187 
2193 static void
2194 delete_schedule_data_reset (delete_schedule_data_t *data)
2195 {
2196  free (data->schedule_id);
2197 
2198  memset (data, 0, sizeof (delete_schedule_data_t));
2199 }
2200 
2204 typedef struct
2205 {
2206  char *tag_id;
2207  int ultimate;
2209 
2215 static void
2216 delete_tag_data_reset (delete_tag_data_t *data)
2217 {
2218  free (data->tag_id);
2219 
2220  memset (data, 0, sizeof (delete_tag_data_t));
2221 }
2222 
2226 typedef struct
2227 {
2228  char *target_id;
2229  int ultimate;
2231 
2237 static void
2238 delete_target_data_reset (delete_target_data_t *data)
2239 {
2240  free (data->target_id);
2241 
2242  memset (data, 0, sizeof (delete_target_data_t));
2243 }
2244 
2248 typedef struct
2249 {
2250  char *task_id;
2251  int ultimate;
2253 
2259 static void
2260 delete_task_data_reset (delete_task_data_t *data)
2261 {
2262  free (data->task_id);
2263 
2264  memset (data, 0, sizeof (delete_task_data_t));
2265 }
2266 
2270 typedef struct
2271 {
2272  char *name;
2273  char *user_id;
2274  int ultimate;
2278 
2284 static void
2285 delete_user_data_reset (delete_user_data_t *data)
2286 {
2287  free (data->name);
2288  free (data->user_id);
2289  free (data->inheritor_id);
2290  free (data->inheritor_name);
2291 
2292  memset (data, 0, sizeof (delete_user_data_t));
2293 }
2294 
2298 typedef struct
2299 {
2300  char *type;
2302 
2308 static void
2309 get_feeds_data_reset (get_feeds_data_t *data)
2310 {
2311  free (data->type);
2312 
2313  memset (data, 0, sizeof (get_feeds_data_t));
2314 }
2315 
2321 void
2323 {
2324  free (data->id);
2325  free (data->filt_id);
2326  free (data->filter);
2327  free (data->filter_replace);
2328  free (data->filter_replacement);
2329  free (data->subtype);
2330  free (data->type);
2331 
2332  memset (data, 0, sizeof (get_data_t));
2333 }
2334 
2345 static void
2346 get_data_parse_attributes (get_data_t *data, const gchar *type,
2347  const gchar **attribute_names,
2348  const gchar **attribute_values)
2349 {
2350  gchar *name;
2351  const gchar *attribute;
2352 
2353  data->type = g_strdup (type);
2354 
2355  append_attribute (attribute_names, attribute_values, "filter",
2356  &data->filter);
2357 
2358  name = g_strdup_printf ("%s_id", type);
2359  append_attribute (attribute_names, attribute_values, name,
2360  &data->id);
2361  g_free (name);
2362 
2363  append_attribute (attribute_names, attribute_values, "filt_id",
2364  &data->filt_id);
2365 
2366  if (find_attribute (attribute_names, attribute_values,
2367  "trash", &attribute))
2368  data->trash = strcmp (attribute, "0");
2369  else
2370  data->trash = 0;
2371 
2372  if (find_attribute (attribute_names, attribute_values,
2373  "details", &attribute))
2374  data->details = strcmp (attribute, "0");
2375  else
2376  data->details = 0;
2377 
2378  if (find_attribute (attribute_names, attribute_values,
2379  "ignore_pagination", &attribute))
2380  data->ignore_pagination = strcmp (attribute, "0");
2381  else
2382  data->ignore_pagination = 0;
2383 
2384  append_attribute (attribute_names, attribute_values, "filter_replace",
2385  &data->filter_replace);
2386 }
2387 
2391 typedef struct
2392 {
2394  char *format;
2396 
2402 static void
2403 get_agents_data_reset (get_agents_data_t *data)
2404 {
2405  get_data_reset (&data->get);
2406  free (data->format);
2407 
2408  memset (data, 0, sizeof (get_agents_data_t));
2409 }
2410 
2414 typedef struct
2415 {
2417  char *type;
2418  char *subtype;
2419  GList *data_columns;
2420  GList *text_columns;
2423  GList *sort_data;
2426  char *mode;
2428 
2434 static void
2435 get_aggregates_data_reset (get_aggregates_data_t *data)
2436 {
2437  get_data_reset (&data->get);
2438  free (data->type);
2439  g_list_free_full (data->data_columns, g_free);
2440  data->data_columns = NULL;
2441  g_list_free_full (data->text_columns, g_free);
2442  data->text_columns = NULL;
2443  free (data->group_column);
2444  free (data->subgroup_column);
2445  g_list_free_full (data->sort_data, (GDestroyNotify)sort_data_free);
2446  data->sort_data = NULL;
2447  free (data->mode);
2448 
2449  memset (data, 0, sizeof (get_aggregates_data_t));
2450 }
2451 
2455 typedef struct
2456 {
2457  char *type;
2459  int details;
2461 
2467 static void
2468 get_assets_data_reset (get_assets_data_t *data)
2469 {
2470  free (data->type);
2471  get_data_reset (&data->get);
2472 
2473  memset (data, 0, sizeof (get_assets_data_t));
2474 }
2475 
2479 typedef struct
2480 {
2481  int families;
2484  int tasks;
2486 
2492 static void
2493 get_configs_data_reset (get_configs_data_t *data)
2494 {
2495  get_data_reset (&data->get);
2496  memset (data, 0, sizeof (get_configs_data_t));
2497 }
2498 
2502 typedef struct
2503 {
2505  int tasks;
2507 
2513 static void
2514 get_alerts_data_reset (get_alerts_data_t *data)
2515 {
2516  get_data_reset (&data->get);
2517  memset (data, 0, sizeof (get_alerts_data_t));
2518 }
2519 
2523 typedef struct
2524 {
2525  char *format;
2527  int scanners;
2528  int targets;
2530 
2536 static void
2537 get_credentials_data_reset (get_credentials_data_t *data)
2538 {
2539  get_data_reset (&data->get);
2540  memset (data, 0, sizeof (get_credentials_data_t));
2541 }
2542 
2546 typedef struct
2547 {
2549  int alerts;
2551 
2557 static void
2558 get_filters_data_reset (get_filters_data_t *data)
2559 {
2560  get_data_reset (&data->get);
2561  memset (data, 0, sizeof (get_filters_data_t));
2562 }
2563 
2567 typedef struct
2568 {
2571 
2577 static void
2578 get_groups_data_reset (get_groups_data_t *data)
2579 {
2580  get_data_reset (&data->get);
2581  memset (data, 0, sizeof (get_groups_data_t));
2582 }
2583 
2587 typedef struct
2588 {
2589  char *type;
2590  char *name;
2592  int details;
2593 } get_info_data_t;
2594 
2600 static void
2601 get_info_data_reset (get_info_data_t *data)
2602 {
2603  free (data->type);
2604  free (data->name);
2605  get_data_reset (&data->get);
2606 
2607  memset (data, 0, sizeof (get_info_data_t));
2608 }
2609 
2613 typedef struct
2614 {
2616  char *note_id;
2617  char *nvt_oid;
2618  char *task_id;
2619  int result;
2621 
2627 static void
2628 get_notes_data_reset (get_notes_data_t *data)
2629 {
2630  free (data->note_id);
2631  free (data->nvt_oid);
2632  free (data->task_id);
2633 
2634  memset (data, 0, sizeof (get_notes_data_t));
2635 }
2636 
2640 typedef struct
2641 {
2642  char *config_id;
2644  int details;
2645  char *family;
2646  char *nvt_oid;
2649  char *sort_field;
2651  int timeout;
2652 } get_nvts_data_t;
2653 
2659 static void
2660 get_nvts_data_reset (get_nvts_data_t *data)
2661 {
2662  free (data->config_id);
2663  free (data->preferences_config_id);
2664  free (data->family);
2665  free (data->nvt_oid);
2666  free (data->sort_field);
2667 
2668  memset (data, 0, sizeof (get_nvts_data_t));
2669 }
2670 
2674 typedef struct
2675 {
2678 
2684 static void
2685 get_nvt_families_data_reset (get_nvt_families_data_t *data)
2686 {
2687  memset (data, 0, sizeof (get_nvt_families_data_t));
2688 }
2689 
2693 typedef struct
2694 {
2696  char *override_id;
2697  char *nvt_oid;
2698  char *task_id;
2699  int result;
2701 
2707 static void
2708 get_overrides_data_reset (get_overrides_data_t *data)
2709 {
2710  free (data->override_id);
2711  free (data->nvt_oid);
2712  free (data->task_id);
2713 
2714  memset (data, 0, sizeof (get_overrides_data_t));
2715 }
2716 
2720 typedef struct
2721 {
2723  char *resource_id;
2725 
2731 static void
2732 get_permissions_data_reset (get_permissions_data_t *data)
2733 {
2734  free (data->resource_id);
2735 
2736  get_data_reset (&data->get);
2737  memset (data, 0, sizeof (get_permissions_data_t));
2738 }
2739 
2743 typedef struct
2744 {
2745  int targets;
2748 
2754 static void
2755 get_port_lists_data_reset (get_port_lists_data_t *data)
2756 {
2757  get_data_reset (&data->get);
2758  memset (data, 0, sizeof (get_port_lists_data_t));
2759 }
2760 
2764 typedef struct
2765 {
2766  char *config_id;
2767  char *nvt_oid;
2768  char *preference;
2770 
2776 static void
2777 get_preferences_data_reset (get_preferences_data_t *data)
2778 {
2779  free (data->config_id);
2780  free (data->nvt_oid);
2781  free (data->preference);
2782 
2783  memset (data, 0, sizeof (get_preferences_data_t));
2784 }
2785 
2789 typedef struct
2790 {
2794  char *format_id;
2795  char *alert_id;
2796  char *report_id;
2799  char *host_levels;
2803  char *type;
2804  char *host;
2805  char *pos;
2808 
2814 static void
2815 get_reports_data_reset (get_reports_data_t *data)
2816 {
2817  get_data_reset (&data->get);
2818  get_data_reset (&data->report_get);
2819  free (data->delta_report_id);
2820  free (data->format_id);
2821  free (data->alert_id);
2822  free (data->report_id);
2823  free (data->host_levels);
2824  free (data->host_search_phrase);
2825  free (data->type);
2826  free (data->host);
2827  free (data->pos);
2828 
2829  memset (data, 0, sizeof (get_reports_data_t));
2830 }
2831 
2835 typedef struct
2836 {
2838  int alerts;
2839  int params;
2841 
2847 static void
2848 get_report_formats_data_reset (get_report_formats_data_t *data)
2849 {
2850  get_data_reset (&data->get);
2851  memset (data, 0, sizeof (get_report_formats_data_t));
2852 }
2853 
2857 typedef struct
2858 {
2860  char *task_id;
2865 
2871 static void
2872 get_results_data_reset (get_results_data_t *data)
2873 {
2874  get_data_reset (&data->get);
2875  free (data->task_id);
2876 
2877  memset (data, 0, sizeof (get_results_data_t));
2878 }
2879 
2883 typedef struct
2884 {
2887 
2893 static void
2894 get_roles_data_reset (get_roles_data_t *data)
2895 {
2896  get_data_reset (&data->get);
2897  memset (data, 0, sizeof (get_roles_data_t));
2898 }
2899 
2903 typedef struct
2904 {
2906  int tasks;
2908 
2912 typedef struct
2913 {
2916 
2922 static void
2923 get_scanners_data_reset (get_scanners_data_t *data)
2924 {
2925  get_data_reset (&data->get);
2926 
2927  memset (data, 0, sizeof (get_scanners_data_t));
2928 }
2929 
2935 static void
2936 get_schedules_data_reset (get_schedules_data_t *data)
2937 {
2938  get_data_reset (&data->get);
2939  memset (data, 0, sizeof (get_schedules_data_t));
2940 }
2941 
2945 typedef struct
2946 {
2947  char *filter;
2948  int first;
2949  int max;
2950  char *sort_field;
2952  char *setting_id;
2954 
2960 static void
2961 get_settings_data_reset (get_settings_data_t *data)
2962 {
2963  free (data->filter);
2964  free (data->setting_id);
2965  free (data->sort_field);
2966 
2967  memset (data, 0, sizeof (get_settings_data_t));
2968 }
2969 
2973 typedef struct
2974 {
2975  int brief;
2976  char *name;
2977  char *duration;
2978  char *end_time;
2979  char *slave_id;
2980  char *start_time;
2982 
2988 static void
2989 get_system_reports_data_reset (get_system_reports_data_t *data)
2990 {
2991  free (data->name);
2992  free (data->duration);
2993  free (data->end_time);
2994  free (data->slave_id);
2995  free (data->start_time);
2996 
2997  memset (data, 0, sizeof (get_system_reports_data_t));
2998 }
2999 
3003 typedef struct
3004 {
3007 } get_tags_data_t;
3008 
3014 static void
3015 get_tags_data_reset (get_tags_data_t *data)
3016 {
3017  get_data_reset (&data->get);
3018  memset (data, 0, sizeof (get_tags_data_t));
3019 }
3020 
3024 typedef struct
3025 {
3027  int tasks;
3029 
3035 static void
3036 get_targets_data_reset (get_targets_data_t *data)
3037 {
3038  get_data_reset (&data->get);
3039  memset (data, 0, sizeof (get_targets_data_t));
3040 }
3041 
3045 typedef struct
3046 {
3049 
3053 static void
3054 get_users_data_reset (get_users_data_t * data)
3055 {
3056  get_data_reset (&data->get);
3057  memset (data, 0, sizeof (get_users_data_t));
3058 }
3059 
3063 typedef struct
3064 {
3065  char *comment;
3066  char *config_id;
3077  char *name;
3078  char *scanner_id;
3079  array_t *nvt_selection;
3086 
3090 typedef struct
3091 {
3095 
3101 static void
3102 get_tasks_data_reset (get_tasks_data_t *data)
3103 {
3104  get_data_reset (&data->get);
3105 
3106  memset (data, 0, sizeof (get_tasks_data_t));
3107 }
3108 
3112 typedef struct
3113 {
3114  char *format;
3115  char *type;
3116 } help_data_t;
3117 
3123 static void
3124 help_data_reset (help_data_t *data)
3125 {
3126  free (data->format);
3127  free (data->type);
3128 
3129  memset (data, 0, sizeof (help_data_t));
3130 }
3131 
3135 typedef struct
3136 {
3137  char *comment;
3138  char *name;
3139  char *agent_id;
3141 
3147 static void
3148 modify_agent_data_reset (modify_agent_data_t *data)
3149 {
3150  free (data->comment);
3151  free (data->name);
3152  free (data->agent_id);
3153 
3154  memset (data, 0, sizeof (modify_agent_data_t));
3155 }
3156 
3160 typedef struct
3161 {
3162  char *alert_id;
3163  char *name;
3164  char *comment;
3165  char *event;
3166  array_t *event_data;
3167  char *filter_id;
3168  char *condition;
3169  array_t *condition_data;
3170  char *method;
3171  array_t *method_data;
3172  char *part_data;
3173  char *part_name;
3175 
3181 static void
3182 modify_alert_data_reset (modify_alert_data_t *data)
3183 {
3184  free (data->alert_id);
3185  free (data->name);
3186  free (data->comment);
3187  free (data->filter_id);
3188  free (data->event);
3189  array_free (data->event_data);
3190  free (data->condition);
3191  array_free (data->condition_data);
3192  free (data->method);
3193  array_free (data->method_data);
3194 
3195  memset (data, 0, sizeof (modify_alert_data_t));
3196 }
3197 
3201 typedef struct
3202 {
3203  char *comment;
3204  char *asset_id;
3206 
3212 static void
3213 modify_asset_data_reset (modify_asset_data_t *data)
3214 {
3215  free (data->comment);
3216  free (data->asset_id);
3217 
3218  memset (data, 0, sizeof (modify_asset_data_t));
3219 }
3220 
3224 typedef struct
3225 {
3226  gchar *group_name;
3227  GSList *settings;
3228 } auth_group_t;
3229 
3233 typedef struct
3234 {
3235  gchar *key;
3236  gchar *value;
3237  GSList *groups;
3240 
3246 void
3248 {
3249  GSList *item, *subitem;
3250 
3251  g_free (data->key);
3252  g_free (data->value);
3253 
3254  item = data->groups;
3255  subitem = NULL;
3256  while (item)
3257  {
3258  auth_group_t *group = (auth_group_t *) item->data;
3259  g_free (group->group_name);
3260  /* Free settings. */
3261  subitem = group->settings;
3262  while (subitem)
3263  {
3264  auth_conf_setting_t *kvp = (auth_conf_setting_t *) subitem->data;
3265  g_free (kvp->key);
3266  g_free (kvp->value);
3267  g_free (kvp);
3268  subitem = g_slist_next (subitem);
3269  }
3270  item = g_slist_next (item);
3271  }
3272  g_slist_free (data->groups);
3273 
3274  if (data->curr_group_settings)
3275  {
3276  item = data->curr_group_settings;
3277  while (item)
3278  {
3279  /* Free settings. */
3280  auth_conf_setting_t *kvp = (auth_conf_setting_t *) item->data;
3281  g_free (kvp->key);
3282  g_free (kvp->value);
3283  g_free (kvp);
3284  item = g_slist_next (item);
3285  }
3286  g_slist_free (data->curr_group_settings);
3287  }
3288  memset (data, 0, sizeof (modify_auth_data_t));
3289 }
3290 
3296 static void
3297 modify_config_data_reset (modify_config_data_t *data)
3298 {
3299  free (data->comment);
3300  free (data->config_id);
3301  array_free (data->families_growing_empty);
3302  array_free (data->families_growing_all);
3303  array_free (data->families_static_all);
3304  free (data->family_selection_family_all_text);
3306  free (data->family_selection_family_name);
3307  free (data->family_selection_growing_text);
3308  free (data->name);
3309  free (data->scanner_id);
3310  array_free (data->nvt_selection);
3311  free (data->nvt_selection_family);
3312  free (data->nvt_selection_nvt_oid);
3313  free (data->preference_name);
3314  free (data->preference_nvt_oid);
3315  free (data->preference_value);
3316 
3317  memset (data, 0, sizeof (modify_config_data_t));
3318 }
3319 
3323 typedef struct
3324 {
3327  char *certificate;
3328  char *comment;
3329  char *community;
3331  int key;
3332  char *key_phrase;
3333  char *key_private;
3334  char *login;
3335  char *name;
3336  char *password;
3340 
3346 static void
3347 modify_credential_data_reset (modify_credential_data_t *data)
3348 {
3349  free (data->allow_insecure);
3350  free (data->auth_algorithm);
3351  free (data->certificate);
3352  free (data->comment);
3353  free (data->community);
3354  free (data->credential_id);
3355  free (data->key_phrase);
3356  free (data->key_private);
3357  free (data->login);
3358  free (data->name);
3359  free (data->password);
3360  free (data->privacy_algorithm);
3361  free (data->privacy_password);
3362 
3363  memset (data, 0, sizeof (modify_credential_data_t));
3364 }
3365 
3369 typedef struct
3370 {
3371  char *comment;
3372  char *name;
3373  char *filter_id;
3374  char *term;
3375  char *type;
3377 
3383 static void
3384 modify_filter_data_reset (modify_filter_data_t *data)
3385 {
3386  free (data->comment);
3387  free (data->name);
3388  free (data->filter_id);
3389  free (data->term);
3390  free (data->type);
3391 
3392  memset (data, 0, sizeof (modify_filter_data_t));
3393 }
3394 
3398 typedef struct
3399 {
3400  char *comment;
3401  char *name;
3402  char *group_id;
3403  char *users;
3405 
3411 static void
3412 modify_group_data_reset (modify_group_data_t *data)
3413 {
3414  free (data->comment);
3415  free (data->name);
3416  free (data->group_id);
3417  free (data->users);
3418 
3419  memset (data, 0, sizeof (modify_group_data_t));
3420 }
3421 
3425 typedef struct
3426 {
3427  char *comment;
3428  char *name;
3430  char *resource_id;
3433  char *subject_id;
3435 
3441 static void
3442 modify_permission_data_reset (modify_permission_data_t *data)
3443 {
3444  free (data->comment);
3445  free (data->name);
3446  free (data->resource_id);
3447  free (data->resource_type);
3448  free (data->permission_id);
3449  free (data->subject_type);
3450  free (data->subject_id);
3451 
3452  memset (data, 0, sizeof (modify_permission_data_t));
3453 }
3454 
3458 typedef struct
3459 {
3460  char *comment;
3461  char *name;
3464 
3470 static void
3471 modify_port_list_data_reset (modify_port_list_data_t *data)
3472 {
3473  free (data->comment);
3474  free (data->name);
3475  free (data->port_list_id);
3476 
3477  memset (data, 0, sizeof (modify_port_list_data_t));
3478 }
3479 
3483 typedef struct
3484 {
3485  char *comment;
3486  char *report_id;
3488 
3494 static void
3495 modify_report_data_reset (modify_report_data_t *data)
3496 {
3497  free (data->comment);
3498  free (data->report_id);
3499 
3500  memset (data, 0, sizeof (modify_report_data_t));
3501 }
3502 
3506 typedef struct
3507 {
3508  char *active;
3509  char *name;
3510  char *param_name;
3511  char *param_value;
3513  char *summary;
3515 
3521 static void
3522 modify_report_format_data_reset (modify_report_format_data_t *data)
3523 {
3524  free (data->active);
3525  free (data->name);
3526  free (data->param_name);
3527  free (data->param_value);
3528  free (data->report_format_id);
3529  free (data->summary);
3530 
3531  memset (data, 0, sizeof (modify_report_format_data_t));
3532 }
3533 
3537 typedef struct
3538 {
3539  char *comment;
3540  char *name;
3541  char *role_id;
3542  char *users;
3544 
3550 static void
3551 modify_role_data_reset (modify_role_data_t *data)
3552 {
3553  free (data->comment);
3554  free (data->name);
3555  free (data->role_id);
3556  free (data->users);
3557 
3558  memset (data, 0, sizeof (modify_role_data_t));
3559 }
3560 
3564 typedef struct
3565 {
3566  char *comment;
3567  char *name;
3568  char *host;
3569  char *port;
3570  char *type;
3571  char *scanner_id;
3572  char *ca_pub;
3575 
3581 static void
3582 modify_scanner_data_reset (modify_scanner_data_t *data)
3583 {
3584  g_free (data->comment);
3585  g_free (data->name);
3586  g_free (data->host);
3587  g_free (data->port);
3588  g_free (data->type);
3589  g_free (data->scanner_id);
3590  free (data->ca_pub);
3591  free (data->credential_id);
3592 
3593  memset (data, 0, sizeof (modify_scanner_data_t));
3594 }
3595 
3599 typedef struct
3600 {
3601  char *comment;
3602  char *name;
3603  char *schedule_id;
3609  char *period;
3610  char *period_unit;
3611  char *duration;
3613  char *timezone;
3615 
3621 static void
3622 modify_schedule_data_reset (modify_schedule_data_t *data)
3623 {
3624  free (data->comment);
3625  free (data->name);
3626  free (data->schedule_id);
3627  free (data->first_time_day_of_month);
3628  free (data->first_time_hour);
3629  free (data->first_time_minute);
3630  free (data->first_time_month);
3631  free (data->first_time_year);
3632  free (data->period);
3633  free (data->period_unit);
3634  free (data->duration);
3635  free (data->duration_unit);
3636  free (data->timezone);
3637 
3638  memset (data, 0, sizeof (modify_schedule_data_t));
3639 }
3640 
3644 typedef struct
3645 {
3646  char *tag_id;
3647  char *active;
3648  char *resource_id;
3650  char *comment;
3651  char *name;
3652  char *value;
3655 
3661 static void
3662 modify_tag_data_reset (modify_tag_data_t *data)
3663 {
3664  free (data->tag_id);
3665  free (data->active);
3666  free (data->resource_type);
3667  free (data->resource_id);
3668  free (data->comment);
3669  free (data->name);
3670  free (data->value);
3671 
3672  memset (data, 0, sizeof (modify_tag_data_t));
3673 }
3674 
3678 typedef struct
3679 {
3680  char *name;
3681  char *setting_id;
3682  char *value;
3684 
3690 static void
3691 modify_setting_data_reset (modify_setting_data_t *data)
3692 {
3693  free (data->name);
3694  free (data->setting_id);
3695  free (data->value);
3696 
3697  memset (data, 0, sizeof (modify_setting_data_t));
3698 }
3699 
3703 typedef struct
3704 {
3705  char *alive_tests;
3706  char *comment;
3710  char *hosts;
3711  char *name;
3715  char *ssh_port;
3722  char *target_id;
3724 
3730 static void
3731 modify_target_data_reset (modify_target_data_t *data)
3732 {
3733  free (data->alive_tests);
3734  free (data->exclude_hosts);
3735  free (data->reverse_lookup_only);
3736  free (data->reverse_lookup_unify);
3737  free (data->comment);
3738  free (data->hosts);
3739  free (data->name);
3740  free (data->port_list_id);
3741  free (data->ssh_credential_id);
3742  free (data->ssh_lsc_credential_id);
3743  free (data->ssh_port);
3744  free (data->ssh_lsc_port);
3745  free (data->smb_credential_id);
3746  free (data->smb_lsc_credential_id);
3747  free (data->esxi_credential_id);
3748  free (data->esxi_lsc_credential_id);
3749  free (data->snmp_credential_id);
3750  free (data->target_id);
3751 
3752  memset (data, 0, sizeof (modify_target_data_t));
3753 }
3754 
3758 typedef struct
3759 {
3760  char *action;
3761  char *alterable;
3762  char *comment;
3764  char *scanner_id;
3765  char *config_id;
3766  array_t *alerts;
3767  char *file;
3768  char *file_name;
3769  array_t *groups;
3770  char *name;
3771  char *observers;
3773  array_t *preferences;
3774  char *schedule_id;
3776  char *target_id;
3777  char *task_id;
3779 
3785 static void
3786 modify_task_data_reset (modify_task_data_t *data)
3787 {
3788  free (data->action);
3789  free (data->alterable);
3790  array_free (data->alerts);
3791  array_free (data->groups);
3792  free (data->comment);
3793  free (data->hosts_ordering);
3794  free (data->scanner_id);
3795  free (data->config_id);
3796  free (data->file);
3797  free (data->file_name);
3798  free (data->name);
3799  free (data->observers);
3800  if (data->preferences)
3801  {
3802  guint index = data->preferences->len;
3803  while (index--)
3804  {
3805  name_value_t *pair;
3806  pair = (name_value_t*) g_ptr_array_index (data->preferences, index);
3807  if (pair)
3808  {
3809  g_free (pair->name);
3810  g_free (pair->value);
3811  }
3812  }
3813  }
3814  array_free (data->preferences);
3815  free (data->schedule_id);
3816  free (data->schedule_periods);
3817  free (data->target_id);
3818  free (data->task_id);
3819 
3820  memset (data, 0, sizeof (modify_task_data_t));
3821 }
3822 
3826 typedef struct
3827 {
3828  char *active;
3829  char *hosts;
3830  char *note_id;
3831  char *nvt_oid;
3832  char *port;
3833  char *result_id;
3834  char *severity;
3835  char *task_id;
3836  char *text;
3837  char *threat;
3839 
3845 static void
3846 modify_note_data_reset (modify_note_data_t *data)
3847 {
3848  free (data->active);
3849  free (data->hosts);
3850  free (data->note_id);
3851  free (data->nvt_oid);
3852  free (data->port);
3853  free (data->result_id);
3854  free (data->severity);
3855  free (data->task_id);
3856  free (data->text);
3857  free (data->threat);
3858 
3859  memset (data, 0, sizeof (modify_note_data_t));
3860 }
3861 
3865 typedef struct
3866 {
3867  char *active;
3868  char *hosts;
3870  char *new_threat;
3871  char *nvt_oid;
3872  char *override_id;
3873  char *port;
3874  char *result_id;
3875  char *severity;
3876  char *task_id;
3877  char *text;
3878  char *threat;
3880 
3886 static void
3887 modify_override_data_reset (modify_override_data_t *data)
3888 {
3889  free (data->active);
3890  free (data->hosts);
3891  free (data->new_severity);
3892  free (data->new_threat);
3893  free (data->nvt_oid);
3894  free (data->override_id);
3895  free (data->port);
3896  free (data->result_id);
3897  free (data->severity);
3898  free (data->task_id);
3899  free (data->text);
3900  free (data->threat);
3901 
3902  memset (data, 0, sizeof (modify_override_data_t));
3903 }
3904 
3908 typedef struct
3909 {
3910  array_t *groups;
3912  gchar *hosts;
3914  char *ifaces;
3917  gchar *name;
3918  gchar *new_name;
3919  gchar *password;
3920  array_t *roles;
3921  array_t *sources;
3923  gchar *user_id;
3925 
3929 static void
3930 modify_user_data_reset (modify_user_data_t * data)
3931 {
3932  array_free (data->groups);
3933  g_free (data->name);
3934  g_free (data->new_name);
3935  g_free (data->user_id);
3936  g_free (data->password);
3937  g_free (data->hosts);
3938  g_free (data->ifaces);
3939  array_free (data->roles);
3940  if (data->sources)
3941  {
3942  array_free (data->sources);
3943  }
3944  g_free (data->current_source);
3945  memset (data, 0, sizeof (modify_user_data_t));
3946 }
3947 
3951 typedef struct
3952 {
3953  gchar *task_id;
3954  gchar *slave_id;
3956 
3962 static void
3963 move_task_data_reset (move_task_data_t *data)
3964 {
3965  g_free (data->task_id);
3966  g_free (data->slave_id);
3967 
3968  memset (data, 0, sizeof (move_task_data_t));
3969 }
3970 
3974 typedef struct
3975 {
3976  char *id;
3977 } restore_data_t;
3978 
3984 static void
3985 restore_data_reset (restore_data_t *data)
3986 {
3987  free (data->id);
3988 
3989  memset (data, 0, sizeof (restore_data_t));
3990 }
3991 
3995 typedef struct
3996 {
3997  char *task_id;
3999 
4005 static void
4006 resume_task_data_reset (resume_task_data_t *data)
4007 {
4008  free (data->task_id);
4009 
4010  memset (data, 0, sizeof (resume_task_data_t));
4011 }
4012 
4016 typedef struct
4017 {
4018  char *task_id;
4020 
4026 static void
4027 start_task_data_reset (start_task_data_t *data)
4028 {
4029  free (data->task_id);
4030 
4031  memset (data, 0, sizeof (start_task_data_t));
4032 }
4033 
4037 typedef struct
4038 {
4039  char *task_id;
4041 
4050 static void
4051 stop_task_data_reset (stop_task_data_t *data)
4052 {
4053  free (data->task_id);
4054 
4055  memset (data, 0, sizeof (stop_task_data_t));
4056 }
4057 
4061 typedef struct
4062 {
4063  char *config_id;
4065 
4071 static void
4072 sync_config_data_reset (sync_config_data_t *data)
4073 {
4074  g_free (data->config_id);
4075 
4076  memset (data, 0, sizeof (sync_config_data_t));
4077 }
4078 
4082 typedef struct
4083 {
4084  char *alert_id;
4086 
4092 static void
4093 test_alert_data_reset (test_alert_data_t *data)
4094 {
4095  free (data->alert_id);
4096 
4097  memset (data, 0, sizeof (test_alert_data_t));
4098 }
4099 
4103 typedef struct
4104 {
4105  char *agent_id;
4107 
4113 static void
4114 verify_agent_data_reset (verify_agent_data_t *data)
4115 {
4116  free (data->agent_id);
4117 
4118  memset (data, 0, sizeof (verify_agent_data_t));
4119 }
4120 
4124 typedef struct
4125 {
4128 
4134 static void
4135 verify_report_format_data_reset (verify_report_format_data_t *data)
4136 {
4137  free (data->report_format_id);
4138 
4139  memset (data, 0, sizeof (verify_report_format_data_t));
4140 }
4141 
4145 typedef struct
4146 {
4147  char *scanner_id;
4149 
4155 static void
4156 verify_scanner_data_reset (verify_scanner_data_t *data)
4157 {
4158  g_free (data->scanner_id);
4159 
4160  memset (data, 0, sizeof (verify_scanner_data_t));
4161 }
4162 
4166 typedef struct
4167 {
4168  char *mode;
4169  char *name;
4171  array_t *params;
4172  char *read_only;
4174 
4180 static void
4181 run_wizard_data_reset (run_wizard_data_t *data)
4182 {
4183  free (data->mode);
4184  free (data->name);
4185  free (data->read_only);
4186  if (data->params)
4187  {
4188  guint index = data->params->len;
4189  while (index--)
4190  {
4191  name_value_t *pair;
4192  pair = (name_value_t*) g_ptr_array_index (data->params, index);
4193  if (pair)
4194  {
4195  g_free (pair->name);
4196  g_free (pair->value);
4197  }
4198  }
4199  }
4200  array_free (data->params);
4201 
4202  memset (data, 0, sizeof (run_wizard_data_t));
4203 }
4204 
4208 typedef union
4209 {
4313 } command_data_t;
4314 
4318 static void
4319 command_data_init (command_data_t *data)
4320 {
4321  memset (data, 0, sizeof (command_data_t));
4322 }
4323 
4324 
4325 /* Global variables. */
4326 
4331 
4337 
4343 
4349 
4355 
4361 
4367 
4373 
4379 
4385 
4391 
4397 
4403 
4409 
4415 
4421 
4427 
4433 
4439 
4445 
4451 
4457 
4463 
4469 
4475 
4481 
4487 
4493 
4499 
4505 
4511 
4517 
4523 
4529 
4535 
4541 
4547 
4553 
4559 
4565 
4571 
4577 
4583 
4589 
4595 
4601 
4607 
4613 
4619 
4625 
4631 
4637 
4643 
4649 
4655 
4661 
4667 
4673 
4679 
4685 
4691 
4697 
4703 
4709 
4715 
4721 
4727 
4733 
4739 
4745 
4751 
4757 
4763 
4769 
4775 
4781 
4787 
4793 
4799 
4805 
4811 
4817 
4823 
4829 
4835 
4841 
4847 
4853 
4859 
4865 
4871 
4877 
4883 
4889 
4895 
4900 
4905 
4911 
4917 
4923 
4929 
4935 
4941 
4947 
4953 
4959 
4965 
4970 
4975 
4980 
4989 
4993 static GMarkupParseContext*
4994 xml_context = NULL;
4995 
4999 static GMarkupParser xml_parser;
5000 
5004 static const gchar *nvt_sync_script = SBINDIR "/greenbone-nvt-sync";
5005 
5009 static const gchar *scap_sync_script = SBINDIR "/greenbone-scapdata-sync";
5010 
5014 static const gchar *cert_sync_script = SBINDIR "/greenbone-certdata-sync";
5015 
5016 
5017 /* Client state. */
5018 
5022 typedef enum
5023 {
5026 
5086  /* get_configs_response (GCR) is used for config export. CLIENT_C_C is
5087  * for CLIENT_CREATE_CONFIG. */
5160  /* get_port_lists (GPL) is used for port lists export. CLIENT_CPL is
5161  * for CLIENT_CREATE_PORT_LIST. */
5181  /* CREATE_REPORT_FORMAT. */
5190  /* This is here to support importing of older report formats. */
5208  /* CREATE_REPORT. */
5214  /* RR_H is for RR_HOST because it clashes with entities like HOST_START. */
5625 } client_state_t;
5626 
5630 static client_state_t client_state = CLIENT_TOP;
5631 
5635 static void
5636 set_client_state (client_state_t state)
5637 {
5638  client_state = state;
5639  g_debug (" client state set: %i\n", client_state);
5640 }
5641 
5642 
5643 /* Communication. */
5644 
5654 static gboolean
5655 send_to_client (const char* msg,
5656  int (*user_send_to_client) (const char*, void*),
5657  void* user_send_to_client_data)
5658 {
5659  if (user_send_to_client && msg)
5660  return user_send_to_client (msg, user_send_to_client_data);
5661  return FALSE;
5662 }
5663 
5674 static gboolean
5675 send_element_error_to_client (const char* command, const char* element,
5676  int (*write_to_client) (const char*, void*),
5677  void* write_to_client_data)
5678 {
5679  gchar *msg;
5680  gboolean ret;
5681 
5683  msg = g_strdup_printf ("<%s_response status=\""
5685  "\" status_text=\"Bogus element: %s\"/>",
5686  command,
5687  element);
5688  ret = send_to_client (msg, write_to_client, write_to_client_data);
5689  g_free (msg);
5690  return ret;
5691 }
5692 
5703 static gboolean
5704 send_find_error_to_client (const char* command, const char* type,
5705  const char* id, omp_parser_t *omp_parser)
5706 {
5707  gchar *msg;
5708  gboolean ret;
5709 
5710  msg = g_strdup_printf ("<%s_response status=\""
5712  "\" status_text=\"Failed to find %s '%s'\"/>",
5713  command, type, id);
5714  ret = send_to_client (msg, omp_parser->client_writer,
5715  omp_parser->client_writer_data);
5716  g_free (msg);
5717  return ret;
5718 }
5719 
5725 static void
5726 error_send_to_client (GError** error)
5727 {
5728  g_debug (" send_to_client out of space in to_client\n");
5729  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
5730  "Manager out of space for reply to client.");
5731 }
5732 
5738 static void
5739 internal_error_send_to_client (GError** error)
5740 {
5741  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
5742  "Internal Error.");
5743 }
5744 
5745 
5746 /* XML parser handlers. */
5747 
5754 #define XML_ERROR_SYNTAX(tag, text) \
5755  "<" tag "_response" \
5756  " status=\"" STATUS_ERROR_SYNTAX "\"" \
5757  " status_text=\"" text "\"/>"
5758 
5772 static char *
5773 make_xml_error_syntax (const char *tag, const char *text)
5774 {
5775  char *textbuf;
5776  char *ret;
5777 
5778  textbuf = g_markup_escape_text (text, -1);
5779  ret = g_strdup_printf ("<%s_response status=\"" STATUS_ERROR_SYNTAX "\""
5780  " status_text=\"%s\"/>", tag, textbuf);
5781  g_free (textbuf);
5782  return ret;
5783 }
5784 
5785 
5791 #define XML_ERROR_ACCESS(tag) \
5792  "<" tag "_response" \
5793  " status=\"" STATUS_ERROR_ACCESS "\"" \
5794  " status_text=\"" STATUS_ERROR_ACCESS_TEXT "\"/>"
5795 
5802 #define XML_ERROR_UNAVAILABLE(tag, text) \
5803  "<" tag "_response" \
5804  " status=\"" STATUS_SERVICE_UNAVAILABLE "\"" \
5805  " status_text=\"" text "\"/>"
5806 
5812 #define XML_ERROR_MISSING(tag) \
5813  "<" tag "_response" \
5814  " status=\"" STATUS_ERROR_MISSING "\"" \
5815  " status_text=\"" STATUS_ERROR_MISSING_TEXT "\"/>"
5816 
5822 #define XML_ERROR_AUTH_FAILED(tag) \
5823  "<" tag "_response" \
5824  " status=\"" STATUS_ERROR_AUTH_FAILED "\"" \
5825  " status_text=\"" STATUS_ERROR_AUTH_FAILED_TEXT "\"/>"
5826 
5832 #define XML_ERROR_BUSY(tag) \
5833  "<" tag "_response" \
5834  " status=\"" STATUS_ERROR_BUSY "\"" \
5835  " status_text=\"" STATUS_ERROR_BUSY_TEXT "\"/>"
5836 
5842 #define XML_OK(tag) \
5843  "<" tag "_response" \
5844  " status=\"" STATUS_OK "\"" \
5845  " status_text=\"" STATUS_OK_TEXT "\"/>"
5846 
5852 #define XML_OK_CREATED(tag) \
5853  "<" tag "_response" \
5854  " status=\"" STATUS_OK_CREATED "\"" \
5855  " status_text=\"" STATUS_OK_CREATED_TEXT "\"/>"
5856 
5862 #define XML_OK_CREATED_ID(tag) \
5863  "<" tag "_response" \
5864  " status=\"" STATUS_OK_CREATED "\"" \
5865  " status_text=\"" STATUS_OK_CREATED_TEXT "\"" \
5866  " id=\"%s\"/>"
5867 
5873 #define XML_OK_REQUESTED(tag) \
5874  "<" tag "_response" \
5875  " status=\"" STATUS_OK_REQUESTED "\"" \
5876  " status_text=\"" STATUS_OK_REQUESTED_TEXT "\"/>"
5877 
5883 #define XML_INTERNAL_ERROR(tag) \
5884  "<" tag "_response" \
5885  " status=\"" STATUS_INTERNAL_ERROR "\"" \
5886  " status_text=\"" STATUS_INTERNAL_ERROR_TEXT "\"/>"
5887 
5893 #define SEND_XML_SERVICE_DOWN(tag) \
5894  do { \
5895  char *str; \
5896  if (scanner_current_loading && scanner_total_loading) \
5897  str = g_strdup_printf ("<%s_response status='%s' " \
5898  "status_text='Scanner loading nvts (%d/%d)'/>", \
5899  tag, STATUS_SERVICE_DOWN, \
5900  scanner_current_loading, scanner_total_loading); \
5901  else \
5902  str = g_strdup_printf ("<%s_response status='%s' status_text='%s'/>", \
5903  tag, STATUS_SERVICE_DOWN, \
5904  STATUS_SERVICE_DOWN_TEXT); \
5905  SEND_TO_CLIENT_OR_FAIL(str); \
5906  g_free (str); \
5907  } while (0);
5908 
5918 int
5919 send_get_start (const char *type, int (*write_to_client) (const char*, void*),
5920  void* write_to_client_data)
5921 {
5922  gchar *msg;
5923 
5924  if (strcmp (type, "info"))
5925  msg = g_markup_printf_escaped ("<get_%ss_response"
5926  " status=\"" STATUS_OK "\""
5927  " status_text=\"" STATUS_OK_TEXT "\">",
5928  type);
5929  else
5930  msg = g_markup_printf_escaped ("<get_%s_response"
5931  " status=\"" STATUS_OK "\""
5932  " status_text=\"" STATUS_OK_TEXT "\">",
5933  type);
5934 
5935 
5936  if (send_to_client (msg, write_to_client, write_to_client_data))
5937  {
5938  g_free (msg);
5939  return 1;
5940  }
5941  g_free (msg);
5942  return 0;
5943 }
5944 
5958 int
5959 send_get_common (const char *type, get_data_t *get, iterator_t *iterator,
5960  int (*write_to_client) (const char *, void*),
5961  void* write_to_client_data, int writable, int in_use)
5962 {
5963  GString *buffer;
5964  const char *tag_type;
5965  iterator_t tags;
5966 
5967  buffer = g_string_new ("");
5968 
5969  buffer_xml_append_printf (buffer,
5970  "<%s id=\"%s\">"
5971  "<owner><name>%s</name></owner>"
5972  "<name>%s</name>"
5973  "<comment>%s</comment>"
5974  "<creation_time>%s</creation_time>"
5975  "<modification_time>%s</modification_time>"
5976  "<writable>%i</writable>"
5977  "<in_use>%i</in_use>"
5978  "<permissions>",
5979  type,
5982  : "",
5985  : "",
5988  : "",
5991  : "",
5994  : "",
5997  : "",
5998  writable,
5999  in_use);
6000 
6001  if (/* The user is the owner. */
6002  (current_credentials.username
6004  && (strcmp (get_iterator_owner_name (iterator),
6005  current_credentials.username)
6006  == 0))
6007  /* Or the user is effectively the owner. */
6010  /* Or the user has Admin rights and the resource is a permission or a
6011  * report format... */
6012  || (current_credentials.uuid
6013  && (((strcmp (type, "permission") == 0)
6014  || (strcmp (type, "report_format") == 0))
6016  /* ... but not the special Admin permission. */
6019  {
6020  buffer_xml_append_printf (buffer,
6021  "<permission>"
6022  "<name>Everything</name>"
6023  "</permission>"
6024  "</permissions>");
6025  }
6026  else if (current_credentials.uuid
6027  && ((strcmp (type, "user") == 0)
6028  || (strcmp (type, "role") == 0)
6029  || (strcmp (type, "group") == 0))
6030  && (get_iterator_owner (iterator) == 0)
6032  {
6033  if ((strcmp (type, "user") == 0)
6035  && strcmp (get_iterator_uuid (iterator), current_credentials.uuid))
6036  {
6037  /* Resource is the Super Admin. */
6038  buffer_xml_append_printf (buffer,
6039  "<permission><name>get_users</name></permission>"
6040  "</permissions>");
6041  }
6042  else
6043  /* The user has admin rights and it's a global user/role/group.
6044  *
6045  * These are left over from before users/roles/groups had owners. */
6046  buffer_xml_append_printf (buffer,
6047  "<permission>"
6048  "<name>Everything</name>"
6049  "</permission>"
6050  "</permissions>");
6051  }
6052  else
6053  {
6054  iterator_t perms;
6055  get_data_t perms_get;
6056 
6057  memset (&perms_get, '\0', sizeof (perms_get));
6058  perms_get.filter = g_strdup_printf ("resource_uuid=%s"
6059  " owner=any"
6060  " permission=any",
6062  init_permission_iterator (&perms, &perms_get);
6063  g_free (perms_get.filter);
6064  while (next (&perms))
6065  buffer_xml_append_printf (buffer,
6066  "<permission><name>%s</name></permission>",
6067  get_iterator_name (&perms));
6068  cleanup_iterator (&perms);
6069 
6070  buffer_xml_append_printf (buffer, "</permissions>");
6071  }
6072 
6073  tag_type = get->subtype ? get->subtype : get->type;
6074 
6075  if (get->details || get->id)
6076  {
6077  buffer_xml_append_printf (buffer,
6078  "<user_tags>"
6079  "<count>%i</count>",
6080  resource_tag_count (tag_type,
6082  (iterator),
6083  1));
6084 
6085  init_resource_tag_iterator (&tags, tag_type,
6087  1, NULL, 1);
6088 
6089  while (next (&tags))
6090  {
6091  buffer_xml_append_printf (buffer,
6092  "<tag id=\"%s\">"
6093  "<name>%s</name>"
6094  "<value>%s</value>"
6095  "<comment>%s</comment>"
6096  "</tag>",
6101  }
6102 
6103  cleanup_iterator (&tags);
6104 
6105  buffer_xml_append_printf (buffer,
6106  "</user_tags>");
6107  }
6108  else
6109  {
6110  buffer_xml_append_printf (buffer,
6111  "<user_tags>"
6112  "<count>%i</count>"
6113  "</user_tags>",
6114  resource_tag_count (tag_type,
6116  (iterator),
6117  1));
6118  }
6119 
6120  if (send_to_client (buffer->str, write_to_client, write_to_client_data))
6121  {
6122  g_string_free (buffer, TRUE);
6123  return 1;
6124  }
6125  g_string_free (buffer, TRUE);
6126  return 0;
6127 }
6128 
6137 int
6138 buffer_get_filter_xml (GString *msg, const char* type,
6139  const get_data_t *get, const char* filter_term,
6140  const char *extra_xml)
6141 {
6142  keyword_t **point;
6143  array_t *split;
6144  filter_t filter;
6145 
6146  buffer_xml_append_printf (msg,
6147  "<filters id=\"%s\">"
6148  "<term>%s</term>",
6149  get->filt_id ? get->filt_id : "",
6150  filter_term);
6151 
6152  if (get->filt_id
6153  && strcmp (get->filt_id, "")
6154  && (find_filter (get->filt_id, &filter) == 0)
6155  && filter != 0)
6156  buffer_xml_append_printf (msg,
6157  "<name>%s</name>",
6158  filter_name (filter));
6159 
6160  if (extra_xml)
6161  g_string_append (msg, extra_xml);
6162 
6163  buffer_xml_append_printf (msg,
6164  "<keywords>");
6165 
6166  split = split_filter (filter_term);
6167  point = (keyword_t**) split->pdata;
6168  while (*point)
6169  {
6170  keyword_t *keyword;
6171  keyword = *point;
6172  buffer_xml_append_printf (msg,
6173  "<keyword>"
6174  "<column>%s</column>"
6175  "<relation>%s</relation>"
6176  "<value>%s%s%s</value>"
6177  "</keyword>",
6178  keyword->column ? keyword->column : "",
6179  keyword->equal
6180  ? "="
6182  keyword->quoted ? "\"" : "",
6183  keyword->string ? keyword->string : "",
6184  keyword->quoted ? "\"" : "");
6185  point++;
6186  }
6187  filter_free (split);
6188 
6189  buffer_xml_append_printf (msg,
6190  "</keywords>"
6191  "</filters>");
6192  return 0;
6193 }
6194 
6207 int
6208 send_get_end_internal (const char *type, get_data_t *get, int get_counts,
6209  int count, int filtered, int full,
6210  int (*write_to_client) (const char *, void*),
6211  void* write_to_client_data)
6212 {
6213  gchar *sort_field, *filter;
6214  int first, max, sort_order;
6215  GString *type_many, *msg;
6216 
6217  if (get->filt_id && strcmp (get->filt_id, "0"))
6218  {
6219  if (get->filter_replacement)
6220  filter = g_strdup (get->filter_replacement);
6221  else
6222  filter = filter_term (get->filt_id);
6223  if (filter == NULL)
6224  return 2;
6225  }
6226  else
6227  filter = NULL;
6228 
6229  manage_filter_controls (filter ? filter : get->filter,
6230  &first, &max, &sort_field, &sort_order);
6231 
6232  if (get->ignore_pagination
6233  && (strcmp (type, "task") == 0))
6234  {
6235  first = 1;
6236  max = -1;
6237  }
6238 
6239  max = manage_max_rows (max);
6240 
6241  if (filter || get->filter)
6242  {
6243  gchar *new_filter;
6244  new_filter = manage_clean_filter (filter ? filter : get->filter);
6245  g_free (filter);
6246  if ((strcmp (type, "task") == 0)
6247  || (strcmp (type, "report") == 0)
6248  || (strcmp (type, "result") == 0))
6249  {
6250  gchar *value;
6251 
6252  value = filter_term_value (new_filter, "min_qod");
6253  if (value == NULL)
6254  {
6255  filter = new_filter;
6256  new_filter = g_strdup_printf ("min_qod=%i %s",
6258  filter);
6259  g_free (filter);
6260  }
6261  g_free (value);
6262 
6263  value = filter_term_value (new_filter, "apply_overrides");
6264  if (value == NULL)
6265  {
6266  filter = new_filter;
6267  new_filter = g_strdup_printf ("apply_overrides=%i %s",
6269  filter);
6270  g_free (filter);
6271  }
6272  g_free (value);
6273  }
6274  filter = new_filter;
6275  }
6276  else
6277  {
6278  if ((strcmp (type, "task") == 0)
6279  || (strcmp (type, "report") == 0)
6280  || (strcmp (type, "result") == 0))
6281  filter = manage_clean_filter("apply_overrides="
6282  G_STRINGIFY (APPLY_OVERRIDES_DEFAULT)
6283  " min_qod="
6284  G_STRINGIFY (MIN_QOD_DEFAULT));
6285  else
6286  filter = manage_clean_filter ("");
6287  }
6288 
6289  type_many = g_string_new (type);
6290 
6291  if (strcmp (type, "info") != 0)
6292  g_string_append (type_many, "s");
6293 
6294  msg = g_string_new ("");
6295 
6296  buffer_get_filter_xml (msg, type, get, filter, NULL);
6297 
6298  buffer_xml_append_printf (msg,
6299  "<sort>"
6300  "<field>%s<order>%s</order></field>"
6301  "</sort>"
6302  "<%s start=\"%i\" max=\"%i\"/>",
6303  sort_field,
6304  sort_order ? "ascending" : "descending",
6305  type_many->str,
6306  first,
6307  max);
6308  if (get_counts)
6309  buffer_xml_append_printf (msg,
6310  "<%s_count>"
6311  "%i"
6312  "<filtered>%i</filtered>"
6313  "<page>%i</page>"
6314  "</%s_count>",
6315  type,
6316  full,
6317  filtered,
6318  count,
6319  type);
6320  buffer_xml_append_printf (msg,
6321  "</get_%s_response>",
6322  type_many->str);
6323  g_string_free (type_many, TRUE);
6324  g_free (sort_field);
6325  g_free (filter);
6326 
6327  if (send_to_client (msg->str, write_to_client, write_to_client_data))
6328  {
6329  g_string_free (msg, TRUE);
6330  return 1;
6331  }
6332  g_string_free (msg, TRUE);
6333  return 0;
6334 }
6335 
6347 int
6348 send_get_end (const char *type, get_data_t *get, int count, int filtered,
6349  int full, int (*write_to_client) (const char *, void*),
6350  void* write_to_client_data)
6351 {
6352  return send_get_end_internal (type, get, 1, count, filtered, full,
6353  write_to_client, write_to_client_data);
6354 }
6355 
6367 int
6368 send_get_end_no_counts (const char *type, get_data_t *get,
6369  int (*write_to_client) (const char *, void*),
6370  void* write_to_client_data)
6371 {
6372  return send_get_end_internal (type, get, 0, 0, 0, 0, write_to_client,
6373  write_to_client_data);
6374 }
6375 
6382 #define SEND_GET_START(type) \
6383  do \
6384  { \
6385  if (send_get_start (type, omp_parser->client_writer, \
6386  omp_parser->client_writer_data)) \
6387  { \
6388  error_send_to_client (error); \
6389  return; \
6390  } \
6391  } \
6392  while (0)
6393 
6401 #define SEND_GET_COMMON(type, get, iterator) \
6402  do \
6403  { \
6404  if (send_get_common (G_STRINGIFY (type), get, iterator, \
6405  omp_parser->client_writer, \
6406  omp_parser->client_writer_data, \
6407  (get)->trash \
6408  ? trash_ ## type ## _writable \
6409  (get_iterator_resource \
6410  (iterator)) \
6411  : type ## _writable \
6412  (get_iterator_resource \
6413  (iterator)), \
6414  (get)->trash \
6415  ? trash_ ## type ## _in_use \
6416  (get_iterator_resource \
6417  (iterator)) \
6418  : type ## _in_use \
6419  (get_iterator_resource \
6420  (iterator)))) \
6421  { \
6422  error_send_to_client (error); \
6423  return; \
6424  } \
6425  } \
6426  while (0)
6427 
6434 #define SEND_GET_END(type, get, count, filtered) \
6435  do \
6436  { \
6437  if (send_get_end (type, get, count, filtered, \
6438  resource_count (type, get), \
6439  omp_parser->client_writer, \
6440  omp_parser->client_writer_data)) \
6441  { \
6442  error_send_to_client (error); \
6443  return; \
6444  } \
6445  } \
6446  while (0)
6447 
6456 #define SEND_TO_CLIENT_OR_FAIL(msg) \
6457  do \
6458  { \
6459  if (send_to_client (msg, omp_parser->client_writer, \
6460  omp_parser->client_writer_data)) \
6461  { \
6462  error_send_to_client (error); \
6463  return; \
6464  } \
6465  } \
6466  while (0)
6467 
6477 #define SENDF_TO_CLIENT_OR_FAIL(format, args...) \
6478  do \
6479  { \
6480  gchar* msg = g_markup_printf_escaped (format , ## args); \
6481  if (send_to_client (msg, omp_parser->client_writer, \
6482  omp_parser->client_writer_data)) \
6483  { \
6484  g_free (msg); \
6485  error_send_to_client (error); \
6486  return; \
6487  } \
6488  g_free (msg); \
6489  } \
6490  while (0)
6491 
6500 #define ELSE_ERROR(op) \
6501  else if (omp_parser->importing) \
6502  { \
6503  if (omp_parser->read_over == 0) \
6504  { \
6505  omp_parser->read_over = 1; \
6506  omp_parser->parent_state = client_state; \
6507  } \
6508  } \
6509  else \
6510  { \
6511  if (send_element_error_to_client (op, element_name, \
6512  write_to_client, \
6513  write_to_client_data)) \
6514  { \
6515  error_send_to_client (error); \
6516  return; \
6517  } \
6518  set_client_state (CLIENT_AUTHENTIC); \
6519  g_set_error (error, \
6520  G_MARKUP_ERROR, \
6521  G_MARKUP_ERROR_UNKNOWN_ELEMENT, \
6522  "Error"); \
6523  } \
6524  break
6525 
6530 #define ELSE_ERROR_CREATE_TASK() \
6531  else if (omp_parser->importing) \
6532  { \
6533  if (omp_parser->read_over == 0) \
6534  { \
6535  omp_parser->read_over = 1; \
6536  omp_parser->parent_state = client_state; \
6537  } \
6538  } \
6539  else \
6540  { \
6541  request_delete_task (&create_task_data->task); \
6542  if (send_element_error_to_client ("create_task", element_name, \
6543  write_to_client, \
6544  write_to_client_data)) \
6545  { \
6546  error_send_to_client (error); \
6547  return; \
6548  } \
6549  set_client_state (CLIENT_AUTHENTIC); \
6550  g_set_error (error, \
6551  G_MARKUP_ERROR, \
6552  G_MARKUP_ERROR_UNKNOWN_ELEMENT, \
6553  "Error"); \
6554  } \
6555  break
6556 
6566 static void
6567 log_event_internal (const char *type, const char *type_name, const char *id,
6568  const char *action, int fail)
6569 {
6570  gchar *domain;
6571 
6572  domain = g_strdup_printf ("event %s", type);
6573 
6574  if (id)
6575  {
6576  char *name;
6577 
6578  if (manage_resource_name (type, id, &name))
6579  name = NULL;
6580  else if ((name == NULL)
6581  && manage_trash_resource_name (type, id, &name))
6582  name = NULL;
6583 
6584  if (name)
6585  g_log (domain, G_LOG_LEVEL_MESSAGE,
6586  "%s %s (%s) %s %s by %s",
6587  type_name, name, id,
6588  fail ? "could not be" : "has been",
6589  action,
6590  current_credentials.username);
6591  else
6592  g_log (domain, G_LOG_LEVEL_MESSAGE,
6593  "%s %s %s %s by %s",
6594  type_name, id,
6595  fail ? "could not be" : "has been",
6596  action,
6597  current_credentials.username);
6598 
6599  free (name);
6600  }
6601  else
6602  g_log (domain, G_LOG_LEVEL_MESSAGE,
6603  "%s %s %s by %s",
6604  type_name,
6605  fail ? "could not be" : "has been",
6606  action,
6607  current_credentials.username);
6608 
6609  g_free (domain);
6610 }
6611 
6620 static void
6621 log_event (const char *type, const char *type_name, const char *id,
6622  const char *action)
6623 {
6624  log_event_internal (type, type_name, id, action, 0);
6625 }
6626 
6635 static void
6636 log_event_fail (const char *type, const char *type_name, const char *id,
6637  const char *action)
6638 {
6639  log_event_internal (type, type_name, id, action, 1);
6640 }
6641 
6660 static void
6661 omp_xml_handle_start_element (/* unused */ GMarkupParseContext* context,
6662  const gchar *element_name,
6663  const gchar **attribute_names,
6664  const gchar **attribute_values,
6665  gpointer user_data,
6666  GError **error)
6667 {
6668  omp_parser_t *omp_parser = (omp_parser_t*) user_data;
6669  int (*write_to_client) (const char *, void*)
6670  = (int (*) (const char *, void*)) omp_parser->client_writer;
6671  void* write_to_client_data = (void*) omp_parser->client_writer_data;
6672 
6673  g_debug (" XML start: %s (%i)\n", element_name, client_state);
6674 
6675  if (omp_parser->read_over)
6676  omp_parser->read_over++;
6677  else switch (client_state)
6678  {
6679  case CLIENT_TOP:
6680  if (strcasecmp ("GET_VERSION", element_name) == 0)
6681  {
6682  set_client_state (CLIENT_GET_VERSION);
6683  break;
6684  }
6685  /* fallthrough */
6686  case CLIENT_COMMANDS:
6687  if (strcasecmp ("AUTHENTICATE", element_name) == 0)
6688  {
6689  set_client_state (CLIENT_AUTHENTICATE);
6690  }
6691  else if (strcasecmp ("COMMANDS", element_name) == 0)
6692  {
6693  SENDF_TO_CLIENT_OR_FAIL
6694  ("<commands_response"
6695  " status=\"" STATUS_OK "\" status_text=\"" STATUS_OK_TEXT "\">");
6696  set_client_state (CLIENT_COMMANDS);
6697  }
6698  else
6699  {
6701  if (send_to_client
6702  (XML_ERROR_SYNTAX ("omp",
6703  "First command must be AUTHENTICATE,"
6704  " COMMANDS or GET_VERSION"),
6705  write_to_client,
6706  write_to_client_data))
6707  {
6708  error_send_to_client (error);
6709  return;
6710  }
6711  if (client_state == CLIENT_COMMANDS)
6712  send_to_client ("</commands_response>",
6713  write_to_client,
6714  write_to_client_data);
6715  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
6716  "Must authenticate first.");
6717  }
6718  break;
6719 
6720  case CLIENT_AUTHENTIC:
6722  if (command_disabled (omp_parser, element_name))
6723  {
6724  SEND_TO_CLIENT_OR_FAIL
6725  (XML_ERROR_UNAVAILABLE ("omp",
6726  "Service unavailable: Command disabled"));
6727  g_set_error (error,
6728  G_MARKUP_ERROR,
6729  G_MARKUP_ERROR_UNKNOWN_ELEMENT,
6730  "Command Unavailable");
6731  }
6732  else if (strcasecmp ("AUTHENTICATE", element_name) == 0)
6733  {
6734  if (save_tasks ()) abort ();
6735  free_tasks ();
6736  free_credentials (&current_credentials);
6737  set_client_state (CLIENT_AUTHENTICATE);
6738  }
6739  else if (strcasecmp ("COMMANDS", element_name) == 0)
6740  {
6741  SEND_TO_CLIENT_OR_FAIL
6742  ("<commands_response"
6743  " status=\"" STATUS_OK "\" status_text=\"" STATUS_OK_TEXT "\">");
6744  set_client_state (CLIENT_AUTHENTIC_COMMANDS);
6745  }
6746  else if (strcasecmp ("CREATE_AGENT", element_name) == 0)
6747  {
6748  openvas_append_string (&create_agent_data->comment, "");
6749  openvas_append_string (&create_agent_data->installer, "");
6750  openvas_append_string (&create_agent_data->installer_filename, "");
6751  openvas_append_string (&create_agent_data->installer_signature, "");
6752  openvas_append_string (&create_agent_data->howto_install, "");
6753  openvas_append_string (&create_agent_data->howto_use, "");
6754  set_client_state (CLIENT_CREATE_AGENT);
6755  }
6756  else if (strcasecmp ("CREATE_ASSET", element_name) == 0)
6757  set_client_state (CLIENT_CREATE_ASSET);
6758  else if (strcasecmp ("CREATE_CONFIG", element_name) == 0)
6759  {
6760  openvas_append_string (&create_config_data->comment, "");
6761  openvas_append_string (&create_config_data->name, "");
6762  set_client_state (CLIENT_CREATE_CONFIG);
6763  }
6764  else if (strcasecmp ("CREATE_ALERT", element_name) == 0)
6765  {
6766  create_alert_data->condition_data = make_array ();
6767  create_alert_data->event_data = make_array ();
6768  create_alert_data->method_data = make_array ();
6769 
6770  openvas_append_string (&create_alert_data->part_data, "");
6771  openvas_append_string (&create_alert_data->part_name, "");
6772  openvas_append_string (&create_alert_data->comment, "");
6773  openvas_append_string (&create_alert_data->name, "");
6774  openvas_append_string (&create_alert_data->condition, "");
6775  openvas_append_string (&create_alert_data->method, "");
6776  openvas_append_string (&create_alert_data->event, "");
6777 
6778  set_client_state (CLIENT_CREATE_ALERT);
6779  }
6780  else if (strcasecmp ("CREATE_CREDENTIAL", element_name) == 0)
6781  {
6782  openvas_append_string (&create_credential_data->comment, "");
6783  openvas_append_string (&create_credential_data->name, "");
6784  set_client_state (CLIENT_CREATE_CREDENTIAL);
6785  }
6786  else if (strcasecmp ("CREATE_FILTER", element_name) == 0)
6787  {
6788  openvas_append_string (&create_filter_data->comment, "");
6789  openvas_append_string (&create_filter_data->term, "");
6790  set_client_state (CLIENT_CREATE_FILTER);
6791  }
6792  else if (strcasecmp ("CREATE_GROUP", element_name) == 0)
6793  {
6794  openvas_append_string (&create_group_data->users, "");
6795  set_client_state (CLIENT_CREATE_GROUP);
6796  }
6797  else if (strcasecmp ("CREATE_ROLE", element_name) == 0)
6798  {
6799  openvas_append_string (&create_role_data->users, "");
6800  set_client_state (CLIENT_CREATE_ROLE);
6801  }
6802  else if (strcasecmp ("CREATE_NOTE", element_name) == 0)
6803  set_client_state (CLIENT_CREATE_NOTE);
6804  else if (strcasecmp ("CREATE_OVERRIDE", element_name) == 0)
6805  set_client_state (CLIENT_CREATE_OVERRIDE);
6806  else if (strcasecmp ("CREATE_PORT_LIST", element_name) == 0)
6807  set_client_state (CLIENT_CREATE_PORT_LIST);
6808  else if (strcasecmp ("CREATE_PORT_RANGE", element_name) == 0)
6809  set_client_state (CLIENT_CREATE_PORT_RANGE);
6810  else if (strcasecmp ("CREATE_PERMISSION", element_name) == 0)
6811  {
6812  openvas_append_string (&create_permission_data->comment, "");
6813  set_client_state (CLIENT_CREATE_PERMISSION);
6814  }
6815  else if (strcasecmp ("CREATE_REPORT", element_name) == 0)
6816  set_client_state (CLIENT_CREATE_REPORT);
6817  else if (strcasecmp ("CREATE_REPORT_FORMAT", element_name) == 0)
6818  set_client_state (CLIENT_CREATE_REPORT_FORMAT);
6819  else if (strcasecmp ("CREATE_SCANNER", element_name) == 0)
6820  set_client_state (CLIENT_CREATE_SCANNER);
6821  else if (strcasecmp ("CREATE_SCHEDULE", element_name) == 0)
6822  set_client_state (CLIENT_CREATE_SCHEDULE);
6823  else if (strcasecmp ("CREATE_TAG", element_name) == 0)
6824  {
6825  set_client_state (CLIENT_CREATE_TAG);
6826  }
6827  else if (strcasecmp ("CREATE_TARGET", element_name) == 0)
6828  {
6829  openvas_append_string (&create_target_data->comment, "");
6830  set_client_state (CLIENT_CREATE_TARGET);
6831  }
6832  else if (strcasecmp ("CREATE_TASK", element_name) == 0)
6833  {
6834  create_task_data->task = make_task (NULL, NULL, 1, 1);
6835  create_task_data->alerts = make_array ();
6836  create_task_data->groups = make_array ();
6837  set_client_state (CLIENT_CREATE_TASK);
6838  }
6839  else if (strcasecmp ("CREATE_USER", element_name) == 0)
6840  {
6841  set_client_state (CLIENT_CREATE_USER);
6842  create_user_data->groups = make_array ();
6843  create_user_data->roles = make_array ();
6846  }
6847  else if (strcasecmp ("DELETE_AGENT", element_name) == 0)
6848  {
6849  const gchar* attribute;
6850  append_attribute (attribute_names, attribute_values,
6851  "agent_id", &delete_agent_data->agent_id);
6852  if (find_attribute (attribute_names, attribute_values,
6853  "ultimate", &attribute))
6854  delete_agent_data->ultimate = strcmp (attribute, "0");
6855  else
6857  set_client_state (CLIENT_DELETE_AGENT);
6858  }
6859  else if (strcasecmp ("DELETE_ASSET", element_name) == 0)
6860  {
6861  append_attribute (attribute_names, attribute_values, "asset_id",
6863  append_attribute (attribute_names, attribute_values, "report_id",
6865  set_client_state (CLIENT_DELETE_ASSET);
6866  }
6867  else if (strcasecmp ("DELETE_CONFIG", element_name) == 0)
6868  {
6869  const gchar* attribute;
6870  append_attribute (attribute_names, attribute_values,
6871  "config_id", &delete_config_data->config_id);
6872  if (find_attribute (attribute_names, attribute_values,
6873  "ultimate", &attribute))
6874  delete_config_data->ultimate = strcmp (attribute, "0");
6875  else
6877  set_client_state (CLIENT_DELETE_CONFIG);
6878  }
6879  else if (strcasecmp ("DELETE_ALERT", element_name) == 0)
6880  {
6881  const gchar* attribute;
6882  append_attribute (attribute_names, attribute_values,
6883  "alert_id",
6885  if (find_attribute (attribute_names, attribute_values,
6886  "ultimate", &attribute))
6887  delete_alert_data->ultimate = strcmp (attribute, "0");
6888  else
6890  set_client_state (CLIENT_DELETE_ALERT);
6891  }
6892  else if (strcasecmp ("DELETE_CREDENTIAL", element_name) == 0)
6893  {
6894  const gchar* attribute;
6895  append_attribute (attribute_names, attribute_values,
6896  "credential_id",
6898  if (find_attribute (attribute_names, attribute_values,
6899  "ultimate", &attribute))
6901  = strcmp (attribute, "0");
6902  else
6904  set_client_state (CLIENT_DELETE_CREDENTIAL);
6905  }
6906  else if (strcasecmp ("DELETE_FILTER", element_name) == 0)
6907  {
6908  const gchar* attribute;
6909  append_attribute (attribute_names, attribute_values, "filter_id",
6911  if (find_attribute (attribute_names, attribute_values,
6912  "ultimate", &attribute))
6913  delete_filter_data->ultimate = strcmp (attribute, "0");
6914  else
6916  set_client_state (CLIENT_DELETE_FILTER);
6917  }
6918  else if (strcasecmp ("DELETE_GROUP", element_name) == 0)
6919  {
6920  const gchar* attribute;
6921  append_attribute (attribute_names, attribute_values, "group_id",
6923  if (find_attribute (attribute_names, attribute_values,
6924  "ultimate", &attribute))
6925  delete_group_data->ultimate = strcmp (attribute, "0");
6926  else
6928  set_client_state (CLIENT_DELETE_GROUP);
6929  }
6930  else if (strcasecmp ("DELETE_NOTE", element_name) == 0)
6931  {
6932  const gchar* attribute;
6933  append_attribute (attribute_names, attribute_values, "note_id",
6935  if (find_attribute (attribute_names, attribute_values,
6936  "ultimate", &attribute))
6937  delete_note_data->ultimate = strcmp (attribute, "0");
6938  else
6940  set_client_state (CLIENT_DELETE_NOTE);
6941  }
6942  else if (strcasecmp ("DELETE_OVERRIDE", element_name) == 0)
6943  {
6944  const gchar* attribute;
6945  append_attribute (attribute_names, attribute_values, "override_id",
6947  if (find_attribute (attribute_names, attribute_values,
6948  "ultimate", &attribute))
6949  delete_override_data->ultimate = strcmp (attribute, "0");
6950  else
6952  set_client_state (CLIENT_DELETE_OVERRIDE);
6953  }
6954  else if (strcasecmp ("DELETE_PERMISSION", element_name) == 0)
6955  {
6956  const gchar* attribute;
6957  append_attribute (attribute_names, attribute_values,
6958  "permission_id",
6960  if (find_attribute (attribute_names, attribute_values,
6961  "ultimate", &attribute))
6962  delete_permission_data->ultimate = strcmp (attribute, "0");
6963  else
6965  set_client_state (CLIENT_DELETE_PERMISSION);
6966  }
6967  else if (strcasecmp ("DELETE_PORT_LIST", element_name) == 0)
6968  {
6969  const gchar* attribute;
6970  append_attribute (attribute_names, attribute_values, "port_list_id",
6972  if (find_attribute (attribute_names, attribute_values,
6973  "ultimate", &attribute))
6974  delete_port_list_data->ultimate = strcmp (attribute, "0");
6975  else
6977  set_client_state (CLIENT_DELETE_PORT_LIST);
6978  }
6979  else if (strcasecmp ("DELETE_PORT_RANGE", element_name) == 0)
6980  {
6981  append_attribute (attribute_names, attribute_values, "port_range_id",
6983  set_client_state (CLIENT_DELETE_PORT_RANGE);
6984  }
6985  else if (strcasecmp ("DELETE_REPORT", element_name) == 0)
6986  {
6987  append_attribute (attribute_names, attribute_values, "report_id",
6989  set_client_state (CLIENT_DELETE_REPORT);
6990  }
6991  else if (strcasecmp ("DELETE_REPORT_FORMAT", element_name) == 0)
6992  {
6993  const gchar* attribute;
6994  append_attribute (attribute_names, attribute_values, "report_format_id",
6996  if (find_attribute (attribute_names, attribute_values,
6997  "ultimate", &attribute))
6998  delete_report_format_data->ultimate = strcmp (attribute,
6999  "0");
7000  else
7002  set_client_state (CLIENT_DELETE_REPORT_FORMAT);
7003  }
7004  else if (strcasecmp ("DELETE_ROLE", element_name) == 0)
7005  {
7006  const gchar* attribute;
7007  append_attribute (attribute_names, attribute_values, "role_id",
7009  if (find_attribute (attribute_names, attribute_values,
7010  "ultimate", &attribute))
7011  delete_role_data->ultimate = strcmp (attribute, "0");
7012  else
7014  set_client_state (CLIENT_DELETE_ROLE);
7015  }
7016  else if (strcasecmp ("DELETE_SCANNER", element_name) == 0)
7017  {
7018  const gchar* attribute;
7019  append_attribute (attribute_names, attribute_values,
7020  "scanner_id", &delete_scanner_data->scanner_id);
7021  if (find_attribute (attribute_names, attribute_values, "ultimate",
7022  &attribute))
7023  delete_scanner_data->ultimate = strcmp (attribute, "0");
7024  else
7026  set_client_state (CLIENT_DELETE_SCANNER);
7027  }
7028  else if (strcasecmp ("DELETE_SCHEDULE", element_name) == 0)
7029  {
7030  const gchar* attribute;
7031  append_attribute (attribute_names, attribute_values, "schedule_id",
7033  if (find_attribute (attribute_names, attribute_values,
7034  "ultimate", &attribute))
7035  delete_schedule_data->ultimate = strcmp (attribute, "0");
7036  else
7038  set_client_state (CLIENT_DELETE_SCHEDULE);
7039  }
7040  else if (strcasecmp ("DELETE_TAG", element_name) == 0)
7041  {
7042  const gchar* attribute;
7043  append_attribute (attribute_names, attribute_values, "tag_id",
7045  if (find_attribute (attribute_names, attribute_values,
7046  "ultimate", &attribute))
7047  delete_tag_data->ultimate = strcmp (attribute, "0");
7048  else
7050  set_client_state (CLIENT_DELETE_TAG);
7051  }
7052  else if (strcasecmp ("DELETE_TARGET", element_name) == 0)
7053  {
7054  const gchar* attribute;
7055  append_attribute (attribute_names, attribute_values, "target_id",
7057  if (find_attribute (attribute_names, attribute_values,
7058  "ultimate", &attribute))
7059  delete_target_data->ultimate = strcmp (attribute, "0");
7060  else
7062  set_client_state (CLIENT_DELETE_TARGET);
7063  }
7064  else if (strcasecmp ("DELETE_TASK", element_name) == 0)
7065  {
7066  const gchar* attribute;
7067  append_attribute (attribute_names, attribute_values, "task_id",
7069  if (find_attribute (attribute_names, attribute_values,
7070  "ultimate", &attribute))
7071  delete_task_data->ultimate = strcmp (attribute, "0");
7072  else
7074  set_client_state (CLIENT_DELETE_TASK);
7075  }
7076  else if (strcasecmp ("DELETE_USER", element_name) == 0)
7077  {
7078  const gchar* attribute;
7079  append_attribute (attribute_names, attribute_values, "name",
7081  append_attribute (attribute_names, attribute_values, "user_id",
7083  append_attribute (attribute_names, attribute_values,
7084  "inheritor_id",
7086  append_attribute (attribute_names, attribute_values,
7087  "inheritor_name",
7089  if (find_attribute (attribute_names, attribute_values,
7090  "ultimate", &attribute))
7091  delete_user_data->ultimate = strcmp (attribute, "0");
7092  else
7094  set_client_state (CLIENT_DELETE_USER);
7095  }
7096  else if (strcasecmp ("DESCRIBE_AUTH", element_name) == 0)
7097  set_client_state (CLIENT_DESCRIBE_AUTH);
7098  else if (strcasecmp ("EMPTY_TRASHCAN", element_name) == 0)
7099  set_client_state (CLIENT_EMPTY_TRASHCAN);
7100  else if (strcasecmp ("GET_AGENTS", element_name) == 0)
7101  {
7102  get_data_parse_attributes (&get_agents_data->get, "agent",
7103  attribute_names,
7104  attribute_values);
7105  append_attribute (attribute_names, attribute_values, "format",
7107  set_client_state (CLIENT_GET_AGENTS);
7108  }
7109  else if (strcasecmp ("GET_AGGREGATES", element_name) == 0)
7110  {
7111  gchar *data_column = g_strdup ("");
7112  sort_data_t *sort_data;
7113  const gchar *attribute;
7114  int sort_order_given;
7115 
7116  sort_data = g_malloc0 (sizeof (sort_data_t));
7117  sort_data->field = g_strdup ("");
7118  sort_data->stat = g_strdup ("");
7119 
7120  append_attribute (attribute_names, attribute_values, "type",
7122 
7124  && strcasecmp (get_aggregates_data->type, "info") == 0)
7125  {
7126  append_attribute (attribute_names, attribute_values, "info_type",
7128  }
7129 
7130  append_attribute (attribute_names, attribute_values, "data_column",
7131  &data_column);
7133  = g_list_append (get_aggregates_data->data_columns,
7134  data_column);
7135 
7136  append_attribute (attribute_names, attribute_values, "group_column",
7138 
7139  append_attribute (attribute_names, attribute_values,
7140  "subgroup_column",
7142 
7143  append_attribute (attribute_names, attribute_values, "sort_field",
7144  &(sort_data->field));
7145  append_attribute (attribute_names, attribute_values, "sort_stat",
7146  &(sort_data->stat));
7147  if (find_attribute (attribute_names, attribute_values,
7148  "sort_order", &attribute))
7149  {
7150  sort_data->order = strcmp (attribute, "descending");
7151  sort_order_given = 1;
7152  }
7153  else
7154  {
7155  sort_data->order = 1;
7156  sort_order_given = 0;
7157  }
7158 
7159  if (strcmp (sort_data->field, "") || sort_order_given)
7160  {
7162  = g_list_append (get_aggregates_data->sort_data,
7163  sort_data);
7164  }
7165 
7166  append_attribute (attribute_names, attribute_values, "mode",
7168 
7169  if (find_attribute (attribute_names, attribute_values,
7170  "first_group", &attribute))
7171  get_aggregates_data->first_group = atoi (attribute) - 1;
7172  else
7174 
7175  if (find_attribute (attribute_names, attribute_values,
7176  "max_groups", &attribute))
7177  get_aggregates_data->max_groups = atoi (attribute);
7178  else
7180 
7181  get_data_parse_attributes (&get_aggregates_data->get,
7184  : "",
7185  attribute_names,
7186  attribute_values);
7187  set_client_state (CLIENT_GET_AGGREGATES);
7188  }
7189  else if (strcasecmp ("GET_CONFIGS", element_name) == 0)
7190  {
7191  const gchar* attribute;
7192 
7193  get_data_parse_attributes (&get_configs_data->get,
7194  "config",
7195  attribute_names,
7196  attribute_values);
7197 
7198  if (find_attribute (attribute_names, attribute_values,
7199  "tasks", &attribute))
7200  get_configs_data->tasks = strcmp (attribute, "0");
7201  else
7202  get_configs_data->tasks = 0;
7203 
7204  if (find_attribute (attribute_names, attribute_values,
7205  "families", &attribute))
7206  get_configs_data->families = strcmp (attribute, "0");
7207  else
7209 
7210  if (find_attribute (attribute_names, attribute_values,
7211  "preferences", &attribute))
7212  get_configs_data->preferences = strcmp (attribute, "0");
7213  else
7215 
7216  set_client_state (CLIENT_GET_CONFIGS);
7217  }
7218  else if (strcasecmp ("GET_ALERTS", element_name) == 0)
7219  {
7220  const gchar* attribute;
7221 
7222  get_data_parse_attributes (&get_alerts_data->get,
7223  "alert",
7224  attribute_names,
7225  attribute_values);
7226  if (find_attribute (attribute_names, attribute_values,
7227  "tasks", &attribute))
7228  get_alerts_data->tasks = strcmp (attribute, "0");
7229  else
7230  get_alerts_data->tasks = 0;
7231 
7232  set_client_state (CLIENT_GET_ALERTS);
7233  }
7234  else if (strcasecmp ("GET_ASSETS", element_name) == 0)
7235  {
7236  const gchar* typebuf;
7237  get_data_parse_attributes (&get_assets_data->get, "asset",
7238  attribute_names,
7239  attribute_values);
7240  if (find_attribute (attribute_names, attribute_values,
7241  "type", &typebuf))
7242  get_assets_data->type = g_ascii_strdown (typebuf, -1);
7243  set_client_state (CLIENT_GET_ASSETS);
7244  }
7245  else if (strcasecmp ("GET_CREDENTIALS", element_name) == 0)
7246  {
7247  const gchar* attribute;
7248 
7249  get_data_parse_attributes (&get_credentials_data->get,
7250  "credential",
7251  attribute_names,
7252  attribute_values);
7253 
7254  if (find_attribute (attribute_names, attribute_values,
7255  "scanners", &attribute))
7256  get_credentials_data->scanners = strcmp (attribute, "0");
7257  else
7259 
7260  if (find_attribute (attribute_names, attribute_values,
7261  "targets", &attribute))
7262  get_credentials_data->targets = strcmp (attribute, "0");
7263  else
7265 
7266  append_attribute (attribute_names, attribute_values, "format",
7268  set_client_state (CLIENT_GET_CREDENTIALS);
7269  }
7270  else if (strcasecmp ("GET_FEEDS", element_name) == 0)
7271  {
7272  append_attribute (attribute_names, attribute_values, "type",
7273  &get_feeds_data->type);
7274  set_client_state (CLIENT_GET_FEEDS);
7275  }
7276  else if (strcasecmp ("GET_FILTERS", element_name) == 0)
7277  {
7278  const gchar* attribute;
7279  get_data_parse_attributes (&get_filters_data->get, "filter",
7280  attribute_names,
7281  attribute_values);
7282  if (find_attribute (attribute_names, attribute_values,
7283  "alerts", &attribute))
7284  get_filters_data->alerts = strcmp (attribute, "0");
7285  else
7286  get_filters_data->alerts = 0;
7287  set_client_state (CLIENT_GET_FILTERS);
7288  }
7289  else if (strcasecmp ("GET_GROUPS", element_name) == 0)
7290  {
7291  get_data_parse_attributes (&get_groups_data->get, "group",
7292  attribute_names,
7293  attribute_values);
7294  set_client_state (CLIENT_GET_GROUPS);
7295  }
7296  else if (strcasecmp ("GET_NOTES", element_name) == 0)
7297  {
7298  const gchar* attribute;
7299 
7300  get_data_parse_attributes (&get_notes_data->get, "note",
7301  attribute_names,
7302  attribute_values);
7303 
7304  append_attribute (attribute_names, attribute_values, "note_id",
7306 
7307  append_attribute (attribute_names, attribute_values, "nvt_oid",
7309 
7310  append_attribute (attribute_names, attribute_values, "task_id",
7312 
7313  if (find_attribute (attribute_names, attribute_values,
7314  "result", &attribute))
7315  get_notes_data->result = strcmp (attribute, "0");
7316  else
7317  get_notes_data->result = 0;
7318 
7319  set_client_state (CLIENT_GET_NOTES);
7320  }
7321  else if (strcasecmp ("GET_NVTS", element_name) == 0)
7322  {
7323  const gchar* attribute;
7324  append_attribute (attribute_names, attribute_values, "nvt_oid",
7326  append_attribute (attribute_names, attribute_values, "config_id",
7328  append_attribute (attribute_names, attribute_values,
7329  "preferences_config_id",
7331  if (find_attribute (attribute_names, attribute_values,
7332  "details", &attribute))
7333  get_nvts_data->details = strcmp (attribute, "0");
7334  else
7335  get_nvts_data->details = 0;
7336  append_attribute (attribute_names, attribute_values, "family",
7337  &get_nvts_data->family);
7338  if (find_attribute (attribute_names, attribute_values,
7339  "preferences", &attribute))
7340  get_nvts_data->preferences = strcmp (attribute, "0");
7341  else
7343  if (find_attribute (attribute_names, attribute_values,
7344  "preference_count", &attribute))
7345  get_nvts_data->preference_count = strcmp (attribute, "0");
7346  else
7348  if (find_attribute (attribute_names, attribute_values,
7349  "timeout", &attribute))
7350  get_nvts_data->timeout = strcmp (attribute, "0");
7351  else
7352  get_nvts_data->timeout = 0;
7353  append_attribute (attribute_names, attribute_values, "sort_field",
7355  if (find_attribute (attribute_names, attribute_values,
7356  "sort_order", &attribute))
7357  get_nvts_data->sort_order = strcmp (attribute,
7358  "descending");
7359  else
7361  set_client_state (CLIENT_GET_NVTS);
7362  }
7363  else if (strcasecmp ("GET_NVT_FAMILIES", element_name) == 0)
7364  {
7365  const gchar* attribute;
7366  if (find_attribute (attribute_names, attribute_values,
7367  "sort_order", &attribute))
7368  get_nvt_families_data->sort_order = strcmp (attribute,
7369  "descending");
7370  else
7372  set_client_state (CLIENT_GET_NVT_FAMILIES);
7373  }
7374  else if (strcasecmp ("GET_OVERRIDES", element_name) == 0)
7375  {
7376  const gchar* attribute;
7377 
7378  get_data_parse_attributes (&get_overrides_data->get, "override",
7379  attribute_names,
7380  attribute_values);
7381 
7382  append_attribute (attribute_names, attribute_values, "override_id",
7384 
7385  append_attribute (attribute_names, attribute_values, "nvt_oid",
7387 
7388  append_attribute (attribute_names, attribute_values, "task_id",
7390 
7391  if (find_attribute (attribute_names, attribute_values,
7392  "result", &attribute))
7393  get_overrides_data->result = strcmp (attribute, "0");
7394  else
7396 
7397  set_client_state (CLIENT_GET_OVERRIDES);
7398  }
7399  else if (strcasecmp ("GET_PORT_LISTS", element_name) == 0)
7400  {
7401  const gchar* attribute;
7402 
7403  get_data_parse_attributes (&get_port_lists_data->get,
7404  "port_list",
7405  attribute_names,
7406  attribute_values);
7407  if (find_attribute (attribute_names, attribute_values,
7408  "targets", &attribute))
7409  get_port_lists_data->targets = strcmp (attribute, "0");
7410  else
7412  set_client_state (CLIENT_GET_PORT_LISTS);
7413  }
7414  else if (strcasecmp ("GET_PERMISSIONS", element_name) == 0)
7415  {
7416  get_data_parse_attributes (&get_permissions_data->get, "permission",
7417  attribute_names,
7418  attribute_values);
7419  append_attribute (attribute_names, attribute_values, "resource_id",
7421  set_client_state (CLIENT_GET_PERMISSIONS);
7422  }
7423  else if (strcasecmp ("GET_PREFERENCES", element_name) == 0)
7424  {
7425  append_attribute (attribute_names, attribute_values, "nvt_oid",
7427  append_attribute (attribute_names, attribute_values, "config_id",
7429  append_attribute (attribute_names, attribute_values, "preference",
7431  set_client_state (CLIENT_GET_PREFERENCES);
7432  }
7433  else if (strcasecmp ("GET_REPORTS", element_name) == 0)
7434  {
7435  const gchar* attribute;
7436 
7437  get_data_parse_attributes (&get_reports_data->get, "report",
7438  attribute_names,
7439  attribute_values);
7440 
7441  get_data_parse_attributes (&get_reports_data->report_get, "report",
7442  attribute_names,
7443  attribute_values);
7444 
7445  /* Special case details with default 1, for backward
7446  * compatibility. */
7447  if (find_attribute (attribute_names, attribute_values,
7448  "details", &attribute))
7449  get_reports_data->report_get.details = strcmp (attribute, "0");
7450  else
7454 
7457  append_attribute (attribute_names, attribute_values,
7458  "report_filt_id",
7460 
7463  append_attribute (attribute_names, attribute_values,
7464  "report_filter",
7466 
7467  append_attribute (attribute_names, attribute_values, "report_id",
7469 
7470  append_attribute (attribute_names, attribute_values,
7471  "delta_report_id",
7473 
7474  append_attribute (attribute_names, attribute_values, "alert_id",
7476 
7477  append_attribute (attribute_names, attribute_values, "format_id",
7479 
7480  if (find_attribute (attribute_names, attribute_values,
7481  "host_first_result", &attribute))
7482  /* Subtract 1 to switch from 1 to 0 indexing. */
7483  get_reports_data->host_first_result = atoi (attribute) - 1;
7484  else
7486 
7487  if (find_attribute (attribute_names, attribute_values,
7488  "host_max_results", &attribute))
7489  get_reports_data->host_max_results = atoi (attribute);
7490  else
7492 
7493  append_attribute (attribute_names, attribute_values, "host_levels",
7495 
7496  append_attribute (attribute_names, attribute_values,
7497  "host_search_phrase",
7499 
7500  if (find_attribute (attribute_names, attribute_values,
7501  "notes_details", &attribute))
7502  get_reports_data->notes_details = strcmp (attribute, "0");
7503  else
7505 
7506  if (find_attribute (attribute_names, attribute_values,
7507  "overrides_details", &attribute))
7508  get_reports_data->overrides_details = strcmp (attribute, "0");
7509  else
7511 
7512  if (find_attribute (attribute_names, attribute_values,
7513  "type", &attribute))
7514  openvas_append_string (&get_reports_data->type, attribute);
7515  else
7516  get_reports_data->type = g_strdup ("scan");
7517 
7518  append_attribute (attribute_names,
7519  attribute_values,
7520  "host",
7522 
7523  append_attribute (attribute_names,
7524  attribute_values,
7525  "pos",
7526  &get_reports_data->pos);
7527 
7528  if (find_attribute (attribute_names, attribute_values,
7529  "ignore_pagination", &attribute))
7530  get_reports_data->ignore_pagination = atoi (attribute);
7531  else
7533 
7534  set_client_state (CLIENT_GET_REPORTS);
7535  }
7536  else if (strcasecmp ("GET_REPORT_FORMATS", element_name) == 0)
7537  {
7538  const gchar* attribute;
7539 
7540  get_data_parse_attributes (&get_report_formats_data->get,
7541  "report_format",
7542  attribute_names,
7543  attribute_values);
7544  if (find_attribute (attribute_names, attribute_values,
7545  "alerts", &attribute))
7546  get_report_formats_data->alerts = strcmp (attribute, "0");
7547  else
7549 
7550  if (find_attribute (attribute_names, attribute_values,
7551  "params", &attribute))
7552  get_report_formats_data->params = strcmp (attribute, "0");
7553  else
7555 
7556  set_client_state (CLIENT_GET_REPORT_FORMATS);
7557  }
7558  else if (strcasecmp ("GET_RESULTS", element_name) == 0)
7559  {
7560  const gchar* attribute;
7561  get_data_parse_attributes (&get_results_data->get,
7562  "result",
7563  attribute_names,
7564  attribute_values);
7565 
7566  append_attribute (attribute_names, attribute_values, "task_id",
7568 
7569  if (find_attribute (attribute_names, attribute_values,
7570  "notes_details", &attribute))
7571  get_results_data->notes_details = strcmp (attribute, "0");
7572  else
7574 
7575  if (find_attribute (attribute_names, attribute_values,
7576  "overrides_details", &attribute))
7577  get_results_data->overrides_details = strcmp (attribute, "0");
7578  else
7580 
7581  if (find_attribute (attribute_names, attribute_values,
7582  "get_counts", &attribute))
7583  get_results_data->get_counts = strcmp (attribute, "0");
7584  else
7586 
7587  set_client_state (CLIENT_GET_RESULTS);
7588  }
7589  else if (strcasecmp ("GET_ROLES", element_name) == 0)
7590  {
7591  get_data_parse_attributes (&get_roles_data->get, "role",
7592  attribute_names,
7593  attribute_values);
7594  set_client_state (CLIENT_GET_ROLES);
7595  }
7596  else if (strcasecmp ("GET_SCANNERS", element_name) == 0)
7597  {
7598  get_data_parse_attributes (&get_scanners_data->get, "scanner",
7599  attribute_names, attribute_values);
7600  set_client_state (CLIENT_GET_SCANNERS);
7601  }
7602  else if (strcasecmp ("GET_SCHEDULES", element_name) == 0)
7603  {
7604  const gchar *attribute;
7605  get_data_parse_attributes (&get_schedules_data->get, "schedule",
7606  attribute_names,
7607  attribute_values);
7608  if (find_attribute (attribute_names, attribute_values,
7609  "tasks", &attribute))
7610  get_schedules_data->tasks = strcmp (attribute, "0");
7611  else
7613  set_client_state (CLIENT_GET_SCHEDULES);
7614  }
7615  else if (strcasecmp ("GET_SETTINGS", element_name) == 0)
7616  {
7617  const gchar* attribute;
7618 
7619  append_attribute (attribute_names, attribute_values, "setting_id",
7621 
7622  append_attribute (attribute_names, attribute_values, "filter",
7624 
7625  if (find_attribute (attribute_names, attribute_values,
7626  "first", &attribute))
7627  /* Subtract 1 to switch from 1 to 0 indexing. */
7628  get_settings_data->first = atoi (attribute) - 1;
7629  else
7630  get_settings_data->first = 0;
7631  if (get_settings_data->first < 0)
7632  get_settings_data->first = 0;
7633 
7634  if (find_attribute (attribute_names, attribute_values,
7635  "max", &attribute))
7636  get_settings_data->max = atoi (attribute);
7637  else
7638  get_settings_data->max = -1;
7639  if (get_settings_data->max < 1)
7640  get_settings_data->max = -1;
7641 
7642  append_attribute (attribute_names, attribute_values, "sort_field",
7644 
7645  if (find_attribute (attribute_names, attribute_values,
7646  "sort_order", &attribute))
7647  get_settings_data->sort_order = strcmp (attribute, "descending");
7648  else
7650 
7651  set_client_state (CLIENT_GET_SETTINGS);
7652  }
7653  else if (strcasecmp ("GET_TAGS", element_name) == 0)
7654  {
7655  const gchar* attribute;
7656  get_data_parse_attributes (&get_tags_data->get, "tag",
7657  attribute_names,
7658  attribute_values);
7659 
7660  if (find_attribute (attribute_names, attribute_values,
7661  "names_only", &attribute))
7662  get_tags_data->names_only = strcmp (attribute, "0");
7663  else
7665 
7666  set_client_state (CLIENT_GET_TAGS);
7667  }
7668  else if (strcasecmp ("GET_SYSTEM_REPORTS", element_name) == 0)
7669  {
7670  const gchar* attribute;
7671  append_attribute (attribute_names, attribute_values, "name",
7673  append_attribute (attribute_names, attribute_values, "duration",
7675  append_attribute (attribute_names, attribute_values, "end_time",
7677  append_attribute (attribute_names, attribute_values, "slave_id",
7679  append_attribute (attribute_names, attribute_values, "start_time",
7681  if (find_attribute (attribute_names, attribute_values,
7682  "brief", &attribute))
7683  get_system_reports_data->brief = strcmp (attribute, "0");
7684  else
7686  set_client_state (CLIENT_GET_SYSTEM_REPORTS);
7687  }
7688  else if (strcasecmp ("GET_TARGETS", element_name) == 0)
7689  {
7690  const gchar *attribute;
7691  get_data_parse_attributes (&get_targets_data->get, "target",
7692  attribute_names,
7693  attribute_values);
7694  if (find_attribute (attribute_names, attribute_values,
7695  "tasks", &attribute))
7696  get_targets_data->tasks = strcmp (attribute, "0");
7697  else
7698  get_targets_data->tasks = 0;
7699  set_client_state (CLIENT_GET_TARGETS);
7700  }
7701  else if (strcasecmp ("GET_TASKS", element_name) == 0)
7702  {
7703  const gchar *attribute;
7704  get_data_parse_attributes (&get_tasks_data->get, "task",
7705  attribute_names,
7706  attribute_values);
7707  if (find_attribute (attribute_names, attribute_values,
7708  "schedules_only", &attribute))
7709  get_tasks_data->schedules_only = strcmp (attribute, "0");
7710  else
7712  set_client_state (CLIENT_GET_TASKS);
7713  }
7714  else if (strcasecmp ("GET_USERS", element_name) == 0)
7715  {
7716  get_data_parse_attributes (&get_users_data->get, "user",
7717  attribute_names,
7718  attribute_values);
7719  set_client_state (CLIENT_GET_USERS);
7720  }
7721  else if (strcasecmp ("GET_INFO", element_name) == 0)
7722  {
7723  const gchar* attribute;
7724  const gchar* typebuf;
7725  get_data_parse_attributes (&get_info_data->get, "info",
7726  attribute_names,
7727  attribute_values);
7728  append_attribute (attribute_names, attribute_values, "name",
7729  &get_info_data->name);
7730  if (find_attribute (attribute_names, attribute_values,
7731  "details", &attribute))
7732  get_info_data->details = strcmp (attribute, "0");
7733  else
7734  get_info_data->details = 0;
7735 
7736  if (find_attribute (attribute_names, attribute_values,
7737  "type", &typebuf))
7738  get_info_data->type = g_ascii_strdown (typebuf, -1);
7739  set_client_state (CLIENT_GET_INFO);
7740  }
7741  else if (strcasecmp ("GET_VERSION", element_name) == 0)
7742  set_client_state (CLIENT_GET_VERSION_AUTHENTIC);
7743  else if (strcasecmp ("HELP", element_name) == 0)
7744  {
7745  append_attribute (attribute_names, attribute_values, "format",
7746  &help_data->format);
7747  append_attribute (attribute_names, attribute_values, "type",
7748  &help_data->type);
7749  set_client_state (CLIENT_HELP);
7750  }
7751  else if (strcasecmp ("MODIFY_AGENT", element_name) == 0)
7752  {
7753  append_attribute (attribute_names, attribute_values, "agent_id",
7755  set_client_state (CLIENT_MODIFY_AGENT);
7756  }
7757  else if (strcasecmp ("MODIFY_ALERT", element_name) == 0)
7758  {
7759  modify_alert_data->event_data = make_array ();
7760  openvas_append_string (&modify_alert_data->event, "");
7761  modify_alert_data->condition_data = make_array ();
7762  openvas_append_string (&modify_alert_data->condition, "");
7763  modify_alert_data->method_data = make_array ();
7764  openvas_append_string (&modify_alert_data->method, "");
7765 
7766  append_attribute (attribute_names, attribute_values, "alert_id",
7768  set_client_state (CLIENT_MODIFY_ALERT);
7769  }
7770  else if (strcasecmp ("MODIFY_ASSET", element_name) == 0)
7771  {
7772  append_attribute (attribute_names, attribute_values, "asset_id",
7774  set_client_state (CLIENT_MODIFY_ASSET);
7775  }
7776  else if (strcasecmp ("MODIFY_AUTH", element_name) == 0)
7777  set_client_state (CLIENT_MODIFY_AUTH);
7778  else if (strcasecmp ("MODIFY_CONFIG", element_name) == 0)
7779  {
7780  append_attribute (attribute_names, attribute_values, "config_id",
7782  set_client_state (CLIENT_MODIFY_CONFIG);
7783  }
7784  else if (strcasecmp ("MODIFY_CREDENTIAL", element_name) == 0)
7785  {
7786  append_attribute (attribute_names, attribute_values,
7787  "credential_id",
7789  set_client_state (CLIENT_MODIFY_CREDENTIAL);
7790  }
7791  else if (strcasecmp ("MODIFY_FILTER", element_name) == 0)
7792  {
7793  append_attribute (attribute_names, attribute_values, "filter_id",
7795  set_client_state (CLIENT_MODIFY_FILTER);
7796  }
7797  else if (strcasecmp ("MODIFY_GROUP", element_name) == 0)
7798  {
7799  append_attribute (attribute_names, attribute_values, "group_id",
7801  set_client_state (CLIENT_MODIFY_GROUP);
7802  }
7803  else if (strcasecmp ("MODIFY_PORT_LIST", element_name) == 0)
7804  {
7805  append_attribute (attribute_names, attribute_values,
7806  "port_list_id",
7808  set_client_state (CLIENT_MODIFY_PORT_LIST);
7809  }
7810  else if (strcasecmp ("MODIFY_NOTE", element_name) == 0)
7811  {
7812  append_attribute (attribute_names, attribute_values, "note_id",
7814  set_client_state (CLIENT_MODIFY_NOTE);
7815  }
7816  else if (strcasecmp ("MODIFY_OVERRIDE", element_name) == 0)
7817  {
7818  append_attribute (attribute_names, attribute_values, "override_id",
7820  set_client_state (CLIENT_MODIFY_OVERRIDE);
7821  }
7822  else if (strcasecmp ("MODIFY_PERMISSION", element_name) == 0)
7823  {
7824  append_attribute (attribute_names, attribute_values,
7825  "permission_id",
7827  set_client_state (CLIENT_MODIFY_PERMISSION);
7828  }
7829  else if (strcasecmp ("MODIFY_REPORT", element_name) == 0)
7830  {
7831  append_attribute (attribute_names, attribute_values, "report_id",
7833  set_client_state (CLIENT_MODIFY_REPORT);
7834  }
7835  else if (strcasecmp ("MODIFY_REPORT_FORMAT", element_name) == 0)
7836  {
7837  append_attribute (attribute_names, attribute_values,
7838  "report_format_id",
7840  set_client_state (CLIENT_MODIFY_REPORT_FORMAT);
7841  }
7842  else if (strcasecmp ("MODIFY_ROLE", element_name) == 0)
7843  {
7844  append_attribute (attribute_names, attribute_values, "role_id",
7846  set_client_state (CLIENT_MODIFY_ROLE);
7847  }
7848  else if (strcasecmp ("MODIFY_SCANNER", element_name) == 0)
7849  {
7850  append_attribute (attribute_names, attribute_values, "scanner_id",
7852  set_client_state (CLIENT_MODIFY_SCANNER);
7853  }
7854  else if (strcasecmp ("MODIFY_SCHEDULE", element_name) == 0)
7855  {
7856  append_attribute (attribute_names, attribute_values, "schedule_id",
7858  set_client_state (CLIENT_MODIFY_SCHEDULE);
7859  }
7860  else if (strcasecmp ("MODIFY_SETTING", element_name) == 0)
7861  {
7862  append_attribute (attribute_names, attribute_values,
7863  "setting_id",
7865  set_client_state (CLIENT_MODIFY_SETTING);
7866  }
7867  else if (strcasecmp ("MODIFY_TAG", element_name) == 0)
7868  {
7869  append_attribute (attribute_names, attribute_values, "tag_id",
7871  set_client_state (CLIENT_MODIFY_TAG);
7872  }
7873  else if (strcasecmp ("MODIFY_TARGET", element_name) == 0)
7874  {
7875  append_attribute (attribute_names, attribute_values, "target_id",
7877  set_client_state (CLIENT_MODIFY_TARGET);
7878  }
7879  else if (strcasecmp ("MODIFY_TASK", element_name) == 0)
7880  {
7881  append_attribute (attribute_names, attribute_values, "task_id",
7883  modify_task_data->alerts = make_array ();
7884  modify_task_data->groups = make_array ();
7885  set_client_state (CLIENT_MODIFY_TASK);
7886  }
7887  else if (strcasecmp ("MODIFY_USER", element_name) == 0)
7888  {
7889  append_attribute (attribute_names, attribute_values, "user_id",
7891  set_client_state (CLIENT_MODIFY_USER);
7892  }
7893  else if (strcasecmp ("MOVE_TASK", element_name) == 0)
7894  {
7895  append_attribute (attribute_names, attribute_values, "task_id",
7897  append_attribute (attribute_names, attribute_values, "slave_id",
7899  set_client_state (CLIENT_MOVE_TASK);
7900  }
7901  else if (strcasecmp ("RESTORE", element_name) == 0)
7902  {
7903  append_attribute (attribute_names, attribute_values, "id",
7904  &restore_data->id);
7905  set_client_state (CLIENT_RESTORE);
7906  }
7907  else if (strcasecmp ("RESUME_TASK", element_name) == 0)
7908  {
7909  append_attribute (attribute_names, attribute_values, "task_id",
7911  set_client_state (CLIENT_RESUME_TASK);
7912  }
7913  else if (strcasecmp ("RUN_WIZARD", element_name) == 0)
7914  {
7915  append_attribute (attribute_names, attribute_values, "name",
7916  &run_wizard_data->name);
7917  append_attribute (attribute_names, attribute_values, "read_only",
7919  set_client_state (CLIENT_RUN_WIZARD);
7920  }
7921  else if (strcasecmp ("START_TASK", element_name) == 0)
7922  {
7923  append_attribute (attribute_names, attribute_values, "task_id",
7925  set_client_state (CLIENT_START_TASK);
7926  }
7927  else if (strcasecmp ("STOP_TASK", element_name) == 0)
7928  {
7929  append_attribute (attribute_names, attribute_values, "task_id",
7931  set_client_state (CLIENT_STOP_TASK);
7932  }
7933  else if (strcasecmp ("SYNC_CERT", element_name) == 0)
7934  set_client_state (CLIENT_SYNC_CERT);
7935  else if (strcasecmp ("SYNC_CONFIG", element_name) == 0)
7936  {
7937  append_attribute (attribute_names, attribute_values, "config_id",
7939  set_client_state (CLIENT_SYNC_CONFIG);
7940  }
7941  else if (strcasecmp ("SYNC_FEED", element_name) == 0)
7942  set_client_state (CLIENT_SYNC_FEED);
7943  else if (strcasecmp ("SYNC_SCAP", element_name) == 0)
7944  set_client_state (CLIENT_SYNC_SCAP);
7945  else if (strcasecmp ("TEST_ALERT", element_name) == 0)
7946  {
7947  append_attribute (attribute_names, attribute_values,
7948  "alert_id",
7950  set_client_state (CLIENT_TEST_ALERT);
7951  }
7952  else if (strcasecmp ("VERIFY_AGENT", element_name) == 0)
7953  {
7954  append_attribute (attribute_names, attribute_values, "agent_id",
7956  set_client_state (CLIENT_VERIFY_AGENT);
7957  }
7958  else if (strcasecmp ("VERIFY_REPORT_FORMAT", element_name) == 0)
7959  {
7960  append_attribute (attribute_names, attribute_values, "report_format_id",
7962  set_client_state (CLIENT_VERIFY_REPORT_FORMAT);
7963  }
7964  else if (strcasecmp ("VERIFY_SCANNER", element_name) == 0)
7965  {
7966  append_attribute (attribute_names, attribute_values, "scanner_id",
7968  set_client_state (CLIENT_VERIFY_SCANNER);
7969  }
7970  else
7971  {
7972  if (send_to_client (XML_ERROR_SYNTAX ("omp", "Bogus command name"),
7973  write_to_client,
7974  write_to_client_data))
7975  {
7976  error_send_to_client (error);
7977  return;
7978  }
7979  g_set_error (error,
7980  G_MARKUP_ERROR,
7981  G_MARKUP_ERROR_UNKNOWN_ELEMENT,
7982  "Error");
7983  }
7984  break;
7985 
7986  case CLIENT_AUTHENTICATE:
7987  if (strcasecmp ("CREDENTIALS", element_name) == 0)
7988  {
7989  /* Init, so it's the empty string when the entity is empty. */
7990  append_to_credentials_password (&current_credentials, "", 0);
7991  set_client_state (CLIENT_AUTHENTICATE_CREDENTIALS);
7992  }
7993  ELSE_ERROR ("authenticate");
7994 
7996  if (strcasecmp ("USERNAME", element_name) == 0)
7997  set_client_state (CLIENT_AUTHENTICATE_CREDENTIALS_USERNAME);
7998  else if (strcasecmp ("PASSWORD", element_name) == 0)
7999  set_client_state (CLIENT_AUTHENTICATE_CREDENTIALS_PASSWORD);
8000  ELSE_ERROR ("authenticate");
8001 
8002  case CLIENT_CREATE_SCANNER:
8003  if (strcasecmp ("COMMENT", element_name) == 0)
8004  set_client_state (CLIENT_CREATE_SCANNER_COMMENT);
8005  else if (strcasecmp ("COPY", element_name) == 0)
8006  set_client_state (CLIENT_CREATE_SCANNER_COPY);
8007  else if (strcasecmp ("NAME", element_name) == 0)
8008  set_client_state (CLIENT_CREATE_SCANNER_NAME);
8009  else if (strcasecmp ("HOST", element_name) == 0)
8010  set_client_state (CLIENT_CREATE_SCANNER_HOST);
8011  else if (strcasecmp ("PORT", element_name) == 0)
8012  set_client_state (CLIENT_CREATE_SCANNER_PORT);
8013  else if (strcasecmp ("TYPE", element_name) == 0)
8014  set_client_state (CLIENT_CREATE_SCANNER_TYPE);
8015  else if (strcasecmp ("CA_PUB", element_name) == 0)
8016  set_client_state (CLIENT_CREATE_SCANNER_CA_PUB);
8017  else if (strcasecmp ("CREDENTIAL", element_name) == 0)
8018  {
8019  append_attribute (attribute_names, attribute_values, "id",
8021  set_client_state (CLIENT_CREATE_SCANNER_CREDENTIAL);
8022  }
8023  ELSE_ERROR ("create_scanner");
8024 
8026  if (strcasecmp ("COMMENT", element_name) == 0)
8027  set_client_state (CLIENT_CREATE_SCHEDULE_COMMENT);
8028  else if (strcasecmp ("COPY", element_name) == 0)
8029  set_client_state (CLIENT_CREATE_SCHEDULE_COPY);
8030  else if (strcasecmp ("DURATION", element_name) == 0)
8031  set_client_state (CLIENT_CREATE_SCHEDULE_DURATION);
8032  else if (strcasecmp ("FIRST_TIME", element_name) == 0)
8033  set_client_state (CLIENT_CREATE_SCHEDULE_FIRST_TIME);
8034  else if (strcasecmp ("NAME", element_name) == 0)
8035  set_client_state (CLIENT_CREATE_SCHEDULE_NAME);
8036  else if (strcasecmp ("PERIOD", element_name) == 0)
8037  set_client_state (CLIENT_CREATE_SCHEDULE_PERIOD);
8038  else if (strcasecmp ("TIMEZONE", element_name) == 0)
8039  set_client_state (CLIENT_CREATE_SCHEDULE_TIMEZONE);
8040  ELSE_ERROR ("create_schedule");
8041 
8043  if (strcasecmp ("DAY_OF_MONTH", element_name) == 0)
8045  else if (strcasecmp ("HOUR", element_name) == 0)
8046  set_client_state (CLIENT_CREATE_SCHEDULE_FIRST_TIME_HOUR);
8047  else if (strcasecmp ("MINUTE", element_name) == 0)
8048  set_client_state (CLIENT_CREATE_SCHEDULE_FIRST_TIME_MINUTE);
8049  else if (strcasecmp ("MONTH", element_name) == 0)
8050  set_client_state (CLIENT_CREATE_SCHEDULE_FIRST_TIME_MONTH);
8051  else if (strcasecmp ("YEAR", element_name) == 0)
8052  set_client_state (CLIENT_CREATE_SCHEDULE_FIRST_TIME_YEAR);
8053  ELSE_ERROR ("create_schedule");
8054 
8056  if (strcasecmp ("UNIT", element_name) == 0)
8057  set_client_state (CLIENT_CREATE_SCHEDULE_DURATION_UNIT);
8058  ELSE_ERROR ("create_schedule");
8059 
8061  if (strcasecmp ("UNIT", element_name) == 0)
8062  set_client_state (CLIENT_CREATE_SCHEDULE_PERIOD_UNIT);
8063  ELSE_ERROR ("create_schedule");
8064 
8065  case CLIENT_GET_AGGREGATES:
8066  if (strcasecmp ("DATA_COLUMN", element_name) == 0)
8067  {
8069  = g_list_append (get_aggregates_data->data_columns,
8070  g_strdup (""));
8071  set_client_state (CLIENT_GET_AGGREGATES_DATA_COLUMN);
8072  }
8073  else if (strcasecmp ("SORT", element_name) == 0)
8074  {
8075  int sort_order_given;
8076  const gchar* attribute;
8077  sort_data_t *sort_data;
8078  sort_data = g_malloc0 (sizeof (sort_data_t));
8079  sort_data->field = g_strdup ("");
8080  sort_data->stat = g_strdup ("");
8081 
8082  append_attribute (attribute_names, attribute_values, "field",
8083  &(sort_data->field));
8084  append_attribute (attribute_names, attribute_values, "stat",
8085  &(sort_data->stat));
8086  if (find_attribute (attribute_names, attribute_values,
8087  "order", &attribute))
8088  {
8089  sort_order_given = 1;
8090  sort_data->order = strcmp (attribute, "descending");
8091  }
8092  else
8093  {
8094  sort_order_given = 0;
8095  sort_data->order = 1;
8096  }
8097 
8098  if (strcmp (sort_data->field, "") || sort_order_given)
8099  {
8101  = g_list_append (get_aggregates_data->sort_data,
8102  sort_data);
8103  }
8104 
8105  set_client_state (CLIENT_GET_AGGREGATES_SORT);
8106  }
8107  else if (strcasecmp ("TEXT_COLUMN", element_name) == 0)
8108  {
8110  = g_list_append (get_aggregates_data->text_columns,
8111  g_strdup (""));
8112  set_client_state (CLIENT_GET_AGGREGATES_TEXT_COLUMN);
8113  }
8114  ELSE_ERROR ("get_aggregates");
8115 
8116  case CLIENT_MODIFY_AGENT:
8117  if (strcasecmp ("COMMENT", element_name) == 0)
8118  {
8119  openvas_append_string (&modify_agent_data->comment, "");
8120  set_client_state (CLIENT_MODIFY_AGENT_COMMENT);
8121  }
8122  else if (strcasecmp ("NAME", element_name) == 0)
8123  {
8124  openvas_append_string (&modify_agent_data->name, "");
8125  set_client_state (CLIENT_MODIFY_AGENT_NAME);
8126  }
8127  ELSE_ERROR ("modify_agent");
8128 
8129  case CLIENT_MODIFY_ALERT:
8130  if (strcasecmp ("NAME", element_name) == 0)
8131  {
8132  openvas_append_string (&modify_alert_data->name, "");
8133  set_client_state (CLIENT_MODIFY_ALERT_NAME);
8134  }
8135  else if (strcasecmp ("COMMENT", element_name) == 0)
8136  {
8137  openvas_append_string (&modify_alert_data->comment, "");
8138  set_client_state (CLIENT_MODIFY_ALERT_COMMENT);
8139  }
8140  else if (strcasecmp ("EVENT", element_name) == 0)
8141  set_client_state (CLIENT_MODIFY_ALERT_EVENT);
8142  else if (strcasecmp ("FILTER", element_name) == 0)
8143  {
8144  append_attribute (attribute_names, attribute_values, "id",
8146  set_client_state (CLIENT_MODIFY_ALERT_FILTER);
8147  }
8148  else if (strcasecmp ("CONDITION", element_name) == 0)
8149  set_client_state (CLIENT_MODIFY_ALERT_CONDITION);
8150  else if (strcasecmp ("METHOD", element_name) == 0)
8151  set_client_state (CLIENT_MODIFY_ALERT_METHOD);
8152  ELSE_ERROR ("modify_alert");
8153 
8155  if (strcasecmp ("DATA", element_name) == 0)
8156  set_client_state (CLIENT_MODIFY_ALERT_EVENT_DATA);
8157  ELSE_ERROR ("modify_alert");
8158 
8160  if (strcasecmp ("NAME", element_name) == 0)
8161  set_client_state (CLIENT_MODIFY_ALERT_EVENT_DATA_NAME);
8162  ELSE_ERROR ("modify_alert");
8163 
8165  if (strcasecmp ("DATA", element_name) == 0)
8166  set_client_state (CLIENT_MODIFY_ALERT_CONDITION_DATA);
8167  ELSE_ERROR ("modify_alert");
8168 
8170  if (strcasecmp ("NAME", element_name) == 0)
8171  set_client_state (CLIENT_MODIFY_ALERT_CONDITION_DATA_NAME);
8172  ELSE_ERROR ("modify_alert");
8173 
8175  if (strcasecmp ("DATA", element_name) == 0)
8176  set_client_state (CLIENT_MODIFY_ALERT_METHOD_DATA);
8177  ELSE_ERROR ("modify_alert");
8178 
8180  if (strcasecmp ("NAME", element_name) == 0)
8181  set_client_state (CLIENT_MODIFY_ALERT_METHOD_DATA_NAME);
8182  ELSE_ERROR ("modify_alert");
8183 
8184  case CLIENT_MODIFY_ASSET:
8185  if (strcasecmp ("COMMENT", element_name) == 0)
8186  {
8187  openvas_append_string (&modify_asset_data->comment, "");
8188  set_client_state (CLIENT_MODIFY_ASSET_COMMENT);
8189  }
8190  ELSE_ERROR ("modify_asset");
8191 
8192  case CLIENT_MODIFY_AUTH:
8193  if (strcasecmp ("GROUP", element_name) == 0)
8194  {
8195  const gchar* attribute;
8196  auth_group_t *new_group;
8197 
8198  new_group = g_malloc0 (sizeof (auth_group_t));
8199  if (find_attribute (attribute_names, attribute_values, "name",
8200  &attribute))
8201  new_group->group_name = g_strdup (attribute);
8203  g_slist_prepend (modify_auth_data->groups, new_group);
8204  set_client_state (CLIENT_MODIFY_AUTH_GROUP);
8205  }
8206  ELSE_ERROR ("modify_auth");
8207 
8209  if (strcasecmp ("AUTH_CONF_SETTING", element_name) == 0)
8210  set_client_state (CLIENT_MODIFY_AUTH_GROUP_AUTH_CONF_SETTING);
8211  ELSE_ERROR ("modify_auth");
8212 
8214  if (strcasecmp ("KEY", element_name) == 0)
8216  else if (strcasecmp ("VALUE", element_name) == 0)
8218  ELSE_ERROR ("modify_auth");
8219 
8220  case CLIENT_MODIFY_CONFIG:
8221  if (strcasecmp ("COMMENT", element_name) == 0)
8222  {
8223  openvas_free_string_var (&modify_config_data->comment);
8224  openvas_append_string (&modify_config_data->comment, "");
8225  set_client_state (CLIENT_MODIFY_CONFIG_COMMENT);
8226  }
8227  else if (strcasecmp ("SCANNER", element_name) == 0)
8228  {
8229  openvas_free_string_var (&modify_config_data->scanner_id);
8230  openvas_append_string (&modify_config_data->scanner_id, "");
8231  set_client_state (CLIENT_MODIFY_CONFIG_SCANNER);
8232  }
8233  else if (strcasecmp ("FAMILY_SELECTION", element_name) == 0)
8234  {
8235  modify_config_data->families_growing_all = make_array ();
8236  modify_config_data->families_static_all = make_array ();
8237  modify_config_data->families_growing_empty = make_array ();
8238  /* For GROWING entity, in case missing. */
8240  set_client_state (CLIENT_MODIFY_CONFIG_FAMILY_SELECTION);
8241  }
8242  else if (strcasecmp ("NAME", element_name) == 0)
8243  set_client_state (CLIENT_MODIFY_CONFIG_NAME);
8244  else if (strcasecmp ("NVT_SELECTION", element_name) == 0)
8245  {
8246  modify_config_data->nvt_selection = make_array ();
8247  set_client_state (CLIENT_MODIFY_CONFIG_NVT_SELECTION);
8248  }
8249  else if (strcasecmp ("PREFERENCE", element_name) == 0)
8250  {
8251  openvas_free_string_var (&modify_config_data->preference_name);
8252  openvas_free_string_var (&modify_config_data->preference_nvt_oid);
8253  openvas_free_string_var (&modify_config_data->preference_value);
8254  set_client_state (CLIENT_MODIFY_CONFIG_PREFERENCE);
8255  }
8256  ELSE_ERROR ("modify_config");
8257 
8259  if (strcasecmp ("FAMILY", element_name) == 0)
8260  set_client_state (CLIENT_MODIFY_CONFIG_NVT_SELECTION_FAMILY);
8261  else if (strcasecmp ("NVT", element_name) == 0)
8262  {
8263  append_attribute (attribute_names, attribute_values, "oid",
8265  set_client_state (CLIENT_MODIFY_CONFIG_NVT_SELECTION_NVT);
8266  }
8267  ELSE_ERROR ("modify_config");
8268 
8270  if (strcasecmp ("FAMILY", element_name) == 0)
8271  {
8272  /* For ALL entity, in case missing. */
8274  /* For GROWING entity, in case missing. */
8277  }
8278  else if (strcasecmp ("GROWING", element_name) == 0)
8280  ELSE_ERROR ("modify_config");
8281 
8283  if (strcasecmp ("ALL", element_name) == 0)
8284  set_client_state
8286  else if (strcasecmp ("GROWING", element_name) == 0)
8287  set_client_state
8289  else if (strcasecmp ("NAME", element_name) == 0)
8291  ELSE_ERROR ("modify_config");
8292 
8294  if (strcasecmp ("NAME", element_name) == 0)
8295  set_client_state (CLIENT_MODIFY_CONFIG_PREFERENCE_NAME);
8296  else if (strcasecmp ("NVT", element_name) == 0)
8297  {
8298  append_attribute (attribute_names, attribute_values, "oid",
8300  set_client_state (CLIENT_MODIFY_CONFIG_PREFERENCE_NVT);
8301  }
8302  else if (strcasecmp ("VALUE", element_name) == 0)
8303  set_client_state (CLIENT_MODIFY_CONFIG_PREFERENCE_VALUE);
8304  ELSE_ERROR ("modify_config");
8305 
8307  if (strcasecmp ("ALLOW_INSECURE", element_name) == 0)
8308  set_client_state (CLIENT_MODIFY_CREDENTIAL_ALLOW_INSECURE);
8309  else if (strcasecmp ("AUTH_ALGORITHM", element_name) == 0)
8310  {
8311  set_client_state (CLIENT_MODIFY_CREDENTIAL_AUTH_ALGORITHM);
8312  }
8313  else if (strcasecmp ("NAME", element_name) == 0)
8314  set_client_state (CLIENT_MODIFY_CREDENTIAL_NAME);
8315  else if (strcasecmp ("COMMENT", element_name) == 0)
8316  {
8317  openvas_free_string_var (&modify_credential_data->comment);
8318  openvas_append_string (&modify_credential_data->comment, "");
8319  set_client_state (CLIENT_MODIFY_CREDENTIAL_COMMENT);
8320  }
8321  else if (strcasecmp ("CERTIFICATE", element_name) == 0)
8322  {
8323  set_client_state (CLIENT_MODIFY_CREDENTIAL_CERTIFICATE);
8324  }
8325  else if (strcasecmp ("COMMUNITY", element_name) == 0)
8326  {
8327  openvas_append_string (&modify_credential_data->community, "");
8328  set_client_state (CLIENT_MODIFY_CREDENTIAL_COMMUNITY);
8329  }
8330  else if (strcasecmp ("KEY", element_name) == 0)
8331  {
8333  set_client_state (CLIENT_MODIFY_CREDENTIAL_KEY);
8334  }
8335  else if (strcasecmp ("LOGIN", element_name) == 0)
8336  set_client_state (CLIENT_MODIFY_CREDENTIAL_LOGIN);
8337  else if (strcasecmp ("PASSWORD", element_name) == 0)
8338  {
8339  openvas_free_string_var (&modify_credential_data->password);
8340  openvas_append_string (&modify_credential_data->password, "");
8341  set_client_state (CLIENT_MODIFY_CREDENTIAL_PASSWORD);
8342  }
8343  else if (strcasecmp ("PRIVACY", element_name) == 0)
8344  {
8345  set_client_state (CLIENT_MODIFY_CREDENTIAL_PRIVACY);
8346  openvas_append_string (&modify_credential_data->privacy_algorithm,
8347  "");
8348  }
8349  ELSE_ERROR ("modify_credential");
8350 
8352  if (strcasecmp ("PHRASE", element_name) == 0)
8353  {
8354  openvas_free_string_var (&modify_credential_data->key_phrase);
8355  openvas_append_string (&modify_credential_data->key_phrase, "");
8356  set_client_state (CLIENT_MODIFY_CREDENTIAL_KEY_PHRASE);
8357  }
8358  else if (strcasecmp ("PRIVATE", element_name) == 0)
8359  {
8360  set_client_state (CLIENT_MODIFY_CREDENTIAL_KEY_PRIVATE);
8361  }
8362  ELSE_ERROR ("modify_credential");
8363 
8365  if (strcasecmp ("ALGORITHM", element_name) == 0)
8366  {
8367  set_client_state (CLIENT_MODIFY_CREDENTIAL_PRIVACY_ALGORITHM);
8368  }
8369  else if (strcasecmp ("PASSWORD", element_name) == 0)
8370  {
8371  openvas_free_string_var (&modify_credential_data->privacy_password);
8372  openvas_append_string (&modify_credential_data->privacy_password,
8373  "");
8374  set_client_state (CLIENT_MODIFY_CREDENTIAL_PRIVACY_PASSWORD);
8375  }
8376  ELSE_ERROR ("modify_credential");
8377 
8378  case CLIENT_MODIFY_FILTER:
8379  if (strcasecmp ("COMMENT", element_name) == 0)
8380  {
8381  openvas_append_string (&modify_filter_data->comment, "");
8382  set_client_state (CLIENT_MODIFY_FILTER_COMMENT);
8383  }
8384  else if (strcasecmp ("NAME", element_name) == 0)
8385  {
8386  openvas_append_string (&modify_filter_data->name, "");
8387  set_client_state (CLIENT_MODIFY_FILTER_NAME);
8388  }
8389  else if (strcasecmp ("TERM", element_name) == 0)
8390  {
8391  openvas_append_string (&modify_filter_data->term, "");
8392  set_client_state (CLIENT_MODIFY_FILTER_TERM);
8393  }
8394  else if (strcasecmp ("TYPE", element_name) == 0)
8395  {
8396  openvas_append_string (&modify_filter_data->type, "");
8397  set_client_state (CLIENT_MODIFY_FILTER_TYPE);
8398  }
8399  ELSE_ERROR ("modify_filter");
8400 
8401  case CLIENT_MODIFY_GROUP:
8402  if (strcasecmp ("COMMENT", element_name) == 0)
8403  {
8404  openvas_append_string (&modify_group_data->comment, "");
8405  set_client_state (CLIENT_MODIFY_GROUP_COMMENT);
8406  }
8407  else if (strcasecmp ("NAME", element_name) == 0)
8408  {
8409  openvas_append_string (&modify_group_data->name, "");
8410  set_client_state (CLIENT_MODIFY_GROUP_NAME);
8411  }
8412  else if (strcasecmp ("USERS", element_name) == 0)
8413  {
8414  openvas_append_string (&modify_group_data->users, "");
8415  set_client_state (CLIENT_MODIFY_GROUP_USERS);
8416  }
8417  ELSE_ERROR ("modify_group");
8418 
8420  if (strcasecmp ("COMMENT", element_name) == 0)
8421  set_client_state (CLIENT_MODIFY_PERMISSION_COMMENT);
8422  else if (strcasecmp ("NAME", element_name) == 0)
8423  set_client_state (CLIENT_MODIFY_PERMISSION_NAME);
8424  else if (strcasecmp ("RESOURCE", element_name) == 0)
8425  {
8426  append_attribute (attribute_names, attribute_values, "id",
8428  set_client_state (CLIENT_MODIFY_PERMISSION_RESOURCE);
8429  }
8430  else if (strcasecmp ("SUBJECT", element_name) == 0)
8431  {
8432  append_attribute (attribute_names, attribute_values, "id",
8434  set_client_state (CLIENT_MODIFY_PERMISSION_SUBJECT);
8435  }
8436  ELSE_ERROR ("modify_permission");
8437 
8439  if (strcasecmp ("TYPE", element_name) == 0)
8440  set_client_state (CLIENT_MODIFY_PERMISSION_RESOURCE_TYPE);
8441  ELSE_ERROR ("modify_permission");
8442 
8444  if (strcasecmp ("TYPE", element_name) == 0)
8445  set_client_state (CLIENT_MODIFY_PERMISSION_SUBJECT_TYPE);
8446  ELSE_ERROR ("modify_permission");
8447 
8449  if (strcasecmp ("NAME", element_name) == 0)
8450  set_client_state (CLIENT_MODIFY_PORT_LIST_NAME);
8451  else if (strcasecmp ("COMMENT", element_name) == 0)
8452  {
8453  openvas_free_string_var (&modify_port_list_data->comment);
8454  openvas_append_string (&modify_port_list_data->comment, "");
8455  set_client_state (CLIENT_MODIFY_PORT_LIST_COMMENT);
8456  }
8457  ELSE_ERROR ("modify_port_list");
8458 
8459  case CLIENT_MODIFY_REPORT:
8460  if (strcasecmp ("COMMENT", element_name) == 0)
8461  set_client_state (CLIENT_MODIFY_REPORT_COMMENT);
8462  ELSE_ERROR ("modify_report");
8463 
8465  if (strcasecmp ("ACTIVE", element_name) == 0)
8466  set_client_state (CLIENT_MODIFY_REPORT_FORMAT_ACTIVE);
8467  else if (strcasecmp ("NAME", element_name) == 0)
8468  set_client_state (CLIENT_MODIFY_REPORT_FORMAT_NAME);
8469  else if (strcasecmp ("SUMMARY", element_name) == 0)
8470  set_client_state (CLIENT_MODIFY_REPORT_FORMAT_SUMMARY);
8471  else if (strcasecmp ("PARAM", element_name) == 0)
8472  set_client_state (CLIENT_MODIFY_REPORT_FORMAT_PARAM);
8473  ELSE_ERROR ("modify_report_format");
8474 
8476  if (strcasecmp ("NAME", element_name) == 0)
8477  set_client_state (CLIENT_MODIFY_REPORT_FORMAT_PARAM_NAME);
8478  else if (strcasecmp ("VALUE", element_name) == 0)
8479  set_client_state (CLIENT_MODIFY_REPORT_FORMAT_PARAM_VALUE);
8480  ELSE_ERROR ("modify_report_format");
8481 
8482  case CLIENT_MODIFY_ROLE:
8483  if (strcasecmp ("COMMENT", element_name) == 0)
8484  {
8485  openvas_append_string (&modify_role_data->comment, "");
8486  set_client_state (CLIENT_MODIFY_ROLE_COMMENT);
8487  }
8488  else if (strcasecmp ("NAME", element_name) == 0)
8489  {
8490  openvas_append_string (&modify_role_data->name, "");
8491  set_client_state (CLIENT_MODIFY_ROLE_NAME);
8492  }
8493  else if (strcasecmp ("USERS", element_name) == 0)
8494  {
8495  openvas_append_string (&modify_role_data->users, "");
8496  set_client_state (CLIENT_MODIFY_ROLE_USERS);
8497  }
8498  ELSE_ERROR ("modify_role");
8499 
8500  case CLIENT_MODIFY_SCANNER:
8501  if (strcasecmp ("COMMENT", element_name) == 0)
8502  {
8503  openvas_append_string (&modify_scanner_data->comment, "");
8504  set_client_state (CLIENT_MODIFY_SCANNER_COMMENT);
8505  }
8506  else if (strcasecmp ("NAME", element_name) == 0)
8507  {
8508  openvas_append_string (&modify_scanner_data->name, "");
8509  set_client_state (CLIENT_MODIFY_SCANNER_NAME);
8510  }
8511  else if (strcasecmp ("HOST", element_name) == 0)
8512  {
8513  openvas_append_string (&modify_scanner_data->host, "");
8514  set_client_state (CLIENT_MODIFY_SCANNER_HOST);
8515  }
8516  else if (strcasecmp ("PORT", element_name) == 0)
8517  {
8518  openvas_append_string (&modify_scanner_data->port, "");
8519  set_client_state (CLIENT_MODIFY_SCANNER_PORT);
8520  }
8521  else if (strcasecmp ("TYPE", element_name) == 0)
8522  {
8523  openvas_append_string (&modify_scanner_data->type, "");
8524  set_client_state (CLIENT_MODIFY_SCANNER_TYPE);
8525  }
8526  else if (strcasecmp ("CA_PUB", element_name) == 0)
8527  {
8528  openvas_append_string (&modify_scanner_data->ca_pub, "");
8529  set_client_state (CLIENT_MODIFY_SCANNER_CA_PUB);
8530  }
8531  else if (strcasecmp ("CREDENTIAL", element_name) == 0)
8532  {
8533  append_attribute (attribute_names, attribute_values, "id",
8535  set_client_state (CLIENT_MODIFY_SCANNER_CREDENTIAL);
8536  }
8537  ELSE_ERROR ("modify_scanner");
8538 
8540  if (strcasecmp ("COMMENT", element_name) == 0)
8541  {
8542  openvas_append_string (&modify_schedule_data->comment, "");
8543  set_client_state (CLIENT_MODIFY_SCHEDULE_COMMENT);
8544  }
8545  else if (strcasecmp ("NAME", element_name) == 0)
8546  {
8547  openvas_append_string (&modify_schedule_data->name, "");
8548  set_client_state (CLIENT_MODIFY_SCHEDULE_NAME);
8549  }
8550  else if (strcasecmp ("DURATION", element_name) == 0)
8551  set_client_state (CLIENT_MODIFY_SCHEDULE_DURATION);
8552  else if (strcasecmp ("FIRST_TIME", element_name) == 0)
8553  set_client_state (CLIENT_MODIFY_SCHEDULE_FIRST_TIME);
8554  else if (strcasecmp ("NAME", element_name) == 0)
8555  set_client_state (CLIENT_MODIFY_SCHEDULE_NAME);
8556  else if (strcasecmp ("PERIOD", element_name) == 0)
8557  set_client_state (CLIENT_MODIFY_SCHEDULE_PERIOD);
8558  else if (strcasecmp ("TIMEZONE", element_name) == 0)
8559  set_client_state (CLIENT_MODIFY_SCHEDULE_TIMEZONE);
8560  ELSE_ERROR ("modify_schedule");
8561 
8563  if (strcasecmp ("DAY_OF_MONTH", element_name) == 0)
8565  else if (strcasecmp ("HOUR", element_name) == 0)
8566  set_client_state (CLIENT_MODIFY_SCHEDULE_FIRST_TIME_HOUR);
8567  else if (strcasecmp ("MINUTE", element_name) == 0)
8568  set_client_state (CLIENT_MODIFY_SCHEDULE_FIRST_TIME_MINUTE);
8569  else if (strcasecmp ("MONTH", element_name) == 0)
8570  set_client_state (CLIENT_MODIFY_SCHEDULE_FIRST_TIME_MONTH);
8571  else if (strcasecmp ("YEAR", element_name) == 0)
8572  set_client_state (CLIENT_MODIFY_SCHEDULE_FIRST_TIME_YEAR);
8573  ELSE_ERROR ("modify_schedule");
8574 
8576  if (strcasecmp ("UNIT", element_name) == 0)
8577  set_client_state (CLIENT_MODIFY_SCHEDULE_DURATION_UNIT);
8578  ELSE_ERROR ("modify_schedule");
8579 
8581  if (strcasecmp ("UNIT", element_name) == 0)
8582  set_client_state (CLIENT_MODIFY_SCHEDULE_PERIOD_UNIT);
8583  ELSE_ERROR ("modify_schedule");
8584 
8585  case CLIENT_MODIFY_SETTING:
8586  if (strcasecmp ("NAME", element_name) == 0)
8587  set_client_state (CLIENT_MODIFY_SETTING_NAME);
8588  else if (strcasecmp ("VALUE", element_name) == 0)
8589  {
8590  openvas_append_string (&modify_setting_data->value, "");
8591  set_client_state (CLIENT_MODIFY_SETTING_VALUE);
8592  }
8593  ELSE_ERROR ("modify_setting");
8594 
8595  case CLIENT_MODIFY_TAG:
8596  if (strcasecmp ("ACTIVE", element_name) == 0)
8597  {
8598  openvas_append_string (&modify_tag_data->active, "");
8599  set_client_state (CLIENT_MODIFY_TAG_ACTIVE);
8600  }
8601  else if (strcasecmp ("RESOURCE", element_name) == 0)
8602  {
8603  append_attribute (attribute_names, attribute_values, "id",
8605  set_client_state (CLIENT_MODIFY_TAG_RESOURCE);
8606  }
8607  else if (strcasecmp ("COMMENT", element_name) == 0)
8608  {
8609  openvas_append_string (&modify_tag_data->comment, "");
8610  set_client_state (CLIENT_MODIFY_TAG_COMMENT);
8611  }
8612  else if (strcasecmp ("NAME", element_name) == 0)
8613  {
8614  openvas_append_string (&modify_tag_data->name, "");
8615  set_client_state (CLIENT_MODIFY_TAG_NAME);
8616  }
8617  else if (strcasecmp ("VALUE", element_name) == 0)
8618  {
8619  openvas_append_string (&modify_tag_data->value, "");
8620  set_client_state (CLIENT_MODIFY_TAG_VALUE);
8621  }
8622  ELSE_ERROR ("modify_tag");
8623 
8625  if (strcasecmp ("TYPE", element_name) == 0)
8626  {
8627  openvas_append_string (&modify_tag_data->resource_type, "");
8628  set_client_state (CLIENT_MODIFY_TAG_RESOURCE_TYPE);
8629  }
8630  ELSE_ERROR ("modify_tag");
8631 
8632  case CLIENT_MODIFY_TARGET:
8633  if (strcasecmp ("EXCLUDE_HOSTS", element_name) == 0)
8634  {
8635  openvas_append_string (&modify_target_data->exclude_hosts, "");
8636  set_client_state (CLIENT_MODIFY_TARGET_EXCLUDE_HOSTS);
8637  }
8638  else if (strcasecmp ("REVERSE_LOOKUP_ONLY", element_name) == 0)
8639  set_client_state (CLIENT_MODIFY_TARGET_REVERSE_LOOKUP_ONLY);
8640  else if (strcasecmp ("REVERSE_LOOKUP_UNIFY", element_name) == 0)
8641  set_client_state (CLIENT_MODIFY_TARGET_REVERSE_LOOKUP_UNIFY);
8642  else if (strcasecmp ("ALIVE_TESTS", element_name) == 0)
8643  set_client_state (CLIENT_MODIFY_TARGET_ALIVE_TESTS);
8644  else if (strcasecmp ("COMMENT", element_name) == 0)
8645  {
8646  openvas_append_string (&modify_target_data->comment, "");
8647  set_client_state (CLIENT_MODIFY_TARGET_COMMENT);
8648  }
8649  else if (strcasecmp ("ESXI_CREDENTIAL", element_name) == 0)
8650  {
8651  append_attribute (attribute_names, attribute_values, "id",
8653  set_client_state (CLIENT_MODIFY_TARGET_ESXI_CREDENTIAL);
8654  }
8655  else if (strcasecmp ("ESXI_LSC_CREDENTIAL", element_name) == 0)
8656  {
8657  append_attribute (attribute_names, attribute_values, "id",
8659  set_client_state (CLIENT_MODIFY_TARGET_ESXI_LSC_CREDENTIAL);
8660  }
8661  else if (strcasecmp ("HOSTS", element_name) == 0)
8662  {
8663  openvas_append_string (&modify_target_data->hosts, "");
8664  set_client_state (CLIENT_MODIFY_TARGET_HOSTS);
8665  }
8666  else if (strcasecmp ("PORT_LIST", element_name) == 0)
8667  {
8668  append_attribute (attribute_names, attribute_values, "id",
8670  set_client_state (CLIENT_MODIFY_TARGET_PORT_LIST);
8671  }
8672  else if (strcasecmp ("SSH_CREDENTIAL", element_name) == 0)
8673  {
8674  append_attribute (attribute_names, attribute_values, "id",
8676  set_client_state (CLIENT_MODIFY_TARGET_SSH_CREDENTIAL);
8677  }
8678  else if (strcasecmp ("SSH_LSC_CREDENTIAL", element_name) == 0)
8679  {
8680  append_attribute (attribute_names, attribute_values, "id",
8682  set_client_state (CLIENT_MODIFY_TARGET_SSH_LSC_CREDENTIAL);
8683  }
8684  else if (strcasecmp ("SMB_CREDENTIAL", element_name) == 0)
8685  {
8686  append_attribute (attribute_names, attribute_values, "id",
8688  set_client_state (CLIENT_MODIFY_TARGET_SMB_CREDENTIAL);
8689  }
8690  else if (strcasecmp ("SMB_LSC_CREDENTIAL", element_name) == 0)
8691  {
8692  append_attribute (attribute_names, attribute_values, "id",
8694  set_client_state (CLIENT_MODIFY_TARGET_SMB_LSC_CREDENTIAL);
8695  }
8696  else if (strcasecmp ("SNMP_CREDENTIAL", element_name) == 0)
8697  {
8698  append_attribute (attribute_names, attribute_values, "id",
8700  set_client_state (CLIENT_MODIFY_TARGET_SNMP_CREDENTIAL);
8701  }
8702  else if (strcasecmp ("NAME", element_name) == 0)
8703  {
8704  openvas_append_string (&modify_target_data->name, "");
8705  set_client_state (CLIENT_MODIFY_TARGET_NAME);
8706  }
8707  ELSE_ERROR ("modify_target");
8708 
8710  if (strcasecmp ("PORT", element_name) == 0)
8711  set_client_state (CLIENT_MODIFY_TARGET_SSH_CREDENTIAL_PORT);
8712  ELSE_ERROR ("modify_target");
8713 
8715  if (strcasecmp ("PORT", element_name) == 0)
8717  ELSE_ERROR ("modify_target");
8718 
8719  case CLIENT_MODIFY_TASK:
8720  if (strcasecmp ("ALTERABLE", element_name) == 0)
8721  set_client_state (CLIENT_MODIFY_TASK_ALTERABLE);
8722  else if (strcasecmp ("COMMENT", element_name) == 0)
8723  {
8724  openvas_append_string (&modify_task_data->comment, "");
8725  set_client_state (CLIENT_MODIFY_TASK_COMMENT);
8726  }
8727  else if (strcasecmp ("HOSTS_ORDERING", element_name) == 0)
8728  set_client_state (CLIENT_MODIFY_TASK_HOSTS_ORDERING);
8729  else if (strcasecmp ("SCANNER", element_name) == 0)
8730  {
8731  append_attribute (attribute_names, attribute_values, "id",
8733  set_client_state (CLIENT_MODIFY_TASK_SCANNER);
8734  }
8735  else if (strcasecmp ("ALERT", element_name) == 0)
8736  {
8737  const gchar* attribute;
8738  if (find_attribute (attribute_names, attribute_values, "id",
8739  &attribute))
8740  array_add (modify_task_data->alerts, g_strdup (attribute));
8741  set_client_state (CLIENT_MODIFY_TASK_ALERT);
8742  }
8743  else if (strcasecmp ("CONFIG", element_name) == 0)
8744  {
8745  append_attribute (attribute_names, attribute_values, "id",
8747  set_client_state (CLIENT_MODIFY_TASK_CONFIG);
8748  }
8749  else if (strcasecmp ("NAME", element_name) == 0)
8750  set_client_state (CLIENT_MODIFY_TASK_NAME);
8751  else if (strcasecmp ("OBSERVERS", element_name) == 0)
8752  {
8753  openvas_append_string (&modify_task_data->observers, "");
8754  set_client_state (CLIENT_MODIFY_TASK_OBSERVERS);
8755  }
8756  else if (strcasecmp ("PREFERENCES", element_name) == 0)
8757  {
8758  modify_task_data->preferences = make_array ();
8759  set_client_state (CLIENT_MODIFY_TASK_PREFERENCES);
8760  }
8761  else if (strcasecmp ("SCHEDULE", element_name) == 0)
8762  {
8763  append_attribute (attribute_names, attribute_values, "id",
8765  set_client_state (CLIENT_MODIFY_TASK_SCHEDULE);
8766  }
8767  else if (strcasecmp ("SCHEDULE_PERIODS", element_name) == 0)
8768  set_client_state (CLIENT_MODIFY_TASK_SCHEDULE_PERIODS);
8769  else if (strcasecmp ("TARGET", element_name) == 0)
8770  {
8771  append_attribute (attribute_names, attribute_values, "id",
8773  set_client_state (CLIENT_MODIFY_TASK_TARGET);
8774  }
8775  else if (strcasecmp ("FILE", element_name) == 0)
8776  {
8777  const gchar* attribute;
8778  append_attribute (attribute_names, attribute_values, "name",
8780  if (find_attribute (attribute_names, attribute_values,
8781  "action", &attribute))
8782  openvas_append_string (&modify_task_data->action, attribute);
8783  else
8784  openvas_append_string (&modify_task_data->action, "update");
8785  set_client_state (CLIENT_MODIFY_TASK_FILE);
8786  }
8787  ELSE_ERROR ("modify_task");
8788 
8790  if (strcasecmp ("GROUP", element_name) == 0)
8791  {
8792  const gchar* attribute;
8793  if (find_attribute (attribute_names, attribute_values, "id",
8794  &attribute))
8795  array_add (modify_task_data->groups, g_strdup (attribute));
8796  set_client_state (CLIENT_MODIFY_TASK_OBSERVERS_GROUP);
8797  }
8798  ELSE_ERROR ("modify_task");
8799 
8801  if (strcasecmp ("PREFERENCE", element_name) == 0)
8802  {
8803  assert (modify_task_data->preference == NULL);
8804  modify_task_data->preference = g_malloc (sizeof (name_value_t));
8805  modify_task_data->preference->name = NULL;
8807  set_client_state (CLIENT_MODIFY_TASK_PREFERENCES_PREFERENCE);
8808  }
8809  ELSE_ERROR ("modify_task");
8810 
8812  if (strcasecmp ("SCANNER_NAME", element_name) == 0)
8814  else if (strcasecmp ("VALUE", element_name) == 0)
8816  ELSE_ERROR ("modify_task");
8817 
8818  case CLIENT_MODIFY_USER:
8819  if (strcasecmp ("GROUPS", element_name) == 0)
8820  {
8821  if (modify_user_data->groups)
8822  array_free (modify_user_data->groups);
8823  modify_user_data->groups = make_array ();
8824  set_client_state (CLIENT_MODIFY_USER_GROUPS);
8825  }
8826  else if (strcasecmp ("HOSTS", element_name) == 0)
8827  {
8828  const gchar *attribute;
8829  if (find_attribute
8830  (attribute_names, attribute_values, "allow", &attribute))
8831  modify_user_data->hosts_allow = strcmp (attribute, "0");
8832  else
8834  /* Init, so that modify_user clears hosts if HOSTS is empty. */
8835  openvas_append_string (&modify_user_data->hosts, "");
8836  set_client_state (CLIENT_MODIFY_USER_HOSTS);
8837  }
8838  else if (strcasecmp ("IFACES", element_name) == 0)
8839  {
8840  const gchar *attribute;
8841  if (find_attribute
8842  (attribute_names, attribute_values, "allow", &attribute))
8843  modify_user_data->ifaces_allow = strcmp (attribute, "0");
8844  else
8846  openvas_append_string (&modify_user_data->ifaces, "");
8847  set_client_state (CLIENT_MODIFY_USER_IFACES);
8848  }
8849  else if (strcasecmp ("NAME", element_name) == 0)
8850  set_client_state (CLIENT_MODIFY_USER_NAME);
8851  else if (strcasecmp ("NEW_NAME", element_name) == 0)
8852  set_client_state (CLIENT_MODIFY_USER_NEW_NAME);
8853  else if (strcasecmp ("PASSWORD", element_name) == 0)
8854  {
8855  const gchar *attribute;
8856  if (find_attribute
8857  (attribute_names, attribute_values, "modify", &attribute))
8858  modify_user_data->modify_password = strcmp (attribute, "0");
8859  else
8861  set_client_state (CLIENT_MODIFY_USER_PASSWORD);
8862  }
8863  else if (strcasecmp ("ROLE", element_name) == 0)
8864  {
8865  const gchar* attribute;
8866  /* Init array here, so it's NULL if there are no ROLEs. */
8867  if (modify_user_data->roles == NULL)
8868  {
8869  array_free (modify_user_data->roles);
8870  modify_user_data->roles = make_array ();
8871  }
8872  if (find_attribute (attribute_names, attribute_values, "id",
8873  &attribute))
8874  array_add (modify_user_data->roles, g_strdup (attribute));
8875  set_client_state (CLIENT_MODIFY_USER_ROLE);
8876  }
8877  else if (strcasecmp ("SOURCES", element_name) == 0)
8878  {
8879  modify_user_data->sources = make_array ();
8880  set_client_state (CLIENT_MODIFY_USER_SOURCES);
8881  }
8882  else
8883  {
8884  if (send_element_error_to_client ("modify_user", element_name,
8885  write_to_client,
8886  write_to_client_data))
8887  {
8888  error_send_to_client (error);
8889  return;
8890  }
8891  set_client_state (CLIENT_AUTHENTIC);
8892  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
8893  "Error");
8894  }
8895  break;
8896 
8898  if (strcasecmp ("GROUP", element_name) == 0)
8899  {
8900  const gchar* attribute;
8901  if (find_attribute (attribute_names, attribute_values, "id",
8902  &attribute))
8903  array_add (modify_user_data->groups, g_strdup (attribute));
8904  set_client_state (CLIENT_MODIFY_USER_GROUPS_GROUP);
8905  }
8906  ELSE_ERROR ("modify_user");
8907 
8909  if (strcasecmp ("SOURCE", element_name) == 0)
8910  {
8911  set_client_state (CLIENT_MODIFY_USER_SOURCES_SOURCE);
8912  }
8913  else
8914  {
8915  if (send_element_error_to_client ("modify_user_sources",
8916  element_name,
8917  write_to_client,
8918  write_to_client_data))
8919  {
8920  error_send_to_client (error);
8921  return;
8922  }
8923  set_client_state (CLIENT_AUTHENTIC);
8924  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
8925  "Error");
8926  }
8927  break;
8928 
8929  case CLIENT_CREATE_AGENT:
8930  if (strcasecmp ("COMMENT", element_name) == 0)
8931  set_client_state (CLIENT_CREATE_AGENT_COMMENT);
8932  else if (strcasecmp ("COPY", element_name) == 0)
8933  set_client_state (CLIENT_CREATE_AGENT_COPY);
8934  else if (strcasecmp ("HOWTO_INSTALL", element_name) == 0)
8935  set_client_state (CLIENT_CREATE_AGENT_HOWTO_INSTALL);
8936  else if (strcasecmp ("HOWTO_USE", element_name) == 0)
8937  set_client_state (CLIENT_CREATE_AGENT_HOWTO_USE);
8938  else if (strcasecmp ("INSTALLER", element_name) == 0)
8939  set_client_state (CLIENT_CREATE_AGENT_INSTALLER);
8940  else if (strcasecmp ("NAME", element_name) == 0)
8941  {
8942  openvas_append_string (&create_agent_data->name, "");
8943  set_client_state (CLIENT_CREATE_AGENT_NAME);
8944  }
8945  ELSE_ERROR ("create_agent");
8947  if (strcasecmp ("FILENAME", element_name) == 0)
8948  set_client_state (CLIENT_CREATE_AGENT_INSTALLER_FILENAME);
8949  else if (strcasecmp ("SIGNATURE", element_name) == 0)
8950  set_client_state (CLIENT_CREATE_AGENT_INSTALLER_SIGNATURE);
8951  ELSE_ERROR ("create_agent");
8952 
8953  case CLIENT_CREATE_ASSET:
8954  if (strcasecmp ("ASSET", element_name) == 0)
8955  set_client_state (CLIENT_CREATE_ASSET_ASSET);
8956  else if (strcasecmp ("REPORT", element_name) == 0)
8957  {
8958  append_attribute (attribute_names, attribute_values, "id",
8960  set_client_state (CLIENT_CREATE_ASSET_REPORT);
8961  }
8962  ELSE_ERROR ("create_asset");
8963 
8965  if (strcasecmp ("COMMENT", element_name) == 0)
8966  set_client_state (CLIENT_CREATE_ASSET_ASSET_COMMENT);
8967  else if (strcasecmp ("NAME", element_name) == 0)
8968  set_client_state (CLIENT_CREATE_ASSET_ASSET_NAME);
8969  else if (strcasecmp ("TYPE", element_name) == 0)
8970  set_client_state (CLIENT_CREATE_ASSET_ASSET_TYPE);
8971  ELSE_ERROR ("create_asset");
8972 
8974  if (strcasecmp ("FILTER", element_name) == 0)
8975  set_client_state (CLIENT_CREATE_ASSET_REPORT_FILTER);
8976  ELSE_ERROR ("create_asset");
8977 
8979  if (strcasecmp ("TERM", element_name) == 0)
8980  set_client_state (CLIENT_CREATE_ASSET_REPORT_FILTER_TERM);
8981  ELSE_ERROR ("create_asset");
8982 
8983  case CLIENT_CREATE_CONFIG:
8984  if (strcasecmp ("COMMENT", element_name) == 0)
8985  set_client_state (CLIENT_CREATE_CONFIG_COMMENT);
8986  else if (strcasecmp ("SCANNER", element_name) == 0)
8987  set_client_state (CLIENT_CREATE_CONFIG_SCANNER);
8988  else if (strcasecmp ("COPY", element_name) == 0)
8989  set_client_state (CLIENT_CREATE_CONFIG_COPY);
8990  else if (strcasecmp ("GET_CONFIGS_RESPONSE", element_name) == 0)
8991  {
8992  omp_parser->importing = 1;
8994  set_client_state (CLIENT_C_C_GCR);
8995  }
8996  else if (strcasecmp ("NAME", element_name) == 0)
8997  set_client_state (CLIENT_CREATE_CONFIG_NAME);
8998  ELSE_ERROR ("create_config");
8999 
9000  case CLIENT_C_C_GCR:
9001  if (strcasecmp ("CONFIG", element_name) == 0)
9002  {
9003  /* Reset here in case there was a previous config element. */
9004  create_config_data_reset (create_config_data);
9006  set_client_state (CLIENT_C_C_GCR_CONFIG);
9007  }
9008  ELSE_ERROR ("create_config");
9009 
9010  case CLIENT_C_C_GCR_CONFIG:
9011  if (strcasecmp ("COMMENT", element_name) == 0)
9012  set_client_state (CLIENT_C_C_GCR_CONFIG_COMMENT);
9013  else if (strcasecmp ("NAME", element_name) == 0)
9014  set_client_state (CLIENT_C_C_GCR_CONFIG_NAME);
9015  else if (strcasecmp ("NVT_SELECTORS", element_name) == 0)
9016  {
9017  /* Reset array, in case there was a previous nvt_selectors element. */
9018  array_reset (&import_config_data->nvt_selectors);
9019  set_client_state (CLIENT_C_C_GCR_CONFIG_NVT_SELECTORS);
9020  }
9021  else if (strcasecmp ("PREFERENCES", element_name) == 0)
9022  {
9023  /* Reset array, in case there was a previous preferences element. */
9024  array_reset (&import_config_data->preferences);
9025  set_client_state (CLIENT_C_C_GCR_CONFIG_PREFERENCES);
9026  }
9027  else if (strcasecmp ("TYPE", element_name) == 0)
9028  {
9029  set_client_state (CLIENT_C_C_GCR_CONFIG_TYPE);
9030  }
9031  ELSE_ERROR ("create_config");
9032 
9034  if (strcasecmp ("NVT_SELECTOR", element_name) == 0)
9036  ELSE_ERROR ("create_config");
9037 
9039  if (strcasecmp ("INCLUDE", element_name) == 0)
9040  set_client_state
9042  else if (strcasecmp ("NAME", element_name) == 0)
9043  set_client_state
9045  else if (strcasecmp ("TYPE", element_name) == 0)
9046  set_client_state
9048  else if (strcasecmp ("FAMILY_OR_NVT", element_name) == 0)
9049  set_client_state
9051  ELSE_ERROR ("create_config");
9052 
9054  if (strcasecmp ("PREFERENCE", element_name) == 0)
9055  {
9056  array_reset (&import_config_data->preference_alts);
9058  }
9059  ELSE_ERROR ("create_config");
9060 
9062  if (strcasecmp ("ALT", element_name) == 0)
9063  set_client_state
9065  else if (strcasecmp ("DEFAULT", element_name) == 0)
9066  set_client_state
9068  else if (strcasecmp ("HR_NAME", element_name) == 0)
9069  set_client_state
9071  else if (strcasecmp ("NAME", element_name) == 0)
9072  set_client_state
9074  else if (strcasecmp ("NVT", element_name) == 0)
9075  {
9076  append_attribute (attribute_names, attribute_values, "oid",
9078  set_client_state
9080  }
9081  else if (strcasecmp ("TYPE", element_name) == 0)
9082  set_client_state
9084  else if (strcasecmp ("VALUE", element_name) == 0)
9085  set_client_state
9087  ELSE_ERROR ("create_config");
9088 
9090  if (strcasecmp ("NAME", element_name) == 0)
9091  set_client_state
9093  ELSE_ERROR ("create_config");
9094 
9095  case CLIENT_CREATE_ALERT:
9096  if (strcasecmp ("COMMENT", element_name) == 0)
9097  set_client_state (CLIENT_CREATE_ALERT_COMMENT);
9098  else if (strcasecmp ("COPY", element_name) == 0)
9099  set_client_state (CLIENT_CREATE_ALERT_COPY);
9100  else if (strcasecmp ("CONDITION", element_name) == 0)
9101  set_client_state (CLIENT_CREATE_ALERT_CONDITION);
9102  else if (strcasecmp ("EVENT", element_name) == 0)
9103  set_client_state (CLIENT_CREATE_ALERT_EVENT);
9104  else if (strcasecmp ("FILTER", element_name) == 0)
9105  {
9106  append_attribute (attribute_names, attribute_values, "id",
9108  set_client_state (CLIENT_CREATE_ALERT_FILTER);
9109  }
9110  else if (strcasecmp ("METHOD", element_name) == 0)
9111  set_client_state (CLIENT_CREATE_ALERT_METHOD);
9112  else if (strcasecmp ("NAME", element_name) == 0)
9113  set_client_state (CLIENT_CREATE_ALERT_NAME);
9114  ELSE_ERROR ("create_alert");
9115 
9117  if (strcasecmp ("DATA", element_name) == 0)
9118  set_client_state (CLIENT_CREATE_ALERT_CONDITION_DATA);
9119  ELSE_ERROR ("create_alert");
9120 
9122  if (strcasecmp ("NAME", element_name) == 0)
9123  set_client_state (CLIENT_CREATE_ALERT_CONDITION_DATA_NAME);
9124  ELSE_ERROR ("create_alert");
9125 
9127  if (strcasecmp ("DATA", element_name) == 0)
9128  set_client_state (CLIENT_CREATE_ALERT_EVENT_DATA);
9129  ELSE_ERROR ("create_alert");
9130 
9132  if (strcasecmp ("NAME", element_name) == 0)
9133  set_client_state (CLIENT_CREATE_ALERT_EVENT_DATA_NAME);
9134  ELSE_ERROR ("create_alert");
9135 
9137  if (strcasecmp ("DATA", element_name) == 0)
9138  set_client_state (CLIENT_CREATE_ALERT_METHOD_DATA);
9139  ELSE_ERROR ("create_alert");
9140 
9142  if (strcasecmp ("NAME", element_name) == 0)
9143  set_client_state (CLIENT_CREATE_ALERT_METHOD_DATA_NAME);
9144  ELSE_ERROR ("create_alert");
9145 
9147  if (strcasecmp ("ALLOW_INSECURE", element_name) == 0)
9148  set_client_state (CLIENT_CREATE_CREDENTIAL_ALLOW_INSECURE);
9149  else if (strcasecmp ("AUTH_ALGORITHM", element_name) == 0)
9150  set_client_state (CLIENT_CREATE_CREDENTIAL_AUTH_ALGORITHM);
9151  else if (strcasecmp ("CERTIFICATE", element_name) == 0)
9152  set_client_state (CLIENT_CREATE_CREDENTIAL_CERTIFICATE);
9153  else if (strcasecmp ("COMMENT", element_name) == 0)
9154  set_client_state (CLIENT_CREATE_CREDENTIAL_COMMENT);
9155  else if (strcasecmp ("COMMUNITY", element_name) == 0)
9156  set_client_state (CLIENT_CREATE_CREDENTIAL_COMMUNITY);
9157  else if (strcasecmp ("KEY", element_name) == 0)
9158  {
9160  set_client_state (CLIENT_CREATE_CREDENTIAL_KEY);
9161  }
9162  else if (strcasecmp ("LOGIN", element_name) == 0)
9163  set_client_state (CLIENT_CREATE_CREDENTIAL_LOGIN);
9164  else if (strcasecmp ("COPY", element_name) == 0)
9165  set_client_state (CLIENT_CREATE_CREDENTIAL_COPY);
9166  else if (strcasecmp ("NAME", element_name) == 0)
9167  set_client_state (CLIENT_CREATE_CREDENTIAL_NAME);
9168  else if (strcasecmp ("PASSWORD", element_name) == 0)
9169  {
9170  openvas_append_string (&create_credential_data->password, "");
9171  set_client_state (CLIENT_CREATE_CREDENTIAL_PASSWORD);
9172  }
9173  else if (strcasecmp ("PRIVACY", element_name) == 0)
9174  set_client_state (CLIENT_CREATE_CREDENTIAL_PRIVACY);
9175  else if (strcasecmp ("TYPE", element_name) == 0)
9176  set_client_state (CLIENT_CREATE_CREDENTIAL_TYPE);
9177  ELSE_ERROR ("create_credential");
9178 
9180  if (strcasecmp ("PHRASE", element_name) == 0)
9181  {
9182  openvas_append_string (&create_credential_data->key_phrase, "");
9183  set_client_state (CLIENT_CREATE_CREDENTIAL_KEY_PHRASE);
9184  }
9185  else if (strcasecmp ("PRIVATE", element_name) == 0)
9186  set_client_state (CLIENT_CREATE_CREDENTIAL_KEY_PRIVATE);
9187  ELSE_ERROR ("create_credential");
9188 
9190  if (strcasecmp ("ALGORITHM", element_name) == 0)
9191  set_client_state (CLIENT_CREATE_CREDENTIAL_PRIVACY_ALGORITHM);
9192  else if (strcasecmp ("PASSWORD", element_name) == 0)
9193  set_client_state (CLIENT_CREATE_CREDENTIAL_PRIVACY_PASSWORD);
9194  ELSE_ERROR ("create_credential");
9195 
9196  case CLIENT_CREATE_FILTER:
9197  if (strcasecmp ("COMMENT", element_name) == 0)
9198  set_client_state (CLIENT_CREATE_FILTER_COMMENT);
9199  else if (strcasecmp ("COPY", element_name) == 0)
9200  set_client_state (CLIENT_CREATE_FILTER_COPY);
9201  else if (strcasecmp ("NAME", element_name) == 0)
9202  {
9203  openvas_append_string (&create_filter_data->name, "");
9204  set_client_state (CLIENT_CREATE_FILTER_NAME);
9205  }
9206  else if (strcasecmp ("TERM", element_name) == 0)
9207  set_client_state (CLIENT_CREATE_FILTER_TERM);
9208  else if (strcasecmp ("TYPE", element_name) == 0)
9209  set_client_state (CLIENT_CREATE_FILTER_TYPE);
9210  ELSE_ERROR ("create_filter");
9211 
9213  if (strcasecmp ("MAKE_UNIQUE", element_name) == 0)
9214  set_client_state (CLIENT_CREATE_FILTER_NAME_MAKE_UNIQUE);
9215  ELSE_ERROR ("create_filter");
9216 
9217  case CLIENT_CREATE_GROUP:
9218  if (strcasecmp ("COMMENT", element_name) == 0)
9219  set_client_state (CLIENT_CREATE_GROUP_COMMENT);
9220  else if (strcasecmp ("COPY", element_name) == 0)
9221  set_client_state (CLIENT_CREATE_GROUP_COPY);
9222  else if (strcasecmp ("NAME", element_name) == 0)
9223  {
9224  openvas_append_string (&create_group_data->name, "");
9225  set_client_state (CLIENT_CREATE_GROUP_NAME);
9226  }
9227  else if (strcasecmp ("SPECIALS", element_name) == 0)
9228  set_client_state (CLIENT_CREATE_GROUP_SPECIALS);
9229  else if (strcasecmp ("USERS", element_name) == 0)
9230  set_client_state (CLIENT_CREATE_GROUP_USERS);
9231  ELSE_ERROR ("create_group");
9232 
9234  if (strcasecmp ("FULL", element_name) == 0)
9235  {
9237  set_client_state (CLIENT_CREATE_GROUP_SPECIALS_FULL);
9238  }
9239  ELSE_ERROR ("create_group");
9240 
9241  case CLIENT_CREATE_NOTE:
9242  if (strcasecmp ("ACTIVE", element_name) == 0)
9243  set_client_state (CLIENT_CREATE_NOTE_ACTIVE);
9244  else if (strcasecmp ("COPY", element_name) == 0)
9245  set_client_state (CLIENT_CREATE_NOTE_COPY);
9246  else if (strcasecmp ("HOSTS", element_name) == 0)
9247  set_client_state (CLIENT_CREATE_NOTE_HOSTS);
9248  else if (strcasecmp ("NVT", element_name) == 0)
9249  {
9250  append_attribute (attribute_names, attribute_values, "oid",
9252  set_client_state (CLIENT_CREATE_NOTE_NVT);
9253  }
9254  else if (strcasecmp ("PORT", element_name) == 0)
9255  set_client_state (CLIENT_CREATE_NOTE_PORT);
9256  else if (strcasecmp ("RESULT", element_name) == 0)
9257  {
9258  append_attribute (attribute_names, attribute_values, "id",
9261  && create_note_data->result_id[0] == '\0')
9262  {
9263  g_free (create_note_data->result_id);
9264  create_note_data->result_id = NULL;
9265  }
9266  set_client_state (CLIENT_CREATE_NOTE_RESULT);
9267  }
9268  else if (strcasecmp ("SEVERITY", element_name) == 0)
9269  set_client_state (CLIENT_CREATE_NOTE_SEVERITY);
9270  else if (strcasecmp ("TASK", element_name) == 0)
9271  {
9272  append_attribute (attribute_names, attribute_values, "id",
9275  && create_note_data->task_id[0] == '\0')
9276  {
9277  g_free (create_note_data->task_id);
9278  create_note_data->task_id = NULL;
9279  }
9280  set_client_state (CLIENT_CREATE_NOTE_TASK);
9281  }
9282  else if (strcasecmp ("TEXT", element_name) == 0)
9283  set_client_state (CLIENT_CREATE_NOTE_TEXT);
9284  else if (strcasecmp ("THREAT", element_name) == 0)
9285  set_client_state (CLIENT_CREATE_NOTE_THREAT);
9286  ELSE_ERROR ("create_note");
9287 
9289  if (strcasecmp ("COMMENT", element_name) == 0)
9290  set_client_state (CLIENT_CREATE_PERMISSION_COMMENT);
9291  else if (strcasecmp ("COPY", element_name) == 0)
9292  set_client_state (CLIENT_CREATE_PERMISSION_COPY);
9293  else if (strcasecmp ("NAME", element_name) == 0)
9294  {
9295  openvas_append_string (&create_permission_data->name, "");
9296  set_client_state (CLIENT_CREATE_PERMISSION_NAME);
9297  }
9298  else if (strcasecmp ("RESOURCE", element_name) == 0)
9299  {
9300  append_attribute (attribute_names, attribute_values, "id",
9302  set_client_state (CLIENT_CREATE_PERMISSION_RESOURCE);
9303  }
9304  else if (strcasecmp ("SUBJECT", element_name) == 0)
9305  {
9306  append_attribute (attribute_names, attribute_values, "id",
9308  set_client_state (CLIENT_CREATE_PERMISSION_SUBJECT);
9309  }
9310  ELSE_ERROR ("create_permission");
9311 
9313  if (strcasecmp ("TYPE", element_name) == 0)
9314  set_client_state (CLIENT_CREATE_PERMISSION_RESOURCE_TYPE);
9315  ELSE_ERROR ("create_permission");
9316 
9318  if (strcasecmp ("TYPE", element_name) == 0)
9319  set_client_state (CLIENT_CREATE_PERMISSION_SUBJECT_TYPE);
9320  ELSE_ERROR ("create_permission");
9321 
9323  if (strcasecmp ("COMMENT", element_name) == 0)
9324  set_client_state (CLIENT_CREATE_PORT_LIST_COMMENT);
9325  else if (strcasecmp ("COPY", element_name) == 0)
9326  set_client_state (CLIENT_CREATE_PORT_LIST_COPY);
9327  else if (strcasecmp ("GET_PORT_LISTS_RESPONSE", element_name) == 0)
9328  {
9329  omp_parser->importing = 1;
9331  set_client_state (CLIENT_CPL_GPLR);
9332  }
9333  else if (strcasecmp ("PORT_RANGE", element_name) == 0)
9334  {
9335  openvas_append_string (&create_port_list_data->port_range, "");
9336  set_client_state (CLIENT_CREATE_PORT_LIST_PORT_RANGE);
9337  }
9338  else if (strcasecmp ("NAME", element_name) == 0)
9339  set_client_state (CLIENT_CREATE_PORT_LIST_NAME);
9340  ELSE_ERROR ("create_port_list");
9341 
9342  case CLIENT_CPL_GPLR:
9343  if (strcasecmp ("PORT_LIST", element_name) == 0)
9344  {
9345  append_attribute (attribute_names, attribute_values, "id",
9347  set_client_state (CLIENT_CPL_GPLR_PORT_LIST);
9348  }
9349  ELSE_ERROR ("create_port_list");
9350 
9352  if (strcasecmp ("COMMENT", element_name) == 0)
9353  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_COMMENT);
9354  else if (strcasecmp ("IN_USE", element_name) == 0)
9355  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_IN_USE);
9356  else if (strcasecmp ("NAME", element_name) == 0)
9357  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_NAME);
9358  else if (strcasecmp ("PORT_RANGE", element_name) == 0)
9359  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_PORT_RANGE);
9360  else if (strcasecmp ("PORT_RANGES", element_name) == 0)
9361  {
9362  create_port_list_data->ranges = make_array ();
9363  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_PORT_RANGES);
9364  }
9365  else if (strcasecmp ("TARGETS", element_name) == 0)
9366  {
9367  omp_parser->read_over = 1;
9368  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_TARGETS);
9369  }
9370  ELSE_ERROR ("create_port_list");
9371 
9373  if (strcasecmp ("PORT_RANGE", element_name) == 0)
9374  {
9375  assert (create_port_list_data->range == NULL);
9377  = g_malloc0 (sizeof (create_port_list_range_t));
9378  append_attribute (attribute_names, attribute_values, "id",
9381  }
9382  ELSE_ERROR ("create_port_list");
9383 
9385  if (strcasecmp ("COMMENT", element_name) == 0)
9386  {
9387  openvas_append_string (&create_port_list_data->range->comment, "");
9389  }
9390  else if (strcasecmp ("END", element_name) == 0)
9391  {
9392  openvas_append_string (&create_port_list_data->range->end, "");
9394  }
9395  else if (strcasecmp ("START", element_name) == 0)
9396  {
9397  openvas_append_string (&create_port_list_data->range->start, "");
9399  }
9400  else if (strcasecmp ("TYPE", element_name) == 0)
9401  {
9402  openvas_append_string (&create_port_list_data->range->type, "");
9404  }
9405  ELSE_ERROR ("create_port_list");
9406 
9408  if (strcasecmp ("COMMENT", element_name) == 0)
9409  set_client_state (CLIENT_CREATE_PORT_RANGE_COMMENT);
9410  else if (strcasecmp ("END", element_name) == 0)
9411  set_client_state (CLIENT_CREATE_PORT_RANGE_END);
9412  else if (strcasecmp ("PORT_LIST", element_name) == 0)
9413  {
9414  append_attribute (attribute_names, attribute_values, "id",
9416  set_client_state (CLIENT_CREATE_PORT_RANGE_PORT_LIST);
9417  }
9418  else if (strcasecmp ("START", element_name) == 0)
9419  set_client_state (CLIENT_CREATE_PORT_RANGE_START);
9420  else if (strcasecmp ("TYPE", element_name) == 0)
9421  set_client_state (CLIENT_CREATE_PORT_RANGE_TYPE);
9422  ELSE_ERROR ("create_port_range");
9423 
9424  case CLIENT_CREATE_ROLE:
9425  if (strcasecmp ("COMMENT", element_name) == 0)
9426  set_client_state (CLIENT_CREATE_ROLE_COMMENT);
9427  else if (strcasecmp ("COPY", element_name) == 0)
9428  set_client_state (CLIENT_CREATE_ROLE_COPY);
9429  else if (strcasecmp ("NAME", element_name) == 0)
9430  {
9431  openvas_append_string (&create_role_data->name, "");
9432  set_client_state (CLIENT_CREATE_ROLE_NAME);
9433  }
9434  else if (strcasecmp ("USERS", element_name) == 0)
9435  set_client_state (CLIENT_CREATE_ROLE_USERS);
9436  ELSE_ERROR ("create_role");
9437 
9438  case CLIENT_CREATE_REPORT:
9439  if (strcasecmp ("IN_ASSETS", element_name) == 0)
9440  {
9441  set_client_state (CLIENT_CREATE_REPORT_IN_ASSETS);
9442  }
9443  else if (strcasecmp ("REPORT", element_name) == 0)
9444  {
9445  const gchar* attribute;
9446 
9447  omp_parser->importing = 1;
9448 
9449  append_attribute (attribute_names, attribute_values,
9450  "type", &create_report_data->type);
9451 
9452  if (find_attribute (attribute_names, attribute_values, "format_id",
9453  &attribute))
9454  {
9455  /* Assume this is the wrapper REPORT. */
9457  set_client_state (CLIENT_CREATE_REPORT_REPORT);
9458  }
9459  else
9460  {
9461  /* Assume the report is immediately inside the CREATE_REPORT. */
9463  create_report_data->details = make_array ();
9464  create_report_data->host_ends = make_array ();
9465  create_report_data->host_starts = make_array ();
9466  create_report_data->results = make_array ();
9467  set_client_state (CLIENT_CREATE_REPORT_RR);
9468  }
9469  }
9470  else if (strcasecmp ("TASK", element_name) == 0)
9471  {
9472  append_attribute (attribute_names, attribute_values, "id",
9474  set_client_state (CLIENT_CREATE_REPORT_TASK);
9475  }
9476  ELSE_ERROR ("create_report");
9477 
9479  if (strcasecmp ("REPORT", element_name) == 0)
9480  {
9481  create_report_data->details = make_array ();
9482  create_report_data->host_ends = make_array ();
9483  create_report_data->host_starts = make_array ();
9484  create_report_data->results = make_array ();
9485  set_client_state (CLIENT_CREATE_REPORT_RR);
9486  }
9487  ELSE_ERROR ("create_report");
9488 
9490  if (strcasecmp ("FILTERS", element_name) == 0)
9491  {
9492  omp_parser->read_over = 1;
9493  set_client_state (CLIENT_CREATE_REPORT_RR_FILTERS);
9494  }
9495  else if (strcasecmp ("HOST", element_name) == 0)
9496  {
9497  set_client_state (CLIENT_CREATE_REPORT_RR_H);
9498  }
9499  else if (strcasecmp ("HOST_COUNT", element_name) == 0)
9500  {
9501  omp_parser->read_over = 1;
9502  set_client_state (CLIENT_CREATE_REPORT_RR_HOST_COUNT);
9503  }
9504  else if (strcasecmp ("HOST_END", element_name) == 0)
9505  set_client_state (CLIENT_CREATE_REPORT_RR_HOST_END);
9506  else if (strcasecmp ("HOST_START", element_name) == 0)
9507  set_client_state (CLIENT_CREATE_REPORT_RR_HOST_START);
9508  else if (strcasecmp ("HOSTS", element_name) == 0)
9509  {
9510  omp_parser->read_over = 1;
9511  set_client_state (CLIENT_CREATE_REPORT_RR_HOSTS);
9512  }
9513  else if (strcasecmp ("PORTS", element_name) == 0)
9514  {
9515  omp_parser->read_over = 1;
9516  set_client_state (CLIENT_CREATE_REPORT_RR_PORTS);
9517  }
9518  else if (strcasecmp ("REPORT_FORMAT", element_name) == 0)
9519  {
9520  omp_parser->read_over = 1;
9521  set_client_state (CLIENT_CREATE_REPORT_RR_REPORT_FORMAT);
9522  }
9523  else if (strcasecmp ("RESULTS", element_name) == 0)
9524  set_client_state (CLIENT_CREATE_REPORT_RR_RESULTS);
9525  else if (strcasecmp ("RESULT_COUNT", element_name) == 0)
9526  {
9527  omp_parser->read_over = 1;
9528  set_client_state (CLIENT_CREATE_REPORT_RR_RESULT_COUNT);
9529  }
9530  else if (strcasecmp ("SCAN_RUN_STATUS", element_name) == 0)
9531  {
9532  omp_parser->read_over = 1;
9533  set_client_state
9535  }
9536  else if (strcasecmp ("SCAN_END", element_name) == 0)
9537  {
9538  set_client_state (CLIENT_CREATE_REPORT_RR_SCAN_END);
9539  }
9540  else if (strcasecmp ("SCAN_START", element_name) == 0)
9541  {
9542  set_client_state (CLIENT_CREATE_REPORT_RR_SCAN_START);
9543  }
9544  else if (strcasecmp ("SORT", element_name) == 0)
9545  {
9546  omp_parser->read_over = 1;
9547  set_client_state (CLIENT_CREATE_REPORT_RR_SORT);
9548  }
9549  else if (strcasecmp ("TASK", element_name) == 0)
9550  {
9551  omp_parser->read_over = 1;
9552  set_client_state (CLIENT_CREATE_REPORT_RR_TASK);
9553  }
9554  ELSE_ERROR ("create_report");
9555 
9557  if (strcasecmp ("HOST", element_name) == 0)
9558  set_client_state (CLIENT_CREATE_REPORT_RR_HOST_END_HOST);
9559  ELSE_ERROR ("create_report");
9560 
9562  if (strcasecmp ("HOST", element_name) == 0)
9563  set_client_state (CLIENT_CREATE_REPORT_RR_HOST_START_HOST);
9564  ELSE_ERROR ("create_report");
9565 
9567  if (strcasecmp ("IP", element_name) == 0)
9568  {
9569  set_client_state (CLIENT_CREATE_REPORT_RR_H_IP);
9570  }
9571  else if (strcasecmp ("DETAIL", element_name) == 0)
9572  {
9573  set_client_state (CLIENT_CREATE_REPORT_RR_H_DETAIL);
9574  }
9575  else if (strcasecmp ("END", element_name) == 0)
9576  {
9577  set_client_state (CLIENT_CREATE_REPORT_RR_H_END);
9578  }
9579  else if (strcasecmp ("START", element_name) == 0)
9580  {
9581  set_client_state (CLIENT_CREATE_REPORT_RR_H_START);
9582  }
9583  ELSE_ERROR ("create_report");
9584 
9586  if (strcasecmp ("NAME", element_name) == 0)
9587  {
9588  set_client_state (CLIENT_CREATE_REPORT_RR_H_DETAIL_NAME);
9589  }
9590  else if (strcasecmp ("VALUE", element_name) == 0)
9591  {
9592  set_client_state (CLIENT_CREATE_REPORT_RR_H_DETAIL_VALUE);
9593  }
9594  else if (strcasecmp ("SOURCE", element_name) == 0)
9595  {
9596  set_client_state (CLIENT_CREATE_REPORT_RR_H_DETAIL_SOURCE);
9597  }
9598  ELSE_ERROR ("create_report");
9599 
9601  if (strcasecmp ("DESCRIPTION", element_name) == 0)
9602  {
9604  }
9605  else if (strcasecmp ("NAME", element_name) == 0)
9606  {
9608  }
9609  else if (strcasecmp ("TYPE", element_name) == 0)
9610  {
9612  }
9613  ELSE_ERROR ("create_report");
9614 
9616  if (strcasecmp ("RESULT", element_name) == 0)
9617  set_client_state
9619  ELSE_ERROR ("create_report");
9620 
9622  if (strcasecmp ("COMMENT", element_name) == 0)
9623  {
9624  set_client_state
9626  omp_parser->read_over = 1;
9627  }
9628  else if (strcasecmp ("CREATION_TIME", element_name) == 0)
9629  {
9630  set_client_state
9632  omp_parser->read_over = 1;
9633  }
9634  else if (strcasecmp ("DESCRIPTION", element_name) == 0)
9635  set_client_state
9637  else if (strcasecmp ("DETECTION", element_name) == 0)
9638  {
9639  omp_parser->read_over = 1;
9641  }
9642  else if (strcasecmp ("HOST", element_name) == 0)
9643  {
9644  omp_parser->read_over = 1;
9646  }
9647  else if (strcasecmp ("MODIFICATION_TIME", element_name) == 0)
9648  {
9649  set_client_state
9651  omp_parser->read_over = 1;
9652  }
9653  else if (strcasecmp ("NAME", element_name) == 0)
9654  {
9655  set_client_state
9657  omp_parser->read_over = 1;
9658  }
9659  else if (strcasecmp ("NOTES", element_name) == 0)
9660  {
9661  omp_parser->read_over = 1;
9663  }
9664  else if (strcasecmp ("NVT", element_name) == 0)
9665  {
9666  append_attribute (attribute_names, attribute_values, "oid",
9668  set_client_state (CLIENT_CREATE_REPORT_RR_RESULTS_RESULT_NVT);
9669  }
9670  else if (strcasecmp ("ORIGINAL_SEVERITY", element_name) == 0)
9671  set_client_state
9673  else if (strcasecmp ("ORIGINAL_THREAT", element_name) == 0)
9674  set_client_state
9676  else if (strcasecmp ("OVERRIDES", element_name) == 0)
9677  {
9678  omp_parser->read_over = 1;
9680  }
9681  else if (strcasecmp ("OWNER", element_name) == 0)
9682  {
9683  set_client_state
9685  omp_parser->read_over = 1;
9686  }
9687  else if (strcasecmp ("PORT", element_name) == 0)
9689  else if (strcasecmp ("QOD", element_name) == 0)
9690  set_client_state (CLIENT_CREATE_REPORT_RR_RESULTS_RESULT_QOD);
9691  else if (strcasecmp ("SCAN_NVT_VERSION", element_name) == 0)
9692  set_client_state
9694  else if (strcasecmp ("SEVERITY", element_name) == 0)
9696  else if (strcasecmp ("THREAT", element_name) == 0)
9698  ELSE_ERROR ("create_report");
9699 
9701  if (strcasecmp ("BID", element_name) == 0)
9703  else if (strcasecmp ("CVE", element_name) == 0)
9705  else if (strcasecmp ("CVSS_BASE", element_name) == 0)
9706  set_client_state
9708  else if (strcasecmp ("FAMILY", element_name) == 0)
9710  else if (strcasecmp ("NAME", element_name) == 0)
9712  else if (strcasecmp ("XREF", element_name) == 0)
9714  else if (strcasecmp ("CERT", element_name) == 0)
9716  ELSE_ERROR ("create_report");
9717 
9719  if (strcasecmp ("CERT_REF", element_name) == 0)
9720  set_client_state
9722  ELSE_ERROR ("create_report");
9723 
9725  if (strcasecmp ("TYPE", element_name) == 0)
9727  else if (strcasecmp ("VALUE", element_name) == 0)
9729  ELSE_ERROR ("create_report");
9730 
9732  if (strcasecmp ("COMMENT", element_name) == 0)
9733  set_client_state (CLIENT_CREATE_REPORT_TASK_COMMENT);
9734  else if (strcasecmp ("NAME", element_name) == 0)
9735  set_client_state (CLIENT_CREATE_REPORT_TASK_NAME);
9736  ELSE_ERROR ("create_report");
9737 
9739  if (strcasecmp ("GET_REPORT_FORMATS_RESPONSE", element_name) == 0)
9740  {
9741  omp_parser->importing = 1;
9743  set_client_state (CLIENT_CRF_GRFR);
9744  }
9745  else if (strcasecmp ("COPY", element_name) == 0)
9746  set_client_state (CLIENT_CREATE_REPORT_FORMAT_COPY);
9747  ELSE_ERROR ("create_report_format");
9748 
9749  case CLIENT_CRF_GRFR:
9750  if (strcasecmp ("REPORT_FORMAT", element_name) == 0)
9751  {
9752  create_report_format_data->files = make_array ();
9753  create_report_format_data->params = make_array ();
9754  create_report_format_data->params_options = make_array ();
9755  append_attribute (attribute_names, attribute_values, "id",
9757  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT);
9758  }
9759  ELSE_ERROR ("create_report_format");
9760 
9762  if (strcasecmp ("CONTENT_TYPE", element_name) == 0)
9763  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_CONTENT_TYPE);
9764  else if (strcasecmp ("DESCRIPTION", element_name) == 0)
9765  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_DESCRIPTION);
9766  else if (strcasecmp ("EXTENSION", element_name) == 0)
9767  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_EXTENSION);
9768  else if (strcasecmp ("GLOBAL", element_name) == 0)
9769  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_GLOBAL);
9770  else if (strcasecmp ("FILE", element_name) == 0)
9771  {
9772  assert (create_report_format_data->file == NULL);
9773  assert (create_report_format_data->file_name == NULL);
9774  openvas_append_string (&create_report_format_data->file, "");
9775  append_attribute (attribute_names, attribute_values, "name",
9777  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_FILE);
9778  }
9779  else if (strcasecmp ("NAME", element_name) == 0)
9780  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_NAME);
9781  else if (strcasecmp ("PARAM", element_name) == 0)
9782  {
9783  assert (create_report_format_data->param_name == NULL);
9784  assert (create_report_format_data->param_type == NULL);
9785  assert (create_report_format_data->param_value == NULL);
9786  openvas_append_string (&create_report_format_data->param_name, "");
9787  openvas_append_string (&create_report_format_data->param_value, "");
9788  create_report_format_data->param_options = make_array ();
9789  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_PARAM);
9790  }
9791  else if (strcasecmp ("PREDEFINED", element_name) == 0)
9792  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_PREDEFINED);
9793  else if (strcasecmp ("SIGNATURE", element_name) == 0)
9794  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_SIGNATURE);
9795  else if (strcasecmp ("SUMMARY", element_name) == 0)
9796  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_SUMMARY);
9797  else if (strcasecmp ("TRUST", element_name) == 0)
9798  {
9799  omp_parser->read_over = 1;
9800  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_TRUST);
9801  }
9802  ELSE_ERROR ("create_report_format");
9803 
9805  if (strcasecmp ("DEFAULT", element_name) == 0)
9806  {
9807  openvas_append_string (&create_report_format_data->param_default,
9808  "");
9810  }
9811  else if (strcasecmp ("NAME", element_name) == 0)
9812  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_PARAM_NAME);
9813  else if (strcasecmp ("OPTIONS", element_name) == 0)
9815  else if (strcasecmp ("TYPE", element_name) == 0)
9816  {
9817  openvas_append_string (&create_report_format_data->param_type, "");
9818  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_PARAM_TYPE);
9819  }
9820  else if (strcasecmp ("VALUE", element_name) == 0)
9821  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT_PARAM_VALUE);
9822  ELSE_ERROR ("create_report_format");
9823 
9825  if (strcasecmp ("REPORT_FORMAT", element_name) == 0)
9826  {
9827  omp_parser->read_over = 1;
9828  set_client_state
9830  }
9831  ELSE_ERROR ("create_report_format");
9832 
9834  if (strcasecmp ("REPORT_FORMAT", element_name) == 0)
9835  {
9836  omp_parser->read_over = 1;
9837  set_client_state
9839  }
9840  ELSE_ERROR ("create_report_format");
9841 
9843  if (strcasecmp ("OPTION", element_name) == 0)
9844  {
9845  openvas_append_string (&create_report_format_data->param_option,
9846  "");
9847  set_client_state
9849  }
9850  ELSE_ERROR ("create_report_format");
9851 
9853  if (strcasecmp ("MAX", element_name) == 0)
9854  {
9855  set_client_state
9857  }
9858  else if (strcasecmp ("MIN", element_name) == 0)
9859  {
9860  set_client_state
9862  }
9863  ELSE_ERROR ("create_report_format");
9864 
9866  if (strcasecmp ("ACTIVE", element_name) == 0)
9867  set_client_state (CLIENT_CREATE_OVERRIDE_ACTIVE);
9868  else if (strcasecmp ("COPY", element_name) == 0)
9869  set_client_state (CLIENT_CREATE_OVERRIDE_COPY);
9870  else if (strcasecmp ("HOSTS", element_name) == 0)
9871  set_client_state (CLIENT_CREATE_OVERRIDE_HOSTS);
9872  else if (strcasecmp ("NEW_SEVERITY", element_name) == 0)
9873  set_client_state (CLIENT_CREATE_OVERRIDE_NEW_SEVERITY);
9874  else if (strcasecmp ("NEW_THREAT", element_name) == 0)
9875  set_client_state (CLIENT_CREATE_OVERRIDE_NEW_THREAT);
9876  else if (strcasecmp ("NVT", element_name) == 0)
9877  {
9878  append_attribute (attribute_names, attribute_values, "oid",
9880  set_client_state (CLIENT_CREATE_OVERRIDE_NVT);
9881  }
9882  else if (strcasecmp ("PORT", element_name) == 0)
9883  set_client_state (CLIENT_CREATE_OVERRIDE_PORT);
9884  else if (strcasecmp ("RESULT", element_name) == 0)
9885  {
9886  append_attribute (attribute_names, attribute_values, "id",
9889  && create_override_data->result_id[0] == '\0')
9890  {
9891  g_free (create_override_data->result_id);
9893  }
9894  set_client_state (CLIENT_CREATE_OVERRIDE_RESULT);
9895  }
9896  else if (strcasecmp ("SEVERITY", element_name) == 0)
9897  set_client_state (CLIENT_CREATE_OVERRIDE_SEVERITY);
9898  else if (strcasecmp ("TASK", element_name) == 0)
9899  {
9900  append_attribute (attribute_names, attribute_values, "id",
9903  && create_override_data->task_id[0] == '\0')
9904  {
9905  g_free (create_override_data->task_id);
9906  create_override_data->task_id = NULL;
9907  }
9908  set_client_state (CLIENT_CREATE_OVERRIDE_TASK);
9909  }
9910  else if (strcasecmp ("TEXT", element_name) == 0)
9911  set_client_state (CLIENT_CREATE_OVERRIDE_TEXT);
9912  else if (strcasecmp ("THREAT", element_name) == 0)
9913  set_client_state (CLIENT_CREATE_OVERRIDE_THREAT);
9914  ELSE_ERROR ("create_override");
9915 
9916  case CLIENT_CREATE_TAG:
9917  if (strcasecmp ("ACTIVE", element_name) == 0)
9918  {
9919  openvas_append_string (&create_tag_data->active, "");
9920  set_client_state (CLIENT_CREATE_TAG_ACTIVE);
9921  }
9922  else if (strcasecmp ("RESOURCE", element_name) == 0)
9923  {
9924  append_attribute (attribute_names, attribute_values, "id",
9926  set_client_state (CLIENT_CREATE_TAG_RESOURCE);
9927  }
9928  else if (strcasecmp ("COMMENT", element_name) == 0)
9929  {
9930  openvas_append_string (&create_tag_data->comment, "");
9931  set_client_state (CLIENT_CREATE_TAG_COMMENT);
9932  }
9933  else if (strcasecmp ("COPY", element_name) == 0)
9934  {
9935  openvas_append_string (&create_tag_data->copy, "");
9936  set_client_state (CLIENT_CREATE_TAG_COPY);
9937  }
9938  else if (strcasecmp ("NAME", element_name) == 0)
9939  {
9940  openvas_append_string (&create_tag_data->name, "");
9941  set_client_state (CLIENT_CREATE_TAG_NAME);
9942  }
9943  else if (strcasecmp ("VALUE", element_name) == 0)
9944  {
9945  openvas_append_string (&create_tag_data->value, "");
9946  set_client_state (CLIENT_CREATE_TAG_VALUE);
9947  }
9948  ELSE_ERROR ("create_tag");
9949 
9951  if (strcasecmp ("TYPE", element_name) == 0)
9952  {
9953  openvas_append_string (&create_tag_data->resource_type, "");
9954  set_client_state (CLIENT_CREATE_TAG_RESOURCE_TYPE);
9955  }
9956  ELSE_ERROR ("create_tag");
9957 
9958  case CLIENT_CREATE_TARGET:
9959  if (strcasecmp ("ASSET_HOSTS", element_name) == 0)
9960  {
9961  append_attribute (attribute_names, attribute_values, "filter",
9963  set_client_state (CLIENT_CREATE_TARGET_ASSET_HOSTS);
9964  }
9965  else if (strcasecmp ("EXCLUDE_HOSTS", element_name) == 0)
9966  set_client_state (CLIENT_CREATE_TARGET_EXCLUDE_HOSTS);
9967  else if (strcasecmp ("REVERSE_LOOKUP_ONLY", element_name) == 0)
9968  set_client_state (CLIENT_CREATE_TARGET_REVERSE_LOOKUP_ONLY);
9969  else if (strcasecmp ("REVERSE_LOOKUP_UNIFY", element_name) == 0)
9970  set_client_state (CLIENT_CREATE_TARGET_REVERSE_LOOKUP_UNIFY);
9971  else if (strcasecmp ("ALIVE_TESTS", element_name) == 0)
9972  set_client_state (CLIENT_CREATE_TARGET_ALIVE_TESTS);
9973  else if (strcasecmp ("COMMENT", element_name) == 0)
9974  set_client_state (CLIENT_CREATE_TARGET_COMMENT);
9975  else if (strcasecmp ("COPY", element_name) == 0)
9976  set_client_state (CLIENT_CREATE_TARGET_COPY);
9977  else if (strcasecmp ("ESXI_CREDENTIAL", element_name) == 0)
9978  {
9979  append_attribute (attribute_names, attribute_values, "id",
9981  set_client_state (CLIENT_CREATE_TARGET_ESXI_CREDENTIAL);
9982  }
9983  else if (strcasecmp ("ESXI_LSC_CREDENTIAL", element_name) == 0)
9984  {
9985  append_attribute (attribute_names, attribute_values, "id",
9987  set_client_state (CLIENT_CREATE_TARGET_ESXI_LSC_CREDENTIAL);
9988  }
9989  else if (strcasecmp ("HOSTS", element_name) == 0)
9990  set_client_state (CLIENT_CREATE_TARGET_HOSTS);
9991  else if (strcasecmp ("PORT_LIST", element_name) == 0)
9992  {
9993  append_attribute (attribute_names, attribute_values, "id",
9995  set_client_state (CLIENT_CREATE_TARGET_PORT_LIST);
9996  }
9997  else if (strcasecmp ("PORT_RANGE", element_name) == 0)
9998  {
9999  openvas_append_string (&create_target_data->port_range, "");
10000  set_client_state (CLIENT_CREATE_TARGET_PORT_RANGE);
10001  }
10002  else if (strcasecmp ("SSH_CREDENTIAL", element_name) == 0)
10003  {
10004  append_attribute (attribute_names, attribute_values, "id",
10006  set_client_state (CLIENT_CREATE_TARGET_SSH_CREDENTIAL);
10007  }
10008  else if (strcasecmp ("SSH_LSC_CREDENTIAL", element_name) == 0)
10009  {
10010  append_attribute (attribute_names, attribute_values, "id",
10012  set_client_state (CLIENT_CREATE_TARGET_SSH_LSC_CREDENTIAL);
10013  }
10014  else if (strcasecmp ("SMB_CREDENTIAL", element_name) == 0)
10015  {
10016  append_attribute (attribute_names, attribute_values, "id",
10018  set_client_state (CLIENT_CREATE_TARGET_SMB_CREDENTIAL);
10019  }
10020  else if (strcasecmp ("SMB_LSC_CREDENTIAL", element_name) == 0)
10021  {
10022  append_attribute (attribute_names, attribute_values, "id",
10024  set_client_state (CLIENT_CREATE_TARGET_SMB_LSC_CREDENTIAL);
10025  }
10026  else if (strcasecmp ("SNMP_CREDENTIAL", element_name) == 0)
10027  {
10028  append_attribute (attribute_names, attribute_values, "id",
10030  set_client_state (CLIENT_CREATE_TARGET_SNMP_CREDENTIAL);
10031  }
10032  else if (strcasecmp ("NAME", element_name) == 0)
10033  {
10034  openvas_append_string (&create_target_data->name, "");
10035  set_client_state (CLIENT_CREATE_TARGET_NAME);
10036  }
10037  ELSE_ERROR ("create_target");
10038 
10040  if (strcasecmp ("MAKE_UNIQUE", element_name) == 0)
10041  set_client_state (CLIENT_CREATE_TARGET_NAME_MAKE_UNIQUE);
10042  ELSE_ERROR ("create_target");
10043 
10045  if (strcasecmp ("PORT", element_name) == 0)
10046  set_client_state (CLIENT_CREATE_TARGET_SSH_CREDENTIAL_PORT);
10047  ELSE_ERROR ("create_target");
10048 
10050  if (strcasecmp ("PORT", element_name) == 0)
10052  ELSE_ERROR ("create_target");
10053 
10054  case CLIENT_CREATE_TASK:
10055  if (strcasecmp ("ALTERABLE", element_name) == 0)
10056  set_client_state (CLIENT_CREATE_TASK_ALTERABLE);
10057  else if (strcasecmp ("COPY", element_name) == 0)
10058  set_client_state (CLIENT_CREATE_TASK_COPY);
10059  else if (strcasecmp ("PREFERENCES", element_name) == 0)
10060  {
10061  create_task_data->preferences = make_array ();
10062  set_client_state (CLIENT_CREATE_TASK_PREFERENCES);
10063  }
10064  else if (strcasecmp ("NAME", element_name) == 0)
10065  set_client_state (CLIENT_CREATE_TASK_NAME);
10066  else if (strcasecmp ("COMMENT", element_name) == 0)
10067  set_client_state (CLIENT_CREATE_TASK_COMMENT);
10068  else if (strcasecmp ("HOSTS_ORDERING", element_name) == 0)
10069  set_client_state (CLIENT_CREATE_TASK_HOSTS_ORDERING);
10070  else if (strcasecmp ("SCANNER", element_name) == 0)
10071  {
10072  append_attribute (attribute_names, attribute_values, "id",
10074  set_client_state (CLIENT_CREATE_TASK_SCANNER);
10075  }
10076  else if (strcasecmp ("CONFIG", element_name) == 0)
10077  {
10078  append_attribute (attribute_names, attribute_values, "id",
10080  set_client_state (CLIENT_CREATE_TASK_CONFIG);
10081  }
10082  else if (strcasecmp ("ALERT", element_name) == 0)
10083  {
10084  const gchar* attribute;
10085  if (find_attribute (attribute_names, attribute_values, "id",
10086  &attribute))
10087  array_add (create_task_data->alerts, g_strdup (attribute));
10088  set_client_state (CLIENT_CREATE_TASK_ALERT);
10089  }
10090  else if (strcasecmp ("OBSERVERS", element_name) == 0)
10091  set_client_state (CLIENT_CREATE_TASK_OBSERVERS);
10092  else if (strcasecmp ("SCHEDULE", element_name) == 0)
10093  {
10094  append_attribute (attribute_names, attribute_values, "id",
10096  set_client_state (CLIENT_CREATE_TASK_SCHEDULE);
10097  }
10098  else if (strcasecmp ("SCHEDULE_PERIODS", element_name) == 0)
10099  set_client_state (CLIENT_CREATE_TASK_SCHEDULE_PERIODS);
10100  else if (strcasecmp ("TARGET", element_name) == 0)
10101  {
10102  append_attribute (attribute_names, attribute_values, "id",
10104  set_client_state (CLIENT_CREATE_TASK_TARGET);
10105  }
10107 
10109  if (strcasecmp ("GROUP", element_name) == 0)
10110  {
10111  const gchar* attribute;
10112  if (find_attribute (attribute_names, attribute_values, "id",
10113  &attribute))
10114  array_add (create_task_data->groups, g_strdup (attribute));
10115  set_client_state (CLIENT_CREATE_TASK_OBSERVERS_GROUP);
10116  }
10118 
10120  if (strcasecmp ("PREFERENCE", element_name) == 0)
10121  {
10122  assert (create_task_data->preference == NULL);
10123  create_task_data->preference = g_malloc (sizeof (name_value_t));
10124  create_task_data->preference->name = NULL;
10126  set_client_state (CLIENT_CREATE_TASK_PREFERENCES_PREFERENCE);
10127  }
10129 
10131  if (strcasecmp ("SCANNER_NAME", element_name) == 0)
10133  else if (strcasecmp ("VALUE", element_name) == 0)
10136 
10137  case CLIENT_CREATE_USER:
10138  if (strcasecmp ("COPY", element_name) == 0)
10139  set_client_state (CLIENT_CREATE_USER_COPY);
10140  else if (strcasecmp ("GROUPS", element_name) == 0)
10141  set_client_state (CLIENT_CREATE_USER_GROUPS);
10142  else if (strcasecmp ("HOSTS", element_name) == 0)
10143  {
10144  const gchar *attribute;
10145  if (find_attribute
10146  (attribute_names, attribute_values, "allow", &attribute))
10147  create_user_data->hosts_allow = strcmp (attribute, "0");
10148  else
10150  set_client_state (CLIENT_CREATE_USER_HOSTS);
10151  }
10152  else if (strcasecmp ("IFACES", element_name) == 0)
10153  {
10154  const gchar *attribute;
10155  if (find_attribute
10156  (attribute_names, attribute_values, "allow", &attribute))
10157  create_user_data->ifaces_allow = strcmp (attribute, "0");
10158  else
10160  set_client_state (CLIENT_CREATE_USER_IFACES);
10161  }
10162  else if (strcasecmp ("NAME", element_name) == 0)
10163  set_client_state (CLIENT_CREATE_USER_NAME);
10164  else if (strcasecmp ("PASSWORD", element_name) == 0)
10165  set_client_state (CLIENT_CREATE_USER_PASSWORD);
10166  else if (strcasecmp ("ROLE", element_name) == 0)
10167  {
10168  const gchar* attribute;
10169  if (find_attribute (attribute_names, attribute_values, "id",
10170  &attribute))
10171  array_add (create_user_data->roles, g_strdup (attribute));
10172  set_client_state (CLIENT_CREATE_USER_ROLE);
10173  }
10174  else if (strcasecmp ("SOURCES", element_name) == 0)
10175  {
10176  create_user_data->sources = make_array ();
10177  set_client_state (CLIENT_CREATE_USER_SOURCES);
10178  }
10179  else
10180  {
10181  if (send_element_error_to_client ("create_user", element_name,
10182  write_to_client,
10183  write_to_client_data))
10184  {
10185  error_send_to_client (error);
10186  return;
10187  }
10188  set_client_state (CLIENT_AUTHENTIC);
10189  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
10190  "Error");
10191  }
10192  break;
10193 
10195  if (strcasecmp ("GROUP", element_name) == 0)
10196  {
10197  const gchar* attribute;
10198  if (find_attribute (attribute_names, attribute_values, "id",
10199  &attribute))
10200  array_add (create_user_data->groups, g_strdup (attribute));
10201  set_client_state (CLIENT_CREATE_USER_GROUPS_GROUP);
10202  }
10203  ELSE_ERROR ("create_user");
10204 
10206  if (strcasecmp ("SOURCE", element_name) == 0)
10207  set_client_state (CLIENT_CREATE_USER_SOURCES_SOURCE);
10208  else
10209  {
10210  if (send_element_error_to_client ("create_user", element_name,
10211  write_to_client,
10212  write_to_client_data))
10213  {
10214  error_send_to_client (error);
10215  return;
10216  }
10217  set_client_state (CLIENT_AUTHENTIC);
10218  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
10219  "Error");
10220  }
10221  break;
10222 
10223  case CLIENT_MODIFY_NOTE:
10224  if (strcasecmp ("ACTIVE", element_name) == 0)
10225  set_client_state (CLIENT_MODIFY_NOTE_ACTIVE);
10226  else if (strcasecmp ("HOSTS", element_name) == 0)
10227  set_client_state (CLIENT_MODIFY_NOTE_HOSTS);
10228  else if (strcasecmp ("PORT", element_name) == 0)
10229  set_client_state (CLIENT_MODIFY_NOTE_PORT);
10230  else if (strcasecmp ("RESULT", element_name) == 0)
10231  {
10232  append_attribute (attribute_names, attribute_values, "id",
10235  && modify_note_data->result_id[0] == '\0')
10236  {
10237  g_free (modify_note_data->result_id);
10238  modify_note_data->result_id = NULL;
10239  }
10240  set_client_state (CLIENT_MODIFY_NOTE_RESULT);
10241  }
10242  else if (strcasecmp ("SEVERITY", element_name) == 0)
10243  set_client_state (CLIENT_MODIFY_NOTE_SEVERITY);
10244  else if (strcasecmp ("TASK", element_name) == 0)
10245  {
10246  append_attribute (attribute_names, attribute_values, "id",
10249  && modify_note_data->task_id[0] == '\0')
10250  {
10251  g_free (modify_note_data->task_id);
10252  modify_note_data->task_id = NULL;
10253  }
10254  set_client_state (CLIENT_MODIFY_NOTE_TASK);
10255  }
10256  else if (strcasecmp ("TEXT", element_name) == 0)
10257  set_client_state (CLIENT_MODIFY_NOTE_TEXT);
10258  else if (strcasecmp ("THREAT", element_name) == 0)
10259  set_client_state (CLIENT_MODIFY_NOTE_THREAT);
10260  ELSE_ERROR ("modify_note");
10261 
10263  if (strcasecmp ("ACTIVE", element_name) == 0)
10264  set_client_state (CLIENT_MODIFY_OVERRIDE_ACTIVE);
10265  else if (strcasecmp ("HOSTS", element_name) == 0)
10266  set_client_state (CLIENT_MODIFY_OVERRIDE_HOSTS);
10267  else if (strcasecmp ("NEW_SEVERITY", element_name) == 0)
10268  set_client_state (CLIENT_MODIFY_OVERRIDE_NEW_SEVERITY);
10269  else if (strcasecmp ("NEW_THREAT", element_name) == 0)
10270  set_client_state (CLIENT_MODIFY_OVERRIDE_NEW_THREAT);
10271  else if (strcasecmp ("PORT", element_name) == 0)
10272  set_client_state (CLIENT_MODIFY_OVERRIDE_PORT);
10273  else if (strcasecmp ("RESULT", element_name) == 0)
10274  {
10275  append_attribute (attribute_names, attribute_values, "id",
10278  && modify_override_data->result_id[0] == '\0')
10279  {
10280  g_free (modify_override_data->result_id);
10282  }
10283  set_client_state (CLIENT_MODIFY_OVERRIDE_RESULT);
10284  }
10285  else if (strcasecmp ("SEVERITY", element_name) == 0)
10286  set_client_state (CLIENT_MODIFY_OVERRIDE_SEVERITY);
10287  else if (strcasecmp ("TASK", element_name) == 0)
10288  {
10289  append_attribute (attribute_names, attribute_values, "id",
10292  && modify_override_data->task_id[0] == '\0')
10293  {
10294  g_free (modify_override_data->task_id);
10295  modify_override_data->task_id = NULL;
10296  }
10297  set_client_state (CLIENT_MODIFY_OVERRIDE_TASK);
10298  }
10299  else if (strcasecmp ("TEXT", element_name) == 0)
10300  set_client_state (CLIENT_MODIFY_OVERRIDE_TEXT);
10301  else if (strcasecmp ("THREAT", element_name) == 0)
10302  set_client_state (CLIENT_MODIFY_OVERRIDE_THREAT);
10303  ELSE_ERROR ("modify_override");
10304 
10305  case CLIENT_RUN_WIZARD:
10306  if (strcasecmp ("MODE", element_name) == 0)
10307  {
10308  set_client_state (CLIENT_RUN_WIZARD_MODE);
10309  }
10310  else if (strcasecmp ("NAME", element_name) == 0)
10311  {
10312  set_client_state (CLIENT_RUN_WIZARD_NAME);
10313  }
10314  else if (strcasecmp ("PARAMS", element_name) == 0)
10315  {
10316  run_wizard_data->params = make_array ();
10317  set_client_state (CLIENT_RUN_WIZARD_PARAMS);
10318  }
10319  ELSE_ERROR ("run_wizard");
10320 
10322  if (strcasecmp ("PARAM", element_name) == 0)
10323  {
10324  assert (run_wizard_data->param == NULL);
10325  run_wizard_data->param = g_malloc (sizeof (name_value_t));
10326  run_wizard_data->param->name = NULL;
10327  run_wizard_data->param->value = NULL;
10328  set_client_state (CLIENT_RUN_WIZARD_PARAMS_PARAM);
10329  }
10330  ELSE_ERROR ("run_wizard");
10331 
10333  if (strcasecmp ("NAME", element_name) == 0)
10334  {
10335  set_client_state (CLIENT_RUN_WIZARD_PARAMS_PARAM_NAME);
10336  }
10337  else if (strcasecmp ("VALUE", element_name) == 0)
10338  {
10339  set_client_state (CLIENT_RUN_WIZARD_PARAMS_PARAM_VALUE);
10340  }
10341  ELSE_ERROR ("run_wizard");
10342 
10343  default:
10344  /* Send a generic response. */
10345  if (send_element_error_to_client ("omp", element_name,
10346  write_to_client,
10347  write_to_client_data))
10348  {
10349  error_send_to_client (error);
10350  return;
10351  }
10352  set_client_state (CLIENT_AUTHENTIC);
10353  g_set_error (error,
10354  G_MARKUP_ERROR,
10355  G_MARKUP_ERROR_UNKNOWN_ELEMENT,
10356  "Error");
10357  break;
10358  }
10359 
10360  return;
10361 }
10362 
10379 static gboolean
10380 send_nvt (iterator_t *nvts, int details, int preferences, int pref_count,
10381  const char *timeout, config_t config,
10382  int (*write_to_client) (const char *, void*),
10383  void* write_to_client_data)
10384 {
10385  gchar *msg;
10386 
10387  msg = get_nvti_xml (nvts, details, pref_count, preferences, timeout, config,
10388  0);
10389  if (send_to_client (msg, write_to_client, write_to_client_data))
10390  {
10391  g_free (msg);
10392  return TRUE;
10393  }
10394  g_free (msg);
10395  return FALSE;
10396 }
10397 
10410 static int
10411 send_reports (task_t task, int apply_overrides, int min_qod,
10412  int (*write_to_client) (const char*, void*),
10413  void* write_to_client_data)
10414 {
10416  report_t index;
10417 
10418  if (send_to_client ("<reports>", write_to_client, write_to_client_data))
10419  return -4;
10420 
10422  while (next_report (&iterator, &index))
10423  {
10424  gchar *uuid, *timestamp, *msg;
10425  int debugs, false_positives, holes, infos, logs, warnings, run_status;
10426  double severity;
10427  char *scan_start, *scan_end;
10428 
10429  uuid = report_uuid (index);
10430 
10431  if (report_counts (uuid, &debugs, &holes, &infos, &logs, &warnings,
10432  &false_positives, &severity, apply_overrides,
10433  0, min_qod))
10434  {
10435  free (uuid);
10436  return -5;
10437  }
10438 
10439  if (report_timestamp (uuid, &timestamp))
10440  {
10441  free (uuid);
10442  return -6;
10443  }
10444 
10445  g_debug (" %s\n", uuid);
10446 
10447  report_scan_run_status (index, &run_status);
10448  scan_start = scan_start_time (index);
10449  scan_end = scan_end_time (index);
10450  msg = g_strdup_printf ("<report"
10451  " id=\"%s\">"
10452  "<timestamp>%s</timestamp>"
10453  "<scan_start>%s</scan_start>"
10454  "<scan_end>%s</scan_end>"
10455  "<scan_run_status>%s</scan_run_status>"
10456  "<result_count>"
10457  "<debug>%i</debug>"
10458  "<hole>%i</hole>"
10459  "<info>%i</info>"
10460  "<log>%i</log>"
10461  "<warning>%i</warning>"
10462  "<false_positive>%i</false_positive>"
10463  "</result_count>"
10464  "<severity>%1.1f</severity>"
10465  "</report>",
10466  uuid,
10467  timestamp,
10468  scan_start,
10469  scan_end,
10471  (run_status ? run_status
10473  debugs,
10474  holes,
10475  infos,
10476  logs,
10477  warnings,
10478  false_positives,
10479  severity);
10480  free (scan_start);
10481  free (scan_end);
10482  g_free (timestamp);
10483  if (send_to_client (msg, write_to_client, write_to_client_data))
10484  {
10485  g_free (msg);
10486  free (uuid);
10487  return -4;
10488  }
10489  g_free (msg);
10490  free (uuid);
10491  }
10493 
10494  if (send_to_client ("</reports>", write_to_client, write_to_client_data))
10495  return -4;
10496 
10497  return 0;
10498 }
10499 
10507 static gchar*
10508 convert_to_newlines (const char *text)
10509 {
10510  char *nptr, *new;
10511 
10512  new = g_malloc (strlen (text) + 1);
10513  nptr = new;
10514  while (*text)
10515  if (*text == '\\')
10516  {
10517  /* Convert "\\n" to '\n' */
10518  if (*(text+1) == 'n')
10519  {
10520  text += 2;
10521  *nptr++ = '\n';
10522  }
10523  /* Skip "\\r" */
10524  else if (*(text+1) == 'r')
10525  text += 2;
10526  else
10527  *nptr++ = *text++;
10528  }
10529  else
10530  *nptr++ = *text++;
10531  *nptr = '\0';
10532 
10533  return new;
10534 }
10535 
10543 static void
10544 buffer_xml_append_printf (GString *buffer, const char *format, ...)
10545 {
10546  va_list args;
10547  gchar *msg;
10548  va_start (args, format);
10549  msg = g_markup_vprintf_escaped (format, args);
10550  va_end (args);
10551  g_string_append (buffer, msg);
10552  g_free (msg);
10553 }
10554 
10564 static gchar *
10565 utf8_substring (const gchar *str, glong start_pos, glong end_pos)
10566 {
10567  gchar *start, *end, *out;
10568 
10569  /* TODO This is a copy of g_utf8_substring from glib 2.38.2. Once our glib
10570  * minimum goes past 2.30 we can just use g_utf8_substring. */
10571 
10572  start = g_utf8_offset_to_pointer (str, start_pos);
10573  end = g_utf8_offset_to_pointer (start, end_pos - start_pos);
10574 
10575  out = g_malloc (end - start + 1);
10576  memcpy (out, start, end - start);
10577  out[end - start] = 0;
10578 
10579  return out;
10580 }
10581 
10591 static void
10592 buffer_notes_xml (GString *buffer, iterator_t *notes, int include_notes_details,
10593  int include_result, int *count)
10594 {
10595  while (next (notes))
10596  {
10597  char *uuid_task, *uuid_result;
10598 
10599  if (count)
10600  (*count)++;
10601 
10602  if (note_iterator_task (notes))
10603  task_uuid (note_iterator_task (notes),
10604  &uuid_task);
10605  else
10606  uuid_task = NULL;
10607 
10608  if (note_iterator_result (notes))
10610  &uuid_result);
10611  else
10612  uuid_result = NULL;
10613 
10614  buffer_xml_append_printf (buffer,
10615  "<note id=\"%s\">"
10616  "<permissions>",
10617  get_iterator_uuid (notes));
10618 
10619  if (/* The user is the owner. */
10620  (current_credentials.username
10621  && get_iterator_owner_name (notes)
10622  && (strcmp (get_iterator_owner_name (notes),
10623  current_credentials.username)
10624  == 0))
10625  /* Or the user is effectively the owner. */
10627  get_iterator_owner (notes)))
10628  buffer_xml_append_printf (buffer,
10629  "<permission><name>Everything</name></permission>"
10630  "</permissions>");
10631  else
10632  {
10633  iterator_t perms;
10634  get_data_t perms_get;
10635 
10636  memset (&perms_get, '\0', sizeof (perms_get));
10637  perms_get.filter = g_strdup_printf ("resource_uuid=%s"
10638  " owner=any"
10639  " permission=any",
10640  get_iterator_uuid (notes));
10641  init_permission_iterator (&perms, &perms_get);
10642  g_free (perms_get.filter);
10643  while (next (&perms))
10644  buffer_xml_append_printf (buffer,
10645  "<permission><name>%s</name></permission>",
10646  get_iterator_name (&perms));
10647  cleanup_iterator (&perms);
10648 
10649  buffer_xml_append_printf (buffer, "</permissions>");
10650  }
10651 
10652  if (include_notes_details == 0)
10653  {
10654  const char *text = note_iterator_text (notes);
10655  gchar *excerpt = utf8_substring (text, 0, 60);
10656  /* This must match send_get_common. */
10657  buffer_xml_append_printf (buffer,
10658  "<owner><name>%s</name></owner>"
10659  "<nvt oid=\"%s\">"
10660  "<name>%s</name>"
10661  "<type>%s</type>"
10662  "</nvt>"
10663  "<creation_time>%s</creation_time>"
10664  "<modification_time>%s</modification_time>"
10665  "<writable>1</writable>"
10666  "<in_use>0</in_use>"
10667  "<active>%i</active>"
10668  "<text excerpt=\"%i\">%s</text>"
10669  "<orphan>%i</orphan>"
10670  "<user_tags>"
10671  "<count>%i</count>"
10672  "</user_tags>"
10673  "</note>",
10674  get_iterator_owner_name (notes)
10675  ? get_iterator_owner_name (notes)
10676  : "",
10677  note_iterator_nvt_oid (notes),
10678  note_iterator_nvt_name (notes),
10679  note_iterator_nvt_type (notes),
10682  note_iterator_active (notes),
10683  strlen (excerpt) < strlen (text),
10684  excerpt,
10685  ((note_iterator_task (notes)
10686  && (uuid_task == NULL))
10687  || (note_iterator_result (notes)
10688  && (uuid_result == NULL))),
10689  resource_tag_count ("note",
10691  (notes),
10692  1));
10693  g_free (excerpt);
10694  }
10695  else
10696  {
10697  char *name_task;
10698  int trash_task;
10699  time_t end_time;
10700  iterator_t tags;
10701 
10702  if (uuid_task)
10703  {
10704  name_task = task_name (note_iterator_task (notes));
10705  trash_task = task_in_trash (note_iterator_task (notes));
10706  }
10707  else
10708  {
10709  name_task = NULL;
10710  trash_task = 0;
10711  }
10712 
10713  end_time = note_iterator_end_time (notes);
10714 
10715  /* This must match send_get_common. */
10716  buffer_xml_append_printf
10717  (buffer,
10718  "<owner><name>%s</name></owner>"
10719  "<nvt oid=\"%s\">"
10720  "<name>%s</name>"
10721  "<type>%s</type>"
10722  "</nvt>"
10723  "<creation_time>%s</creation_time>"
10724  "<modification_time>%s</modification_time>"
10725  "<writable>1</writable>"
10726  "<in_use>0</in_use>"
10727  "<active>%i</active>"
10728  "<end_time>%s</end_time>"
10729  "<text>%s</text>"
10730  "<hosts>%s</hosts>"
10731  "<port>%s</port>"
10732  "<severity>%s</severity>"
10733  "<threat>%s</threat>"
10734  "<task id=\"%s\"><name>%s</name><trash>%i</trash></task>"
10735  "<orphan>%i</orphan>",
10736  get_iterator_owner_name (notes)
10737  ? get_iterator_owner_name (notes)
10738  : "",
10739  note_iterator_nvt_oid (notes),
10740  note_iterator_nvt_name (notes),
10741  note_iterator_nvt_type (notes),
10744  note_iterator_active (notes),
10745  end_time > 1 ? iso_time (&end_time) : "",
10746  note_iterator_text (notes),
10747  note_iterator_hosts (notes)
10748  ? note_iterator_hosts (notes) : "",
10749  note_iterator_port (notes)
10750  ? note_iterator_port (notes) : "",
10751  note_iterator_severity (notes)
10752  ? note_iterator_severity (notes) : "",
10753  note_iterator_threat (notes)
10754  ? note_iterator_threat (notes) : "",
10755  uuid_task ? uuid_task : "",
10756  name_task ? name_task : "",
10757  trash_task,
10758  ((note_iterator_task (notes) && (uuid_task == NULL))
10759  || (note_iterator_result (notes) && (uuid_result == NULL))));
10760 
10761  free (name_task);
10762 
10763  if (include_result && note_iterator_result (notes))
10764  {
10765  iterator_t results;
10766  get_data_t *result_get;
10767  result_get = report_results_get_data (1, 1,
10768  1, /* apply_overrides */
10769  0, /* autofp*/
10770  0 /* min_qod */);
10771 
10772  init_result_get_iterator (&results, result_get,
10773  0, /* No report restriction */
10774  NULL, /* No host restriction */
10775  NULL); /* No extra order SQL. */
10776  get_data_reset (result_get);
10777  free (result_get);
10778 
10779  while (next (&results))
10780  buffer_results_xml (buffer,
10781  &results,
10782  0,
10783  0, /* Notes. */
10784  0, /* Note details. */
10785  0, /* Overrides. */
10786  0, /* Override details. */
10787  0, /* Tags. */
10788  0, /* Tag details. */
10789  0, /* Result details. */
10790  NULL,
10791  NULL,
10792  0);
10793  cleanup_iterator (&results);
10794  }
10795  else
10796  buffer_xml_append_printf (buffer,
10797  "<result id=\"%s\"/>",
10798  uuid_result ? uuid_result : "");
10799 
10800  buffer_xml_append_printf (buffer,
10801  "<user_tags>"
10802  "<count>%i</count>",
10803  resource_tag_count ("note",
10805  (notes),
10806  1));
10807 
10808  init_resource_tag_iterator (&tags, "note",
10809  get_iterator_resource (notes),
10810  1, NULL, 1);
10811 
10812  while (next (&tags))
10813  {
10814  buffer_xml_append_printf (buffer,
10815  "<tag id=\"%s\">"
10816  "<name>%s</name>"
10817  "<value>%s</value>"
10818  "<comment>%s</comment>"
10819  "</tag>",
10824  }
10825 
10826  cleanup_iterator (&tags);
10827 
10828  buffer_xml_append_printf (buffer,
10829  "</user_tags>"
10830  "</note>");
10831  }
10832  free (uuid_task);
10833  free (uuid_result);
10834  }
10835 }
10836 
10846 static void
10847 buffer_overrides_xml (GString *buffer, iterator_t *overrides,
10848  int include_overrides_details, int include_result,
10849  int *count)
10850 {
10851  while (next (overrides))
10852  {
10853  char *uuid_task, *uuid_result;
10854 
10855  if (count)
10856  (*count)++;
10857 
10858  if (override_iterator_task (overrides))
10859  task_uuid (override_iterator_task (overrides),
10860  &uuid_task);
10861  else
10862  uuid_task = NULL;
10863 
10864  if (override_iterator_result (overrides))
10866  &uuid_result);
10867  else
10868  uuid_result = NULL;
10869 
10870  buffer_xml_append_printf (buffer,
10871  "<override id=\"%s\">"
10872  "<permissions>",
10873  get_iterator_uuid (overrides));
10874 
10875  if (/* The user is the owner. */
10876  (current_credentials.username
10877  && get_iterator_owner_name (overrides)
10878  && (strcmp (get_iterator_owner_name (overrides),
10879  current_credentials.username)
10880  == 0))
10881  /* Or the user is effectively the owner. */
10883  get_iterator_owner (overrides)))
10884  buffer_xml_append_printf (buffer,
10885  "<permission><name>Everything</name></permission>"
10886  "</permissions>");
10887  else
10888  {
10889  iterator_t perms;
10890  get_data_t perms_get;
10891 
10892  memset (&perms_get, '\0', sizeof (perms_get));
10893  perms_get.filter = g_strdup_printf ("resource_uuid=%s"
10894  " owner=any"
10895  " permission=any",
10896  get_iterator_uuid (overrides));
10897  init_permission_iterator (&perms, &perms_get);
10898  g_free (perms_get.filter);
10899  while (next (&perms))
10900  buffer_xml_append_printf (buffer,
10901  "<permission><name>%s</name></permission>",
10902  get_iterator_name (&perms));
10903  cleanup_iterator (&perms);
10904 
10905  buffer_xml_append_printf (buffer, "</permissions>");
10906  }
10907 
10908  if (include_overrides_details == 0)
10909  {
10910  const char *text = override_iterator_text (overrides);
10911  gchar *excerpt = utf8_substring (text, 0, 60);
10912  /* This must match send_get_common. */
10913  buffer_xml_append_printf (buffer,
10914  "<owner><name>%s</name></owner>"
10915  "<nvt oid=\"%s\">"
10916  "<name>%s</name>"
10917  "<type>%s</type>"
10918  "</nvt>"
10919  "<creation_time>%s</creation_time>"
10920  "<modification_time>%s</modification_time>"
10921  "<writable>1</writable>"
10922  "<in_use>0</in_use>"
10923  "<active>%i</active>"
10924  "<text excerpt=\"%i\">%s</text>"
10925  "<threat>%s</threat>"
10926  "<severity>%s</severity>"
10927  "<new_threat>%s</new_threat>"
10928  "<new_severity>%s</new_severity>"
10929  "<orphan>%i</orphan>"
10930  "<user_tags>"
10931  "<count>%i</count>"
10932  "</user_tags>"
10933  "</override>",
10934  get_iterator_owner_name (overrides)
10935  ? get_iterator_owner_name (overrides)
10936  : "",
10937  override_iterator_nvt_oid (overrides),
10938  override_iterator_nvt_name (overrides),
10939  override_iterator_nvt_type (overrides),
10940  get_iterator_creation_time (overrides),
10941  get_iterator_modification_time (overrides),
10942  override_iterator_active (overrides),
10943  strlen (excerpt) < strlen (text),
10944  excerpt,
10945  override_iterator_threat (overrides)
10946  ? override_iterator_threat (overrides)
10947  : "",
10948  override_iterator_severity (overrides)
10949  ? override_iterator_severity (overrides)
10950  : "",
10951  override_iterator_new_threat (overrides),
10952  override_iterator_new_severity (overrides),
10953  ((override_iterator_task (overrides)
10954  && (uuid_task == NULL))
10955  || (override_iterator_result (overrides)
10956  && (uuid_result == NULL))),
10957  resource_tag_count ("override",
10959  (overrides),
10960  1));
10961  g_free (excerpt);
10962  }
10963  else
10964  {
10965  char *name_task;
10966  int trash_task;
10967  time_t end_time;
10968  iterator_t tags;
10969 
10970  if (uuid_task)
10971  {
10972  name_task = task_name (override_iterator_task (overrides));
10973  trash_task = task_in_trash (override_iterator_task (overrides));
10974  }
10975  else
10976  {
10977  name_task = NULL;
10978  trash_task = 0;
10979  }
10980 
10981  end_time = override_iterator_end_time (overrides);
10982 
10983  /* This must match send_get_common. */
10984  buffer_xml_append_printf
10985  (buffer,
10986  "<owner><name>%s</name></owner>"
10987  "<nvt oid=\"%s\">"
10988  "<name>%s</name>"
10989  "<type>%s</type>"
10990  "</nvt>"
10991  "<creation_time>%s</creation_time>"
10992  "<modification_time>%s</modification_time>"
10993  "<writable>1</writable>"
10994  "<in_use>0</in_use>"
10995  "<active>%i</active>"
10996  "<end_time>%s</end_time>"
10997  "<text>%s</text>"
10998  "<hosts>%s</hosts>"
10999  "<port>%s</port>"
11000  "<threat>%s</threat>"
11001  "<severity>%s</severity>"
11002  "<new_threat>%s</new_threat>"
11003  "<new_severity>%s</new_severity>"
11004  "<task id=\"%s\"><name>%s</name><trash>%i</trash></task>"
11005  "<orphan>%i</orphan>",
11006  get_iterator_owner_name (overrides)
11007  ? get_iterator_owner_name (overrides)
11008  : "",
11009  override_iterator_nvt_oid (overrides),
11010  override_iterator_nvt_name (overrides),
11011  override_iterator_nvt_type (overrides),
11012  get_iterator_creation_time (overrides),
11013  get_iterator_modification_time (overrides),
11014  override_iterator_active (overrides),
11015  end_time > 1 ? iso_time (&end_time) : "",
11016  override_iterator_text (overrides),
11017  override_iterator_hosts (overrides)
11018  ? override_iterator_hosts (overrides) : "",
11019  override_iterator_port (overrides)
11020  ? override_iterator_port (overrides) : "",
11021  override_iterator_threat (overrides)
11022  ? override_iterator_threat (overrides) : "",
11023  override_iterator_severity (overrides)
11024  ? override_iterator_severity (overrides) : "",
11025  override_iterator_new_threat (overrides),
11026  override_iterator_new_severity (overrides),
11027  uuid_task ? uuid_task : "",
11028  name_task ? name_task : "",
11029  trash_task,
11030  ((override_iterator_task (overrides) && (uuid_task == NULL))
11031  || (override_iterator_result (overrides) && (uuid_result == NULL))));
11032 
11033  free (name_task);
11034 
11035  if (include_result && override_iterator_result (overrides))
11036  {
11037  iterator_t results;
11038  get_data_t *result_get;
11039  result_get = report_results_get_data (1, 1,
11040  1, /* apply_overrides */
11041  0, /* autofp */
11042  0 /* min_qod */);
11044  &(result_get->id));
11045  init_result_get_iterator (&results, result_get,
11046  0, /* No report restriction */
11047  NULL, /* No host restriction */
11048  NULL); /* No extra order SQL. */
11049  get_data_reset (result_get);
11050  free (result_get);
11051 
11052  while (next (&results))
11053  buffer_results_xml (buffer,
11054  &results,
11055  0,
11056  0, /* Overrides. */
11057  0, /* Override details. */
11058  0, /* Overrides. */
11059  0, /* Override details. */
11060  0, /* Tags. */
11061  0, /* Tag details. */
11062  0, /* Result details. */
11063  NULL,
11064  NULL,
11065  0);
11066  cleanup_iterator (&results);
11067  }
11068  else
11069  buffer_xml_append_printf (buffer,
11070  "<result id=\"%s\"/>",
11071  uuid_result ? uuid_result : "");
11072 
11073  buffer_xml_append_printf (buffer,
11074  "<user_tags>"
11075  "<count>%i</count>",
11076  resource_tag_count ("override",
11078  (overrides),
11079  1));
11080 
11081  init_resource_tag_iterator (&tags, "override",
11082  get_iterator_resource (overrides),
11083  1, NULL, 1);
11084 
11085  while (next (&tags))
11086  {
11087  buffer_xml_append_printf (buffer,
11088  "<tag id=\"%s\">"
11089  "<name>%s</name>"
11090  "<value>%s</value>"
11091  "<comment>%s</comment>"
11092  "</tag>",
11097  }
11098 
11099  cleanup_iterator (&tags);
11100 
11101  buffer_xml_append_printf (buffer,
11102  "</user_tags>"
11103  "</override>");
11104  }
11105  free (uuid_task);
11106  free (uuid_result);
11107  }
11108 }
11109 
11110 /* External for manage.c. */
11119 void
11120 buffer_config_preference_xml (GString *buffer, iterator_t *prefs,
11121  config_t config, int hide_passwords)
11122 {
11123  char *real_name, *type, *value, *nvt;
11124  const char *default_value;
11125  char *oid = NULL;
11126 
11127  real_name = nvt_preference_iterator_real_name (prefs);
11129  value = nvt_preference_iterator_config_value (prefs, config);
11130  nvt = nvt_preference_iterator_nvt (prefs);
11131 
11132  default_value = nvt_preference_iterator_value (prefs);
11133 
11134  if (nvt) oid = nvt_oid (nvt);
11135 
11136  buffer_xml_append_printf (buffer,
11137  "<preference>"
11138  "<nvt oid=\"%s\"><name>%s</name></nvt>"
11139  "<hr_name>%s</hr_name>"
11140  "<name>%s</name>"
11141  "<type>%s</type>",
11142  oid ? oid : "",
11143  nvt ? nvt : "",
11144  real_name ? real_name : "",
11145  real_name ? real_name : "",
11146  type ? type : "");
11147 
11148  if (value
11149  && type
11150  && (strcmp (type, "radio") == 0))
11151  {
11152  /* Handle the other possible values. */
11153  char *pos = strchr (value, ';');
11154  if (pos) *pos = '\0';
11155  buffer_xml_append_printf (buffer, "<value>%s</value>", value);
11156  while (pos)
11157  {
11158  char *pos2 = strchr (++pos, ';');
11159  if (pos2) *pos2 = '\0';
11160  buffer_xml_append_printf (buffer, "<alt>%s</alt>", pos);
11161  pos = pos2;
11162  }
11163  }
11164  else if (value
11165  && type
11166  && hide_passwords
11167  && (strcmp (type, "password") == 0))
11168  buffer_xml_append_printf (buffer, "<value></value>");
11169  else
11170  buffer_xml_append_printf (buffer, "<value>%s</value>", value ? value : "");
11171 
11172  if (default_value
11173  && type
11174  && (strcmp (type, "radio") == 0))
11175  {
11176  /* Handle the other possible values. */
11177  char *pos = strchr (default_value, ';');
11178  if (pos) *pos = '\0';
11179  buffer_xml_append_printf (buffer, "<default>%s</default>", default_value);
11180  }
11181  else if (default_value
11182  && type
11183  && (strcmp (type, "password") == 0))
11184  buffer_xml_append_printf (buffer, "<default></default>");
11185  else
11186  buffer_xml_append_printf (buffer, "<default>%s</default>", default_value
11187  ? default_value
11188  : "");
11189 
11190  buffer_xml_append_printf (buffer, "</preference>");
11191 
11192  free (real_name);
11193  free (type);
11194  free (value);
11195  free (nvt);
11196  free (oid);
11197 }
11198 
11207 gchar *
11208 strdiff (const gchar *one, const gchar *two)
11209 {
11210  gchar **cmd, *ret, *one_file, *two_file, *old_lc_all, *old_language;
11211  gint exit_status;
11212  gchar *standard_out = NULL;
11213  gchar *standard_err = NULL;
11214  char dir[] = "/tmp/openvasmd-strdiff-XXXXXX";
11215  GError *error = NULL;
11216 
11217  if (mkdtemp (dir) == NULL)
11218  return NULL;
11219 
11220  one_file = g_build_filename (dir, "Report 1", NULL);
11221 
11222  g_file_set_contents (one_file, one, strlen (one), &error);
11223  if (error)
11224  {
11225  g_warning ("%s", error->message);
11226  g_error_free (error);
11227  openvas_file_remove_recurse (dir);
11228  g_free (one_file);
11229  return NULL;
11230  }
11231 
11232  two_file = g_build_filename (dir, "Report 2", NULL);
11233 
11234  g_file_set_contents (two_file, two, strlen (two), &error);
11235  if (error)
11236  {
11237  g_warning ("%s", error->message);
11238  g_error_free (error);
11239  openvas_file_remove_recurse (dir);
11240  g_free (one_file);
11241  g_free (two_file);
11242  return NULL;
11243  }
11244 
11245  old_lc_all = getenv ("LC_ALL") ? g_strdup (getenv ("LC_ALL")) : NULL;
11246  if (setenv ("LC_ALL", "C", 1) == -1)
11247  {
11248  g_warning ("%s: failed to set LC_ALL\n", __FUNCTION__);
11249  return NULL;
11250  }
11251 
11252  old_language = getenv ("LANGUAGE") ? g_strdup (getenv ("LANGUAGE")) : NULL;
11253  if (setenv ("LANGUAGE", "C", 1) == -1)
11254  {
11255  g_warning ("%s: failed to set LANGUAGE\n", __FUNCTION__);
11256  return NULL;
11257  }
11258 
11259  cmd = (gchar **) g_malloc (5 * sizeof (gchar *));
11260 
11261  cmd[0] = g_strdup ("diff");
11262  cmd[1] = g_strdup ("-u");
11263  cmd[2] = g_strdup ("Report 1");
11264  cmd[3] = g_strdup ("Report 2");
11265  cmd[4] = NULL;
11266  g_debug ("%s: Spawning in %s: %s \"%s\" \"%s\"\n",
11267  __FUNCTION__, dir,
11268  cmd[0], cmd[1], cmd[2]);
11269  if ((g_spawn_sync (dir,
11270  cmd,
11271  NULL, /* Environment. */
11272  G_SPAWN_SEARCH_PATH,
11273  NULL, /* Setup func. */
11274  NULL,
11275  &standard_out,
11276  &standard_err,
11277  &exit_status,
11278  NULL) == FALSE)
11279  || (WIFEXITED (exit_status) == 0)
11280  || WEXITSTATUS (exit_status))
11281  {
11282  if (WEXITSTATUS (exit_status) == 1)
11283  ret = standard_out;
11284  else
11285  {
11286  g_debug ("%s: failed to run diff: %d (WIF %i, WEX %i)",
11287  __FUNCTION__,
11288  exit_status,
11289  WIFEXITED (exit_status),
11290  WEXITSTATUS (exit_status));
11291  g_debug ("%s: stdout: %s\n", __FUNCTION__, standard_out);
11292  g_debug ("%s: stderr: %s\n", __FUNCTION__, standard_err);
11293  ret = NULL;
11294  g_free (standard_out);
11295  }
11296  }
11297  else
11298  ret = standard_out;
11299 
11300  if (old_lc_all && (setenv ("LC_ALL", old_lc_all, 1) == -1))
11301  {
11302  g_warning ("%s: failed to reset LC_ALL\n", __FUNCTION__);
11303  ret = NULL;
11304  }
11305  else if (old_language && (setenv ("LANGUAGE", old_language, 1) == -1))
11306  {
11307  g_warning ("%s: failed to reset LANGUAGE\n", __FUNCTION__);
11308  ret = NULL;
11309  }
11310 
11311  g_free (old_lc_all);
11312  g_free (old_language);
11313  g_free (cmd[0]);
11314  g_free (cmd[1]);
11315  g_free (cmd[2]);
11316  g_free (cmd[3]);
11317  g_free (cmd);
11318  g_free (standard_err);
11319  g_free (one_file);
11320  g_free (two_file);
11321  openvas_file_remove_recurse (dir);
11322 
11323  return ret;
11324 }
11325 
11334 static void
11335 buffer_result_notes_xml (GString *buffer, result_t result, task_t task,
11336  int include_notes_details)
11337 {
11338  g_string_append (buffer, "<notes>");
11339 
11340  if (task)
11341  {
11342  get_data_t get;
11343  iterator_t notes;
11344  memset (&get, '\0', sizeof (get));
11345  /* Most recent first. */
11346  get.filter = "sort-reverse=created owner=any permission=any";
11347  init_note_iterator (&notes,
11348  &get,
11349  0,
11350  result,
11351  task);
11352  buffer_notes_xml (buffer,
11353  &notes,
11354  include_notes_details,
11355  0,
11356  NULL);
11357  cleanup_iterator (&notes);
11358  }
11359 
11360  g_string_append (buffer, "</notes>");
11361 }
11362 
11371 static void
11372 buffer_result_overrides_xml (GString *buffer, result_t result, task_t task,
11373  int include_overrides_details)
11374 {
11375  g_string_append (buffer, "<overrides>");
11376 
11377  if (task)
11378  {
11379  get_data_t get;
11380  iterator_t overrides;
11381  memset (&get, '\0', sizeof (get));
11382  /* Most recent first. */
11383  get.filter = "sort-reverse=created owner=any permission=any";
11384  init_override_iterator (&overrides,
11385  &get,
11386  0,
11387  result,
11388  task);
11389  buffer_overrides_xml (buffer,
11390  &overrides,
11391  include_overrides_details,
11392  0,
11393  NULL);
11394  cleanup_iterator (&overrides);
11395  }
11396 
11397  g_string_append (buffer, "</overrides>");
11398 }
11399 
11407 static void
11408 add_detail (GString *buffer, const gchar *name, const gchar *value)
11409 {
11410  buffer_xml_append_printf (buffer,
11411  "<detail>"
11412  "<name>%s</name>"
11413  "<value>%s</value>"
11414  "</detail>",
11415  name,
11416  value);
11417 }
11418 
11425 static void
11426 results_xml_append_cert (GString *buffer, const char *oid)
11427 {
11428  iterator_t cert_refs_iterator;
11429 
11430  buffer_xml_append_printf (buffer, "<cert>");
11431  if (manage_cert_loaded ())
11432  {
11433  init_nvt_cert_bund_adv_iterator (&cert_refs_iterator, oid, 0, 0);
11434  while (next (&cert_refs_iterator))
11435  {
11436  g_string_append_printf
11437  (buffer, "<cert_ref type=\"CERT-Bund\" id=\"%s\"/>",
11438  get_iterator_name (&cert_refs_iterator));
11439  }
11440  cleanup_iterator (&cert_refs_iterator);
11441 
11442  init_nvt_dfn_cert_adv_iterator (&cert_refs_iterator, oid, 0, 0);
11443  while (next (&cert_refs_iterator))
11444  {
11445  g_string_append_printf
11446  (buffer, "<cert_ref type=\"DFN-CERT\" id=\"%s\"/>",
11447  get_iterator_name (&cert_refs_iterator));
11448  }
11449  cleanup_iterator (&cert_refs_iterator);
11450  }
11451  else
11452  g_string_append_printf (buffer,
11453  "<warning>database not available</warning>");
11454  buffer_xml_append_printf (buffer, "</cert>");
11455 }
11456 
11463 static void
11464 results_xml_append_nvt (iterator_t *results, GString *buffer)
11465 {
11466  const char *oid = result_iterator_nvt_oid (results);
11467 
11468  assert (results);
11469  assert (buffer);
11470 
11471  if (g_str_has_prefix (oid, "CVE-"))
11472  {
11473  gchar *cvss_base;
11474  cvss_base = cve_cvss_base (oid);
11475  buffer_xml_append_printf (buffer,
11476  "<nvt oid=\"%s\">"
11477  "<type>cve</type>"
11478  "<name>%s</name>"
11479  "<cvss_base>%s</cvss_base>"
11480  "<cpe id='%s'/>"
11481  "<cve>%s</cve>"
11482  "</nvt>",
11483  oid,
11484  oid,
11485  cvss_base,
11486  result_iterator_port (results),
11487  oid);
11488  g_free (cvss_base);
11489  return;
11490  }
11491 
11492  if (g_str_has_prefix (oid, "oval:"))
11493  {
11494  int ret;
11495  char *cves;
11496  get_data_t get;
11498 
11499  memset (&get, '\0', sizeof (get));
11500  get.id = g_strdup (oid);
11501  ret = init_ovaldef_info_iterator (&iterator, &get, NULL);
11502  if (ret)
11503  assert (0);
11504  if (!next (&iterator))
11505  abort ();
11506  cves = ovaldef_cves (oid);
11507  buffer_xml_append_printf (buffer,
11508  "<nvt oid=\"%s\">"
11509  "<type>ovaldef</type>"
11510  "<name>%s</name>"
11511  "<family/>"
11512  "<cvss_base>%s</cvss_base>"
11513  "<cve>%s</cve>"
11514  "<bid/>"
11515  "<tags>summary=%s</tags>"
11516  "<xref/>",
11517  oid,
11520  cves ?: "",
11522  g_free (cves);
11523  g_free (get.id);
11525  }
11526  else
11527  {
11528  const char *cvss_base = result_iterator_nvt_cvss_base (results);
11529 
11530  if (!cvss_base && !strcmp (oid, "0"))
11531  cvss_base = "0.0";
11532 
11533  buffer_xml_append_printf (buffer,
11534  "<nvt oid=\"%s\">"
11535  "<type>nvt</type>"
11536  "<name>%s</name>"
11537  "<family>%s</family>"
11538  "<cvss_base>%s</cvss_base>"
11539  "<cve>%s</cve>"
11540  "<bid>%s</bid>"
11541  "<xref>%s</xref>"
11542  "<tags>%s</tags>",
11543  oid,
11544  result_iterator_nvt_name (results) ?: oid,
11545  result_iterator_nvt_family (results) ?: "",
11546  cvss_base ?: "",
11547  result_iterator_nvt_cve (results) ?: "",
11548  result_iterator_nvt_bid (results) ?: "",
11549  result_iterator_nvt_xref (results) ?: "",
11550  result_iterator_nvt_tag (results) ?: "");
11551  }
11552 
11553  results_xml_append_cert (buffer, oid);
11554  buffer_xml_append_printf (buffer, "</nvt>");
11555 }
11556 
11578 void
11579 buffer_results_xml (GString *buffer, iterator_t *results, task_t task,
11580  int include_notes, int include_notes_details,
11581  int include_overrides, int include_overrides_details,
11582  int include_tags, int include_tags_details,
11583  int include_details,
11584  const char *delta_state, iterator_t *delta_results,
11585  int changed)
11586 {
11587  const char *descr = result_iterator_descr (results);
11588  const char *name, *owner_name, *comment, *creation_time, *modification_time;
11589  gchar *nl_descr, *asset_id;
11590  const char *qod = result_iterator_qod (results);
11591  const char *qod_type = result_iterator_qod_type (results);
11592  result_t result = result_iterator_result (results);
11593  char *uuid;
11594  char *detect_ref, *detect_cpe, *detect_loc, *detect_oid, *detect_name;
11595  task_t selected_task;
11596 
11597  nl_descr = descr ? convert_to_newlines (descr) : NULL;
11598 
11599  result_uuid (result, &uuid);
11600 
11601  buffer_xml_append_printf (buffer, "<result id=\"%s\">", uuid);
11602 
11603  selected_task = task;
11604 
11605  name = get_iterator_name (results);
11606  if (name)
11607  buffer_xml_append_printf (buffer,
11608  "<name>%s</name>",
11609  name);
11610 
11611  owner_name = get_iterator_owner_name (results);
11612  if (owner_name)
11613  buffer_xml_append_printf (buffer,
11614  "<owner><name>%s</name></owner>",
11615  owner_name);
11616 
11617  comment = get_iterator_comment (results);
11618  if (comment)
11619  buffer_xml_append_printf (buffer,
11620  "<comment>%s</comment>",
11621  comment);
11622 
11623  creation_time = get_iterator_creation_time (results);
11624  if (creation_time)
11625  buffer_xml_append_printf (buffer,
11626  "<creation_time>%s</creation_time>",
11627  creation_time);
11628 
11629  modification_time = get_iterator_modification_time (results);
11630  if (modification_time)
11631  buffer_xml_append_printf (buffer,
11632  "<modification_time>%s</modification_time>",
11633  modification_time);
11634 
11635  if (include_details)
11636  {
11637  char *result_report_id, *result_task_id, *result_task_name;
11638 
11639  if (task == 0)
11640  selected_task = result_iterator_task (results);
11641 
11642  task_uuid (selected_task, &result_task_id);
11643  result_task_name = task_name (result_iterator_task (results));
11644  result_report_id = report_uuid (result_iterator_report (results));
11645 
11646  buffer_xml_append_printf (buffer,
11647  "<report id=\"%s\"/>"
11648  "<task id=\"%s\"><name>%s</name></task>",
11649  result_report_id,
11650  result_task_id,
11651  result_task_name);
11652 
11653  free (result_report_id);
11654  free (result_task_id);
11655  free (result_task_name);
11656  }
11657 
11658  if (include_tags)
11659  {
11660  buffer_xml_append_printf (buffer,
11661  "<user_tags>"
11662  "<count>%i</count>",
11663  resource_tag_count ("result", result, 1));
11664 
11665  if (include_tags_details)
11666  {
11667  iterator_t tags;
11668 
11669  init_resource_tag_iterator (&tags, "result", result, 1, NULL, 1);
11670 
11671  while (next (&tags))
11672  {
11673  buffer_xml_append_printf (buffer,
11674  "<tag id=\"%s\">"
11675  "<name>%s</name>"
11676  "<value>%s</value>"
11677  "<comment>%s</comment>"
11678  "</tag>",
11683  }
11684 
11685  cleanup_iterator (&tags);
11686  }
11687 
11688  buffer_xml_append_printf (buffer, "</user_tags>");
11689  }
11690 
11691  detect_ref = detect_cpe = detect_loc = detect_oid = detect_name = NULL;
11692  if (result_detection_reference (result, &detect_ref, &detect_cpe, &detect_loc,
11693  &detect_oid, &detect_name) == 0)
11694  {
11695  buffer_xml_append_printf (buffer,
11696  "<detection>"
11697  "<result id=\"%s\">"
11698  "<details>",
11699  detect_ref);
11700 
11701  add_detail (buffer, "product", detect_cpe);
11702  add_detail (buffer, "location", detect_loc);
11703  add_detail (buffer, "source_oid", detect_oid);
11704  add_detail (buffer, "source_name", detect_name);
11705 
11706  buffer_xml_append_printf (buffer,
11707  "</details>"
11708  "</result>"
11709  "</detection>");
11710  }
11711  g_free (detect_ref);
11712  g_free (detect_cpe);
11713  g_free (detect_loc);
11714  g_free (detect_oid);
11715  g_free (detect_name);
11716 
11717  if (result_iterator_host (results))
11718  asset_id = result_host_asset_id (result_iterator_host (results),
11719  get_iterator_resource (results));
11720  else
11721  asset_id = NULL;
11722 
11723  buffer_xml_append_printf (buffer,
11724  "<host>"
11725  "%s"
11726  "<asset asset_id=\"%s\"/>"
11727  "</host>",
11728  result_iterator_host (results),
11729  asset_id ? asset_id : "");
11730  free (asset_id);
11731 
11732  buffer_xml_append_printf (buffer,
11733  "<port>%s</port>",
11734  result_iterator_port (results));
11735 
11736  results_xml_append_nvt (results, buffer);
11737 
11738  buffer_xml_append_printf
11739  (buffer,
11740  "<scan_nvt_version>%s</scan_nvt_version>"
11741  "<threat>%s</threat>"
11742  "<severity>%.1f</severity>"
11743  "<qod><value>%s</value><type>%s</type></qod>"
11744  "<description>%s</description>",
11746  result_iterator_level (results),
11748  qod ? qod : "",
11749  qod_type ? qod_type : "",
11750  descr ? nl_descr : "");
11751 
11752  if (include_overrides)
11753  buffer_xml_append_printf (buffer,
11754  "<original_threat>%s</original_threat>"
11755  "<original_severity>%s</original_severity>",
11758 
11759  free (uuid);
11760 
11761  if (include_notes)
11762  buffer_result_notes_xml (buffer, result,
11763  selected_task, include_notes_details);
11764 
11765  if (include_overrides)
11766  buffer_result_overrides_xml (buffer, result,
11767  selected_task, include_overrides_details);
11768 
11769  if (delta_state || delta_results)
11770  {
11771  g_string_append (buffer, "<delta>");
11772  if (delta_state)
11773  g_string_append_printf (buffer, "%s", delta_state);
11774  if (changed && delta_results)
11775  {
11776  gchar *diff, *delta_nl_descr;
11777  const char *delta_descr;
11778  buffer_results_xml (buffer, delta_results, selected_task,
11779  include_notes, include_notes_details,
11780  include_overrides, include_overrides_details,
11781  include_tags, include_tags_details,
11782  include_details, delta_state, NULL, 0);
11783  delta_descr = result_iterator_descr (delta_results);
11784  delta_nl_descr = delta_descr ? convert_to_newlines (delta_descr)
11785  : NULL;
11786  diff = strdiff (descr ? nl_descr : "",
11787  delta_descr ? delta_nl_descr : "");
11788  g_free (delta_nl_descr);
11789  if (diff)
11790  {
11791  gchar **split, *diff_xml;
11792  /* Remove the leading filename lines. */
11793  split = g_strsplit ((gchar*) diff, "\n", 3);
11794  if (split[0] && split[1] && split[2])
11795  diff_xml = g_markup_escape_text (split[2], strlen (split[2]));
11796  else
11797  diff_xml = g_markup_escape_text (diff, strlen (diff));
11798  g_strfreev (split);
11799  g_string_append_printf (buffer, "<diff>%s</diff>", diff_xml);
11800  g_free (diff_xml);
11801  g_free (diff);
11802  }
11803  else
11804  g_string_append (buffer, "<diff>Error creating diff.</diff>");
11805  }
11806 
11807  if (delta_results)
11808  {
11809  if (include_notes)
11810  buffer_result_notes_xml (buffer,
11811  result_iterator_result (delta_results),
11812  selected_task,
11813  include_notes_details);
11814 
11815  if (include_overrides)
11816  buffer_result_overrides_xml (buffer,
11817  result_iterator_result (delta_results),
11818  selected_task,
11819  include_overrides_details);
11820  }
11821  g_string_append (buffer, "</delta>");
11822  }
11823 
11824  if (descr) g_free (nl_descr);
11825 
11826  g_string_append (buffer, "</result>");
11827 }
11828 
11829 #undef ADD_DETAIL
11830 
11848 void
11849 init_aggregate_lists (const gchar* group_column,
11850  const gchar* subgroup_column,
11851  GList *data_column_list,
11852  GList *text_column_list,
11853  GList *sort_data_list,
11854  gchar **group_column_type,
11855  gchar **subgroup_column_type,
11856  GArray **data_column_types,
11857  GArray **data_columns,
11858  GArray **text_column_types,
11859  GArray **text_columns,
11860  GArray **sort_data,
11861  GArray **c_sums)
11862 {
11863  if (group_column == NULL)
11864  *group_column_type = "";
11865  else if (strcmp (group_column, "severity") == 0)
11866  *group_column_type = "cvss";
11867  else if (strcmp (group_column, "created") == 0
11868  || strcmp (group_column, "modified") == 0)
11869  *group_column_type = "unix_time";
11870  else
11871  *group_column_type = "text";
11872 
11873  if (subgroup_column == NULL)
11874  *subgroup_column_type = "";
11875  else if (strcmp (subgroup_column, "severity") == 0)
11876  *subgroup_column_type = "cvss";
11877  else if (strcmp (subgroup_column, "created") == 0
11878  || strcmp (subgroup_column, "modified") == 0)
11879  *subgroup_column_type = "unix_time";
11880  else
11881  *subgroup_column_type = "text";
11882 
11883  *data_columns = g_array_new (TRUE, TRUE, sizeof (gchar*));
11884  *data_column_types = g_array_new (TRUE, TRUE, sizeof (char*));
11885  *text_columns = g_array_new (TRUE, TRUE, sizeof (gchar*));
11886  *text_column_types = g_array_new (TRUE, TRUE, sizeof (char*));
11887  *c_sums = g_array_new (TRUE, TRUE, sizeof (double));
11888  *sort_data = g_array_new (TRUE, TRUE, sizeof (sort_data_t*));
11889 
11890  data_column_list = g_list_first (data_column_list);
11891  while (data_column_list)
11892  {
11893  gchar *data_column = data_column_list->data;
11894  if (strcmp (data_column, ""))
11895  {
11896  gchar *current_column = g_strdup (data_column);
11897  gchar *current_column_type;
11898  double c_sum = 0.0;
11899  g_array_append_val (*data_columns,
11900  current_column);
11901 
11902  if (strcmp (data_column, "severity") == 0)
11903  current_column_type = g_strdup ("cvss");
11904  else if (strcmp (data_column, "created") == 0
11905  || strcmp (data_column, "modified") == 0)
11906  current_column_type = g_strdup ("unix_time");
11907  else
11908  current_column_type = g_strdup ("decimal");
11909 
11910  g_array_append_val (*data_column_types, current_column_type);
11911 
11912  g_array_append_val (*c_sums, c_sum);
11913  }
11914  data_column_list = data_column_list->next;
11915  }
11916 
11917  text_column_list = g_list_first (text_column_list);
11918  while (text_column_list)
11919  {
11920  gchar *text_column = text_column_list->data;
11921  if (strcmp (text_column, ""))
11922  {
11923  gchar *current_column = g_strdup (text_column);
11924  gchar *current_column_type;
11925 
11926  current_column_type = g_strdup ("text");
11927 
11928  g_array_append_val (*text_columns, current_column);
11929  g_array_append_val (*text_column_types, current_column_type);
11930  }
11931  text_column_list = text_column_list->next;
11932  }
11933 
11934  sort_data_list = g_list_first (sort_data_list);
11935  while (sort_data_list)
11936  {
11937  sort_data_t *sort_data_item = sort_data_list->data;
11938  sort_data_t *sort_data_copy = g_malloc0 (sizeof (sort_data_t));
11939 
11940  sort_data_copy->field = g_strdup (sort_data_item->field);
11941  sort_data_copy->stat = g_strdup (sort_data_item->stat);
11942  sort_data_copy->order = sort_data_item->order;
11943  g_array_append_val (*sort_data, sort_data_copy);
11944 
11945  sort_data_list = sort_data_list->next;
11946  }
11947 }
11948 
11952 typedef struct
11953 {
11954  gchar *string;
11955  int count;
11956 } count_data_t;
11957 
11961 typedef struct
11962 {
11963  GString *buffer;
11964  int skip;
11965  int limit;
11967 
11976 static int
11977 strcasecmp_reverse (gchar *s1, gchar *s2)
11978 {
11979  return g_ascii_strcasecmp (s2, s1);
11980 }
11981 
11991 static int
11992 compare_count_data (gconstpointer c1, gconstpointer c2, gpointer dummy)
11993 {
11994  return (((count_data_t*)c2)->count - ((count_data_t*)c1)->count);
11995 }
11996 
12006 static int
12007 compare_count_data_reverse (gconstpointer c1, gconstpointer c2, gpointer dummy)
12008 {
12009  return (((count_data_t*)c1)->count - ((count_data_t*)c2)->count);
12010 }
12011 
12021 static gboolean
12022 copy_word_counts_asc (gpointer key, gpointer value, gpointer data)
12023 {
12024  count_data_t* new_count = g_malloc (sizeof (count_data_t));
12025 
12026  new_count->string = (gchar*)key;
12027  new_count->count = GPOINTER_TO_INT (value);
12028 
12029  g_sequence_insert_sorted ((GSequence*) data,
12030  new_count,
12031  compare_count_data_reverse,
12032  NULL);
12033 
12034  return FALSE;
12035 }
12036 
12046 static gboolean
12047 copy_word_counts_desc (gpointer key, gpointer value, gpointer data)
12048 {
12049  count_data_t* new_count = g_malloc (sizeof (count_data_t));
12050 
12051  new_count->string = (gchar*)key;
12052  new_count->count = GPOINTER_TO_INT (value);
12053 
12054  g_sequence_insert_sorted ((GSequence*) data,
12055  new_count,
12056  compare_count_data,
12057  NULL);
12058 
12059  return FALSE;
12060 }
12061 
12071 static gboolean
12072 buffer_word_counts_tree (gpointer key, gpointer value, gpointer data)
12073 {
12074  buffer_counts_data_t* count_data = (buffer_counts_data_t*) data;
12075  if (count_data->skip)
12076  {
12077  count_data->skip--;
12078  return FALSE;
12079  }
12080  xml_string_append (count_data->buffer,
12081  "<group>"
12082  "<value>%s</value>"
12083  "<count>%d</count>"
12084  "</group>",
12085  (gchar*) key,
12086  GPOINTER_TO_INT (value));
12087  if (count_data->limit > 0)
12088  count_data->limit--;
12089 
12090  return (count_data->limit == 0);
12091 }
12092 
12101 static void
12102 buffer_word_counts_seq (gpointer value, gpointer buffer)
12103 {
12104  xml_string_append ((GString*) buffer,
12105  "<group>"
12106  "<value>%s</value>"
12107  "<count>%d</count>"
12108  "</group>",
12109  ((count_data_t*) value)->string,
12110  ((count_data_t*) value)->count);
12111 }
12112 
12124 void
12125 buffer_aggregate_wc_xml (GString *xml, iterator_t* aggregate,
12126  const gchar* type, const char* group_column,
12127  GArray* sort_data,
12128  int first_group, int max_groups)
12129 {
12130  sort_data_t *first_sort_data;
12131  const char *sort_stat;
12132  int sort_order;
12133 
12134  if (sort_data && sort_data->len)
12135  {
12136  first_sort_data = g_array_index (sort_data, sort_data_t*, 0);
12137  sort_stat = first_sort_data->stat;
12138  sort_order = first_sort_data->order;
12139  }
12140  else
12141  {
12142  sort_stat = "value";
12143  sort_order = 0;
12144  }
12145 
12146  GTree *word_counts, *ignore_words;
12147  GRegex *word_regex;
12148 
12149  // Word regex: Words must contain at least 1 letter
12150  word_regex = g_regex_new ("[[:alpha:]]", 0, 0, NULL);
12151 
12152  ignore_words = g_tree_new_full ((GCompareDataFunc) g_ascii_strcasecmp, NULL,
12153  g_free, NULL);
12154  g_tree_insert (ignore_words, g_strdup ("an"), GINT_TO_POINTER (1));
12155  g_tree_insert (ignore_words, g_strdup ("the"), GINT_TO_POINTER (1));
12156  g_tree_insert (ignore_words, g_strdup ("and"), GINT_TO_POINTER (1));
12157  g_tree_insert (ignore_words, g_strdup ("or"), GINT_TO_POINTER (1));
12158  g_tree_insert (ignore_words, g_strdup ("not"), GINT_TO_POINTER (1));
12159  g_tree_insert (ignore_words, g_strdup ("is"), GINT_TO_POINTER (1));
12160  g_tree_insert (ignore_words, g_strdup ("are"), GINT_TO_POINTER (1));
12161  g_tree_insert (ignore_words, g_strdup ("was"), GINT_TO_POINTER (1));
12162  g_tree_insert (ignore_words, g_strdup ("were"), GINT_TO_POINTER (1));
12163  g_tree_insert (ignore_words, g_strdup ("you"), GINT_TO_POINTER (1));
12164  g_tree_insert (ignore_words, g_strdup ("your"), GINT_TO_POINTER (1));
12165  g_tree_insert (ignore_words, g_strdup ("it"), GINT_TO_POINTER (1));
12166  g_tree_insert (ignore_words, g_strdup ("its"), GINT_TO_POINTER (1));
12167  g_tree_insert (ignore_words, g_strdup ("they"), GINT_TO_POINTER (1));
12168  g_tree_insert (ignore_words, g_strdup ("this"), GINT_TO_POINTER (1));
12169  g_tree_insert (ignore_words, g_strdup ("that"), GINT_TO_POINTER (1));
12170  g_tree_insert (ignore_words, g_strdup ("which"), GINT_TO_POINTER (1));
12171  g_tree_insert (ignore_words, g_strdup ("when"), GINT_TO_POINTER (1));
12172  g_tree_insert (ignore_words, g_strdup ("if"), GINT_TO_POINTER (1));
12173  g_tree_insert (ignore_words, g_strdup ("do"), GINT_TO_POINTER (1));
12174  g_tree_insert (ignore_words, g_strdup ("does"), GINT_TO_POINTER (1));
12175  g_tree_insert (ignore_words, g_strdup ("did"), GINT_TO_POINTER (1));
12176  g_tree_insert (ignore_words, g_strdup ("at"), GINT_TO_POINTER (1));
12177  g_tree_insert (ignore_words, g_strdup ("where"), GINT_TO_POINTER (1));
12178  g_tree_insert (ignore_words, g_strdup ("in"), GINT_TO_POINTER (1));
12179  g_tree_insert (ignore_words, g_strdup ("will"), GINT_TO_POINTER (1));
12180  g_tree_insert (ignore_words, g_strdup ("as"), GINT_TO_POINTER (1));
12181  g_tree_insert (ignore_words, g_strdup ("has"), GINT_TO_POINTER (1));
12182  g_tree_insert (ignore_words, g_strdup ("have"), GINT_TO_POINTER (1));
12183  g_tree_insert (ignore_words, g_strdup ("can"), GINT_TO_POINTER (1));
12184  g_tree_insert (ignore_words, g_strdup ("cannot"), GINT_TO_POINTER (1));
12185  g_tree_insert (ignore_words, g_strdup ("been"), GINT_TO_POINTER (1));
12186  g_tree_insert (ignore_words, g_strdup ("with"), GINT_TO_POINTER (1));
12187  g_tree_insert (ignore_words, g_strdup ("under"), GINT_TO_POINTER (1));
12188  g_tree_insert (ignore_words, g_strdup ("for"), GINT_TO_POINTER (1));
12189  g_tree_insert (ignore_words, g_strdup ("than"), GINT_TO_POINTER (1));
12190  g_tree_insert (ignore_words, g_strdup ("seen"), GINT_TO_POINTER (1));
12191  g_tree_insert (ignore_words, g_strdup ("full"), GINT_TO_POINTER (1));
12192  g_tree_insert (ignore_words, g_strdup ("use"), GINT_TO_POINTER (1));
12193  g_tree_insert (ignore_words, g_strdup ("see"), GINT_TO_POINTER (1));
12194  g_tree_insert (ignore_words, g_strdup ("more"), GINT_TO_POINTER (1));
12195 
12196  if (sort_order)
12197  word_counts = g_tree_new_full ((GCompareDataFunc) g_ascii_strcasecmp, NULL,
12198  g_free, NULL);
12199  else
12200  word_counts = g_tree_new_full ((GCompareDataFunc) strcasecmp_reverse, NULL,
12201  g_free, NULL);
12202 
12203  g_string_append_printf (xml, "<aggregate>");
12204 
12205  g_string_append_printf (xml,
12206  "<group_column>%s</group_column>",
12207  group_column);
12208 
12209  while (next (aggregate))
12210  {
12211  const gchar *value = aggregate_iterator_value (aggregate);
12212  int count = aggregate_iterator_count (aggregate);
12213 
12214  int current_index = 0;
12215  gchar **split_string;
12216 
12217  if (!value)
12218  continue;
12219 
12220  split_string = g_strsplit_set (value, " \t\n.,:;\"'()[]{}<>&", -1);
12221  while (split_string [current_index])
12222  {
12223  gchar *word = split_string [current_index];
12224  if (strlen (word) >= 3
12225  && g_regex_match (word_regex, word, 0, NULL)
12226  && g_tree_lookup (ignore_words, word) == 0)
12227  {
12228  int word_count
12229  = GPOINTER_TO_INT (g_tree_lookup (word_counts, word));
12230  if (word_count)
12231  {
12232  g_tree_insert (word_counts, word,
12233  GINT_TO_POINTER (word_count + count));
12234  }
12235  else
12236  {
12237  g_tree_insert (word_counts, g_strdup (word),
12238  GINT_TO_POINTER (count));
12239  }
12240  }
12241  current_index++;
12242  }
12243  }
12244 
12245  if (sort_stat && strcasecmp (sort_stat, "count") == 0)
12246  {
12247  GSequence *word_counts_sorted;
12248  GSequenceIter *start, *end;
12249  word_counts_sorted = g_sequence_new (g_free);
12250  g_tree_foreach (word_counts,
12251  sort_order
12252  ? copy_word_counts_asc
12253  : copy_word_counts_desc,
12254  word_counts_sorted);
12255 
12256  start = g_sequence_get_iter_at_pos (word_counts_sorted, first_group);
12257  if (max_groups < 0)
12258  end = g_sequence_get_end_iter (word_counts_sorted);
12259  else
12260  end = g_sequence_get_iter_at_pos (word_counts_sorted,
12261  first_group + max_groups);
12262 
12263  g_sequence_foreach_range (start, end, buffer_word_counts_seq, xml);
12264 
12265  g_sequence_free (word_counts_sorted);
12266  }
12267  else
12268  {
12269  // value: use default alphabetical sorting
12270  buffer_counts_data_t counts_data;
12271  counts_data.buffer = xml;
12272  counts_data.skip = first_group;
12273  counts_data.limit = max_groups;
12274  g_tree_foreach (word_counts, buffer_word_counts_tree, &counts_data);
12275  }
12276 
12277  g_tree_destroy (word_counts);
12278  g_tree_destroy (ignore_words);
12279 
12280  g_string_append (xml, "<column_info>");
12281 
12282  g_string_append_printf (xml,
12283  "<aggregate_column>"
12284  "<name>value</name>"
12285  "<stat>value</stat>"
12286  "<type>%s</type>"
12287  "<column>%s</column>"
12288  "<data_type>text</data_type>"
12289  "</aggregate_column>",
12290  type,
12291  group_column);
12292 
12293  g_string_append_printf (xml,
12294  "<aggregate_column>"
12295  "<name>count</name>"
12296  "<stat>count</stat>"
12297  "<type>%s</type>"
12298  "<column></column>"
12299  "<data_type>integer</data_type>"
12300  "</aggregate_column>",
12301  type);
12302 
12303  g_string_append (xml, "</column_info>");
12304 
12305  g_string_append_printf (xml, "</aggregate>");
12306 }
12307 
12315 static gboolean
12316 buffer_aggregate_subgroup_value (gchar *key,
12317  long int *value,
12318  GString *buffer)
12319 {
12320  xml_string_append (buffer, "<value>%s</value>", key ? key : "");
12321  return FALSE;
12322 }
12323 
12340 void
12341 buffer_aggregate_xml (GString *xml, iterator_t* aggregate, const gchar* type,
12342  const char* group_column, const char* group_column_type,
12343  const char* subgroup_column,
12344  const char* subgroup_column_type,
12345  GArray *data_columns, GArray *data_column_types,
12346  GArray *text_columns, GArray *text_column_types,
12347  GArray *c_sums)
12348 {
12349  int index;
12350  long c_count, previous_c_count;
12351  gchar *previous_group_value;
12352  long int aggregate_group_count;
12353  GArray *group_mins, *group_maxs, *group_mean_sums, *group_sums, *group_c_sums;
12354  GTree *subgroup_c_counts;
12355  int has_groups = 0;
12356 
12357  g_string_append_printf (xml, "<aggregate>");
12358 
12359  for (index = 0; index < data_columns->len ;index ++)
12360  {
12361  gchar *column_name = g_array_index (data_columns, gchar*, index);
12362  if (column_name && strcmp (column_name, ""))
12363  {
12364  g_string_append_printf (xml,
12365  "<data_column>%s</data_column>",
12366  column_name);
12367  }
12368  }
12369 
12370  for (index = 0; index < text_columns->len ;index ++)
12371  {
12372  gchar *column_name = g_array_index (text_columns, gchar*, index);
12373  if (column_name && strcmp (column_name, ""))
12374  {
12375  g_string_append_printf (xml,
12376  "<text_column>%s</text_column>",
12377  column_name);
12378  }
12379  }
12380 
12381  if (group_column)
12382  g_string_append_printf (xml,
12383  "<group_column>%s</group_column>",
12384  group_column);
12385 
12386  if (subgroup_column)
12387  g_string_append_printf (xml,
12388  "<subgroup_column>%s</subgroup_column>",
12389  subgroup_column);
12390 
12391  previous_group_value = NULL;
12392  aggregate_group_count = 0L;
12393  c_count = 0L;
12394  previous_c_count = 0L;
12395 
12396  if (subgroup_column)
12397  {
12398  group_mins = g_array_new (TRUE, TRUE, sizeof (double));
12399  group_maxs = g_array_new (TRUE, TRUE, sizeof (double));
12400  group_mean_sums = g_array_new (TRUE, TRUE, sizeof (double));
12401  group_sums = g_array_new (TRUE, TRUE, sizeof (double));
12402 
12403  group_c_sums = g_array_new (TRUE, TRUE, sizeof (GTree*));
12404  for (index = 0; index < data_columns->len; index++)
12405  {
12406  g_array_index (group_c_sums, GTree*, index)
12407  = g_tree_new_full ((GCompareDataFunc) g_strcmp0, NULL,
12408  g_free, g_free);
12409  }
12410 
12411  subgroup_c_counts = g_tree_new_full ((GCompareDataFunc) g_strcmp0, NULL,
12412  g_free, g_free);
12413  }
12414  else
12415  {
12416  group_mins = NULL;
12417  group_maxs = NULL;
12418  group_mean_sums = NULL;
12419  group_sums = NULL;
12420  group_c_sums = NULL;
12421  subgroup_c_counts = NULL;
12422  }
12423 
12424  while (next (aggregate))
12425  {
12426  const char *value = aggregate_iterator_value (aggregate);
12427  const char *subgroup_value
12428  = aggregate_iterator_subgroup_value (aggregate);
12429  gchar *value_escaped, *subgroup_value_escaped;
12430 
12431  has_groups = 1;
12432 
12433  c_count += aggregate_iterator_count (aggregate);
12434 
12435  if (value && column_is_timestamp (group_column))
12436  {
12437  time_t value_int;
12438  if (sscanf (value, "%ld", &value_int) == 1)
12439  value_escaped = g_strdup (iso_time (&value_int));
12440  else
12441  value_escaped = g_markup_escape_text (value, -1);
12442  }
12443  else if (value && group_column_type
12444  && strcmp (group_column_type, "cvss") == 0)
12445  {
12446  double dbl_value;
12447  sscanf (value, "%lf", &dbl_value);
12448  value_escaped = g_strdup_printf ("%0.1lf", dbl_value);
12449  }
12450  else if (group_column && value)
12451  value_escaped = g_markup_escape_text (value, -1);
12452  else
12453  value_escaped = NULL;
12454 
12455  if (subgroup_column && column_is_timestamp (subgroup_column))
12456  {
12457  time_t value_int;
12458  if (sscanf (subgroup_value, "%ld", &value_int) == 1)
12459  subgroup_value_escaped = g_strdup (iso_time (&value_int));
12460  else
12461  subgroup_value_escaped = g_markup_escape_text (subgroup_value, -1);
12462  }
12463  else if (subgroup_value && subgroup_column_type
12464  && strcmp (subgroup_column_type, "cvss") == 0)
12465  {
12466  double dbl_value;
12467  sscanf (subgroup_value, "%lf", &dbl_value);
12468  subgroup_value_escaped = g_strdup_printf ("%0.1lf", dbl_value);
12469  }
12470  else if (subgroup_column && subgroup_value)
12471  subgroup_value_escaped = g_markup_escape_text (subgroup_value, -1);
12472  else
12473  subgroup_value_escaped = NULL;
12474 
12475  if (group_column)
12476  {
12477  if (subgroup_column)
12478  {
12479  long int *subgroup_c_count;
12480 
12481  // Update cumulative count for subgroup value
12482  subgroup_c_count
12483  = g_tree_lookup (subgroup_c_counts, subgroup_value);
12484  if (subgroup_c_count == NULL)
12485  {
12486  subgroup_c_count = g_malloc0 (sizeof (long int*));
12487  g_tree_insert (subgroup_c_counts,
12488  g_strdup (subgroup_value),
12489  subgroup_c_count);
12490  }
12491  *subgroup_c_count += aggregate_iterator_count (aggregate);
12492 
12493  // Output of group elements
12494  if (previous_group_value == NULL)
12495  {
12496  // Output start of first group
12497  g_string_append_printf (xml,
12498  "<group>"
12499  "<value>%s</value>",
12500  value_escaped);
12501  }
12502  else if (strcmp (previous_group_value, value))
12503  {
12504  // First subgroup of a new group:
12505  // output collected data of previous group and close it, ...
12506  g_string_append_printf (xml,
12507  "<count>%ld</count>"
12508  "<c_count>%ld</c_count>",
12509  aggregate_group_count,
12510  previous_c_count);
12511 
12512  for (index = 0; index < data_columns->len; index++)
12513  {
12514  gchar *data_column = g_array_index (data_columns,
12515  gchar*, index);
12516  double c_sum = g_array_index (c_sums, double, index);
12517 
12518  if (column_is_timestamp (data_column))
12519  {
12520  time_t min, max, mean;
12521  min = (time_t)(g_array_index (group_mins,
12522  double, index));
12523  max = (time_t)(g_array_index (group_maxs,
12524  double, index));
12525  mean = (time_t)(g_array_index (group_mean_sums,
12526  double, index)
12527  / aggregate_group_count);
12528 
12529  g_string_append_printf (xml,
12530  "<stats column=\"%s\">"
12531  "<min>%s</min>"
12532  "<max>%s</max>"
12533  "<mean>%s</mean>"
12534  "<sum></sum>"
12535  "<c_sum></c_sum>"
12536  "</stats>",
12537  data_column,
12538  iso_time (&min),
12539  iso_time (&max),
12540  iso_time (&mean));
12541  }
12542  else
12543  g_string_append_printf (xml,
12544  "<stats column=\"%s\">"
12545  "<min>%g</min>"
12546  "<max>%g</max>"
12547  "<mean>%g</mean>"
12548  "<sum>%g</sum>"
12549  "<c_sum>%g</c_sum>"
12550  "</stats>",
12551  data_column,
12552  g_array_index (group_mins,
12553  double, index),
12554  g_array_index (group_maxs,
12555  double, index),
12556  (g_array_index (group_mean_sums,
12557  double, index)
12558  / aggregate_group_count),
12559  g_array_index (group_sums,
12560  double, index),
12561  c_sum);
12562  }
12563 
12564  g_string_append_printf (xml,
12565  "</group>");
12566 
12567  // ... then start new group
12568  g_string_append_printf (xml,
12569  "<group>"
12570  "<value>%s</value>",
12571  value_escaped);
12572  }
12573 
12574  // Update group statistics using current subgroup after output
12575  if (previous_group_value == NULL
12576  || strcmp (previous_group_value, value))
12577  {
12578  // First subgroup of any group:
12579  // Reset group statistics using current subgroup data
12580  aggregate_group_count = aggregate_iterator_count (aggregate);
12581 
12582  for (index = 0; index < data_columns->len; index++)
12583  {
12584  g_array_index (group_mins, double, index)
12585  = aggregate_iterator_min (aggregate, index);
12586  g_array_index (group_maxs, double, index)
12587  = aggregate_iterator_max (aggregate, index);
12588  g_array_index (group_mean_sums, double, index)
12589  = (aggregate_iterator_mean (aggregate, index)
12590  * aggregate_iterator_count (aggregate));
12591  g_array_index (group_sums, double, index)
12592  = aggregate_iterator_sum (aggregate, index);
12593  }
12594  }
12595  else
12596  {
12597  // Subgroup, but no new group: Update statistics
12598  aggregate_group_count += aggregate_iterator_count (aggregate);
12599 
12600  for (index = 0; index < data_columns->len; index++)
12601  {
12602  g_array_index (group_mins, double, index)
12603  = fmin (aggregate_iterator_min (aggregate, index),
12604  g_array_index (group_mins, double, index));
12605  g_array_index (group_maxs, double, index)
12606  = fmax (aggregate_iterator_max (aggregate, index),
12607  g_array_index (group_maxs, double, index));
12608  g_array_index (group_mean_sums, double, index)
12609  += (aggregate_iterator_mean (aggregate, index)
12610  * aggregate_iterator_count (aggregate));
12611  g_array_index (group_sums, double, index)
12612  += aggregate_iterator_sum (aggregate, index);
12613  }
12614  }
12615 
12616  g_free (previous_group_value);
12617  previous_group_value = g_strdup (value);
12618 
12619  // Add subgroup values
12620  g_string_append_printf (xml,
12621  "<subgroup>"
12622  "<value>%s</value>"
12623  "<count>%d</count>"
12624  "<c_count>%ld</c_count>",
12625  subgroup_value_escaped
12626  ? subgroup_value_escaped : "",
12627  aggregate_iterator_count (aggregate),
12628  *subgroup_c_count);
12629  }
12630  else
12631  {
12632  // No subgrouping
12633  g_string_append_printf (xml,
12634  "<group>"
12635  "<value>%s</value>"
12636  "<count>%d</count>"
12637  "<c_count>%ld</c_count>",
12638  value_escaped ? value_escaped : "",
12639  aggregate_iterator_count (aggregate),
12640  c_count);
12641  }
12642 
12643  previous_c_count = c_count;
12644  }
12645  else
12646  {
12647  g_string_append_printf (xml,
12648  "<overall>"
12649  "<count>%d</count>"
12650  "<c_count>%ld</c_count>",
12651  aggregate_iterator_count (aggregate),
12652  c_count);
12653  }
12654 
12655  for (index = 0; index < data_columns->len; index++)
12656  {
12657  gchar *data_column = g_array_index (data_columns, gchar*, index);;
12658  double c_sum;
12659  double *subgroup_c_sum = NULL;
12660 
12661  if (subgroup_column && column_is_timestamp (data_column) == FALSE)
12662  {
12663  GTree *c_sum_tree;
12664  const gchar *subgroup_value;
12665 
12666 
12667  subgroup_value = aggregate_iterator_subgroup_value (aggregate);
12668  c_sum_tree = g_array_index (group_c_sums, GTree*, index);
12669  subgroup_c_sum = g_tree_lookup (c_sum_tree, subgroup_value);
12670 
12671  if (subgroup_c_sum == NULL)
12672  {
12673  subgroup_c_sum = g_malloc (sizeof (double *));
12674  *subgroup_c_sum = 0;
12675 
12676  g_tree_insert (c_sum_tree,
12677  g_strdup (subgroup_value),
12678  subgroup_c_sum);
12679  }
12680 
12681  *subgroup_c_sum += aggregate_iterator_sum (aggregate, index);
12682  }
12683 
12684  c_sum = g_array_index (c_sums, double, index);
12685  c_sum += aggregate_iterator_sum (aggregate, index);
12686  g_array_index (c_sums, double, index) = c_sum;
12687 
12688  if (column_is_timestamp (data_column))
12689  {
12690  time_t min, max, mean;
12691  min = (time_t)(aggregate_iterator_min (aggregate, index));
12692  max = (time_t)(aggregate_iterator_max (aggregate, index));
12693  mean = (time_t)(aggregate_iterator_mean (aggregate, index));
12694 
12695  g_string_append_printf (xml,
12696  "<stats column=\"%s\">"
12697  "<min>%s</min>"
12698  "<max>%s</max>"
12699  "<mean>%s</mean>"
12700  "<sum></sum>"
12701  "<c_sum></c_sum>"
12702  "</stats>",
12703  data_column,
12704  iso_time (&min),
12705  iso_time (&max),
12706  iso_time (&mean));
12707  }
12708  else
12709  g_string_append_printf (xml,
12710  "<stats column=\"%s\">"
12711  "<min>%g</min>"
12712  "<max>%g</max>"
12713  "<mean>%g</mean>"
12714  "<sum>%g</sum>"
12715  "<c_sum>%g</c_sum>"
12716  "</stats>",
12717  data_column,
12718  aggregate_iterator_min (aggregate, index),
12719  aggregate_iterator_max (aggregate, index),
12720  aggregate_iterator_mean (aggregate, index),
12721  aggregate_iterator_sum (aggregate, index),
12722  subgroup_column
12723  ? *subgroup_c_sum : c_sum);
12724  }
12725 
12726  for (index = 0; index < text_columns->len; index++)
12727  {
12728  const char *text = aggregate_iterator_text (aggregate, index,
12729  data_columns->len);
12730  gchar *text_escaped;
12731  gchar *text_column = g_array_index (text_columns, gchar*, index);
12732 
12733  if (text && column_is_timestamp (text_column))
12734  {
12735  time_t text_int;
12736  if (sscanf (text, "%ld", &text_int) == 1)
12737  text_escaped = g_strdup (iso_time (&text_int));
12738  else
12739  text_escaped = g_markup_escape_text (text, -1);
12740  }
12741  else if (text)
12742  text_escaped = g_markup_escape_text (text, -1);
12743  else
12744  text_escaped = NULL;
12745 
12746  g_string_append_printf (xml,
12747  "<text column=\"%s\">%s</text>",
12748  text_column,
12749  text_escaped ? text_escaped : "");
12750  g_free (text_escaped);
12751  }
12752 
12753  if (subgroup_column)
12754  {
12755  g_string_append_printf (xml, "</subgroup>");
12756  }
12757  else if (group_column)
12758  {
12759  g_string_append_printf (xml, "</group>");
12760  }
12761  else
12762  {
12763  g_string_append_printf (xml, "</overall>");
12764  }
12765  g_free (value_escaped);
12766  g_free (subgroup_value_escaped);
12767  }
12768 
12769  if (subgroup_column)
12770  {
12771  // Add elements for last group in case subgroups are used
12772  if (has_groups)
12773  {
12774  g_string_append_printf (xml,
12775  "<count>%ld</count>"
12776  "<c_count>%ld</c_count>"
12777  "</group>",
12778  aggregate_group_count,
12779  previous_c_count);
12780  }
12781 
12782  // Also add overview of all subgroup values
12783  g_string_append_printf (xml,
12784  "<subgroups>");
12785 
12786  g_tree_foreach (subgroup_c_counts,
12787  (GTraverseFunc) buffer_aggregate_subgroup_value,
12788  xml);
12789 
12790  g_string_append_printf (xml,
12791  "</subgroups>");
12792  }
12793 
12794  g_string_append (xml, "<column_info>");
12795 
12796  if (group_column)
12797  {
12798  g_string_append_printf (xml,
12799  "<aggregate_column>"
12800  "<name>value</name>"
12801  "<stat>value</stat>"
12802  "<type>%s</type>"
12803  "<column>%s</column>"
12804  "<data_type>%s</data_type>"
12805  "</aggregate_column>",
12806  type,
12807  group_column,
12808  group_column_type);
12809  }
12810 
12811  if (subgroup_column)
12812  {
12813  g_string_append_printf (xml,
12814  "<aggregate_column>"
12815  "<name>subgroup_value</name>"
12816  "<stat>value</stat>"
12817  "<type>%s</type>"
12818  "<column>%s</column>"
12819  "<data_type>%s</data_type>"
12820  "</aggregate_column>",
12821  type,
12822  subgroup_column,
12823  subgroup_column_type);
12824  }
12825 
12826  g_string_append_printf (xml,
12827  "<aggregate_column>"
12828  "<name>count</name>"
12829  "<stat>count</stat>"
12830  "<type>%s</type>"
12831  "<column></column>"
12832  "<data_type>integer</data_type>"
12833  "</aggregate_column>",
12834  type);
12835 
12836  g_string_append_printf (xml,
12837  "<aggregate_column>"
12838  "<name>c_count</name>"
12839  "<stat>c_count</stat>"
12840  "<type>%s</type>"
12841  "<column></column>"
12842  "<data_type>integer</data_type>"
12843  "</aggregate_column>",
12844  type);
12845 
12846  for (index = 0; index < data_columns->len; index++)
12847  {
12848  gchar *column_name, *column_type;
12849  column_name = g_array_index (data_columns, gchar*, index);
12850  column_type = g_array_index (data_column_types, gchar*, index);
12851  g_string_append_printf (xml,
12852  "<aggregate_column>"
12853  "<name>%s_min</name>"
12854  "<stat>min</stat>"
12855  "<type>%s</type>"
12856  "<column>%s</column>"
12857  "<data_type>%s</data_type>"
12858  "</aggregate_column>",
12859  column_name,
12860  type,
12861  column_name,
12862  column_type);
12863  g_string_append_printf (xml,
12864  "<aggregate_column>"
12865  "<name>%s_max</name>"
12866  "<stat>max</stat>"
12867  "<type>%s</type>"
12868  "<column>%s</column>"
12869  "<data_type>%s</data_type>"
12870  "</aggregate_column>",
12871  column_name,
12872  type,
12873  column_name,
12874  column_type);
12875  g_string_append_printf (xml,
12876  "<aggregate_column>"
12877  "<name>%s_mean</name>"
12878  "<stat>mean</stat>"
12879  "<type>%s</type>"
12880  "<column>%s</column>"
12881  "<data_type>%s</data_type>"
12882  "</aggregate_column>",
12883  column_name,
12884  type,
12885  column_name,
12886  column_type);
12887  g_string_append_printf (xml,
12888  "<aggregate_column>"
12889  "<name>%s_sum</name>"
12890  "<stat>sum</stat>"
12891  "<type>%s</type>"
12892  "<column>%s</column>"
12893  "<data_type>%s</data_type>"
12894  "</aggregate_column>",
12895  column_name,
12896  type,
12897  column_name,
12898  column_type);
12899  g_string_append_printf (xml,
12900  "<aggregate_column>"
12901  "<name>%s_c_sum</name>"
12902  "<stat>c_sum</stat>"
12903  "<type>%s</type>"
12904  "<column>%s</column>"
12905  "<data_type>%s</data_type>"
12906  "</aggregate_column>",
12907  column_name,
12908  type,
12909  column_name,
12910  column_type);
12911  }
12912 
12913  for (index = 0; index < text_columns->len; index++)
12914  {
12915  gchar *column_name, *column_type;
12916  column_name = g_array_index (text_columns, gchar*, index);
12917  column_type = g_array_index (text_column_types, gchar*, index);
12918  g_string_append_printf (xml,
12919  "<aggregate_column>"
12920  "<name>%s</name>"
12921  "<stat>text</stat>"
12922  "<type>%s</type>"
12923  "<column>%s</column>"
12924  "<data_type>%s</data_type>"
12925  "</aggregate_column>",
12926  column_name,
12927  type,
12928  column_name,
12929  column_type);
12930  }
12931 
12932  g_string_append (xml, "</column_info>");
12933 
12934  g_string_append (xml, "</aggregate>");
12935 
12936  if (subgroup_column)
12937  {
12938  g_array_free (group_mins, TRUE);
12939  g_array_free (group_maxs, TRUE);
12940  g_array_free (group_mean_sums, TRUE);
12941  g_array_free (group_sums, TRUE);
12942 
12943  for (index = 0; index < data_columns->len; index++)
12944  {
12945  g_tree_destroy (g_array_index (group_c_sums, GTree*, index));
12946  }
12947 
12948  g_array_free (group_c_sums, TRUE);
12949 
12950  g_tree_destroy(subgroup_c_counts);
12951  };
12952 }
12953 
12961 static array_t *
12962 convert_to_manage_ranges (array_t *ranges)
12963 {
12964  if (ranges)
12965  {
12966  guint index;
12967  array_t *manage_ranges;
12968 
12969  manage_ranges = make_array ();
12970 
12971  index = ranges->len;
12972  while (index--)
12973  {
12974  create_port_list_range_t *range;
12975  range = (create_port_list_range_t*) g_ptr_array_index (ranges,
12976  index);
12977  if (range)
12978  {
12979  range_t *manage_range;
12980 
12981  manage_range = g_malloc0 (sizeof (range_t));
12982  manage_range->comment = range->comment;
12983  manage_range->end = atoi (range->end);
12984  manage_range->id = range->id;
12985  manage_range->start = atoi (range->start);
12986  if (strcasecmp (range->type, "TCP") == 0)
12987  manage_range->type = PORT_PROTOCOL_TCP;
12988  else if (strcasecmp (range->type, "UDP") == 0)
12989  manage_range->type = PORT_PROTOCOL_UDP;
12990  else
12991  manage_range->type = PORT_PROTOCOL_OTHER;
12992  manage_range->exclude = 0;
12993 
12994  array_add (manage_ranges, manage_range);
12995  }
12996  }
12997  return manage_ranges;
12998  }
12999  return NULL;
13000 }
13001 
13008 #define CLOSE(parent, element) \
13009  case parent ## _ ## element: \
13010  assert (strcasecmp (G_STRINGIFY (element), element_name) == 0); \
13011  set_client_state (parent); \
13012  break
13013 
13022 #define CLOSE_READ_OVER(parent, element) \
13023  case parent ## _ ## element: \
13024  assert (strcasecmp (G_STRINGIFY (element), element_name) == 0); \
13025  omp_parser->read_over = 0; \
13026  set_client_state (parent); \
13027  break
13028 
13044 static int
13045 get_next (iterator_t *resources, get_data_t *get, int *first, int *count,
13046  int (*init) (iterator_t*, const get_data_t *))
13047 {
13048  if (next (resources) == FALSE)
13049  {
13050  gchar *new_filter;
13051 
13052  if (get->filt_id && strcmp (get->filt_id, "0"))
13053  /* If filtering by a named filter, then just end, because changing
13054  * the filter term would probably surprise the user. */
13055  return 1;
13056 
13057  if (*first == 0)
13058  return 1;
13059 
13060  if (*first == 1 || *count > 0)
13061  /* Some results were found or first was 1, so stop iterating. */
13062  return 1;
13063 
13064  /* Reset the iterator with first 1, and start again. */
13065  cleanup_iterator (resources);
13066  new_filter = g_strdup_printf ("first=1 %s", get->filter);
13067  g_free (get->filter);
13068  get->filter = new_filter;
13069  if (init (resources, get))
13070  return -1;
13071  *count = 0;
13072  *first = 1;
13073  if (next (resources) == FALSE)
13074  return 1;
13075  }
13076  return 0;
13077 }
13078 
13079 
13087 #define CASE_DELETE(upper, type, capital) \
13088  case CLIENT_DELETE_ ## upper : \
13089  assert (strcasecmp ("DELETE_" G_STRINGIFY (upper), element_name) == 0); \
13090  if (delete_ ## type ## _data-> type ## _id) \
13091  switch (delete_ ## type (delete_ ## type ## _data-> type ## _id, \
13092  delete_ ## type ## _data->ultimate)) \
13093  { \
13094  case 0: \
13095  SEND_TO_CLIENT_OR_FAIL (XML_OK ("delete_" G_STRINGIFY (type))); \
13096  log_event (G_STRINGIFY(type), capital, \
13097  delete_ ## type ## _data-> type ## _id, "deleted"); \
13098  break; \
13099  case 1: \
13100  SEND_TO_CLIENT_OR_FAIL \
13101  (XML_ERROR_SYNTAX ("delete_" G_STRINGIFY (type), \
13102  capital " is in use")); \
13103  log_event_fail (G_STRINGIFY(type), capital, \
13104  delete_ ## type ## _data-> type ## _id, \
13105  "deleted"); \
13106  break; \
13107  case 2: \
13108  if (send_find_error_to_client \
13109  ("delete_" G_STRINGIFY (type), \
13110  G_STRINGIFY (type), \
13111  delete_ ## type ## _data-> type ## _id, \
13112  omp_parser)) \
13113  { \
13114  error_send_to_client (error); \
13115  return; \
13116  } \
13117  log_event_fail (G_STRINGIFY(type), capital, \
13118  delete_ ## type ## _data-> type ## _id, \
13119  "deleted"); \
13120  break; \
13121  case 3: \
13122  SEND_TO_CLIENT_OR_FAIL \
13123  (XML_ERROR_SYNTAX ("delete_" G_STRINGIFY (type), \
13124  "Attempt to delete a predefined" \
13125  " " G_STRINGIFY (type))); \
13126  break; \
13127  case 99: \
13128  SEND_TO_CLIENT_OR_FAIL \
13129  (XML_ERROR_SYNTAX ("delete_" G_STRINGIFY (type), \
13130  "Permission denied")); \
13131  log_event_fail (G_STRINGIFY(type), capital, \
13132  delete_ ## type ## _data-> type ## _id, \
13133  "deleted"); \
13134  break; \
13135  default: \
13136  SEND_TO_CLIENT_OR_FAIL \
13137  (XML_INTERNAL_ERROR ("delete_" G_STRINGIFY (type))); \
13138  log_event_fail (G_STRINGIFY(type), capital, \
13139  delete_ ## type ## _data-> type ## _id, \
13140  "deleted"); \
13141  } \
13142  else \
13143  SEND_TO_CLIENT_OR_FAIL \
13144  (XML_ERROR_SYNTAX ("delete_" G_STRINGIFY (type), \
13145  "DELETE_" G_STRINGIFY (upper) " requires a " \
13146  G_STRINGIFY (type) "_id attribute")); \
13147  delete_ ## type ## _data_reset (delete_ ## type ## _data); \
13148  set_client_state (CLIENT_AUTHENTIC); \
13149  break
13150 
13157 #define INIT_GET(type, capital) \
13158  count = 0; \
13159  ret = init_get ("get_" G_STRINGIFY (type) "s", \
13160  &get_ ## type ## s_data->get, \
13161  G_STRINGIFY (capital) "s", \
13162  &first); \
13163  if (ret) \
13164  { \
13165  switch (ret) \
13166  { \
13167  case 99: \
13168  SEND_TO_CLIENT_OR_FAIL \
13169  (XML_ERROR_SYNTAX ("get_" G_STRINGIFY (type) "s", \
13170  "Permission denied")); \
13171  break; \
13172  default: \
13173  internal_error_send_to_client (error); \
13174  return; \
13175  } \
13176  get_ ## type ## s_data_reset (get_ ## type ## s_data); \
13177  set_client_state (CLIENT_AUTHENTIC); \
13178  return; \
13179  }
13180 
13187 char *
13189 {
13191  char *result = NULL;
13192 
13194  while (next (&iterator))
13195  {
13196  char *tmp;
13197  const char *fname = ovaldi_file_iterator_name (&iterator);
13198 
13199  if (!fname)
13200  continue;
13201  tmp = g_strconcat (fname, result ? "|" : "", result, NULL);
13202  g_free (result);
13203  result = tmp;
13204  }
13206  return result;
13207 }
13208 
13215 static void
13216 handle_get_agents (omp_parser_t *omp_parser, GError **error)
13217 {
13218  int format;
13219 
13220  if (get_agents_data->format)
13221  {
13222  if (strlen (get_agents_data->format))
13223  {
13224  if (strcasecmp (get_agents_data->format, "installer") == 0)
13225  format = 1;
13226  else if (strcasecmp (get_agents_data->format, "howto_install") == 0)
13227  format = 2;
13228  else if (strcasecmp (get_agents_data->format, "howto_use") == 0)
13229  format = 3;
13230  else
13231  format = -1;
13232  }
13233  else
13234  format = 0;
13235  }
13236  else if (get_agents_data->get.details == 1) /* For exporting */
13237  format = 1;
13238  else
13239  format = 0;
13240 
13241  if (format == -1)
13242  SEND_TO_CLIENT_OR_FAIL
13243  (XML_ERROR_SYNTAX ("get_agents",
13244  "GET_AGENTS format attribute should"
13245  " be 'installer', 'howto_install' or 'howto_use'."));
13246  else
13247  {
13248  iterator_t agents;
13249  int ret, count, filtered, first;
13250 
13251  INIT_GET (agent, Agent);
13252 
13253  ret = init_agent_iterator (&agents,
13254  &get_agents_data->get);
13255  if (ret)
13256  {
13257  switch (ret)
13258  {
13259  case 1:
13260  if (send_find_error_to_client ("get_agents",
13261  "agents",
13263  omp_parser))
13264  {
13265  error_send_to_client (error);
13266  return;
13267  }
13268  break;
13269  case 2:
13270  if (send_find_error_to_client ("get_agents", "filter",
13272  omp_parser))
13273  {
13274  error_send_to_client (error);
13275  return;
13276  }
13277  break;
13278  case -1:
13279  SEND_TO_CLIENT_OR_FAIL
13280  (XML_INTERNAL_ERROR ("get_agents"));
13281  break;
13282  }
13283  get_agents_data_reset (get_agents_data);
13284  set_client_state (CLIENT_AUTHENTIC);
13285  return;
13286  }
13287 
13288  SEND_GET_START ("agent");
13289  while (1)
13290  {
13291  ret = get_next (&agents, &get_agents_data->get, &first,
13292  &count, init_agent_iterator);
13293  if (ret == 1)
13294  break;
13295  if (ret == -1)
13296  {
13297  internal_error_send_to_client (error);
13298  return;
13299  }
13300 
13301  SEND_GET_COMMON (agent, &get_agents_data->get,
13302  &agents);
13303  switch (format)
13304  {
13305  case 1: /* installer */
13306  {
13307  time_t trust_time;
13308  trust_time = agent_iterator_trust_time (&agents);
13309 
13310  SENDF_TO_CLIENT_OR_FAIL
13311  ("<package format=\"installer\">"
13312  "<filename>%s</filename>"
13313  "%s"
13314  "</package>"
13315  "<installer>"
13316  "<trust>%s<time>%s</time></trust>"
13317  "</installer>"
13318  "</agent>",
13320  agent_iterator_installer_64 (&agents),
13321  agent_iterator_trust (&agents),
13322  iso_time (&trust_time));
13323  }
13324  break;
13325  case 2: /* howto_install */
13326  SENDF_TO_CLIENT_OR_FAIL
13327  ("<package format=\"howto_install\">%s</package>"
13328  "</agent>",
13329  agent_iterator_howto_install (&agents));
13330  break;
13331  case 3: /* howto_use */
13332  SENDF_TO_CLIENT_OR_FAIL
13333  ("<package format=\"howto_use\">%s</package>"
13334  "</agent>",
13335  agent_iterator_howto_use (&agents));
13336  break;
13337  default:
13338  {
13339  time_t trust_time;
13340 
13341  trust_time = agent_iterator_trust_time (&agents);
13342 
13343  SENDF_TO_CLIENT_OR_FAIL
13344  ("<installer>"
13345  "<trust>%s<time>%s</time></trust>"
13346  "</installer>"
13347  "</agent>",
13348  agent_iterator_trust (&agents),
13349  iso_time (&trust_time));
13350  }
13351  break;
13352  }
13353  count++;
13354  }
13355  cleanup_iterator (&agents);
13356  filtered = get_agents_data->get.id
13357  ? 1
13359  SEND_GET_END ("agent", &get_agents_data->get, count, filtered);
13360  }
13361  get_agents_data_reset (get_agents_data);
13362  set_client_state (CLIENT_AUTHENTIC);
13363 }
13364 
13371 static void
13372 handle_get_aggregates (omp_parser_t *omp_parser, GError **error)
13373 {
13374  iterator_t aggregate;
13375  const char *type;
13376  get_data_t *get;
13377  GArray *data_columns, *data_column_types;
13378  GArray *text_columns, *text_column_types;
13379  GArray *sort_data;
13380  GArray *c_sums;
13381  const char *group_column, *subgroup_column;
13382  char *group_column_type, *subgroup_column_type;
13383  int ret, index;
13384  GString *xml;
13385  gchar *sort_field, *filter;
13386  int first, sort_order;
13387  GString *type_many;
13388 
13390  if (type == NULL)
13391  {
13392  SEND_TO_CLIENT_OR_FAIL
13393  (XML_ERROR_SYNTAX ("get_aggregates",
13394  "GET_AGGREGATES requires a 'type' attribute"));
13395  return;
13396  }
13397 
13398  get = &get_aggregates_data->get;
13399 
13400  ret = init_get ("get_aggregates",
13402  "Aggregates",
13403  &first);
13404  if (ret)
13405  {
13406  switch (ret)
13407  {
13408  case 99:
13409  SEND_TO_CLIENT_OR_FAIL
13410  (XML_ERROR_SYNTAX ("get_aggregates",
13411  "Permission denied"));
13412  break;
13413  default:
13414  internal_error_send_to_client (error);
13415  return;
13416  }
13417  get_aggregates_data_reset (get_aggregates_data);
13418  set_client_state (CLIENT_AUTHENTIC);
13419  return;
13420  }
13421 
13422  group_column = get_aggregates_data->group_column;
13423  subgroup_column = get_aggregates_data->subgroup_column;
13424 
13425  init_aggregate_lists (group_column,
13426  subgroup_column,
13430  &group_column_type, &subgroup_column_type,
13431  &data_column_types, &data_columns,
13432  &text_column_types, &text_columns,
13433  &sort_data,
13434  &c_sums);
13435 
13437  && strcasecmp (get_aggregates_data->mode, "word_counts") == 0)
13438  {
13439  ret = init_aggregate_iterator (&aggregate, type, get,
13440  0 /* distinct */,
13441  data_columns,
13442  group_column, subgroup_column,
13443  text_columns,
13444  NULL, /* ignore sorting */
13445  0, /* get all groups */
13446  -1,
13447  NULL /* extra_tables */,
13448  NULL /* extra_where */);
13449  }
13450  else
13451  {
13452  ret = init_aggregate_iterator (&aggregate, type, get,
13453  0 /* distinct */,
13454  data_columns,
13455  group_column, subgroup_column,
13456  text_columns,
13457  sort_data,
13460  NULL /* extra_tables */,
13461  NULL /* extra_where */);
13462  }
13463 
13464  switch (ret)
13465  {
13466  case 0:
13467  break;
13468  case 1:
13469  SEND_TO_CLIENT_OR_FAIL
13470  (XML_ERROR_SYNTAX ("get_aggregates",
13471  "Failed to find resource"));
13472  break;
13473  case 2:
13474  SEND_TO_CLIENT_OR_FAIL
13475  (XML_ERROR_SYNTAX ("get_aggregates",
13476  "Failed to find filter"));
13477  break;
13478  case 3:
13479  SEND_TO_CLIENT_OR_FAIL
13480  (XML_ERROR_SYNTAX ("get_aggregates",
13481  "Invalid data_column"));
13482  break;
13483  case 4:
13484  SEND_TO_CLIENT_OR_FAIL
13485  (XML_ERROR_SYNTAX ("get_aggregates",
13486  "Invalid group_column"));
13487  break;
13488  case 5:
13489  SEND_TO_CLIENT_OR_FAIL
13490  (XML_ERROR_SYNTAX ("get_aggregates",
13491  "Invalid resource type"));
13492  break;
13493  case 6:
13494  SEND_TO_CLIENT_OR_FAIL
13495  (XML_ERROR_SYNTAX ("get_aggregates",
13496  "Trashcan not used by resource type"));
13497  break;
13498  case 7:
13499  SEND_TO_CLIENT_OR_FAIL
13500  (XML_ERROR_SYNTAX ("get_aggregates",
13501  "Invalid text_column"));
13502  break;
13503  case 8:
13504  SEND_TO_CLIENT_OR_FAIL
13505  (XML_ERROR_SYNTAX ("get_aggregates",
13506  "Invalid subgroup_column"));
13507  break;
13508  case 99:
13509  SEND_TO_CLIENT_OR_FAIL
13510  (XML_ERROR_SYNTAX ("get_aggregates",
13511  "Permission denied"));
13512  break;
13513  default:
13514  assert (0);
13515  /* fallthrough */
13516  case -1:
13517  SEND_TO_CLIENT_OR_FAIL
13518  (XML_INTERNAL_ERROR ("get_aggregates"));
13519  break;
13520  }
13521 
13522  if (ret)
13523  {
13524  g_array_free (data_columns, TRUE);
13525  g_array_free (data_column_types, TRUE);
13526  for (index = 0; index < sort_data->len; index++)
13527  sort_data_free (g_array_index (sort_data, sort_data_t*, index));
13528  g_array_free (sort_data, TRUE);
13529  g_array_free (c_sums, TRUE);
13530  return;
13531  }
13532 
13533  xml = g_string_new ("<get_aggregates_response"
13534  " status_text=\"" STATUS_OK_TEXT "\""
13535  " status=\"" STATUS_OK "\">");
13536 
13538  && strcasecmp (get_aggregates_data->mode, "word_counts") == 0)
13539  {
13540  buffer_aggregate_wc_xml (xml, &aggregate, type, group_column,
13541  sort_data,
13544  }
13545  else
13546  {
13547  buffer_aggregate_xml (xml, &aggregate, type,
13548  group_column, group_column_type,
13549  subgroup_column, subgroup_column_type,
13550  data_columns, data_column_types,
13551  text_columns, text_column_types,
13552  c_sums);
13553  }
13554 
13555  if (get->filt_id && strcmp (get->filt_id, "0"))
13556  {
13557  if (get->filter_replacement)
13558  filter = g_strdup (get->filter_replacement);
13559  else
13560  filter = filter_term (get->filt_id);
13561  if (filter == NULL)
13562  SEND_TO_CLIENT_OR_FAIL
13563  (XML_ERROR_SYNTAX ("get_aggregates",
13564  "Failed to find filter"));
13565  }
13566  else
13567  filter = NULL;
13568 
13569  manage_filter_controls (filter ? filter : get->filter,
13570  &first, NULL, &sort_field, &sort_order);
13571 
13572  if (filter || get->filter)
13573  {
13574  gchar *new_filter;
13575  new_filter = manage_clean_filter (filter ? filter : get->filter);
13576  g_free (filter);
13577  if ((strcmp (type, "task") == 0)
13578  && (filter_term_value (new_filter, "apply_overrides")
13579  == NULL))
13580  {
13581  filter = new_filter;
13582  new_filter = g_strdup_printf ("apply_overrides=%i %s",
13584  filter);
13585  g_free (filter);
13586  }
13587  filter = new_filter;
13588  }
13589  else
13590  filter = manage_clean_filter ("");
13591 
13592  type_many = g_string_new (type);
13593 
13594  if (strcmp (type, "info") != 0)
13595  g_string_append (type_many, "s");
13596 
13597  buffer_get_filter_xml (xml, type, get, filter, NULL);
13598 
13599  g_string_append (xml, "</get_aggregates_response>");
13600 
13601  for (index = 0; index < data_columns->len; index++)
13602  g_free (g_array_index (data_columns, gchar*, index));
13603  g_array_free (data_columns, TRUE);
13604  for (index = 0; index < data_column_types->len; index++)
13605  g_free (g_array_index (data_column_types, gchar*, index));
13606  g_array_free (data_column_types, TRUE);
13607  for (index = 0; index < sort_data->len; index++)
13608  sort_data_free (g_array_index (sort_data, sort_data_t*, index));
13609  g_array_free (sort_data, TRUE);
13610  g_array_free (c_sums, TRUE);
13611 
13612  SEND_TO_CLIENT_OR_FAIL (xml->str);
13613 
13614  cleanup_iterator (&aggregate);
13615  g_string_free (xml, TRUE);
13616  get_aggregates_data_reset (get_aggregates_data);
13617  set_client_state (CLIENT_AUTHENTIC);
13618 }
13619 
13626 static void
13627 handle_get_alerts (omp_parser_t *omp_parser, GError **error)
13628 {
13629  iterator_t alerts;
13630  int count, filtered, ret, first;
13631 
13632  INIT_GET (alert, Alert);
13633 
13634  ret = init_alert_iterator (&alerts, &get_alerts_data->get);
13635  if (ret)
13636  {
13637  switch (ret)
13638  {
13639  case 1:
13640  if (send_find_error_to_client ("get_alerts", "alert",
13642  omp_parser))
13643  {
13644  error_send_to_client (error);
13645  return;
13646  }
13647  break;
13648  case 2:
13649  if (send_find_error_to_client
13650  ("get_alerts", "alert", get_alerts_data->get.filt_id,
13651  omp_parser))
13652  {
13653  error_send_to_client (error);
13654  return;
13655  }
13656  break;
13657  case -1:
13658  SEND_TO_CLIENT_OR_FAIL
13659  (XML_INTERNAL_ERROR ("get_alerts"));
13660  break;
13661  }
13662  get_alerts_data_reset (get_alerts_data);
13663  set_client_state (CLIENT_AUTHENTIC);
13664  return;
13665  }
13666 
13667  SEND_GET_START ("alert");
13668  while (1)
13669  {
13670  iterator_t data;
13671  char *filter_uuid;
13672  int notice, message, has_secinfo_type;
13673  const char *method;
13674 
13675  ret = get_next (&alerts, &get_alerts_data->get, &first,
13676  &count, init_alert_iterator);
13677  if (ret == 1)
13678  break;
13679  if (ret == -1)
13680  {
13681  internal_error_send_to_client (error);
13682  return;
13683  }
13684  SEND_GET_COMMON (alert, &get_alerts_data->get,
13685  &alerts);
13686 
13687  /* Filter. */
13688 
13690  if (filter_uuid)
13691  {
13692  SENDF_TO_CLIENT_OR_FAIL ("<filter id=\"%s\">"
13693  "<name>%s</name>"
13694  "<trash>%i</trash>",
13695  filter_uuid,
13696  alert_iterator_filter_name (&alerts),
13697  alert_iterator_filter_trash (&alerts));
13698  if (alert_iterator_filter_readable (&alerts))
13699  SEND_TO_CLIENT_OR_FAIL ("</filter>");
13700  else
13701  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
13702  "</filter>");
13703  }
13704 
13705  /* Condition. */
13706 
13707  SENDF_TO_CLIENT_OR_FAIL ("<condition>%s",
13709  (alert_iterator_condition (&alerts)));
13712  "condition");
13713  while (next (&data))
13714  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13715  "<name>%s</name>"
13716  "%s"
13717  "</data>",
13718  alert_data_iterator_name (&data),
13719  alert_data_iterator_data (&data));
13720  cleanup_iterator (&data);
13721 
13722  SEND_TO_CLIENT_OR_FAIL ("</condition>");
13723 
13724  /* Event. */
13725 
13726  SENDF_TO_CLIENT_OR_FAIL ("<event>%s",
13727  event_name (alert_iterator_event (&alerts)));
13729  get_alerts_data->get.trash, "event");
13730  has_secinfo_type = 0;
13731  while (next (&data))
13732  {
13733  if (strcmp (alert_data_iterator_name (&data), "secinfo_type")
13734  == 0)
13735  has_secinfo_type = 1;
13736  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13737  "<name>%s</name>"
13738  "%s"
13739  "</data>",
13740  alert_data_iterator_name (&data),
13741  alert_data_iterator_data (&data));
13742  }
13743  if ((alert_iterator_event (&alerts) == EVENT_NEW_SECINFO
13745  && (has_secinfo_type == 0))
13746  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13747  "<name>secinfo_type</name>"
13748  "NVT"
13749  "</data>");
13750  cleanup_iterator (&data);
13751  SEND_TO_CLIENT_OR_FAIL ("</event>");
13752 
13753  /* Method. */
13754 
13755  method = alert_method_name (alert_iterator_method (&alerts));
13756  SENDF_TO_CLIENT_OR_FAIL ("<method>%s", method);
13758  get_alerts_data->get.trash, "method");
13759  notice = -1;
13760  message = 0;
13761  while (next (&data))
13762  {
13763  const char *name;
13764  name = alert_data_iterator_name (&data);
13765  if (strcmp (name, "notice") == 0)
13766  notice = atoi (alert_data_iterator_data (&data));
13767  else if (strcmp (method, "Email") == 0
13768  && strcmp (name, "message") == 0)
13769  {
13770  if (strlen (alert_data_iterator_data (&data)) == 0)
13771  continue;
13772  message = 1;
13773  }
13774 
13775  if (strcmp (name, "scp_credential") == 0
13776  || strcmp (name, "verinice_server_credential") == 0)
13777  {
13778  // Username + Password credentials
13779  const char *credential_id;
13780  credential_t credential;
13781  credential_id = alert_data_iterator_data (&data);
13782  if (find_credential_with_permission (credential_id,
13783  &credential,
13784  "get_credentials"))
13785  {
13786  abort ();
13787  }
13788  else if (credential == 0)
13789  {
13790  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13791  "<name>%s</name>"
13792  "%s"
13793  "</data>",
13794  name,
13795  credential_id);
13796  }
13797  else
13798  {
13799  gchar *cred_name, *username;
13800  cred_name = credential_name (credential);
13801  username = credential_value (credential, "username");
13802 
13803  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13804  "<name>%s</name>"
13805  "<credential id=\"%s\">"
13806  "<name>%s</name>"
13807  "<login>%s</login>"
13808  "</credential>"
13809  "%s"
13810  "</data>",
13811  name,
13812  credential_id,
13813  cred_name,
13814  username,
13815  credential_id);
13816 
13817  g_free (cred_name);
13818  g_free (username);
13819  }
13820  }
13821  else
13822  {
13823  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13824  "<name>%s</name>"
13825  "%s"
13826  "</data>",
13827  name,
13828  alert_data_iterator_data (&data));
13829  }
13830  }
13831  /* If there is no email message data, send the default. */
13832  if (strcmp (method, "Email") == 0
13833  && message == 0
13834  && (notice == 0 || notice == 2))
13835  SENDF_TO_CLIENT_OR_FAIL ("<data>"
13836  "<name>message</name>"
13837  "%s"
13838  "</data>",
13839  notice == 0
13842  cleanup_iterator (&data);
13843  SEND_TO_CLIENT_OR_FAIL ("</method>");
13844 
13845  if (get_alerts_data->tasks)
13846  {
13847  iterator_t tasks;
13848 
13849  SEND_TO_CLIENT_OR_FAIL ("<tasks>");
13850  init_alert_task_iterator (&tasks,
13851  get_iterator_resource (&alerts), 0);
13852  while (next (&tasks))
13853  {
13854  SENDF_TO_CLIENT_OR_FAIL ("<task id=\"%s\">"
13855  "<name>%s</name>",
13856  alert_task_iterator_uuid (&tasks),
13857  alert_task_iterator_name (&tasks));
13858 
13859  if (alert_task_iterator_readable (&tasks))
13860  SEND_TO_CLIENT_OR_FAIL ("</task>");
13861  else
13862  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
13863  "</task>");
13864  }
13865  cleanup_iterator (&tasks);
13866  SEND_TO_CLIENT_OR_FAIL ("</tasks>");
13867  }
13868 
13869  SEND_TO_CLIENT_OR_FAIL ("</alert>");
13870  count++;
13871  }
13872  cleanup_iterator (&alerts);
13873  filtered = get_alerts_data->get.id
13874  ? 1
13876  SEND_GET_END ("alert", &get_alerts_data->get, count, filtered);
13877 
13878  get_alerts_data_reset (get_alerts_data);
13879  set_client_state (CLIENT_AUTHENTIC);
13880 }
13881 
13888 static void
13889 handle_get_assets (omp_parser_t *omp_parser, GError **error)
13890 {
13891  iterator_t assets;
13892  int count, first, filtered, ret;
13893  int (*init_asset_iterator) (iterator_t *, const get_data_t *);
13894  int (*asset_count) (const get_data_t *get);
13895 
13896  if (acl_user_may ("get_assets") == 0)
13897  {
13898  SEND_TO_CLIENT_OR_FAIL
13899  (XML_ERROR_SYNTAX ("get_assets",
13900  "Permission denied"));
13901  get_assets_data_reset (get_assets_data);
13902  set_client_state (CLIENT_AUTHENTIC);
13903  return;
13904  }
13905 
13906  if (get_assets_data->type == NULL)
13907  {
13908  SEND_TO_CLIENT_OR_FAIL
13909  (XML_ERROR_SYNTAX ("get_assets",
13910  "No type specified."));
13911  get_assets_data_reset (get_assets_data);
13912  set_client_state (CLIENT_AUTHENTIC);
13913  return;
13914  }
13915 
13916  INIT_GET (asset, Asset);
13917 
13918  /* Set type specific functions. */
13919  if (g_strcmp0 ("host", get_assets_data->type) == 0)
13920  {
13921  init_asset_iterator = init_asset_host_iterator;
13922  asset_count = asset_host_count;
13923  get_assets_data->get.subtype = g_strdup ("host");
13924  }
13925  else if (g_strcmp0 ("os", get_assets_data->type) == 0)
13926  {
13927  init_asset_iterator = init_asset_os_iterator;
13928  asset_count = asset_os_count;
13929  get_assets_data->get.subtype = g_strdup ("os");
13930  }
13931  else
13932  {
13933  if (send_find_error_to_client ("get_assets", "type",
13934  get_assets_data->type, omp_parser))
13935  {
13936  error_send_to_client (error);
13937  }
13938  get_assets_data_reset (get_assets_data);
13939  set_client_state (CLIENT_AUTHENTIC);
13940  return;
13941  }
13942 
13943  ret = init_asset_iterator (&assets, &get_assets_data->get);
13944  if (ret)
13945  {
13946  switch (ret)
13947  {
13948  case 1:
13949  if (send_find_error_to_client ("get_assets", "type",
13951  omp_parser))
13952  {
13953  error_send_to_client (error);
13954  return;
13955  }
13956  break;
13957  case 2:
13958  if (send_find_error_to_client
13959  ("get_assets", "filter", get_assets_data->get.filt_id,
13960  omp_parser))
13961  {
13962  error_send_to_client (error);
13963  return;
13964  }
13965  break;
13966  case -1:
13967  SEND_TO_CLIENT_OR_FAIL
13968  (XML_INTERNAL_ERROR ("get_assets"));
13969  break;
13970  }
13971  get_assets_data_reset (get_assets_data);
13972  set_client_state (CLIENT_AUTHENTIC);
13973  return;
13974  }
13975 
13976  count = 0;
13977  manage_filter_controls (get_assets_data->get.filter, &first, NULL, NULL, NULL);
13978  SEND_GET_START ("asset");
13979  while (next (&assets))
13980  {
13981  GString *result;
13982  iterator_t identifiers;
13983  resource_t asset;
13984  gchar *routes_xml;
13985 
13986  asset = get_iterator_resource (&assets);
13987  /* Assets are currently always writable. */
13988  if (send_get_common ("asset", &get_assets_data->get, &assets,
13989  omp_parser->client_writer,
13990  omp_parser->client_writer_data,
13991  asset_iterator_writable (&assets),
13992  asset_iterator_in_use (&assets)))
13993  {
13994  error_send_to_client (error);
13995  return;
13996  }
13997 
13998  result = g_string_new ("");
13999 
14000  /* Information depending on type. */
14001 
14002  if (g_strcmp0 ("host", get_assets_data->type) == 0)
14003  {
14004  xml_string_append (result, "<identifiers>");
14005  init_host_identifier_iterator (&identifiers,
14006  get_iterator_resource (&assets),
14007  0, NULL);
14008  while (next (&identifiers))
14009  {
14010  const char *source_type;
14011  gchar *name;
14012 
14014  (&identifiers);
14015  if (strcmp (source_type, "User") == 0)
14017  (&identifiers));
14018  else
14019  name = NULL;
14020 
14021  xml_string_append (result,
14022  "<identifier id=\"%s\">"
14023  "<name>%s</name>"
14024  "<value>%s</value>"
14025  "<creation_time>%s</creation_time>"
14026  "<modification_time>%s</modification_time>"
14027  "<source id=\"%s\">"
14028  "<type>%s</type>"
14029  "<data>%s</data>"
14030  "<deleted>%i</deleted>"
14031  "<name>%s</name>"
14032  "</source>",
14033  get_iterator_uuid (&identifiers),
14034  get_iterator_name (&identifiers),
14035  host_identifier_iterator_value (&identifiers),
14036  get_iterator_creation_time (&identifiers),
14037  get_iterator_modification_time (&identifiers),
14039  (&identifiers),
14040  source_type,
14042  (&identifiers),
14044  (&identifiers),
14045  name ? name : "");
14046 
14047  g_free (name);
14048 
14049  if (strcmp (get_iterator_name (&identifiers), "OS") == 0)
14050  xml_string_append (result,
14051  "<os id=\"%s\">"
14052  "<title>%s</title>"
14053  "</os>",
14055  (&identifiers),
14057  (&identifiers));
14058 
14059  xml_string_append (result, "</identifier>");
14060  }
14061  cleanup_iterator (&identifiers);
14062  xml_string_append (result, "</identifiers>");
14063  }
14064 
14065  g_string_append_printf (result, "<type>%s</type>",
14067  g_string_append_printf (result, "<%s>", get_assets_data->type);
14068 
14069  if (g_strcmp0 ("os", get_assets_data->type) == 0)
14070  {
14071  iterator_t os_hosts;
14072  const char *latest, *highest, *average;
14073 
14074  latest = asset_os_iterator_latest_severity (&assets);
14075  highest = asset_os_iterator_highest_severity (&assets);
14076  average = asset_os_iterator_average_severity (&assets);
14077  g_string_append_printf (result,
14078  "<latest_severity>"
14079  "<value>%s</value>"
14080  "</latest_severity>"
14081  "<highest_severity>"
14082  "<value>%s</value>"
14083  "</highest_severity>"
14084  "<average_severity>"
14085  "<value>%s</value>"
14086  "</average_severity>",
14087  latest ? latest : "",
14088  highest ? highest : "",
14089  average ? average : "");
14090 
14091  g_string_append_printf (result,
14092  "<title>%s</title>"
14093  "<installs>%i</installs>"
14094  "<hosts>"
14095  "%i",
14096  asset_os_iterator_title (&assets),
14097  asset_os_iterator_installs (&assets),
14098  asset_os_iterator_installs (&assets));
14099  init_os_host_iterator (&os_hosts,
14100  get_iterator_resource (&assets));
14101  while (next (&os_hosts))
14102  {
14103  const char *severity;
14104  severity = os_host_iterator_severity (&os_hosts);
14105  g_string_append_printf (result,
14106  "<asset id=\"%s\">"
14107  "<name>%s</name>"
14108  "<severity>"
14109  "<value>%s</value>"
14110  "</severity>"
14111  "</asset>",
14112  get_iterator_uuid (&os_hosts),
14113  get_iterator_name (&os_hosts),
14114  severity ? severity : "");
14115  }
14116  cleanup_iterator (&os_hosts);
14117  g_string_append_printf (result, "</hosts>");
14118  }
14119  else if (g_strcmp0 ("host", get_assets_data->type) == 0)
14120  {
14121  const char *severity;
14122  iterator_t details;
14123 
14124  severity = asset_host_iterator_severity (&assets);
14125  g_string_append_printf (result,
14126  "<severity>"
14127  "<value>%s</value>"
14128  "</severity>",
14129  severity ? severity : "");
14130 
14131  init_host_detail_iterator (&details,
14132  get_iterator_resource (&assets));
14133  while (next (&details))
14134  g_string_append_printf (result,
14135  "<detail>"
14136  "<name>%s</name>"
14137  "<value>%s</value>"
14138  "<source id=\"%s\">"
14139  "<type>%s</type>"
14140  "</source>"
14141  "</detail>",
14143  (&details),
14145  (&details),
14147  (&details),
14149  (&details));
14150  cleanup_iterator (&details);
14151 
14153  {
14154  routes_xml = host_routes_xml (asset);
14155  g_string_append (result, routes_xml);
14156  g_free (routes_xml);
14157  }
14158  }
14159 
14160  g_string_append_printf (result,
14161  "</%s>"
14162  "</asset>",
14164  SEND_TO_CLIENT_OR_FAIL (result->str);
14165  count++;
14166  g_string_free (result, TRUE);
14167  }
14168  cleanup_iterator (&assets);
14169 
14170  if (get_assets_data->details == 1)
14171  SEND_TO_CLIENT_OR_FAIL ("<details>1</details>");
14172 
14173  filtered = get_assets_data->get.id
14174  ? 1
14175  : asset_count (&get_assets_data->get);
14176 
14177  SEND_GET_END ("asset", &get_assets_data->get, count, filtered);
14178 
14179  get_assets_data_reset (get_assets_data);
14180  set_client_state (CLIENT_AUTHENTIC);
14181 }
14182 
14189 static void
14190 handle_get_configs (omp_parser_t *omp_parser, GError **error)
14191 {
14192  iterator_t configs;
14193  int ret, filtered, first, count;
14194 
14195  INIT_GET (config, Config);
14196  ret = init_config_iterator (&configs, &get_configs_data->get);
14197  if (ret)
14198  {
14199  switch (ret)
14200  {
14201  case 1:
14202  if (send_find_error_to_client
14203  ("get_configs", "config", get_configs_data->get.id,
14204  omp_parser))
14205  {
14206  error_send_to_client (error);
14207  return;
14208  }
14209  break;
14210  case 2:
14211  if (send_find_error_to_client
14212  ("get_configs", "config", get_configs_data->get.filt_id,
14213  omp_parser))
14214  {
14215  error_send_to_client (error);
14216  return;
14217  }
14218  break;
14219  case -1:
14220  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_configs"));
14221  break;
14222  }
14223  get_configs_data_reset (get_configs_data);
14224  set_client_state (CLIENT_AUTHENTIC);
14225  return;
14226  }
14227 
14228  SEND_GET_START ("config");
14229  while (1)
14230  {
14232  const char *selector;
14233  config_t config;
14234 
14235  ret = get_next (&configs, &get_configs_data->get, &first,
14236  &count, init_config_iterator);
14237  if (ret == 1)
14238  break;
14239  if (ret == -1)
14240  {
14241  internal_error_send_to_client (error);
14242  return;
14243  }
14244  SEND_GET_COMMON (config, &get_configs_data->get, &configs);
14245 
14247  selector = config_iterator_nvt_selector (&configs);
14248  config = get_iterator_resource (&configs);
14250  config_type = config_iterator_type (&configs);
14252  (&configs);
14253 
14254  SENDF_TO_CLIENT_OR_FAIL ("<family_count>"
14255  "%i<growing>%i</growing>"
14256  "</family_count>"
14257  /* The number of NVT's selected
14258  * by the selector. */
14259  "<nvt_count>"
14260  "%i<growing>%i</growing>"
14261  "</nvt_count>"
14262  "<type>%i</type>",
14263  config_iterator_family_count (&configs),
14265  config_iterator_nvt_count (&configs),
14267  config_type);
14268 
14269  if (config_type == 0 && (get_configs_data->families
14271  {
14272  iterator_t families;
14273  int max_nvt_count = 0, known_nvt_count = 0;
14274 
14275  SENDF_TO_CLIENT_OR_FAIL ("<families>");
14276  init_family_iterator (&families, config_families_growing, selector,
14277  1);
14278  while (next (&families))
14279  {
14280  int family_growing, family_max;
14281  int family_selected_count;
14282  const char *family;
14283 
14284  family = family_iterator_name (&families);
14285  if (family)
14286  {
14287  family_growing = nvt_selector_family_growing
14288  (selector, family, config_families_growing);
14289  family_max = family_nvt_count (family);
14290  family_selected_count
14291  = nvt_selector_nvt_count (selector, family, family_growing);
14292  known_nvt_count += family_selected_count;
14293  }
14294  else
14295  {
14296  /* The family can be NULL if an RC adds an
14297  * NVT to a config and the NVT is missing
14298  * from the NVT cache. */
14299  family_growing = 0;
14300  family_max = -1;
14301  family_selected_count = nvt_selector_nvt_count
14302  (selector, NULL, 0);
14303  }
14304 
14305  SENDF_TO_CLIENT_OR_FAIL
14306  ("<family>"
14307  "<name>%s</name>"
14308  /* The number of selected NVT's. */
14309  "<nvt_count>%i</nvt_count>"
14310  /* The total number of NVT's in the family. */
14311  "<max_nvt_count>%i</max_nvt_count>"
14312  "<growing>%i</growing>"
14313  "</family>",
14314  family ? family : "",
14315  family_selected_count,
14316  family_max,
14317  family_growing);
14318  if (family_max > 0)
14319  max_nvt_count += family_max;
14320  }
14321  cleanup_iterator (&families);
14322  SENDF_TO_CLIENT_OR_FAIL
14323  ("</families>"
14324  /* The total number of NVT's in all the
14325  * families for selector selects at least one
14326  * NVT. */
14327  "<max_nvt_count>%i</max_nvt_count>"
14328  /* Total number of selected known NVT's. */
14329  "<known_nvt_count>"
14330  "%i"
14331  "</known_nvt_count>",
14332  max_nvt_count,
14333  known_nvt_count);
14334  }
14335 
14336  if (config_type > 0)
14337  {
14338  iterator_t prefs;
14339  scanner_t scanner;
14340  config_t config = get_iterator_resource (&configs);
14341  char *s_uuid, *s_name;
14342 
14343  assert (config);
14344 
14345  scanner = config_scanner (config);
14346  s_uuid = scanner_uuid (scanner);
14347  s_name = scanner_name (scanner);
14348  SENDF_TO_CLIENT_OR_FAIL ("<scanner id='%s'>%s</scanner>",
14349  s_uuid, s_name);
14350  g_free (s_uuid);
14351  g_free (s_name);
14352  SEND_TO_CLIENT_OR_FAIL ("<preferences>");
14353 
14354  init_preference_iterator (&prefs, config);
14355  while (next (&prefs))
14356  {
14357  const char *name, *hr_name, *value, *type, *def;
14358  char *ovaldi_files = NULL;
14359 
14360  hr_name = preference_iterator_hr_name (&prefs);
14361  name = preference_iterator_name (&prefs);
14362  value = preference_iterator_value (&prefs);
14363  def = preference_iterator_default (&prefs);
14364  if (!strcmp (name, "definitions_file"))
14365  ovaldi_files = get_ovaldi_files ();
14366  type = preference_iterator_type (&prefs);
14367  SENDF_TO_CLIENT_OR_FAIL
14368  ("<preference>"
14369  "<nvt oid=\"\"><name/></nvt>"
14370  "<hr_name>%s</hr_name>"
14371  "<name>%s</name>"
14372  "<type>osp_%s</type>"
14373  "<value>%s</value>"
14374  "<default>%s</default>"
14375  "</preference>",
14376  hr_name, name, type, value ?: "", ovaldi_files ?: def);
14377  g_free (ovaldi_files);
14378  }
14379  cleanup_iterator (&prefs);
14380  SEND_TO_CLIENT_OR_FAIL ("</preferences>");
14381  }
14382  else if (get_configs_data->preferences
14384  {
14385  iterator_t prefs;
14386  config_t config = get_iterator_resource (&configs);
14387 
14388  assert (config);
14389 
14390  SEND_TO_CLIENT_OR_FAIL ("<preferences>");
14391 
14392  /* Send NVT timeout preferences where a timeout has been
14393  * specified. */
14394  init_config_timeout_iterator (&prefs, config);
14395  while (next (&prefs))
14396  {
14397  const char *timeout;
14398 
14399  timeout = config_timeout_iterator_value (&prefs);
14400 
14401  if (timeout && strlen (timeout))
14402  SENDF_TO_CLIENT_OR_FAIL
14403  ("<preference>"
14404  "<nvt oid=\"%s\">"
14405  "<name>%s</name>"
14406  "</nvt>"
14407  "<name>Timeout</name>"
14408  "<type>entry</type>"
14409  "<value>%s</value>"
14410  "</preference>",
14411  config_timeout_iterator_oid (&prefs),
14413  timeout);
14414  }
14415  cleanup_iterator (&prefs);
14416 
14417  init_nvt_preference_iterator (&prefs, NULL);
14418  while (next (&prefs))
14419  {
14420  GString *buffer = g_string_new ("");
14421  buffer_config_preference_xml (buffer, &prefs, config, 1);
14422  SEND_TO_CLIENT_OR_FAIL (buffer->str);
14423  g_string_free (buffer, TRUE);
14424  }
14425  cleanup_iterator (&prefs);
14426 
14427  SEND_TO_CLIENT_OR_FAIL ("</preferences>");
14428  }
14429 
14430  if (config_type == 0 && get_configs_data->get.details)
14431  {
14432  iterator_t selectors;
14433 
14434  SEND_TO_CLIENT_OR_FAIL ("<nvt_selectors>");
14435 
14436  init_nvt_selector_iterator (&selectors, NULL, config,
14438  while (next (&selectors))
14439  {
14440  int type = nvt_selector_iterator_type (&selectors);
14441  SENDF_TO_CLIENT_OR_FAIL
14442  ("<nvt_selector>"
14443  "<name>%s</name>"
14444  "<include>%i</include>"
14445  "<type>%i</type>"
14446  "<family_or_nvt>%s</family_or_nvt>"
14447  "</nvt_selector>",
14448  nvt_selector_iterator_name (&selectors),
14449  nvt_selector_iterator_include (&selectors),
14450  type,
14452  ? "" : nvt_selector_iterator_nvt (&selectors)));
14453  }
14454  cleanup_iterator (&selectors);
14455 
14456  SEND_TO_CLIENT_OR_FAIL ("</nvt_selectors>");
14457  }
14458 
14459  if (get_configs_data->tasks)
14460  {
14461  iterator_t tasks;
14462 
14463  SEND_TO_CLIENT_OR_FAIL ("<tasks>");
14465  (&tasks, get_iterator_resource (&configs), 0);
14466  while (next (&tasks))
14467  {
14468  if (config_task_iterator_readable (&tasks) == 0)
14469  /* Only show tasks the user may see. */
14470  continue;
14471 
14472  SENDF_TO_CLIENT_OR_FAIL
14473  ("<task id=\"%s\">"
14474  "<name>%s</name>",
14475  config_task_iterator_uuid (&tasks),
14476  config_task_iterator_name (&tasks));
14477  if (config_task_iterator_readable (&tasks))
14478  SEND_TO_CLIENT_OR_FAIL ("</task>");
14479  else
14480  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
14481  "</task>");
14482  }
14483  cleanup_iterator (&tasks);
14484  SEND_TO_CLIENT_OR_FAIL ("</tasks>");
14485  }
14486 
14487  SEND_TO_CLIENT_OR_FAIL ("</config>");
14488  count++;
14489  }
14490  cleanup_iterator (&configs);
14491  filtered = get_configs_data->get.id
14492  ? 1 : config_count (&get_configs_data->get);
14493  SEND_GET_END ("config", &get_configs_data->get, count, filtered);
14494 
14495  get_configs_data_reset (get_configs_data);
14496  set_client_state (CLIENT_AUTHENTIC);
14497 }
14498 
14505 static void
14506 handle_get_credentials (omp_parser_t *omp_parser, GError **error)
14507 {
14508  iterator_t credentials;
14509  int count, filtered, ret, first;
14510  int format;
14511  char *data_format;
14512 
14513  data_format = get_credentials_data->format;
14514  if (data_format)
14515  {
14516  if (strlen (data_format))
14517  {
14518  if (strcasecmp (data_format, "key") == 0)
14519  format = 1;
14520  else if (strcasecmp (data_format, "rpm") == 0)
14521  format = 2;
14522  else if (strcasecmp (data_format, "deb") == 0)
14523  format = 3;
14524  else if (strcasecmp (data_format, "exe") == 0)
14525  format = 4;
14526  else if (strcasecmp (data_format, "pem") == 0)
14527  format = 5;
14528  else
14529  format = -1;
14530  }
14531  else
14532  format = 0;
14533  }
14534  else
14535  format = 0;
14536 
14537  if (format == -1)
14538  SEND_TO_CLIENT_OR_FAIL
14539  (XML_ERROR_SYNTAX ("get_credentials",
14540  "GET_CREDENTIALS format attribute should"
14541  " be 'key', 'rpm', 'deb', 'exe' or 'pem'."));
14542 
14543  INIT_GET (credential, Credential);
14544 
14545  ret = init_credential_iterator (&credentials,
14547  if (ret)
14548  {
14549  switch (ret)
14550  {
14551  case 1:
14552  if (send_find_error_to_client ("get_credentials",
14553  "credential",
14555  omp_parser))
14556  {
14557  error_send_to_client (error);
14558  return;
14559  }
14560  break;
14561  case 2:
14562  if (send_find_error_to_client ("get_credentials",
14563  "credential",
14565  omp_parser))
14566  {
14567  error_send_to_client (error);
14568  return;
14569  }
14570  break;
14571  case -1:
14572  SEND_TO_CLIENT_OR_FAIL
14573  (XML_INTERNAL_ERROR ("get_credentials"));
14574  break;
14575  }
14576  get_credentials_data_reset (get_credentials_data);
14577  set_client_state (CLIENT_AUTHENTIC);
14578  return;
14579  }
14580 
14581  SEND_GET_START("credential");
14582  while (1)
14583  {
14584  const char *private_key, *login, *type, *cert;
14585 
14586  ret = get_next (&credentials, &get_credentials_data->get,
14587  &first, &count, init_credential_iterator);
14588  if (ret == 1)
14589  break;
14590  if (ret == -1)
14591  {
14592  internal_error_send_to_client (error);
14593  return;
14594  }
14595 
14596  SEND_GET_COMMON (credential, &get_credentials_data->get, &credentials);
14597  private_key = credential_iterator_private_key (&credentials);
14598  login = credential_iterator_login (&credentials);
14599  type = credential_iterator_type (&credentials);
14600  cert = credential_iterator_certificate (&credentials);
14601 
14602  SENDF_TO_CLIENT_OR_FAIL
14603  ("<allow_insecure>%d</allow_insecure>"
14604  "<login>%s</login>"
14605  "<type>%s</type>"
14606  "<full_type>%s</full_type>",
14607  credential_iterator_allow_insecure (&credentials),
14608  login ? login : "",
14609  type ? type : "",
14610  type ? credential_full_type (type) : "");
14611 
14612  if (type && (strcmp (type, "snmp") == 0))
14613  {
14614  const char *auth_algorithm, *privacy_algorithm;
14615  auth_algorithm
14616  = credential_iterator_auth_algorithm (&credentials);
14617  privacy_algorithm
14618  = credential_iterator_privacy_algorithm (&credentials);
14619 
14620  SENDF_TO_CLIENT_OR_FAIL
14621  ("<auth_algorithm>%s</auth_algorithm>"
14622  "<privacy><algorithm>%s</algorithm></privacy>",
14623  auth_algorithm ? auth_algorithm : "",
14624  privacy_algorithm ? privacy_algorithm : "");
14625  }
14626 
14627  if (cert && get_credentials_data->get.details)
14628  {
14629  /* get certificate info */
14630  time_t activation_time, expiration_time;
14631  gchar *activation_time_str, *expiration_time_str;
14632  gchar *fingerprint, *issuer;
14633  get_certificate_info (cert,
14634  &activation_time, &expiration_time,
14635  &fingerprint, &issuer);
14636  activation_time_str = certificate_iso_time (activation_time);
14637  expiration_time_str = certificate_iso_time (expiration_time);
14638  SENDF_TO_CLIENT_OR_FAIL
14639  ("<certificate_info>"
14640  "<time_status>%s</time_status>"
14641  "<activation_time>%s</activation_time>"
14642  "<expiration_time>%s</expiration_time>"
14643  "<md5_fingerprint>%s</md5_fingerprint>"
14644  "<issuer>%s</issuer>"
14645  "</certificate_info>",
14646  certificate_time_status (activation_time, expiration_time),
14647  activation_time_str,
14648  expiration_time_str,
14649  fingerprint ? fingerprint : "",
14650  issuer ? issuer : "");
14651  g_free (activation_time_str);
14652  g_free (expiration_time_str);
14653  g_free (fingerprint);
14654  g_free (issuer);
14655  }
14656 
14657  switch (format)
14658  {
14659  char *package;
14660 
14661  case 1: /* key */
14662  {
14663  char *pub;
14664  const char *pass;
14665 
14666  pass = credential_iterator_password (&credentials);
14667  pub = openvas_ssh_public_from_private (private_key, pass);
14668  SENDF_TO_CLIENT_OR_FAIL
14669  ("<public_key>%s</public_key>", pub ?: "");
14670  g_free (pub);
14671  break;
14672  }
14673  case 2: /* rpm */
14674  package = credential_iterator_rpm (&credentials);
14675  SENDF_TO_CLIENT_OR_FAIL
14676  ("<package format=\"rpm\">%s</package>", package ?: "");
14677  g_free (package);
14678  break;
14679  case 3: /* deb */
14680  package = credential_iterator_deb (&credentials);
14681  SENDF_TO_CLIENT_OR_FAIL
14682  ("<package format=\"deb\">%s</package>", package ?: "");
14683  g_free (package);
14684  break;
14685  case 4: /* exe */
14686  package = credential_iterator_exe (&credentials);
14687  SENDF_TO_CLIENT_OR_FAIL
14688  ("<package format=\"exe\">%s</package>", package ?: "");
14689  g_free (package);
14690  break;
14691  case 5:
14692  {
14693  SENDF_TO_CLIENT_OR_FAIL
14694  ("<certificate>%s</certificate>", cert ?: "");
14695  break;
14696  }
14697  }
14698 
14700  {
14701  iterator_t scanners;
14702 
14703  SENDF_TO_CLIENT_OR_FAIL ("<scanners>");
14705  (&scanners, get_iterator_resource (&credentials), 0);
14706  while (next (&scanners))
14707  {
14708  SENDF_TO_CLIENT_OR_FAIL
14709  ("<scanner id=\"%s\">"
14710  "<name>%s</name>",
14712  credential_scanner_iterator_name (&scanners));
14713  if (credential_scanner_iterator_readable (&scanners))
14714  SEND_TO_CLIENT_OR_FAIL ("</scanner>");
14715  else
14716  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
14717  "</scanner>");
14718  }
14719  cleanup_iterator (&scanners);
14720 
14721  SEND_TO_CLIENT_OR_FAIL ("</scanners>");
14722  }
14723 
14725  {
14726  iterator_t targets;
14727 
14728  SENDF_TO_CLIENT_OR_FAIL ("<targets>");
14730  (&targets, get_iterator_resource (&credentials), 0);
14731  while (next (&targets))
14732  {
14733  SENDF_TO_CLIENT_OR_FAIL
14734  ("<target id=\"%s\">"
14735  "<name>%s</name>",
14737  credential_target_iterator_name (&targets));
14738  if (credential_target_iterator_readable (&targets))
14739  SEND_TO_CLIENT_OR_FAIL ("</target>");
14740  else
14741  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
14742  "</target>");
14743  }
14744  cleanup_iterator (&targets);
14745 
14746  SEND_TO_CLIENT_OR_FAIL ("</targets>");
14747  }
14748 
14749  SEND_TO_CLIENT_OR_FAIL ("</credential>");
14750  count++;
14751  }
14752 
14753  cleanup_iterator (&credentials);
14754  filtered = get_credentials_data->get.id
14755  ? 1
14757  SEND_GET_END ("credential", &get_credentials_data->get,
14758  count, filtered);
14759  get_credentials_data_reset (get_credentials_data);
14760  set_client_state (CLIENT_AUTHENTIC);
14761 }
14762 
14770 static const char*
14771 feed_type_name (int feed_type)
14772 {
14773  switch (feed_type)
14774  {
14775  case NVT_FEED:
14776  return "NVT";
14777  case CERT_FEED:
14778  return "CERT";
14779  case SCAP_FEED:
14780  return "SCAP";
14781  default:
14782  return "Error";
14783  }
14784 }
14785 
14794 static void
14795 get_feed (omp_parser_t *omp_parser, GError **error, const gchar *sync_script,
14796  int feed_type)
14797 {
14798  gchar *feed_description, *feed_identification, *feed_version;
14799 
14800  feed_description = NULL;
14801  feed_identification = NULL;
14802  feed_version = NULL;
14803 
14804  if (openvas_get_sync_script_description (sync_script, &feed_description)
14806  &feed_identification,
14807  feed_type)
14808  && openvas_get_sync_script_feed_version (sync_script,
14809  &feed_version))
14810  {
14811  gchar *user, *timestamp;
14812  int syncing;
14813  gchar **ident = g_strsplit (feed_identification, "|", 6);
14814  gchar *selftest_result = NULL;
14815 
14816  syncing = openvas_current_sync (sync_script, &timestamp, &user);
14817  if (syncing < 0 || ident[0] == NULL || ident[1] == NULL
14818  || ident[2] == NULL || ident[3] == NULL)
14819  {
14820  g_strfreev (ident);
14821  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_feeds"));
14822  }
14823  else
14824  {
14825  SENDF_TO_CLIENT_OR_FAIL
14826  ("<feed>"
14827  "<type>%s</type>"
14828  "<name>%s</name>"
14829  "<version>%s</version>"
14830  "<description>%s</description>",
14831  feed_type_name (feed_type),
14832  ident[3],
14833  feed_version,
14834  feed_description);
14835  g_strfreev (ident);
14836  if (openvas_sync_script_perform_selftest (sync_script,
14837  &selftest_result)
14838  == FALSE)
14839  {
14840  SENDF_TO_CLIENT_OR_FAIL ("<sync_not_available>"
14841  "<error>%s</error>"
14842  "</sync_not_available>",
14843  selftest_result ? selftest_result : "");
14844  g_free (selftest_result);
14845  }
14846 
14847  if (syncing > 0)
14848  {
14849  SENDF_TO_CLIENT_OR_FAIL ("<currently_syncing>"
14850  "<timestamp>%s</timestamp>"
14851  "<user>%s</user>"
14852  "</currently_syncing>",
14853  timestamp ? timestamp : "",
14854  user ? user : "");
14855  g_free (timestamp);
14856  g_free (user);
14857  }
14858  SEND_TO_CLIENT_OR_FAIL ("</feed>");
14859  }
14860 
14861  g_free (feed_version);
14862  }
14863  g_free (feed_identification);
14864  g_free (feed_description);
14865 }
14866 
14873 static void
14874 handle_get_feeds (omp_parser_t *omp_parser, GError **error)
14875 {
14876  assert (current_credentials.username);
14877 
14878  if (acl_user_may ("get_feeds") == 0)
14879  {
14880  SEND_TO_CLIENT_OR_FAIL
14881  (XML_ERROR_SYNTAX ("get_feeds",
14882  "Permission denied"));
14883  set_client_state (CLIENT_AUTHENTIC);
14884  return;
14885  }
14886 
14887  SEND_TO_CLIENT_OR_FAIL ("<get_feeds_response"
14888  " status=\"" STATUS_OK "\""
14889  " status_text=\"" STATUS_OK_TEXT "\">");
14890 
14891  if ((get_feeds_data->type == NULL)
14892  || strcmp (get_feeds_data->type, "nvt"))
14893  get_feed (omp_parser, error, nvt_sync_script, NVT_FEED);
14894 
14895  if ((get_feeds_data->type == NULL)
14896  || strcmp (get_feeds_data->type, "scap"))
14897  get_feed (omp_parser, error, scap_sync_script, SCAP_FEED);
14898 
14899  if ((get_feeds_data->type == NULL)
14900  || strcmp (get_feeds_data->type, "cert"))
14901  get_feed (omp_parser, error, cert_sync_script, CERT_FEED);
14902 
14903  SEND_TO_CLIENT_OR_FAIL ("</get_feeds_response>");
14904 
14905  get_feeds_data_reset (get_feeds_data);
14906  set_client_state (CLIENT_AUTHENTIC);
14907 }
14908 
14915 static void
14916 handle_get_filters (omp_parser_t *omp_parser, GError **error)
14917 {
14918  iterator_t filters;
14919  int count, filtered, ret, first;
14920 
14921  INIT_GET (filter, Filter);
14922 
14923  ret = init_filter_iterator (&filters, &get_filters_data->get);
14924  if (ret)
14925  {
14926  switch (ret)
14927  {
14928  case 1:
14929  if (send_find_error_to_client ("get_filters", "filter",
14931  omp_parser))
14932  {
14933  error_send_to_client (error);
14934  return;
14935  }
14936  break;
14937  case 2:
14938  if (send_find_error_to_client
14939  ("get_filters", "filter",
14940  get_filters_data->get.filt_id, omp_parser))
14941  {
14942  error_send_to_client (error);
14943  return;
14944  }
14945  break;
14946  case -1:
14947  SEND_TO_CLIENT_OR_FAIL
14948  (XML_INTERNAL_ERROR ("get_filters"));
14949  break;
14950  }
14951  get_filters_data_reset (get_filters_data);
14952  set_client_state (CLIENT_AUTHENTIC);
14953  return;
14954  }
14955 
14956  SEND_GET_START ("filter");
14957  while (1)
14958  {
14959  ret = get_next (&filters, &get_filters_data->get, &first, &count,
14961  if (ret == 1)
14962  break;
14963  if (ret == -1)
14964  {
14965  internal_error_send_to_client (error);
14966  return;
14967  }
14968 
14969  SEND_GET_COMMON (filter, &get_filters_data->get, &filters);
14970 
14971  SENDF_TO_CLIENT_OR_FAIL ("<type>%s</type>"
14972  "<term>%s</term>",
14973  filter_iterator_type (&filters),
14974  filter_iterator_term (&filters));
14975 
14976  if (get_filters_data->alerts)
14977  {
14978  iterator_t alerts;
14979 
14980  SEND_TO_CLIENT_OR_FAIL ("<alerts>");
14981  init_filter_alert_iterator (&alerts,
14983  (&filters));
14984  while (next (&alerts))
14985  {
14986  SENDF_TO_CLIENT_OR_FAIL
14987  ("<alert id=\"%s\">"
14988  "<name>%s</name>",
14989  filter_alert_iterator_uuid (&alerts),
14990  filter_alert_iterator_name (&alerts));
14991  if (filter_alert_iterator_readable (&alerts))
14992  SEND_TO_CLIENT_OR_FAIL ("</alert>");
14993  else
14994  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
14995  "</alert>");
14996  }
14997  cleanup_iterator (&alerts);
14998  SEND_TO_CLIENT_OR_FAIL ("</alerts>");
14999  }
15000 
15001  SEND_TO_CLIENT_OR_FAIL ("</filter>");
15002 
15003  count++;
15004  }
15005  cleanup_iterator (&filters);
15006  filtered = get_filters_data->get.id
15007  ? 1
15009  SEND_GET_END ("filter", &get_filters_data->get, count, filtered);
15010 
15011  get_filters_data_reset (get_filters_data);
15012  set_client_state (CLIENT_AUTHENTIC);
15013 }
15014 
15021 static void
15022 handle_get_groups (omp_parser_t *omp_parser, GError **error)
15023 {
15024  iterator_t groups;
15025  int count, filtered, ret, first;
15026 
15027  INIT_GET (group, Group);
15028 
15029  ret = init_group_iterator (&groups, &get_groups_data->get);
15030  if (ret)
15031  {
15032  switch (ret)
15033  {
15034  case 1:
15035  if (send_find_error_to_client ("get_groups", "group",
15037  omp_parser))
15038  {
15039  error_send_to_client (error);
15040  return;
15041  }
15042  break;
15043  case 2:
15044  if (send_find_error_to_client
15045  ("get_groups", "group", get_groups_data->get.filt_id,
15046  omp_parser))
15047  {
15048  error_send_to_client (error);
15049  return;
15050  }
15051  break;
15052  case -1:
15053  SEND_TO_CLIENT_OR_FAIL
15054  (XML_INTERNAL_ERROR ("get_groups"));
15055  break;
15056  }
15057  get_groups_data_reset (get_groups_data);
15058  set_client_state (CLIENT_AUTHENTIC);
15059  return;
15060  }
15061 
15062  SEND_GET_START ("group");
15063  while (1)
15064  {
15065  gchar *users;
15066 
15067  ret = get_next (&groups, &get_groups_data->get, &first, &count,
15069  if (ret == 1)
15070  break;
15071  if (ret == -1)
15072  {
15073  internal_error_send_to_client (error);
15074  return;
15075  }
15076 
15077  SEND_GET_COMMON (group, &get_groups_data->get, &groups);
15078 
15079  users = group_users (get_iterator_resource (&groups));
15080  SENDF_TO_CLIENT_OR_FAIL ("<users>%s</users>", users ? users : "");
15081  g_free (users);
15082 
15083  SEND_TO_CLIENT_OR_FAIL ("</group>");
15084 
15085  count++;
15086  }
15087  cleanup_iterator (&groups);
15088  filtered = get_groups_data->get.id
15089  ? 1
15091  SEND_GET_END ("group", &get_groups_data->get, count, filtered);
15092 
15093  get_groups_data_reset (get_groups_data);
15094  set_client_state (CLIENT_AUTHENTIC);
15095 }
15096 
15103 static void
15104 handle_get_info (omp_parser_t *omp_parser, GError **error)
15105 {
15106  iterator_t info;
15107  int count, first, filtered, ret;
15108  int (*init_info_iterator) (iterator_t*, get_data_t *, const char *);
15109  int (*info_count) (const get_data_t *get);
15110  const char *update_time;
15111  get_data_t *get;
15112 
15113  if (acl_user_may ("get_info") == 0)
15114  {
15115  SEND_TO_CLIENT_OR_FAIL
15116  (XML_ERROR_SYNTAX ("get_info",
15117  "Permission denied"));
15118  get_info_data_reset (get_info_data);
15119  set_client_state (CLIENT_AUTHENTIC);
15120  return;
15121  }
15122 
15123  if (manage_scap_loaded () == 0)
15124  {
15125  SEND_TO_CLIENT_OR_FAIL
15126  (XML_ERROR_SYNTAX ("get_info",
15127  "GET_INFO requires the SCAP database."));
15128  get_info_data_reset (get_info_data);
15129  set_client_state (CLIENT_AUTHENTIC);
15130  return;
15131  }
15132  if (manage_cert_loaded () == 0)
15133  {
15134  SEND_TO_CLIENT_OR_FAIL
15135  (XML_ERROR_SYNTAX ("get_info",
15136  "GET_INFO requires the CERT database."));
15137  get_info_data_reset (get_info_data);
15138  set_client_state (CLIENT_AUTHENTIC);
15139  return;
15140  }
15141 
15143  {
15144  SEND_TO_CLIENT_OR_FAIL
15145  (XML_ERROR_SYNTAX ("get_info",
15146  "Only one of name and the id attribute"
15147  " may be given."));
15148  get_info_data_reset (get_info_data);
15149  set_client_state (CLIENT_AUTHENTIC);
15150  return;
15151  }
15152  if (get_info_data->type == NULL)
15153  {
15154  SEND_TO_CLIENT_OR_FAIL
15155  (XML_ERROR_SYNTAX ("get_info",
15156  "No type specified."));
15157  get_info_data_reset (get_info_data);
15158  set_client_state (CLIENT_AUTHENTIC);
15159  return;
15160  }
15161 
15162  get = &get_info_data->get;
15163  if (get->filt_id && strcmp (get->filt_id, "-2") == 0)
15164  {
15165  char *user_filter;
15166  gchar *name;
15167 
15168  if (strcmp (get_info_data->type, "cpe") == 0)
15169  name = g_strdup ("CPE");
15170  else if (strcmp (get_info_data->type, "cve") == 0)
15171  name = g_strdup ("CVE");
15172  else if (strcmp (get_info_data->type, "ovaldef") == 0)
15173  name = g_strdup ("OVAL");
15174  else if (strcmp (get_info_data->type, "cert_bund_adv") == 0)
15175  name = g_strdup ("CERT-Bund");
15176  else if (strcmp (get_info_data->type, "dfn_cert_adv") == 0)
15177  name = g_strdup ("DFN-CERT");
15178  else if (strcmp (get_info_data->type, "nvt") == 0)
15179  name = g_strdup ("NVT");
15180  else if (strcmp (get_info_data->type, "allinfo") == 0)
15181  name = g_strdup ("All SecInfo");
15182  else
15183  {
15184  if (send_find_error_to_client ("get_info", "type",
15186  omp_parser))
15187  {
15188  error_send_to_client (error);
15189  return;
15190  }
15191  get_info_data_reset (get_info_data);
15192  set_client_state (CLIENT_AUTHENTIC);
15193  return;
15194  }
15195 
15196  user_filter = setting_filter (name);
15197  g_free (name);
15198 
15199  if (user_filter && strlen (user_filter))
15200  {
15201  get->filt_id = user_filter;
15202  get->filter = filter_term (user_filter);
15203  }
15204  else
15205  get->filt_id = g_strdup("0");
15206  }
15207 
15208  /* Set type specific functions */
15209  if (g_strcmp0 ("cpe", get_info_data->type) == 0)
15210  {
15211  init_info_iterator = init_cpe_info_iterator;
15212  info_count = cpe_info_count;
15213  get_info_data->get.subtype = g_strdup ("cpe");
15214  }
15215  else if (g_strcmp0 ("cve", get_info_data->type) == 0)
15216  {
15217  init_info_iterator = init_cve_info_iterator;
15218  info_count = cve_info_count;
15219  get_info_data->get.subtype = g_strdup ("cve");
15220  }
15221  else if ((g_strcmp0 ("nvt", get_info_data->type) == 0)
15222  && (get_info_data->name == NULL)
15223  && (get_info_data->get.id == NULL))
15224  {
15225  init_info_iterator = init_nvt_info_iterator;
15226  info_count = nvt_info_count;
15227  get_info_data->get.subtype = g_strdup ("nvt");
15228  }
15229  else if (g_strcmp0 ("nvt", get_info_data->type) == 0)
15230  {
15231  gchar *result;
15232 
15233  get_info_data->get.subtype = g_strdup ("nvt");
15234 
15236  get_info_data->name, &result);
15237  if (result)
15238  {
15239  SEND_GET_START ("info");
15240  SEND_TO_CLIENT_OR_FAIL ("<info>");
15241  SEND_TO_CLIENT_OR_FAIL (result);
15242  SEND_TO_CLIENT_OR_FAIL ("</info>");
15243  SEND_TO_CLIENT_OR_FAIL ("<details>1</details>");
15244  SEND_GET_END ("info", &get_info_data->get, 1, 1);
15245  g_free (result);
15246  get_info_data_reset (get_info_data);
15247  set_client_state (CLIENT_AUTHENTIC);
15248  return;
15249  }
15250  else
15251  {
15252  if (send_find_error_to_client ("get_info",
15254  ? "name"
15255  : "ID",
15257  ? get_info_data->name
15258  : get_info_data->get.id,
15259  omp_parser))
15260  {
15261  error_send_to_client (error);
15262  return;
15263  }
15264  get_info_data_reset (get_info_data);
15265  set_client_state (CLIENT_AUTHENTIC);
15266  return;
15267  }
15268  }
15269  else if (g_strcmp0 ("ovaldef", get_info_data->type) == 0)
15270  {
15271  init_info_iterator = init_ovaldef_info_iterator;
15272  info_count = ovaldef_info_count;
15273  get_info_data->get.subtype = g_strdup ("ovaldef");
15274  }
15275  else if (g_strcmp0 ("cert_bund_adv", get_info_data->type) == 0)
15276  {
15277  init_info_iterator = init_cert_bund_adv_info_iterator;
15278  info_count = cert_bund_adv_info_count;
15279  get_info_data->get.subtype = g_strdup ("cert_bund_adv");
15280  }
15281  else if (g_strcmp0 ("dfn_cert_adv", get_info_data->type) == 0)
15282  {
15283  init_info_iterator = init_dfn_cert_adv_info_iterator;
15284  info_count = dfn_cert_adv_info_count;
15285  get_info_data->get.subtype = g_strdup ("dfn_cert_adv");
15286  }
15287  else if (g_strcmp0 ("allinfo", get_info_data->type) == 0)
15288  {
15289  init_info_iterator = init_all_info_iterator;
15290  info_count = all_info_count;
15291  get_info_data->get.subtype = g_strdup ("allinfo");
15292  }
15293  else
15294  {
15295  if (send_find_error_to_client ("get_info", "type",
15296  get_info_data->type, omp_parser))
15297  {
15298  error_send_to_client (error);
15299  }
15300  return;
15301  }
15302 
15303  ret = init_info_iterator (&info, &get_info_data->get, get_info_data->name);
15304  if (ret)
15305  {
15306  switch (ret)
15307  {
15308  case 1:
15309  if (send_find_error_to_client ("get_info", "type",
15311  omp_parser))
15312  {
15313  error_send_to_client (error);
15314  return;
15315  }
15316  break;
15317  case 2:
15318  if (send_find_error_to_client
15319  ("get_info", "filter", get_info_data->get.filt_id,
15320  omp_parser))
15321  {
15322  error_send_to_client (error);
15323  return;
15324  }
15325  break;
15326  case -1:
15327  SEND_TO_CLIENT_OR_FAIL
15328  (XML_INTERNAL_ERROR ("get_info"));
15329  break;
15330  }
15331  get_info_data_reset (get_info_data);
15332  set_client_state (CLIENT_AUTHENTIC);
15333  return;
15334  }
15335 
15336  count = 0;
15337  manage_filter_controls (get_info_data->get.filter, &first, NULL, NULL, NULL);
15338  SEND_GET_START ("info");
15339  update_time = manage_scap_update_time ();
15340  while (next (&info))
15341  {
15342  GString *result;
15343 
15344  /* Info's are currently always read only */
15345  if (send_get_common ("info", &get_info_data->get, &info,
15346  omp_parser->client_writer,
15347  omp_parser->client_writer_data, 0, 0))
15348  {
15349  error_send_to_client (error);
15350  return;
15351  }
15352 
15353  SENDF_TO_CLIENT_OR_FAIL ("<update_time>%s</update_time>",
15354  update_time);
15355 
15356  result = g_string_new ("");
15357 
15358  /* Information depending on type */
15359 
15360  if (g_strcmp0 ("cpe", get_info_data->type) == 0)
15361  {
15362  const char *title;
15363 
15364  xml_string_append (result, "<cpe>");
15365  title = cpe_info_iterator_title (&info);
15366  if (title)
15367  xml_string_append (result,
15368  "<title>%s</title>",
15369  cpe_info_iterator_title (&info));
15370  xml_string_append (result,
15371  "<nvd_id>%s</nvd_id>"
15372  "<max_cvss>%s</max_cvss>"
15373  "<cve_refs>%s</cve_refs>"
15374  "<status>%s</status>",
15375  cpe_info_iterator_nvd_id (&info),
15378  cpe_info_iterator_status (&info) ?
15379  cpe_info_iterator_status (&info) : "");
15380 
15381  if (get_info_data->details == 1)
15382  {
15383  iterator_t cves;
15384  g_string_append (result, "<cves>");
15385  init_cpe_cve_iterator (&cves, get_iterator_name (&info), 0, NULL);
15386  while (next (&cves))
15387  xml_string_append (result,
15388  "<cve>"
15389  "<entry"
15390  " xmlns:cpe-lang=\"http://cpe.mitre.org/language/2.0\""
15391  " xmlns:vuln=\"http://scap.nist.gov/schema/vulnerability/0.4\""
15392  " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
15393  " xmlns:patch=\"http://scap.nist.gov/schema/patch/0.1\""
15394  " xmlns:scap-core=\"http://scap.nist.gov/schema/scap-core/0.1\""
15395  " xmlns:cvss=\"http://scap.nist.gov/schema/cvss-v2/0.2\""
15396  " xmlns=\"http://scap.nist.gov/schema/feed/vulnerability/2.0\""
15397  " id=\"%s\">"
15398  "<vuln:cvss>"
15399  "<cvss:base_metrics>"
15400  "<cvss:score>%s</cvss:score>"
15401  "</cvss:base_metrics>"
15402  "</vuln:cvss>"
15403  "</entry>"
15404  "</cve>",
15405  cve_iterator_name (&cves),
15406  cve_iterator_cvss (&cves));
15407  cleanup_iterator (&cves);
15408  g_string_append (result, "</cves>");
15409  }
15410  }
15411  else if (g_strcmp0 ("cve", get_info_data->type) == 0)
15412  {
15413  xml_string_append (result,
15414  "<cve>"
15415  "<cvss>%s</cvss>"
15416  "<vector>%s</vector>"
15417  "<complexity>%s</complexity>"
15418  "<authentication>%s</authentication>"
15419  "<confidentiality_impact>%s</confidentiality_impact>"
15420  "<integrity_impact>%s</integrity_impact>"
15421  "<availability_impact>%s</availability_impact>"
15422  "<description>%s</description>"
15423  "<products>%s</products>",
15424  cve_info_iterator_cvss (&info)
15425  ? cve_info_iterator_cvss (&info)
15426  : "",
15427  cve_info_iterator_vector (&info),
15434  cve_info_iterator_products (&info));
15435  if (get_info_data->details == 1)
15436  {
15437  iterator_t nvts;
15438  iterator_t cert_advs;
15439  init_cve_nvt_iterator (&nvts, get_iterator_name (&info), 1, NULL);
15440  g_string_append (result, "<nvts>");
15441  while (next (&nvts))
15442  xml_string_append (result,
15443  "<nvt oid=\"%s\">"
15444  "<name>%s</name>"
15445  "</nvt>",
15446  nvt_iterator_oid (&nvts),
15447  nvt_iterator_name (&nvts));
15448  g_string_append (result, "</nvts>");
15449  cleanup_iterator (&nvts);
15450 
15451  g_string_append (result, "<cert>");
15452  if (manage_cert_loaded())
15453  {
15454  init_cve_cert_bund_adv_iterator (&cert_advs,
15455  get_iterator_name (&info),
15456  1, NULL);
15457  while (next (&cert_advs))
15458  {
15459  xml_string_append
15460  (result,
15461  "<cert_ref type=\"CERT-Bund\">"
15462  "<name>%s</name>"
15463  "<title>%s</title>"
15464  "</cert_ref>",
15465  get_iterator_name (&cert_advs),
15466  cert_bund_adv_info_iterator_title (&cert_advs));
15467  };
15468  cleanup_iterator (&cert_advs);
15469 
15470  init_cve_dfn_cert_adv_iterator (&cert_advs,
15472  (&info),
15473  1, NULL);
15474  while (next (&cert_advs))
15475  {
15476  xml_string_append (result,
15477  "<cert_ref type=\"DFN-CERT\">"
15478  "<name>%s</name>"
15479  "<title>%s</title>"
15480  "</cert_ref>",
15481  get_iterator_name (&cert_advs),
15483  (&cert_advs));
15484  };
15485  cleanup_iterator (&cert_advs);
15486  }
15487  else
15488  {
15489  g_string_append(result, "<warning>"
15490  "database not available"
15491  "</warning>");
15492  }
15493  g_string_append (result, "</cert>");
15494  }
15495  }
15496  else if (g_strcmp0 ("ovaldef", get_info_data->type) == 0)
15497  {
15498  const char *description;
15499  xml_string_append (result,
15500  "<ovaldef>"
15501  "<version>%s</version>"
15502  "<deprecated>%s</deprecated>"
15503  "<status>%s</status>"
15504  "<class>%s</class>"
15505  "<title>%s</title>"
15506  "<max_cvss>%s</max_cvss>"
15507  "<cve_refs>%s</cve_refs>"
15508  "<file>%s</file>",
15516  ovaldef_info_iterator_file (&info));
15517  description = ovaldef_info_iterator_description (&info);
15518  if (get_info_data->details == 1)
15519  xml_string_append (result,
15520  "<description>%s</description>",
15521  description);
15522  }
15523  else if (g_strcmp0 ("cert_bund_adv", get_info_data->type) == 0)
15524  xml_string_append (result,
15525  "<cert_bund_adv>"
15526  "<title>%s</title>"
15527  "<summary>%s</summary>"
15528  "<max_cvss>%s</max_cvss>"
15529  "<cve_refs>%s</cve_refs>",
15534  else if (g_strcmp0 ("dfn_cert_adv", get_info_data->type) == 0)
15535  xml_string_append (result,
15536  "<dfn_cert_adv>"
15537  "<title>%s</title>"
15538  "<summary>%s</summary>"
15539  "<max_cvss>%s</max_cvss>"
15540  "<cve_refs>%s</cve_refs>",
15545  else if (g_strcmp0 ("nvt", get_info_data->type) == 0)
15546  {
15547  if (send_nvt (&info, 1, 1, -1, NULL, 0,
15548  omp_parser->client_writer,
15549  omp_parser->client_writer_data))
15550  {
15551  cleanup_iterator (&info);
15552  error_send_to_client (error);
15553  return;
15554  }
15555  }
15556  else if (g_strcmp0 ("allinfo", get_info_data->type) == 0)
15557  {
15558  const char *extra = all_info_iterator_extra (&info);
15559  xml_string_append (result,
15560  "<allinfo>"
15561  "<type>%s</type>"
15562  "<extra>%s</extra>"
15563  "<severity>%s</severity>",
15564  all_info_iterator_type (&info),
15565  extra ? extra : "",
15566  all_info_iterator_severity (&info));
15567  }
15568 
15569  /* Append raw data if full details are requested */
15570 
15571  if (get_info_data->details == 1)
15572  {
15573  gchar *raw_data = NULL;
15574  gchar *nonconst_id = g_strdup(get_iterator_uuid (&info));
15575  gchar *nonconst_name = g_strdup(get_iterator_name (&info));
15576  manage_read_info (get_info_data->type, nonconst_id,
15577  nonconst_name, &raw_data);
15578  g_string_append_printf (result, "<raw_data>%s</raw_data>",
15579  raw_data);
15580  g_free(nonconst_id);
15581  g_free(nonconst_name);
15582  g_free(raw_data);
15583  }
15584 
15585  g_string_append_printf (result, "</%s></info>", get_info_data->type);
15586  SEND_TO_CLIENT_OR_FAIL (result->str);
15587  count++;
15588  g_string_free (result, TRUE);
15589  }
15590  cleanup_iterator (&info);
15591 
15592  if (get_info_data->details == 1)
15593  SEND_TO_CLIENT_OR_FAIL ("<details>1</details>");
15594 
15595  filtered = get_info_data->get.id
15596  ? 1
15597  : (get_info_data->name
15599  : info_count (&get_info_data->get));
15600 
15601  if (strcmp (get_info_data->type, "allinfo"))
15602  SEND_GET_END ("info", &get_info_data->get, count, filtered);
15603  else
15604  send_get_end ("info", &get_info_data->get, count, filtered,
15606  omp_parser->client_writer, omp_parser->client_writer_data);
15607 
15608  get_info_data_reset (get_info_data);
15609  set_client_state (CLIENT_AUTHENTIC);
15610 }
15611 
15618 static void
15619 handle_get_notes (omp_parser_t *omp_parser, GError **error)
15620 {
15621  nvt_t nvt = 0;
15622  task_t task = 0;
15623 
15625  SEND_TO_CLIENT_OR_FAIL
15626  (XML_ERROR_SYNTAX ("get_notes",
15627  "Only one of NVT and the note_id attribute"
15628  " may be given"));
15630  SEND_TO_CLIENT_OR_FAIL
15631  (XML_ERROR_SYNTAX ("get_notes",
15632  "Only one of the note_id and task_id"
15633  " attributes may be given"));
15634  else if (get_notes_data->task_id
15635  && find_task (get_notes_data->task_id, &task))
15636  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_notes"));
15637  else if (get_notes_data->task_id && task == 0)
15638  {
15639  if (send_find_error_to_client ("get_notes",
15640  "task", get_notes_data->task_id,
15641  omp_parser))
15642  {
15643  error_send_to_client (error);
15644  return;
15645  }
15646  }
15647  else if (get_notes_data->nvt_oid
15648  && find_nvt (get_notes_data->nvt_oid, &nvt))
15649  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_notes"));
15650  else if (get_notes_data->nvt_oid && nvt == 0)
15651  {
15652  if (send_find_error_to_client ("get_notes", "NVT",
15654  omp_parser))
15655  {
15656  error_send_to_client (error);
15657  return;
15658  }
15659  }
15660  else
15661  {
15662  iterator_t notes;
15663  GString *buffer;
15664  int count, filtered, ret, first;
15665 
15666  INIT_GET (note, Note);
15667 
15668  ret = init_note_iterator (&notes, &get_notes_data->get, nvt, 0,
15669  task);
15670  if (ret)
15671  {
15672  switch (ret)
15673  {
15674  case 1:
15675  if (send_find_error_to_client ("get_notes", "note",
15677  omp_parser))
15678  {
15679  error_send_to_client (error);
15680  return;
15681  }
15682  break;
15683  case 2:
15684  if (send_find_error_to_client
15685  ("get_notes", "filter",
15686  get_notes_data->get.filt_id, omp_parser))
15687  {
15688  error_send_to_client (error);
15689  return;
15690  }
15691  break;
15692  case -1:
15693  SEND_TO_CLIENT_OR_FAIL
15694  (XML_INTERNAL_ERROR ("get_notes"));
15695  break;
15696  }
15697  get_notes_data_reset (get_notes_data);
15698  set_client_state (CLIENT_AUTHENTIC);
15699  return;
15700  }
15701 
15702  SEND_GET_START ("note");
15703 
15704  buffer = g_string_new ("");
15705 
15706  // TODO: Do the iteration with get_next so it checks "first".
15707  buffer_notes_xml (buffer, &notes, get_notes_data->get.details,
15708  get_notes_data->result, &count);
15709 
15710  SEND_TO_CLIENT_OR_FAIL (buffer->str);
15711  g_string_free (buffer, TRUE);
15712 
15713  cleanup_iterator (&notes);
15714  filtered = get_notes_data->get.id
15715  ? 1
15716  : note_count (&get_notes_data->get, nvt, 0, task);
15717  SEND_GET_END ("note", &get_notes_data->get, count, filtered);
15718  }
15719  get_notes_data_reset (get_notes_data);
15720  set_client_state (CLIENT_AUTHENTIC);
15721 
15722 }
15723 
15730 static void
15731 handle_get_nvts (omp_parser_t *omp_parser, GError **error)
15732 {
15733  char *feed_version;
15734 
15735  if (acl_user_may ("get_nvts") == 0)
15736  {
15737  SEND_TO_CLIENT_OR_FAIL
15738  (XML_ERROR_SYNTAX ("get_nvts",
15739  "Permission denied"));
15740  get_nvts_data_reset (get_nvts_data);
15741  set_client_state (CLIENT_AUTHENTIC);
15742  return;
15743  }
15744 
15745  feed_version = nvts_feed_version ();
15746  if (feed_version)
15747  {
15748  config_t config, preferences_config;
15749  nvt_t nvt = 0;
15750 
15751  config = preferences_config = 0;
15752 
15753  free (feed_version);
15754 
15756  SEND_TO_CLIENT_OR_FAIL
15757  (XML_ERROR_SYNTAX ("get_nvts",
15758  "Too many parameters at once"));
15759  else if ((get_nvts_data->details == 0)
15761  SEND_TO_CLIENT_OR_FAIL
15762  (XML_ERROR_SYNTAX ("get_nvts",
15763  "GET_NVTS preference_count attribute"
15764  " requires the details attribute"));
15765  else if ((get_nvts_data->details == 0)
15767  SEND_TO_CLIENT_OR_FAIL
15768  (XML_ERROR_SYNTAX ("get_nvts",
15769  "GET_NVTS preferences attribute"
15770  " requires the details attribute"));
15771  else if (((get_nvts_data->details == 0)
15772  || ((get_nvts_data->config_id == NULL)
15773  && (get_nvts_data->preferences_config_id == NULL)))
15774  && get_nvts_data->timeout)
15775  SEND_TO_CLIENT_OR_FAIL
15776  (XML_ERROR_SYNTAX ("get_nvts",
15777  "GET_NVTS timeout attribute"
15778  " requires the details and config_id"
15779  " attributes"));
15780  else if (get_nvts_data->nvt_oid
15781  && find_nvt (get_nvts_data->nvt_oid, &nvt))
15782  SEND_TO_CLIENT_OR_FAIL
15783  (XML_INTERNAL_ERROR ("get_nvts"));
15784  else if (get_nvts_data->nvt_oid && nvt == 0)
15785  {
15786  if (send_find_error_to_client ("get_nvts", "NVT",
15788  omp_parser))
15789  {
15790  error_send_to_client (error);
15791  return;
15792  }
15793  }
15794  else if (get_nvts_data->config_id
15796  SEND_TO_CLIENT_OR_FAIL
15797  (XML_ERROR_SYNTAX ("get_nvts",
15798  "GET_NVTS config_id and"
15799  " preferences_config_id both given"));
15800  else if (get_nvts_data->config_id
15802  &config,
15803  NULL))
15804  SEND_TO_CLIENT_OR_FAIL
15805  (XML_INTERNAL_ERROR ("get_nvts"));
15806  else if (get_nvts_data->config_id && (config == 0))
15807  {
15808  if (send_find_error_to_client
15809  ("get_nvts", "config", get_nvts_data->config_id,
15810  omp_parser))
15811  {
15812  error_send_to_client (error);
15813  return;
15814  }
15815  }
15819  &preferences_config,
15820  NULL))
15821  SEND_TO_CLIENT_OR_FAIL
15822  (XML_INTERNAL_ERROR ("get_nvts"));
15824  && (preferences_config == 0))
15825  {
15826  if (send_find_error_to_client
15827  ("get_nvts", "config",
15829  omp_parser))
15830  {
15831  error_send_to_client (error);
15832  return;
15833  }
15834  }
15835  else
15836  {
15837  iterator_t nvts;
15838 
15839  SENDF_TO_CLIENT_OR_FAIL
15840  ("<get_nvts_response"
15841  " status=\"" STATUS_OK "\""
15842  " status_text=\"" STATUS_OK_TEXT "\">");
15843 
15844  init_nvt_iterator (&nvts,
15845  nvt,
15847  /* Presume the NVT is in the config (if
15848  * a config was given). */
15849  ? 0
15850  : config,
15852  NULL,
15855  if (preferences_config)
15856  config = preferences_config;
15857  if (get_nvts_data->details)
15858  while (next (&nvts))
15859  {
15860  int pref_count = -1;
15861  char *timeout = NULL;
15862 
15863  if (get_nvts_data->timeout)
15864  timeout = config_nvt_timeout (config,
15865  nvt_iterator_oid (&nvts));
15866 
15867  if (get_nvts_data->preferences && (timeout == NULL))
15868  timeout = config_nvt_timeout
15869  (config,
15870  nvt_iterator_oid (&nvts));
15871 
15873  {
15874  const char *nvt_name = nvt_iterator_name (&nvts);
15875  pref_count = nvt_preference_count (nvt_name);
15876  }
15877  if (send_nvt (&nvts, 1, get_nvts_data->preferences,
15878  pref_count, timeout, config,
15879  omp_parser->client_writer,
15880  omp_parser->client_writer_data))
15881  {
15882  free (timeout);
15883  cleanup_iterator (&nvts);
15884  error_send_to_client (error);
15885  return;
15886  }
15887  free (timeout);
15888 
15889  SEND_TO_CLIENT_OR_FAIL ("</nvt>");
15890  }
15891  else
15892  while (next (&nvts))
15893  {
15894  if (send_nvt (&nvts, 0, 0, -1, NULL, 0,
15895  omp_parser->client_writer,
15896  omp_parser->client_writer_data))
15897  {
15898  cleanup_iterator (&nvts);
15899  error_send_to_client (error);
15900  return;
15901  }
15902  SEND_TO_CLIENT_OR_FAIL ("</nvt>");
15903  }
15904  cleanup_iterator (&nvts);
15905 
15906  SEND_TO_CLIENT_OR_FAIL ("</get_nvts_response>");
15907  }
15908  }
15909  else
15910  SEND_XML_SERVICE_DOWN ("get_nvts");
15911 
15912  get_nvts_data_reset (get_nvts_data);
15913  set_client_state (CLIENT_AUTHENTIC);
15914 }
15915 
15922 static void
15923 handle_get_nvt_families (omp_parser_t *omp_parser, GError **error)
15924 {
15925  iterator_t families;
15926 
15927  if (acl_user_may ("get_nvt_families") == 0)
15928  {
15929  SEND_TO_CLIENT_OR_FAIL
15930  (XML_ERROR_SYNTAX ("get_nvt_families",
15931  "Permission denied"));
15932  get_nvt_families_data_reset (get_nvt_families_data);
15933  set_client_state (CLIENT_AUTHENTIC);
15934  return;
15935  }
15936 
15937  SEND_TO_CLIENT_OR_FAIL ("<get_nvt_families_response"
15938  " status=\"" STATUS_OK "\""
15939  " status_text=\"" STATUS_OK_TEXT "\">"
15940  "<families>");
15941 
15942  init_family_iterator (&families,
15943  1,
15944  NULL,
15946  while (next (&families))
15947  {
15948  int family_max;
15949  const char *family;
15950 
15951  family = family_iterator_name (&families);
15952  if (family)
15953  family_max = family_nvt_count (family);
15954  else
15955  family_max = -1;
15956 
15957  SENDF_TO_CLIENT_OR_FAIL
15958  ("<family>"
15959  "<name>%s</name>"
15960  /* The total number of NVT's in the family. */
15961  "<max_nvt_count>%i</max_nvt_count>"
15962  "</family>",
15963  family ? family : "",
15964  family_max);
15965  }
15966  cleanup_iterator (&families);
15967 
15968  SEND_TO_CLIENT_OR_FAIL ("</families>"
15969  "</get_nvt_families_response>");
15970 
15971  get_nvt_families_data_reset (get_nvt_families_data);
15972  set_client_state (CLIENT_AUTHENTIC);
15973 }
15974 
15981 static void
15982 handle_get_overrides (omp_parser_t *omp_parser, GError **error)
15983 {
15984  nvt_t nvt = 0;
15985  task_t task = 0;
15986 
15988  SEND_TO_CLIENT_OR_FAIL
15989  (XML_ERROR_SYNTAX ("get_overrides",
15990  "Only one of NVT and the override_id attribute"
15991  " may be given"));
15994  SEND_TO_CLIENT_OR_FAIL
15995  (XML_ERROR_SYNTAX ("get_overrides",
15996  "Only one of the override_id and task_id"
15997  " attributes may be given"));
15998  else if (get_overrides_data->task_id
15999  && find_task (get_overrides_data->task_id, &task))
16000  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_overrides"));
16001  else if (get_overrides_data->task_id && task == 0)
16002  {
16003  if (send_find_error_to_client ("get_overrides", "task",
16005  omp_parser))
16006  {
16007  error_send_to_client (error);
16008  return;
16009  }
16010  }
16011  else if (get_overrides_data->nvt_oid
16012  && find_nvt (get_overrides_data->nvt_oid, &nvt))
16013  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_overrides"));
16014  else if (get_overrides_data->nvt_oid && nvt == 0)
16015  {
16016  if (send_find_error_to_client ("get_overrides",
16017  "NVT", get_overrides_data->nvt_oid,
16018  omp_parser))
16019  {
16020  error_send_to_client (error);
16021  return;
16022  }
16023  }
16024  else
16025  {
16026  iterator_t overrides;
16027  GString *buffer;
16028  int count, filtered, ret, first;
16029 
16030  INIT_GET (override, Override);
16031 
16032  ret = init_override_iterator (&overrides,
16033  &get_overrides_data->get, nvt, 0,
16034  task);
16035  if (ret)
16036  {
16037  switch (ret)
16038  {
16039  case 1:
16040  if (send_find_error_to_client
16041  ("get_overrides", "override",
16042  get_overrides_data->get.id, omp_parser))
16043  {
16044  error_send_to_client (error);
16045  return;
16046  }
16047  break;
16048  case 2:
16049  if (send_find_error_to_client
16050  ("get_overrides", "filter",
16051  get_overrides_data->get.filt_id, omp_parser))
16052  {
16053  error_send_to_client (error);
16054  return;
16055  }
16056  break;
16057  case -1:
16058  SEND_TO_CLIENT_OR_FAIL
16059  (XML_INTERNAL_ERROR ("get_overrides"));
16060  break;
16061  }
16062  get_overrides_data_reset (get_overrides_data);
16063  set_client_state (CLIENT_AUTHENTIC);
16064  return;
16065  }
16066 
16067  SEND_GET_START ("override");
16068 
16069  buffer = g_string_new ("");
16070 
16071  // TODO: Do the iteration with get_next so it checks "first".
16072  buffer_overrides_xml (buffer, &overrides,
16074  get_overrides_data->result, &count);
16075 
16076  SEND_TO_CLIENT_OR_FAIL (buffer->str);
16077  g_string_free (buffer, TRUE);
16078 
16079  cleanup_iterator (&overrides);
16080  filtered = get_overrides_data->get.id
16081  ? 1
16082  : override_count (&get_overrides_data->get, nvt, 0,
16083  task);
16084  SEND_GET_END ("override", &get_overrides_data->get, count,
16085  filtered);
16086  }
16087  get_overrides_data_reset (get_overrides_data);
16088  set_client_state (CLIENT_AUTHENTIC);
16089 }
16090 
16097 static void
16098 handle_get_permissions (omp_parser_t *omp_parser, GError **error)
16099 {
16100  iterator_t permissions;
16101  int count, filtered, ret, first;
16102 
16103  INIT_GET (permission, Permission);
16104 
16105  ret = init_permission_iterator (&permissions,
16107  if (ret)
16108  {
16109  switch (ret)
16110  {
16111  case 1:
16112  if (send_find_error_to_client ("get_permissions",
16113  "permission",
16115  omp_parser))
16116  {
16117  error_send_to_client (error);
16118  return;
16119  }
16120  break;
16121  case 2:
16122  if (send_find_error_to_client
16123  ("get_permissions", "filter",
16124  get_permissions_data->get.filt_id, omp_parser))
16125  {
16126  error_send_to_client (error);
16127  return;
16128  }
16129  break;
16130  case -1:
16131  SEND_TO_CLIENT_OR_FAIL
16132  (XML_INTERNAL_ERROR ("get_permissions"));
16133  break;
16134  }
16135  get_permissions_data_reset (get_permissions_data);
16136  set_client_state (CLIENT_AUTHENTIC);
16137  return;
16138  }
16139 
16140  SEND_GET_START ("permission");
16141  while (1)
16142  {
16143  const char *resource_type;
16144 
16145  ret = get_next (&permissions, &get_permissions_data->get, &first,
16146  &count, init_permission_iterator);
16147  if (ret == 1)
16148  break;
16149  if (ret == -1)
16150  {
16151  internal_error_send_to_client (error);
16152  return;
16153  }
16154 
16155  SEND_GET_COMMON (permission, &get_permissions_data->get, &permissions);
16156 
16157  resource_type = permission_iterator_resource_type (&permissions);
16158  SENDF_TO_CLIENT_OR_FAIL
16159  ("<resource id=\"%s\">"
16160  "<name>%s</name>"
16161  "<type>%s</type>"
16162  "<trash>%i</trash>"
16163  "<deleted>%i</deleted>",
16164  permission_iterator_resource_uuid (&permissions),
16165  resource_type && strcmp (resource_type, "")
16166  ? permission_iterator_resource_name (&permissions)
16167  : "",
16168  permission_iterator_resource_type (&permissions),
16170  permission_iterator_resource_orphan (&permissions));
16171 
16172  if (permission_iterator_resource_readable (&permissions))
16173  SEND_TO_CLIENT_OR_FAIL ("</resource>");
16174  else
16175  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
16176  "</resource>");
16177 
16178  SENDF_TO_CLIENT_OR_FAIL
16179  ("<subject id=\"%s\">"
16180  "<name>%s</name>"
16181  "<type>%s</type>"
16182  "<trash>%i</trash>",
16183  permission_iterator_subject_uuid (&permissions),
16184  permission_iterator_subject_name (&permissions),
16185  permission_iterator_subject_type (&permissions),
16186  permission_iterator_subject_in_trash (&permissions));
16187 
16188  if (permission_iterator_subject_readable (&permissions))
16189  SEND_TO_CLIENT_OR_FAIL ("</subject>");
16190  else
16191  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
16192  "</subject>");
16193 
16194  SEND_TO_CLIENT_OR_FAIL ("</permission>");
16195  count++;
16196  }
16197  cleanup_iterator (&permissions);
16198  filtered = get_permissions_data->get.id
16199  ? 1
16201  SEND_GET_END ("permission", &get_permissions_data->get, count, filtered);
16202 
16203  get_permissions_data_reset (get_permissions_data);
16204  set_client_state (CLIENT_AUTHENTIC);
16205 }
16206 
16213 static void
16214 handle_get_port_lists (omp_parser_t *omp_parser, GError **error)
16215 {
16216  iterator_t port_lists;
16217  int count, filtered, ret, first;
16218 
16219  INIT_GET (port_list, Port List);
16220 
16221  ret = init_port_list_iterator (&port_lists,
16223  if (ret)
16224  {
16225  switch (ret)
16226  {
16227  case 1:
16228  if (send_find_error_to_client ("get_port_lists",
16229  "port_list",
16231  omp_parser))
16232  {
16233  error_send_to_client (error);
16234  return;
16235  }
16236  break;
16237  case 2:
16238  if (send_find_error_to_client
16239  ("get_port_lists", "port_list",
16240  get_port_lists_data->get.filt_id, omp_parser))
16241  {
16242  error_send_to_client (error);
16243  return;
16244  }
16245  break;
16246  case -1:
16247  SEND_TO_CLIENT_OR_FAIL
16248  (XML_INTERNAL_ERROR ("get_port_lists"));
16249  break;
16250  }
16251  get_port_lists_data_reset (get_port_lists_data);
16252  set_client_state (CLIENT_AUTHENTIC);
16253  return;
16254  }
16255 
16256  SEND_GET_START ("port_list");
16257  while (1)
16258  {
16259  ret = get_next (&port_lists, &get_port_lists_data->get, &first,
16260  &count, init_port_list_iterator);
16261  if (ret == 1)
16262  break;
16263  if (ret == -1)
16264  {
16265  internal_error_send_to_client (error);
16266  return;
16267  }
16268 
16269  SEND_GET_COMMON (port_list, &get_port_lists_data->get,
16270  &port_lists);
16271 
16272  SENDF_TO_CLIENT_OR_FAIL ("<port_count>"
16273  "<all>%i</all>"
16274  "<tcp>%i</tcp>"
16275  "<udp>%i</udp>"
16276  "</port_count>",
16277  port_list_iterator_count_all (&port_lists),
16278  port_list_iterator_count_tcp (&port_lists),
16279  port_list_iterator_count_udp (&port_lists));
16280 
16282  {
16283  iterator_t ranges;
16284 
16285  SEND_TO_CLIENT_OR_FAIL ("<port_ranges>");
16286 
16287  init_port_range_iterator (&ranges,
16288  get_iterator_resource (&port_lists),
16289  0, 1, NULL);
16290  while (next (&ranges))
16291  SENDF_TO_CLIENT_OR_FAIL
16292  ("<port_range id=\"%s\">"
16293  "<start>%s</start>"
16294  "<end>%s</end>"
16295  "<type>%s</type>"
16296  "<comment>%s</comment>"
16297  "</port_range>",
16298  port_range_iterator_uuid (&ranges),
16299  port_range_iterator_start (&ranges),
16300  port_range_iterator_end (&ranges)
16301  ? port_range_iterator_end (&ranges)
16302  : port_range_iterator_start (&ranges),
16303  port_range_iterator_type (&ranges),
16304  port_range_iterator_comment (&ranges));
16305  cleanup_iterator (&ranges);
16306 
16307  SENDF_TO_CLIENT_OR_FAIL ("</port_ranges>");
16308  }
16309 
16311  {
16312  iterator_t targets;
16313 
16314  SEND_TO_CLIENT_OR_FAIL ("<targets>");
16315 
16318  (&port_lists), 0);
16319  while (next (&targets))
16320  {
16321  if (port_list_target_iterator_readable (&targets) == 0)
16322  /* Only show targets the user may see. */
16323  continue;
16324 
16325  SENDF_TO_CLIENT_OR_FAIL
16326  ("<target id=\"%s\">"
16327  "<name>%s</name>",
16328  port_list_target_iterator_uuid (&targets),
16329  port_list_target_iterator_name (&targets));
16330  if (port_list_target_iterator_readable (&targets))
16331  SEND_TO_CLIENT_OR_FAIL ("</target>");
16332  else
16333  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
16334  "</target>");
16335  }
16336 
16337  cleanup_iterator (&targets);
16338 
16339  SEND_TO_CLIENT_OR_FAIL ("</targets>");
16340  }
16341 
16342  SEND_TO_CLIENT_OR_FAIL ("</port_list>");
16343 
16344  count++;
16345  }
16346 
16347  cleanup_iterator (&port_lists);
16348  filtered = get_port_lists_data->get.id
16349  ? 1
16351  SEND_GET_END ("port_list", &get_port_lists_data->get, count, filtered);
16352 
16353  get_port_lists_data_reset (get_port_lists_data);
16354  set_client_state (CLIENT_AUTHENTIC);
16355 }
16356 
16363 static void
16364 handle_get_preferences (omp_parser_t *omp_parser, GError **error)
16365 {
16366  iterator_t prefs;
16367  nvt_t nvt = 0;
16368  config_t config = 0;
16369 
16370  if (acl_user_may ("get_preferences") == 0)
16371  {
16372  SEND_TO_CLIENT_OR_FAIL
16373  (XML_ERROR_SYNTAX ("get_preferences",
16374  "Permission denied"));
16375  get_preferences_data_reset (get_preferences_data);
16376  set_client_state (CLIENT_AUTHENTIC);
16377  return;
16378  }
16379 
16382  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_preferences"));
16383  else if (get_preferences_data->nvt_oid && nvt == 0)
16384  {
16385  if (send_find_error_to_client ("get_preferences", "NVT",
16387  omp_parser))
16388  {
16389  error_send_to_client (error);
16390  return;
16391  }
16392  }
16395  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_preferences"));
16396  else if (get_preferences_data->config_id && config == 0)
16397  {
16398  if (send_find_error_to_client ("get_preferences", "config",
16400  omp_parser))
16401  {
16402  error_send_to_client (error);
16403  return;
16404  }
16405  }
16406  else
16407  {
16408  char *nvt_name = manage_nvt_name (nvt);
16409  SEND_TO_CLIENT_OR_FAIL ("<get_preferences_response"
16410  " status=\"" STATUS_OK "\""
16411  " status_text=\"" STATUS_OK_TEXT "\">");
16412  init_nvt_preference_iterator (&prefs, nvt_name);
16413  free (nvt_name);
16415  while (next (&prefs))
16416  {
16417  char *name = strstr (nvt_preference_iterator_name (&prefs), "]:");
16418  if (name
16419  && (strcmp (name + 2,
16421  == 0))
16422  {
16423  GString *buffer = g_string_new ("");
16424  buffer_config_preference_xml (buffer, &prefs, config, 1);
16425  SEND_TO_CLIENT_OR_FAIL (buffer->str);
16426  g_string_free (buffer, TRUE);
16427  break;
16428  }
16429  }
16430  else
16431  while (next (&prefs))
16432  {
16433  GString *buffer = g_string_new ("");
16434  buffer_config_preference_xml (buffer, &prefs, config, 1);
16435  SEND_TO_CLIENT_OR_FAIL (buffer->str);
16436  g_string_free (buffer, TRUE);
16437  }
16438 
16439  cleanup_iterator (&prefs);
16440  SEND_TO_CLIENT_OR_FAIL ("</get_preferences_response>");
16441  }
16442  get_preferences_data_reset (get_preferences_data);
16443  set_client_state (CLIENT_AUTHENTIC);
16444 }
16445 
16452 static void
16453 handle_get_reports (omp_parser_t *omp_parser, GError **error)
16454 {
16455  report_t request_report = 0, delta_report = 0, report;
16456  report_format_t report_format;
16457  iterator_t reports;
16458  int count, filtered, ret, first;
16459 
16460  if (current_credentials.username == NULL)
16461  {
16462  get_reports_data_reset (get_reports_data);
16463  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_reports"));
16464  set_client_state (CLIENT_AUTHENTIC);
16465  return;
16466  }
16467 
16468  if (acl_user_may ("get_reports") == 0)
16469  {
16470  SEND_TO_CLIENT_OR_FAIL
16471  (XML_ERROR_SYNTAX ("get_reports",
16472  "Permission denied"));
16473  get_reports_data_reset (get_reports_data);
16474  set_client_state (CLIENT_AUTHENTIC);
16475  return;
16476  }
16477 
16488  if (strcmp (get_reports_data->type, "scan")
16489  && strcmp (get_reports_data->type, "assets")
16490  && strcmp (get_reports_data->type, "prognostic"))
16491  {
16492  get_reports_data_reset (get_reports_data);
16493  SEND_TO_CLIENT_OR_FAIL
16494  (XML_ERROR_SYNTAX ("get_reports",
16495  "GET_REPORTS type must be scan, assets or"
16496  " prognostic"));
16497  set_client_state (CLIENT_AUTHENTIC);
16498  return;
16499  }
16500 
16501  if (strcmp (get_reports_data->type, "prognostic") == 0
16502  && manage_scap_loaded () == 0)
16503  {
16504  get_reports_data_reset (get_reports_data);
16505  SEND_TO_CLIENT_OR_FAIL
16506  (XML_ERROR_SYNTAX ("get_reports",
16507  "GET_REPORTS with type prognostic requires the"
16508  " SCAP database"));
16509  set_client_state (CLIENT_AUTHENTIC);
16510  return;
16511  }
16512 
16513  if ((strcmp (get_reports_data->type, "scan") == 0)
16516  &request_report,
16517  NULL))
16518  {
16519  get_reports_data_reset (get_reports_data);
16520  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_reports"));
16521  set_client_state (CLIENT_AUTHENTIC);
16522  return;
16523  }
16524 
16526  && strcmp (get_reports_data->delta_report_id, "0")
16528  &delta_report,
16529  NULL))
16530  {
16531  get_reports_data_reset (get_reports_data);
16532  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_reports"));
16533  set_client_state (CLIENT_AUTHENTIC);
16534  return;
16535  }
16536 
16537  if (get_reports_data->format_id == NULL)
16539  = g_strdup ("a994b278-1f62-11e1-96ac-406186ea4fc5");
16540 
16542  &report_format,
16543  "get_report_formats"))
16544  {
16545  get_reports_data_reset (get_reports_data);
16546  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_reports"));
16547  set_client_state (CLIENT_AUTHENTIC);
16548  return;
16549  }
16550 
16551  if (report_format == 0)
16552  {
16553  if (send_find_error_to_client ("get_reports", "report format",
16555  omp_parser))
16556  {
16557  error_send_to_client (error);
16558  return;
16559  }
16560  get_reports_data_reset (get_reports_data);
16561  set_client_state (CLIENT_AUTHENTIC);
16562  return;
16563  }
16564 
16566  && strcmp (get_reports_data->get.filt_id, "0")
16567  && strcmp (get_reports_data->get.filt_id, "-2"))
16568  {
16569  filter_t filter;
16571  &filter,
16572  "get_filters"))
16573  {
16574  get_reports_data_reset (get_reports_data);
16575  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_reports"));
16576  set_client_state (CLIENT_AUTHENTIC);
16577  return;
16578  }
16579 
16580  if (filter == 0)
16581  {
16582  if (send_find_error_to_client ("get_reports", "filter",
16584  omp_parser))
16585  {
16586  error_send_to_client (error);
16587  return;
16588  }
16589  get_reports_data_reset (get_reports_data);
16590  set_client_state (CLIENT_AUTHENTIC);
16591  return;
16592  }
16593  }
16594 
16595  if ((strcmp (get_reports_data->type, "scan") == 0)
16597  && request_report == 0)
16598  {
16599  if (send_find_error_to_client ("get_reports", "report",
16601  omp_parser))
16602  {
16603  error_send_to_client (error);
16604  return;
16605  }
16606  get_reports_data_reset (get_reports_data);
16607  set_client_state (CLIENT_AUTHENTIC);
16608  return;
16609  }
16610 
16611  if ((strcmp (get_reports_data->type, "scan") == 0)
16613  && strcmp (get_reports_data->delta_report_id, "0")
16614  && delta_report == 0)
16615  {
16616  if (send_find_error_to_client ("get_reports", "report",
16618  omp_parser))
16619  {
16620  error_send_to_client (error);
16621  return;
16622  }
16623  get_reports_data_reset (get_reports_data);
16624  set_client_state (CLIENT_AUTHENTIC);
16625  return;
16626  }
16627 
16628  if (report_format_active (report_format) == 0)
16629  {
16630  get_reports_data_reset (get_reports_data);
16631  SEND_TO_CLIENT_OR_FAIL
16632  (XML_ERROR_SYNTAX ("get_reports",
16633  "GET_REPORTS report format must be active"));
16634  set_client_state (CLIENT_AUTHENTIC);
16635  return;
16636  }
16637 
16638  if ((report_format_predefined (report_format) == 0)
16639  && (report_format_trust (report_format) > 1))
16640  {
16641  get_reports_data_reset (get_reports_data);
16642  SEND_TO_CLIENT_OR_FAIL
16643  (XML_ERROR_SYNTAX ("get_reports",
16644  "GET_REPORTS report format must be predefined"
16645  " or trusted"));
16646  set_client_state (CLIENT_AUTHENTIC);
16647  return;
16648  }
16649 
16650  if (strcmp (get_reports_data->type, "assets") == 0)
16651  {
16652  gchar *extension, *content_type;
16653  int ret, pos;
16654  get_data_t * get;
16655 
16656  /* An asset report. */
16657 
16658  get = &get_reports_data->get;
16659  if (get->filt_id && strcmp (get->filt_id, "-2") == 0)
16660  {
16661  g_free (get->filt_id);
16662  get->filt_id = g_strdup ("0");
16663  }
16664 
16665  if (get_reports_data->alert_id == NULL)
16666  SEND_TO_CLIENT_OR_FAIL
16667  ("<get_reports_response"
16668  " status=\"" STATUS_OK "\""
16669  " status_text=\"" STATUS_OK_TEXT "\">");
16670 
16671  content_type = report_format_content_type (report_format);
16672  extension = report_format_extension (report_format);
16673 
16674  SENDF_TO_CLIENT_OR_FAIL
16675  ("<report"
16676  " type=\"assets\""
16677  " format_id=\"%s\""
16678  " extension=\"%s\""
16679  " content_type=\"%s\">",
16681  extension,
16682  content_type);
16683 
16684  g_free (extension);
16685  g_free (content_type);
16686 
16687  pos = get_reports_data->pos ? atoi (get_reports_data->pos) : 1;
16688  ret = manage_send_report (0,
16689  0,
16690  report_format,
16695  /* Special case the XML reports, bah. */
16696  strcmp
16698  "a994b278-1f62-11e1-96ac-406186ea4fc5")
16699  && strcmp
16701  "5057e5cc-b825-11e4-9d0e-28d24461215b"),
16702  send_to_client,
16703  omp_parser->client_writer,
16704  omp_parser->client_writer_data,
16706  "assets",
16708  pos,
16709  NULL, NULL, 0, 0, NULL);
16710 
16711  if (ret)
16712  {
16713  internal_error_send_to_client (error);
16714  get_reports_data_reset (get_reports_data);
16715  set_client_state (CLIENT_AUTHENTIC);
16716  return;
16717  }
16718 
16719  SEND_TO_CLIENT_OR_FAIL ("</report>"
16720  "</get_reports_response>");
16721 
16722  get_reports_data_reset (get_reports_data);
16723  set_client_state (CLIENT_AUTHENTIC);
16724  return;
16725  }
16726 
16727  if (strcmp (get_reports_data->type, "prognostic") == 0)
16728  {
16729  gchar *extension, *content_type;
16730  int ret, pos;
16731  get_data_t * get;
16732 
16733  /* A prognostic report. */
16734 
16735  get = &get_reports_data->get;
16736  if (get->filt_id && strcmp (get->filt_id, "-2") == 0)
16737  {
16738  g_free (get->filt_id);
16739  get->filt_id = g_strdup ("0");
16740  }
16741 
16742  if (get_reports_data->alert_id == NULL)
16743  SEND_TO_CLIENT_OR_FAIL
16744  ("<get_reports_response"
16745  " status=\"" STATUS_OK "\""
16746  " status_text=\"" STATUS_OK_TEXT "\">");
16747 
16748  content_type = report_format_content_type (report_format);
16749  extension = report_format_extension (report_format);
16750 
16751  SENDF_TO_CLIENT_OR_FAIL
16752  ("<report"
16753  " type=\"prognostic\""
16754  " format_id=\"%s\""
16755  " extension=\"%s\""
16756  " content_type=\"%s\">",
16758  extension,
16759  content_type);
16760 
16761  g_free (extension);
16762  g_free (content_type);
16763 
16764  pos = get_reports_data->pos ? atoi (get_reports_data->pos) : 1;
16765  ret = manage_send_report (0,
16766  0,
16767  report_format,
16772  /* Special case the XML report, bah. */
16773  strcmp
16775  "a994b278-1f62-11e1-96ac-406186ea4fc5")
16776  && strcmp
16778  "5057e5cc-b825-11e4-9d0e-28d24461215b"),
16779  send_to_client,
16780  omp_parser->client_writer,
16781  omp_parser->client_writer_data,
16783  "prognostic",
16785  pos,
16790  NULL);
16791 
16792  if (ret)
16793  {
16794  internal_error_send_to_client (error);
16795  get_reports_data_reset (get_reports_data);
16796  set_client_state (CLIENT_AUTHENTIC);
16797  return;
16798  }
16799 
16800  SEND_TO_CLIENT_OR_FAIL ("</report>"
16801  "</get_reports_response>");
16802 
16803  get_reports_data_reset (get_reports_data);
16804  set_client_state (CLIENT_AUTHENTIC);
16805  return;
16806  }
16807 
16808  /* The usual scan report. */
16809 
16810  if (get_reports_data->get.id)
16811  {
16812  /* Showing requested report, use Results Filter setting. */
16813  INIT_GET (report, Result);
16814  }
16815  else
16816  {
16817  /* Showing multiple reports. Use Report Filter setting. Expand
16818  * INIT_GET here to pass the get_reports_data->report_get to
16819  * init_get. */
16820  ret = init_get ("get_reports",
16822  "Reports",
16823  &first);
16824  if (ret)
16825  {
16826  switch (ret)
16827  {
16828  case 99:
16829  SEND_TO_CLIENT_OR_FAIL
16830  (XML_ERROR_SYNTAX ("get_reports",
16831  "Permission denied"));
16832  break;
16833  default:
16834  internal_error_send_to_client (error);
16835  return;
16836  }
16837  get_reports_data_reset (get_reports_data);
16838  set_client_state (CLIENT_AUTHENTIC);
16839  return;
16840  }
16841  }
16842 
16843  if ((get_reports_data->report_get.id == NULL)
16844  || (strlen (get_reports_data->report_get.id) == 0))
16845  {
16846  gchar *overrides, *min_qod, *filter;
16847  get_data_t * get;
16848 
16849  /* For simplicity, use a fixed result filter when filtering
16850  * reports. A given result filter is only applied when getting
16851  * a single specified report. */
16852 
16853  get = &get_reports_data->report_get;
16854 
16855  /* Get overrides value from report filter. */
16856  if (get->filt_id && strcmp (get->filt_id, "0"))
16857  {
16858  filter = filter_term (get->filt_id);
16859  if (filter == NULL)
16860  assert (0);
16861  }
16862  else
16863  filter = NULL;
16864  g_free (get_reports_data->get.filter);
16865  overrides
16866  = filter_term_value (filter ? filter : get->filter, "apply_overrides");
16867  min_qod
16868  = filter_term_value (filter ? filter : get->filter, "min_qod");
16869  g_free (filter);
16870 
16871  /* Setup result filter from overrides. */
16873  = g_strdup_printf ("apply_overrides=%i min_qod=%s",
16874  overrides && strcmp (overrides, "0"),
16875  min_qod ? min_qod : G_STRINGIFY (MIN_QOD_DEFAULT));
16876  g_free (overrides);
16877  g_free (min_qod);
16878  }
16879 
16880  ret = init_report_iterator (&reports, &get_reports_data->report_get);
16881  if (ret)
16882  {
16883  switch (ret)
16884  {
16885  case 1:
16886  if (send_find_error_to_client ("get_reports", "report",
16888  omp_parser))
16889  {
16890  error_send_to_client (error);
16891  return;
16892  }
16893  break;
16894  case 2:
16895  if (send_find_error_to_client
16896  ("get_reports", "filter",
16897  get_reports_data->get.filt_id, omp_parser))
16898  {
16899  error_send_to_client (error);
16900  return;
16901  }
16902  break;
16903  case -1:
16904  SEND_TO_CLIENT_OR_FAIL
16905  (XML_INTERNAL_ERROR ("get_reports"));
16906  break;
16907  }
16908  get_reports_data_reset (get_reports_data);
16909  set_client_state (CLIENT_AUTHENTIC);
16910  return;
16911  }
16912 
16913  count = 0;
16914  if (get_reports_data->alert_id == NULL)
16915  SEND_GET_START ("report");
16916  while (next_report (&reports, &report))
16917  {
16918  gchar *extension, *content_type;
16919  int ret;
16920  GString *prefix;
16921 
16922  prefix = g_string_new ("");
16923  content_type = report_format_content_type (report_format);
16924  extension = report_format_extension (report_format);
16925 
16926  if (get_reports_data->alert_id == NULL)
16927  g_string_append_printf (prefix,
16928  "<report"
16929  " type=\"scan\""
16930  " id=\"%s\""
16931  " format_id=\"%s\""
16932  " extension=\"%s\""
16933  " content_type=\"%s\">",
16934  report_iterator_uuid (&reports),
16936  extension,
16937  content_type);
16938 
16939  g_free (extension);
16940  g_free (content_type);
16941 
16942  if (get_reports_data->alert_id == NULL)
16943  {
16944  task_t task;
16945 
16946  /* Send the standard elements. Should match send_get_common. */
16947  buffer_xml_append_printf
16948  (prefix,
16949  "<owner><name>%s</name></owner>"
16950  "<name>%s</name>"
16951  "<comment>%s</comment>"
16952  "<creation_time>%s</creation_time>"
16953  "<modification_time>"
16954  "%s"
16955  "</modification_time>"
16956  "<writable>0</writable>"
16957  "<in_use>0</in_use>",
16958  get_iterator_owner_name (&reports)
16959  ? get_iterator_owner_name (&reports)
16960  : "",
16961  get_iterator_name (&reports)
16962  ? get_iterator_name (&reports)
16963  : "",
16964  get_iterator_comment (&reports)
16965  ? get_iterator_comment (&reports)
16966  : "",
16967  get_iterator_creation_time (&reports)
16968  ? get_iterator_creation_time (&reports)
16969  : "",
16971  ? get_iterator_modification_time (&reports)
16972  : "");
16973  /* Send short task and report format info */
16974  report_task (report, &task);
16975  if (task)
16976  {
16977  gchar *report_task_uuid;
16978  task_uuid (task, &report_task_uuid);
16979 
16980  buffer_xml_append_printf (prefix,
16981  "<task id=\"%s\">",
16982  report_task_uuid);
16983 
16984  /* Skip task name for Anonymous XML report format. */
16985  if (strcmp (get_reports_data->format_id,
16986  "5057e5cc-b825-11e4-9d0e-28d24461215b"))
16987  {
16988  gchar *report_task_name;
16989  report_task_name = task_name (task);
16990  buffer_xml_append_printf (prefix,
16991  "<name>%s</name>",
16992  report_task_name);
16993  g_free (report_task_name);
16994  }
16995 
16996  buffer_xml_append_printf (prefix, "</task>");
16997 
16998  g_free (report_task_uuid);
16999  }
17000 
17002  {
17003  gchar *format_name = NULL;
17004  format_name = report_format_name (report_format);
17005 
17006  buffer_xml_append_printf
17007  (prefix,
17008  "<report_format id=\"%s\">"
17009  "<name>%s</name>"
17010  "</report_format>",
17012  format_name ? format_name : "");
17013  // g_free (report_format_name);
17014  }
17015 
17016  }
17017  /* If there's just one report then cleanup the iterator early. This
17018  * closes the iterator transaction, allowing manage_schedule to lock
17019  * the db during generation of large reports. */
17020  if (request_report)
17021  cleanup_iterator (&reports);
17022 
17023  ret = manage_send_report (report,
17024  delta_report,
17025  report_format,
17030  /* Special case the XML report, bah. */
17032  && strcmp
17034  "a994b278-1f62-11e1-96ac-406186ea4fc5")
17035  && strcmp
17037  "5057e5cc-b825-11e4-9d0e-28d24461215b"),
17038  send_to_client,
17039  omp_parser->client_writer,
17040  omp_parser->client_writer_data,
17043  NULL, 0, NULL, NULL, 0, 0, prefix->str);
17044  g_string_free (prefix, TRUE);
17045  if (ret)
17046  {
17048  switch (ret)
17049  {
17050  case 0:
17051  break;
17052  case 1:
17053  if (send_find_error_to_client
17054  ("get_reports", "alert",
17055  get_reports_data->alert_id, omp_parser))
17056  {
17057  error_send_to_client (error);
17058  return;
17059  }
17060  /* Close the connection with the client, as part of the
17061  * response may have been sent before the error
17062  * occurred. */
17063  internal_error_send_to_client (error);
17064  if (request_report == 0)
17065  cleanup_iterator (&reports);
17066  get_reports_data_reset (get_reports_data);
17067  set_client_state (CLIENT_AUTHENTIC);
17068  return;
17069  break;
17070  case 2:
17071  if (send_find_error_to_client
17072  ("get_reports", "filter",
17073  get_reports_data->get.filt_id, omp_parser))
17074  {
17075  error_send_to_client (error);
17076  return;
17077  }
17078  /* This error always occurs before anything is sent
17079  * to the client, so the connection can stay up. */
17080  if (request_report == 0)
17081  cleanup_iterator (&reports);
17082  get_reports_data_reset (get_reports_data);
17083  set_client_state (CLIENT_AUTHENTIC);
17084  return;
17085  break;
17086  case -2:
17087  SEND_TO_CLIENT_OR_FAIL
17088  (XML_ERROR_SYNTAX ("get_reports",
17089  "Failed to find report format for"
17090  " alert"));
17091  if (request_report == 0)
17092  cleanup_iterator (&reports);
17093  get_reports_data_reset (get_reports_data);
17094  set_client_state (CLIENT_AUTHENTIC);
17095  return;
17096  break;
17097  case -3:
17098  SEND_TO_CLIENT_OR_FAIL
17099  (XML_INTERNAL_ERROR ("get_reports"));
17100  if (request_report == 0)
17101  cleanup_iterator (&reports);
17102  get_reports_data_reset (get_reports_data);
17103  set_client_state (CLIENT_AUTHENTIC);
17104  return;
17105  break;
17106  case -4:
17107  SEND_TO_CLIENT_OR_FAIL
17108  (XML_ERROR_SYNTAX ("get_reports",
17109  "Failed to find filter for"
17110  " alert"));
17111  if (request_report == 0)
17112  cleanup_iterator (&reports);
17113  get_reports_data_reset (get_reports_data);
17114  set_client_state (CLIENT_AUTHENTIC);
17115  return;
17116  break;
17117  default:
17118  case -1:
17119  SEND_TO_CLIENT_OR_FAIL
17120  (XML_INTERNAL_ERROR ("get_reports"));
17121  /* Close the connection with the client, as part of the
17122  * response may have been sent before the error
17123  * occurred. */
17124  internal_error_send_to_client (error);
17125  if (request_report == 0)
17126  cleanup_iterator (&reports);
17127  get_reports_data_reset (get_reports_data);
17128  set_client_state (CLIENT_AUTHENTIC);
17129  return;
17130  break;
17131  }
17132  else if (ret == 2)
17133  {
17134  if (send_find_error_to_client
17135  ("get_reports", "filter",
17136  get_reports_data->get.filt_id, omp_parser))
17137  {
17138  error_send_to_client (error);
17139  return;
17140  }
17141  /* This error always occurs before anything is sent
17142  * to the client, so the connection can stay up. */
17143  if (request_report == 0)
17144  cleanup_iterator (&reports);
17145  get_reports_data_reset (get_reports_data);
17146  set_client_state (CLIENT_AUTHENTIC);
17147  return;
17148  }
17149  else
17150  {
17151  /* Close the connection with the client, as part of the
17152  * response may have been sent before the error
17153  * occurred. */
17154  internal_error_send_to_client (error);
17155  if (request_report == 0)
17156  cleanup_iterator (&reports);
17157  get_reports_data_reset (get_reports_data);
17158  set_client_state (CLIENT_AUTHENTIC);
17159  return;
17160  }
17161  }
17162  if (get_reports_data->alert_id == NULL)
17163  SEND_TO_CLIENT_OR_FAIL ("</report>");
17164 
17165  count++;
17166 
17167  if (request_report)
17168  /* Just to be safe, because iterator has been freed. */
17169  break;
17170  }
17171  if (request_report == 0)
17172  cleanup_iterator (&reports);
17173 
17175  SEND_TO_CLIENT_OR_FAIL (XML_OK ("get_reports"));
17176  else
17177  {
17178  filtered = get_reports_data->get.id
17179  ? 1
17181  SEND_GET_END ("report", &get_reports_data->report_get, count,
17182  filtered);
17183  }
17184 
17185  get_reports_data_reset (get_reports_data);
17186  set_client_state (CLIENT_AUTHENTIC);
17187 }
17188 
17195 static void
17196 handle_get_report_formats (omp_parser_t *omp_parser, GError **error)
17197 {
17200  SEND_TO_CLIENT_OR_FAIL
17201  (XML_ERROR_SYNTAX ("get_report_formats",
17202  "GET_REPORT_FORMATS params given with trash"));
17203  else
17204  {
17205  iterator_t report_formats;
17206  int count, filtered, ret, first;
17207 
17208  INIT_GET (report_format, Report Format);
17209 
17210  ret = init_report_format_iterator (&report_formats,
17212  if (ret)
17213  {
17214  switch (ret)
17215  {
17216  case 1:
17217  if (send_find_error_to_client ("get_report_formats",
17218  "report_format",
17220  omp_parser))
17221  {
17222  error_send_to_client (error);
17223  return;
17224  }
17225  break;
17226  case 2:
17227  if (send_find_error_to_client
17228  ("get_report_formats", "filter",
17229  get_report_formats_data->get.filt_id, omp_parser))
17230  {
17231  error_send_to_client (error);
17232  return;
17233  }
17234  break;
17235  case -1:
17236  SEND_TO_CLIENT_OR_FAIL
17237  (XML_INTERNAL_ERROR ("get_report_formats"));
17238  break;
17239  }
17240  get_report_formats_data_reset (get_report_formats_data);
17241  set_client_state (CLIENT_AUTHENTIC);
17242  return;
17243  }
17244 
17245  SEND_GET_START ("report_format");
17246  while (1)
17247  {
17248  time_t trust_time;
17249 
17250  ret = get_next (&report_formats,
17251  &get_report_formats_data->get, &first, &count,
17253  if (ret == 1)
17254  break;
17255  if (ret == -1)
17256  {
17257  internal_error_send_to_client (error);
17258  return;
17259  }
17260 
17261  SEND_GET_COMMON (report_format,
17263  &report_formats);
17264 
17266  (&report_formats);
17267 
17268  SENDF_TO_CLIENT_OR_FAIL
17269  ("<extension>%s</extension>"
17270  "<content_type>%s</content_type>"
17271  "<summary>%s</summary>"
17272  "<description>%s</description>"
17273  "<predefined>%i</predefined>",
17274  report_format_iterator_extension (&report_formats),
17275  report_format_iterator_content_type (&report_formats),
17276  report_format_iterator_summary (&report_formats),
17277  report_format_iterator_description (&report_formats),
17279  ? 0
17281  (get_iterator_resource (&report_formats)));
17282 
17284  {
17285  iterator_t alerts;
17286 
17287  SEND_TO_CLIENT_OR_FAIL ("<alerts>");
17290  (&report_formats));
17291  while (next (&alerts))
17292  {
17293  if (report_format_alert_iterator_readable (&alerts) == 0)
17294  /* Only show alerts the user may see. */
17295  continue;
17296 
17297  SENDF_TO_CLIENT_OR_FAIL
17298  ("<alert id=\"%s\">"
17299  "<name>%s</name>",
17303  SEND_TO_CLIENT_OR_FAIL ("</alert>");
17304  else
17305  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
17306  "</alert>");
17307  }
17308  cleanup_iterator (&alerts);
17309  SEND_TO_CLIENT_OR_FAIL ("</alerts>");
17310  }
17311 
17314  {
17315  iterator_t params;
17317  (&params, get_iterator_resource (&report_formats),
17318  get_report_formats_data->get.trash, 1, NULL);
17319  while (next (&params))
17320  {
17321  long long int min, max;
17322  iterator_t options;
17323 
17324  SENDF_TO_CLIENT_OR_FAIL
17325  ("<param>"
17326  "<name>%s</name>"
17327  "<type>%s",
17330 
17331  min = report_format_param_iterator_type_min (&params);
17332  if (min > LLONG_MIN)
17333  SENDF_TO_CLIENT_OR_FAIL ("<min>%lli</min>", min);
17334 
17335  max = report_format_param_iterator_type_max (&params);
17336  if (max < LLONG_MAX)
17337  SENDF_TO_CLIENT_OR_FAIL ("<max>%lli</max>", max);
17338 
17339  if (report_format_param_iterator_type (&params)
17341  {
17342  const char *value;
17343  const char *fallback;
17344  value = report_format_param_iterator_value (&params);
17346  (&params);
17347 
17348  SENDF_TO_CLIENT_OR_FAIL
17349  ("</type><value>%s",
17350  value ? value : "");
17351  if (value)
17352  {
17353  gchar **ids, **current_id;
17354  ids = g_strsplit (value, ",", -1);
17355  current_id = ids;
17356  while (*current_id)
17357  {
17358  report_format_t value_rf;
17359  gchar *name;
17361  (*current_id, &value_rf,
17362  "get_report_formats");
17363  name = value_rf ? report_format_name (value_rf)
17364  : NULL;
17365 
17366  SENDF_TO_CLIENT_OR_FAIL
17367  ("<report_format id=\"%s\">"
17368  "<name>%s</name>"
17369  "</report_format>",
17370  *current_id,
17371  name ? name : "");
17372 
17373  g_free (name);
17374  current_id ++;
17375  }
17376  g_strfreev (ids);
17377  }
17378 
17379  SENDF_TO_CLIENT_OR_FAIL
17380  ("</value><default>%s",
17381  fallback ? fallback : "");
17382  if (fallback)
17383  {
17384  gchar **ids, **current_id;
17385  ids = g_strsplit (fallback, ",", -1);
17386  current_id = ids;
17387  while (*current_id)
17388  {
17389  report_format_t value_rf;
17390  gchar *name;
17392  (*current_id, &value_rf,
17393  "get_report_formats");
17394  name = value_rf ? report_format_name (value_rf)
17395  : NULL;
17396 
17397  SENDF_TO_CLIENT_OR_FAIL
17398  ("<report_format id=\"%s\">"
17399  "<name>%s</name>"
17400  "</report_format>",
17401  *current_id,
17402  name ? name : "");
17403 
17404  g_free (name);
17405  current_id ++;
17406  }
17407  g_strfreev (ids);
17408  }
17409 
17410  SENDF_TO_CLIENT_OR_FAIL
17411  ("</default>");
17412  }
17413  else
17414  {
17415  SENDF_TO_CLIENT_OR_FAIL
17416  ("</type>"
17417  "<value>%s</value>"
17418  "<default>%s</default>",
17421  }
17422 
17423  if (report_format_param_iterator_type (&params)
17425  {
17426  SEND_TO_CLIENT_OR_FAIL ("<options>");
17428  (&options,
17430  (&params),
17431  1,
17432  NULL);
17433  while (next (&options))
17434  SENDF_TO_CLIENT_OR_FAIL
17435  ("<option>%s</option>",
17436  param_option_iterator_value (&options));
17437  cleanup_iterator (&options);
17438  SEND_TO_CLIENT_OR_FAIL ("</options>");
17439  }
17440 
17441  SEND_TO_CLIENT_OR_FAIL ("</param>");
17442  }
17443  cleanup_iterator (&params);
17444  }
17445 
17447  {
17448  file_iterator_t files;
17450  (&files, get_iterator_resource (&report_formats)))
17451  {
17452  cleanup_iterator (&report_formats);
17453  error_send_to_client (error);
17454  return;
17455  }
17456  while (next_file (&files))
17457  {
17458  gchar *content = file_iterator_content_64 (&files);
17459  SENDF_TO_CLIENT_OR_FAIL
17460  ("<file name=\"%s\">%s</file>",
17461  file_iterator_name (&files),
17462  content);
17463  g_free (content);
17464  }
17465  cleanup_file_iterator (&files);
17466 
17467  SENDF_TO_CLIENT_OR_FAIL
17468  ("<signature>%s</signature>",
17469  report_format_iterator_signature (&report_formats));
17470  }
17471 
17472  SENDF_TO_CLIENT_OR_FAIL
17473  ("<trust>%s<time>%s</time></trust>"
17474  "<active>%i</active>",
17476  ? report_format_iterator_trust (&report_formats)
17478  (&report_formats))
17479  ? "yes"
17480  : report_format_iterator_trust (&report_formats)),
17481  iso_time (&trust_time),
17482  report_format_iterator_active (&report_formats));
17483 
17484  SEND_TO_CLIENT_OR_FAIL ("</report_format>");
17485  count++;
17486  }
17487  cleanup_iterator (&report_formats);
17488  filtered = get_report_formats_data->get.id
17489  ? 1
17491  SEND_GET_END ("report_format", &get_report_formats_data->get,
17492  count, filtered);
17493  }
17494  get_report_formats_data_reset (get_report_formats_data);
17495  set_client_state (CLIENT_AUTHENTIC);
17496 }
17497 
17504 static void
17505 handle_get_results (omp_parser_t *omp_parser, GError **error)
17506 {
17507  result_t result = 0;
17508  task_t task = 0;
17509 
17510  if (acl_user_may ("get_results") == 0)
17511  {
17512  SEND_TO_CLIENT_OR_FAIL
17513  (XML_ERROR_SYNTAX ("get_results",
17514  "Permission denied"));
17515  get_results_data_reset (get_results_data);
17516  set_client_state (CLIENT_AUTHENTIC);
17517  return;
17518  }
17519 
17520  if (current_credentials.username == NULL)
17521  {
17522  get_results_data_reset (get_results_data);
17523  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_results"));
17524  set_client_state (CLIENT_AUTHENTIC);
17525  return;
17526  }
17527 
17528  if (get_results_data->get.id
17530  &result,
17531  NULL))
17532  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_results"));
17533  else if (get_results_data->get.id && result == 0)
17534  {
17535  if (send_find_error_to_client ("get_results", "result",
17537  omp_parser))
17538  {
17539  error_send_to_client (error);
17540  return;
17541  }
17542  }
17543  else if (get_results_data->task_id
17545  &task,
17546  NULL))
17547  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_results"));
17548  else if (get_results_data->task_id && task == 0)
17549  {
17550  if (send_find_error_to_client ("get_results", "task",
17552  omp_parser))
17553  {
17554  error_send_to_client (error);
17555  return;
17556  }
17557  }
17558  else
17559  {
17560  const char* filter;
17561  iterator_t results;
17562  int notes, overrides;
17563  int count, ret, first;
17564 
17566  && strcmp (get_results_data->get.filt_id, "0"))
17567  {
17569  }
17570  else
17571  filter = get_results_data->get.filter;
17572 
17573  SEND_TO_CLIENT_OR_FAIL ("<get_results_response"
17574  " status=\"" STATUS_OK "\""
17575  " status_text=\"" STATUS_OK_TEXT "\">");
17576  INIT_GET (result, Result);
17577 
17578  // Do not allow ignore_pagination here
17580 
17582  0, /* No report restriction */
17583  NULL, /* No host restriction */
17584  NULL); /* No extra order SQL. */
17585 
17587  NULL, /* first */
17588  NULL, /* max */
17589  NULL, /* sort_field */
17590  NULL, /* sort_order */
17591  NULL, /* result_hosts_only */
17592  NULL, /* min_qod */
17593  NULL, /* levels */
17594  NULL, /* delta_states */
17595  NULL, /* search_phrase */
17596  NULL, /* search_phrase_exact */
17597  NULL, /* autofp */
17598  &notes,
17599  &overrides,
17600  NULL, /* apply_overrides */
17601  NULL);/* zone */
17602 
17603  if (next (&results))
17604  {
17605  if (get_results_data->get.id && (task == 0))
17606  {
17607  char *task_id;
17608  task_uuid (result_iterator_task (&results), &task_id);
17609  if (find_task_with_permission (task_id, &task, NULL))
17610  {
17611  free (task_id);
17612  internal_error_send_to_client (error);
17613  cleanup_iterator (&results);
17614  return;
17615  }
17616  free (task_id);
17617  }
17618 
17619  count = 0;
17620  do
17621  {
17622  GString *buffer = g_string_new ("");
17623  buffer_results_xml (buffer,
17624  &results,
17625  task,
17626  notes,
17628  overrides,
17630  1,
17631  /* show tag details if selected by ID */
17632  get_results_data->get.id != NULL,
17634  NULL,
17635  NULL,
17636  0);
17637  SEND_TO_CLIENT_OR_FAIL (buffer->str);
17638  g_string_free (buffer, TRUE);
17639  count ++;
17640  }
17641  while (next (&results));
17642  }
17643  cleanup_iterator (&results);
17644 
17646  &first, NULL, NULL, NULL);
17647 
17649  {
17650  int filtered;
17651 
17652  filtered = get_results_data->get.id
17654  0 /* No report */,
17655  NULL /* No host */);
17656 
17657  if (send_get_end ("result", &get_results_data->get, count, filtered,
17658  resource_count ("result", &get_results_data->get),
17659  omp_parser->client_writer,
17660  omp_parser->client_writer_data))
17661  {
17662  error_send_to_client (error);
17663  return;
17664  }
17665  }
17666  else if (send_get_end_no_counts ("result",
17668  omp_parser->client_writer,
17669  omp_parser->client_writer_data))
17670  {
17671  error_send_to_client (error);
17672  return;
17673  }
17674  }
17675 
17676  get_results_data_reset (get_results_data);
17677  set_client_state (CLIENT_AUTHENTIC);
17678 }
17679 
17686 static void
17687 handle_get_roles (omp_parser_t *omp_parser, GError **error)
17688 {
17689  iterator_t roles;
17690  int count, filtered, ret, first;
17691 
17692  INIT_GET (role, Role);
17693 
17694  ret = init_role_iterator (&roles, &get_roles_data->get);
17695  if (ret)
17696  {
17697  switch (ret)
17698  {
17699  case 1:
17700  if (send_find_error_to_client ("get_roles", "role",
17702  omp_parser))
17703  {
17704  error_send_to_client (error);
17705  return;
17706  }
17707  break;
17708  case 2:
17709  if (send_find_error_to_client
17710  ("get_roles", "role", get_roles_data->get.filt_id,
17711  omp_parser))
17712  {
17713  error_send_to_client (error);
17714  return;
17715  }
17716  break;
17717  case -1:
17718  SEND_TO_CLIENT_OR_FAIL
17719  (XML_INTERNAL_ERROR ("get_roles"));
17720  break;
17721  }
17722  get_roles_data_reset (get_roles_data);
17723  set_client_state (CLIENT_AUTHENTIC);
17724  return;
17725  }
17726 
17727  SEND_GET_START ("role");
17728  while (1)
17729  {
17730  gchar *users;
17731 
17732  ret = get_next (&roles, &get_roles_data->get, &first, &count,
17734  if (ret == 1)
17735  break;
17736  if (ret == -1)
17737  {
17738  internal_error_send_to_client (error);
17739  return;
17740  }
17741 
17742  SEND_GET_COMMON (role, &get_roles_data->get, &roles);
17743 
17744  users = role_users (get_iterator_resource (&roles));
17745  SENDF_TO_CLIENT_OR_FAIL ("<users>%s</users>", users ? users : "");
17746  g_free (users);
17747 
17748  SEND_TO_CLIENT_OR_FAIL ("</role>");
17749 
17750  count++;
17751  }
17752  cleanup_iterator (&roles);
17753  filtered = get_roles_data->get.id
17754  ? 1
17756  SEND_GET_END ("role", &get_roles_data->get, count, filtered);
17757 
17758  get_roles_data_reset (get_roles_data);
17759  set_client_state (CLIENT_AUTHENTIC);
17760 }
17761 
17768 static void
17769 handle_get_scanners (omp_parser_t *omp_parser, GError **error)
17770 {
17771  iterator_t scanners;
17772  int ret, count, filtered, first;
17773 
17774  INIT_GET (scanner, Scanner);
17775  ret = init_scanner_iterator (&scanners, &get_scanners_data->get);
17776  switch (ret)
17777  {
17778  case 0:
17779  break;
17780  case 1:
17781  if (send_find_error_to_client
17782  ("get_scanners", "scanners", get_scanners_data->get.id,
17783  omp_parser))
17784  {
17785  error_send_to_client (error);
17786  break;
17787  }
17788  break;
17789  case 2:
17790  if (send_find_error_to_client
17791  ("get_scanners", "filter", get_scanners_data->get.filt_id,
17792  omp_parser))
17793  {
17794  error_send_to_client (error);
17795  break;
17796  }
17797  break;
17798  case -1:
17799  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("get_scanners"));
17800  break;
17801  }
17802  if (ret)
17803  {
17804  get_scanners_data_reset (get_scanners_data);
17805  set_client_state (CLIENT_AUTHENTIC);
17806  return;
17807  }
17808 
17809  SEND_GET_START ("scanner");
17810  while (1)
17811  {
17812  gchar *credential_id;
17813  ret = get_next (&scanners, &get_scanners_data->get, &first, &count,
17815  if (ret == 1)
17816  break;
17817  if (ret == -1)
17818  {
17819  internal_error_send_to_client (error);
17820  break;
17821  }
17822 
17823  SEND_GET_COMMON (scanner, &get_scanners_data->get, &scanners);
17824 
17825  SENDF_TO_CLIENT_OR_FAIL
17826  ("<host>%s</host>"
17827  "<port>%d</port>"
17828  "<type>%d</type>"
17829  "<ca_pub>%s</ca_pub>",
17830  scanner_iterator_host (&scanners) ?: "",
17831  scanner_iterator_port (&scanners) ?: 0,
17832  scanner_iterator_type (&scanners),
17833  scanner_iterator_ca_pub (&scanners) ?: "");
17834 
17836  {
17837  time_t activation_time, expiration_time;
17838  gchar *activation_time_str, *expiration_time_str;
17839 
17840  if (scanner_iterator_ca_pub (&scanners))
17841  {
17842  /* CA Certificate */
17843  gchar *fingerprint, *issuer;
17845  &activation_time, &expiration_time,
17846  &fingerprint, &issuer);
17847  activation_time_str = certificate_iso_time (activation_time);
17848  expiration_time_str = certificate_iso_time (expiration_time);
17849  SENDF_TO_CLIENT_OR_FAIL
17850  ("<ca_pub_info>"
17851  "<time_status>%s</time_status>"
17852  "<activation_time>%s</activation_time>"
17853  "<expiration_time>%s</expiration_time>"
17854  "<md5_fingerprint>%s</md5_fingerprint>"
17855  "<issuer>%s</issuer>"
17856  "</ca_pub_info>",
17857  certificate_time_status (activation_time, expiration_time),
17858  activation_time_str,
17859  expiration_time_str,
17860  fingerprint,
17861  issuer);
17862  g_free (activation_time_str);
17863  g_free (expiration_time_str);
17864  g_free (fingerprint);
17865  g_free (issuer);
17866  }
17867  }
17868 
17869  credential_id = credential_uuid (scanner_iterator_credential (&scanners));
17870  SENDF_TO_CLIENT_OR_FAIL
17871  ("<credential id=\"%s\">"
17872  "<name>%s</name>"
17873  "<trash>%d</trash>",
17874  credential_id ? credential_id : "",
17875  scanner_iterator_credential_name (&scanners) ?: "",
17876  scanner_iterator_credential_trash (&scanners));
17877 
17879  {
17880  time_t activation_time, expiration_time;
17881  gchar *activation_time_str, *expiration_time_str;
17882 
17883  if (scanner_iterator_key_pub (&scanners))
17884  {
17885  /* Certificate */
17886  gchar *fingerprint, *issuer;
17888  &activation_time, &expiration_time,
17889  &fingerprint, &issuer);
17890  activation_time_str = certificate_iso_time (activation_time);
17891  expiration_time_str = certificate_iso_time (expiration_time);
17892  SENDF_TO_CLIENT_OR_FAIL
17893  ("<certificate_info>"
17894  "<time_status>%s</time_status>"
17895  "<activation_time>%s</activation_time>"
17896  "<expiration_time>%s</expiration_time>"
17897  "<md5_fingerprint>%s</md5_fingerprint>"
17898  "<issuer>%s</issuer>"
17899  "</certificate_info>",
17900  certificate_time_status (activation_time, expiration_time),
17901  activation_time_str,
17902  expiration_time_str,
17903  fingerprint,
17904  issuer);
17905  g_free (activation_time_str);
17906  g_free (expiration_time_str);
17907  g_free (fingerprint);
17908  g_free (issuer);
17909  }
17910  }
17911 
17912  SENDF_TO_CLIENT_OR_FAIL
17913  ("</credential>");
17914  g_free (credential_id);
17915  count++;
17917  {
17918  iterator_t tasks;
17919 
17920  SEND_TO_CLIENT_OR_FAIL ("<tasks>");
17922  get_iterator_resource (&scanners));
17923  while (next (&tasks))
17924  {
17925  if (scanner_task_iterator_readable (&tasks) == 0)
17926  /* Only show tasks the user may see. */
17927  continue;
17928 
17929  SENDF_TO_CLIENT_OR_FAIL
17930  ("<task id=\"%s\">"
17931  "<name>%s</name>",
17932  scanner_task_iterator_uuid (&tasks),
17933  scanner_task_iterator_name (&tasks));
17934 
17935  if (scanner_task_iterator_readable (&tasks))
17936  SEND_TO_CLIENT_OR_FAIL ("</task>");
17937  else
17938  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
17939  "</task>");
17940  }
17941  cleanup_iterator (&tasks);
17942  SEND_TO_CLIENT_OR_FAIL ("</tasks>");
17943  }
17944  if (scanner_iterator_type (&scanners) == SCANNER_TYPE_OSP
17946  {
17947  char *s_name = NULL, *s_ver = NULL;
17948  char *d_name = NULL, *d_ver = NULL;
17949  char *p_name = NULL, *p_ver = NULL, *desc = NULL;
17950  GSList *params = NULL, *nodes;
17951 
17953  (&scanners, &s_name, &s_ver, &d_name, &d_ver, &p_name, &p_ver)
17954  && !osp_get_details_from_iterator (&scanners, &desc, &params))
17955  {
17956  SENDF_TO_CLIENT_OR_FAIL
17957  ("<info><scanner><name>%s</name><version>%s</version>"
17958  "</scanner><daemon><name>%s</name><version>%s</version>"
17959  "</daemon><protocol><name>%s</name><version>%s"
17960  "</version></protocol><description>%s</description>",
17961  s_name, s_ver, d_name, d_ver, p_name, p_ver, desc);
17962 
17963  SENDF_TO_CLIENT_OR_FAIL ("<params>");
17964  nodes = params;
17965  while (nodes)
17966  {
17967  osp_param_t *param = nodes->data;
17968 
17969  SENDF_TO_CLIENT_OR_FAIL
17970  ("<param><id>%s</id><name>%s</name>"
17971  "<default>%s</default><description>%s</description>"
17972  "<type>osp_%s</type><mandatory>%d</mandatory></param>",
17973  osp_param_id (param), osp_param_name (param),
17974  osp_param_default (param), osp_param_desc (param),
17975  osp_param_type_str (param), osp_param_mandatory (param));
17976 
17977  osp_param_free (nodes->data);
17978  nodes = nodes->next;
17979  }
17980  SENDF_TO_CLIENT_OR_FAIL ("</params></info>");
17981  }
17982  else
17983  SENDF_TO_CLIENT_OR_FAIL
17984  ("<info><scanner><name/><version/></scanner>"
17985  "<daemon><name/><version/></daemon>"
17986  "<protocol><name/><version/></protocol><description/><params/>"
17987  "</info>");
17988  g_free (s_name);
17989  g_free (s_ver);
17990  g_free (d_name);
17991  g_free (d_ver);
17992  g_free (p_name);
17993  g_free (p_ver);
17994  g_free (desc);
17995  g_slist_free (params);
17996  }
17997  else if (get_scanners_data->get.details)
17998  {
17999  SENDF_TO_CLIENT_OR_FAIL
18000  ("<info><scanner><name>OpenVAS</name><version/></scanner>"
18001  "<daemon><name/><version/></daemon>"
18002  "<protocol><name/><version/></protocol><description/><params/>"
18003  "</info>");
18004  }
18005  SEND_TO_CLIENT_OR_FAIL ("</scanner>");
18006  }
18007  cleanup_iterator (&scanners);
18008  filtered = get_scanners_data->get.id
18010  SEND_GET_END ("scanner", &get_scanners_data->get, count, filtered);
18011  get_scanners_data_reset (get_scanners_data);
18012  set_client_state (CLIENT_AUTHENTIC);
18013 }
18014 
18021 static void
18022 handle_get_schedules (omp_parser_t *omp_parser, GError **error)
18023 {
18025  SEND_TO_CLIENT_OR_FAIL
18026  (XML_ERROR_SYNTAX ("get_schedules",
18027  "GET_SCHEDULES tasks given with trash"));
18028  else
18029  {
18030  iterator_t schedules;
18031  int count, filtered, ret, first;
18032 
18033  INIT_GET (schedule, Schedule);
18034 
18035  ret = init_schedule_iterator (&schedules, &get_schedules_data->get);
18036  if (ret)
18037  {
18038  switch (ret)
18039  {
18040  case 1:
18041  if (send_find_error_to_client ("get_schedules",
18042  "schedule",
18044  omp_parser))
18045  {
18046  error_send_to_client (error);
18047  return;
18048  }
18049  break;
18050  case 2:
18051  if (send_find_error_to_client
18052  ("get_schedules", "filter",
18053  get_schedules_data->get.filt_id, omp_parser))
18054  {
18055  error_send_to_client (error);
18056  return;
18057  }
18058  break;
18059  case -1:
18060  SEND_TO_CLIENT_OR_FAIL
18061  (XML_INTERNAL_ERROR ("get_schedules"));
18062  break;
18063  }
18064  get_schedules_data_reset (get_schedules_data);
18065  set_client_state (CLIENT_AUTHENTIC);
18066  return;
18067  }
18068 
18069  SEND_GET_START ("schedule");
18070  while (1)
18071  {
18072  time_t first_time, next_time;
18073  gchar *iso;
18074  const char *timezone, *abbrev;
18075  char *simple_period_unit, *simple_duration_unit;
18076  int period, period_minutes, period_hours, period_days;
18077  int period_weeks, period_months, duration, duration_minutes;
18078  int duration_hours, duration_days, duration_weeks;
18079  int simple_period, simple_duration;
18080 
18081  ret = get_next (&schedules, &get_schedules_data->get, &first,
18082  &count, init_schedule_iterator);
18083  if (ret == 1)
18084  break;
18085  if (ret == -1)
18086  {
18087  internal_error_send_to_client (error);
18088  return;
18089  }
18090 
18091  SEND_GET_COMMON (schedule, &get_schedules_data->get, &schedules);
18092 
18093  timezone = schedule_iterator_timezone (&schedules);
18094  first_time = schedule_iterator_first_time (&schedules);
18095  next_time = schedule_iterator_next_time (&schedules);
18096 
18097  /* Duplicate static string because there's an iso_time_tz below. */
18098  abbrev = NULL;
18099  iso = g_strdup (iso_time_tz (&first_time, timezone, &abbrev));
18100 
18101  period = schedule_iterator_period (&schedules);
18102  if (period)
18103  {
18104  period_minutes = period / 60;
18105  period_hours = period_minutes / 60;
18106  period_days = period_hours / 24;
18107  period_weeks = period_days / 7;
18108  }
18109  simple_period_unit = "";
18110  if (period == 0)
18111  simple_period = 0;
18112  else if (period_weeks && (period % (60 * 60 * 24 * 7) == 0))
18113  {
18114  simple_period = period_weeks;
18115  simple_period_unit = "week";
18116  }
18117  else if (period_days && (period % (60 * 60 * 24) == 0))
18118  {
18119  simple_period = period_days;
18120  simple_period_unit = "day";
18121  }
18122  else if (period_hours && (period % (60 * 60) == 0))
18123  {
18124  simple_period = period_hours;
18125  simple_period_unit = "hour";
18126  }
18127  /* The granularity of the "simple" GSA interface stops at hours. */
18128  else
18129  simple_period = 0;
18130 
18131  period_months = schedule_iterator_period_months (&schedules);
18132  if (period_months && (period_months < 25))
18133  {
18134  simple_period = period_months;
18135  simple_period_unit = "month";
18136  }
18137 
18138  duration = schedule_iterator_duration (&schedules);
18139  if (duration)
18140  {
18141  duration_minutes = duration / 60;
18142  duration_hours = duration_minutes / 60;
18143  duration_days = duration_hours / 24;
18144  duration_weeks = duration_days / 7;
18145  }
18146  simple_duration_unit = "";
18147  if (duration == 0)
18148  simple_duration = 0;
18149  else if (duration_weeks
18150  && (duration % (60 * 60 * 24 * 7) == 0))
18151  {
18152  simple_duration = duration_weeks;
18153  simple_duration_unit = "week";
18154  }
18155  else if (duration_days
18156  && (duration % (60 * 60 * 24) == 0))
18157  {
18158  simple_duration = duration_days;
18159  simple_duration_unit = "day";
18160  }
18161  else if (duration_hours
18162  && (duration % (60 * 60) == 0))
18163  {
18164  simple_duration = duration_hours;
18165  simple_duration_unit = "hour";
18166  }
18167  /* The granularity of the "simple" GSA interface stops at hours. */
18168  else
18169  simple_duration = 0;
18170 
18171  SENDF_TO_CLIENT_OR_FAIL
18172  ("<first_time>%s</first_time>"
18173  "<next_time>%s</next_time>"
18174  "<period>%ld</period>"
18175  "<period_months>%ld</period_months>"
18176  "<simple_period>%i<unit>%s</unit></simple_period>"
18177  "<duration>%ld</duration>"
18178  "<simple_duration>%i<unit>%s</unit></simple_duration>"
18179  "<timezone>%s</timezone>"
18180  "<timezone_abbrev>%s</timezone_abbrev>",
18181  iso,
18182  (next_time == 0 ? "over" : iso_time_tz (&next_time, timezone, NULL)),
18183  schedule_iterator_period (&schedules),
18184  schedule_iterator_period_months (&schedules),
18185  simple_period,
18186  simple_period_unit,
18187  schedule_iterator_duration (&schedules),
18188  simple_duration,
18189  simple_duration_unit,
18190  schedule_iterator_timezone (&schedules)
18191  ? schedule_iterator_timezone (&schedules)
18192  : "UTC",
18193  abbrev ? abbrev : "UTC");
18194 
18195  g_free (iso);
18197  {
18198  iterator_t tasks;
18199 
18200  SEND_TO_CLIENT_OR_FAIL ("<tasks>");
18203  (&schedules));
18204  while (next (&tasks))
18205  {
18206  SENDF_TO_CLIENT_OR_FAIL ("<task id=\"%s\">"
18207  "<name>%s</name>",
18208  schedule_task_iterator_uuid (&tasks),
18210  (&tasks));
18211  if (schedule_task_iterator_readable (&tasks))
18212  SEND_TO_CLIENT_OR_FAIL ("</task>");
18213  else
18214  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
18215  "</task>");
18216  }
18217  cleanup_iterator (&tasks);
18218  SEND_TO_CLIENT_OR_FAIL ("</tasks>");
18219  }
18220  SEND_TO_CLIENT_OR_FAIL ("</schedule>");
18221  count++;
18222  }
18223  cleanup_iterator (&schedules);
18224  filtered = get_schedules_data->get.id
18225  ? 1
18227  SEND_GET_END ("schedule", &get_schedules_data->get, count, filtered);
18228  }
18229  get_schedules_data_reset (get_schedules_data);
18230  set_client_state (CLIENT_AUTHENTIC);
18231 }
18232 
18239 static void
18240 handle_get_settings (omp_parser_t *omp_parser, GError **error)
18241 {
18242  setting_t setting = 0;
18243  iterator_t settings;
18244  int count, filtered;
18245 
18246  if (acl_user_may ("get_settings") == 0)
18247  {
18248  SEND_TO_CLIENT_OR_FAIL
18249  (XML_ERROR_SYNTAX ("get_settings",
18250  "Permission denied"));
18251  get_settings_data_reset (get_settings_data);
18252  set_client_state (CLIENT_AUTHENTIC);
18253  return;
18254  }
18255 
18256  init_setting_iterator (&settings,
18263 
18264  SEND_TO_CLIENT_OR_FAIL ("<get_settings_response"
18265  " status=\"" STATUS_OK "\""
18266  " status_text=\"" STATUS_OK_TEXT "\">");
18267  SENDF_TO_CLIENT_OR_FAIL ("<filters>"
18268  "<term>%s</term>"
18269  "</filters>"
18270  "<settings start=\"%i\" max=\"%i\"/>",
18273  : "",
18274  /* Add 1 for 1 indexing. */
18275  get_settings_data->first + 1,
18277  count = 0;
18278  while (next (&settings))
18279  {
18280  SENDF_TO_CLIENT_OR_FAIL ("<setting id=\"%s\">"
18281  "<name>%s</name>"
18282  "<comment>%s</comment>"
18283  "<value>%s</value>",
18284  setting_iterator_uuid (&settings),
18285  setting_iterator_name (&settings),
18286  setting_iterator_comment (&settings),
18287  setting_iterator_value (&settings));
18288 
18290  && setting_iterator_value (&settings)
18291  && strlen (setting_iterator_value (&settings)))
18292  {
18293  time_t activation_time, expiration_time;
18294  gchar *activation_time_str, *expiration_time_str, *fingerprint;
18295  gchar *issuer;
18296 
18298  &activation_time,
18299  &expiration_time, &fingerprint,
18300  &issuer);
18301  activation_time_str = certificate_iso_time (activation_time);
18302  expiration_time_str = certificate_iso_time (expiration_time);
18303  SENDF_TO_CLIENT_OR_FAIL
18304  ("<certificate_info>"
18305  "<time_status>%s</time_status>"
18306  "<activation_time>%s</activation_time>"
18307  "<expiration_time>%s</expiration_time>"
18308  "<md5_fingerprint>%s</md5_fingerprint>"
18309  "<issuer>%s</issuer>"
18310  "</certificate_info>",
18311  certificate_time_status (activation_time, expiration_time),
18312  activation_time_str,
18313  expiration_time_str,
18314  fingerprint,
18315  issuer);
18316  g_warning ("free");
18317  g_free (activation_time_str);
18318  g_free (expiration_time_str);
18319  g_free (fingerprint);
18320  g_free (issuer);
18321  }
18322 
18323  SEND_TO_CLIENT_OR_FAIL ("</setting>");
18324 
18325  count++;
18326  }
18327  filtered = setting
18328  ? 1
18330  SENDF_TO_CLIENT_OR_FAIL ("<setting_count>"
18331  "<filtered>%i</filtered>"
18332  "<page>%i</page>"
18333  "</setting_count>",
18334  filtered,
18335  count);
18336  cleanup_iterator (&settings);
18337  SEND_TO_CLIENT_OR_FAIL ("</get_settings_response>");
18338 
18339  get_settings_data_reset (get_settings_data);
18340  set_client_state (CLIENT_AUTHENTIC);
18341 }
18342 
18349 static void
18350 handle_get_system_reports (omp_parser_t *omp_parser, GError **error)
18351 {
18352  int ret;
18353  report_type_iterator_t types;
18354 
18356  (&types,
18359  switch (ret)
18360  {
18361  case 1:
18362  if (send_find_error_to_client ("get_system_reports",
18363  "system report",
18365  omp_parser))
18366  {
18367  error_send_to_client (error);
18368  return;
18369  }
18370  break;
18371  case 2:
18372  if (send_find_error_to_client
18373  ("get_system_reports", "slave",
18374  get_system_reports_data->slave_id, omp_parser))
18375  {
18376  error_send_to_client (error);
18377  return;
18378  }
18379  break;
18380  case 4:
18381  SEND_TO_CLIENT_OR_FAIL
18382  (XML_ERROR_UNAVAILABLE ("get_system_reports",
18383  "Could not connect to slave"));
18384  break;
18385  case 5:
18386  SEND_TO_CLIENT_OR_FAIL
18387  (XML_ERROR_UNAVAILABLE ("get_system_reports",
18388  "Authentication to slave failed"));
18389  break;
18390  case 6:
18391  SEND_TO_CLIENT_OR_FAIL
18392  (XML_ERROR_UNAVAILABLE ("get_system_reports",
18393  "Failed to get system report from slave"));
18394  break;
18395  case 99:
18396  SEND_TO_CLIENT_OR_FAIL
18397  (XML_ERROR_SYNTAX ("get_system_reports",
18398  "Permission denied"));
18399  break;
18400  default:
18401  assert (0);
18402  /* fallthrough */
18403  case -1:
18404  SEND_TO_CLIENT_OR_FAIL
18405  (XML_INTERNAL_ERROR ("get_system_reports"));
18406  break;
18407  case 0:
18408  case 3:
18409  {
18410  int report_ret;
18411  char *report;
18412  SEND_TO_CLIENT_OR_FAIL ("<get_system_reports_response"
18413  " status=\"" STATUS_OK "\""
18414  " status_text=\"" STATUS_OK_TEXT "\">");
18415  while (next_report_type (&types))
18417  && (ret != 3))
18418  SENDF_TO_CLIENT_OR_FAIL
18419  ("<system_report>"
18420  "<name>%s</name>"
18421  "<title>%s</title>"
18422  "</system_report>",
18423  report_type_iterator_name (&types),
18424  report_type_iterator_title (&types));
18425  else if ((report_ret = manage_system_report
18426  (report_type_iterator_name (&types),
18431  &report))
18432  && (report_ret != 3))
18433  {
18435  internal_error_send_to_client (error);
18436  return;
18437  }
18438  else if (report)
18439  {
18440  SENDF_TO_CLIENT_OR_FAIL
18441  ("<system_report>"
18442  "<name>%s</name>"
18443  "<title>%s</title>"
18444  "<report format=\"%s\""
18445  " start_time=\"%s\" end_time=\"%s\""
18446  " duration=\"%s\">"
18447  "%s"
18448  "</report>"
18449  "</system_report>",
18450  report_type_iterator_name (&types),
18451  report_type_iterator_title (&types),
18452  (ret == 3 ? "txt" : "png"),
18461  ? ""
18462  : "86400",
18463  report);
18464  free (report);
18465  }
18467  SEND_TO_CLIENT_OR_FAIL ("</get_system_reports_response>");
18468  }
18469  }
18470 
18471  get_system_reports_data_reset (get_system_reports_data);
18472  set_client_state (CLIENT_AUTHENTIC);
18473 }
18474 
18481 static void
18482 handle_get_tags (omp_parser_t *omp_parser, GError **error)
18483 {
18484  iterator_t tags;
18485  int ret, count, first, filtered;
18486 
18487  INIT_GET (tag, Tag);
18488 
18490  ret = init_tag_name_iterator (&tags, &get_tags_data->get);
18491  else
18492  ret = init_tag_iterator (&tags, &get_tags_data->get);
18493 
18494  if (ret)
18495  {
18496  switch (ret)
18497  {
18498  case 1:
18499  if (send_find_error_to_client ("get_tags",
18500  "tag", get_tags_data->get.id,
18501  omp_parser))
18502  {
18503  error_send_to_client (error);
18504  return;
18505  }
18506  break;
18507  case 2:
18508  if (send_find_error_to_client
18509  ("get_tags", "filter", get_tags_data->get.filt_id,
18510  omp_parser))
18511  {
18512  error_send_to_client (error);
18513  return;
18514  }
18515  break;
18516  default:
18517  SEND_TO_CLIENT_OR_FAIL
18518  (XML_INTERNAL_ERROR ("get_tags"));
18519  }
18520  get_tags_data_reset (get_tags_data);
18521  set_client_state (CLIENT_AUTHENTIC);
18522  return;
18523  }
18524 
18525  SEND_GET_START ("tag");
18526  while (1)
18527  {
18528  ret = get_next (&tags, &get_tags_data->get, &first, &count,
18531  : init_tag_iterator);
18532  if (ret == 1)
18533  break;
18534  if (ret == -1)
18535  {
18536  internal_error_send_to_client (error);
18537  return;
18538  }
18539 
18541  SENDF_TO_CLIENT_OR_FAIL ("<tag>"
18542  "<name>%s</name>"
18543  "</tag>",
18544  tag_name_iterator_name (&tags));
18545  else
18546  {
18547  gchar* value;
18548 
18549  value = g_markup_escape_text (tag_iterator_value (&tags), -1);
18550 
18551  SEND_GET_COMMON (tag, &get_tags_data->get, &tags);
18552 
18553  SENDF_TO_CLIENT_OR_FAIL ("<resource id=\"%s\">"
18554  "<type>%s</type>"
18555  "<name>%s</name>"
18556  "<trash>%d</trash>",
18561 
18562  if (tag_iterator_resource_readable (&tags) == 0)
18563  SENDF_TO_CLIENT_OR_FAIL ("<permissions/>");
18564 
18565 
18566  SENDF_TO_CLIENT_OR_FAIL ("</resource>"
18567  "<value>%s</value>"
18568  "<active>%d</active>"
18569  "<orphan>%d</orphan>"
18570  "</tag>",
18571  value,
18572  tag_iterator_active (&tags),
18573  tag_iterator_orphan (&tags));
18574  g_free (value);
18575  }
18576  count++;
18577  }
18578  cleanup_iterator (&tags);
18579  filtered = get_tags_data->get.id
18580  ? 1
18581  : tag_count (&get_tags_data->get);
18582  SEND_GET_END ("tag", &get_tags_data->get, count, filtered);
18583 
18584  get_tags_data_reset (get_tags_data);
18585  set_client_state (CLIENT_AUTHENTIC);
18586 }
18587 
18594 static void
18595 handle_get_targets (omp_parser_t *omp_parser, GError **error)
18596 {
18598  SEND_TO_CLIENT_OR_FAIL
18599  (XML_ERROR_SYNTAX ("get_target",
18600  "GET_TARGETS tasks given with trash"));
18601  else
18602  {
18603  iterator_t targets;
18604  int count, filtered, ret, first;
18605 
18606  INIT_GET (target, Target);
18607 
18608  ret = init_target_iterator (&targets, &get_targets_data->get);
18609  if (ret)
18610  {
18611  switch (ret)
18612  {
18613  case 1:
18614  if (send_find_error_to_client ("get_targets",
18615  "target",
18617  omp_parser))
18618  {
18619  error_send_to_client (error);
18620  return;
18621  }
18622  break;
18623  case 2:
18624  if (send_find_error_to_client
18625  ("get_targets", "filter",
18626  get_targets_data->get.filt_id, omp_parser))
18627  {
18628  error_send_to_client (error);
18629  return;
18630  }
18631  break;
18632  case -1:
18633  SEND_TO_CLIENT_OR_FAIL
18634  (XML_INTERNAL_ERROR ("get_targets"));
18635  break;
18636  }
18637  get_targets_data_reset (get_targets_data);
18638  set_client_state (CLIENT_AUTHENTIC);
18639  return;
18640  }
18641 
18642  SEND_GET_START ("target");
18643  while (1)
18644  {
18645  char *ssh_name, *ssh_uuid, *smb_name, *smb_uuid;
18646  char *esxi_name, *esxi_uuid, *snmp_name, *snmp_uuid;
18647  const char *port_list_uuid, *port_list_name, *ssh_port;
18648  const char *hosts, *exclude_hosts, *reverse_lookup_only;
18649  const char *reverse_lookup_unify;
18650  credential_t ssh_credential, smb_credential;
18651  credential_t esxi_credential, snmp_credential;
18652  int port_list_trash, max_hosts, port_list_available;
18653  int ssh_credential_available;
18654  int smb_credential_available;
18655  int esxi_credential_available;
18656  int snmp_credential_available;
18657 
18658  ret = get_next (&targets, &get_targets_data->get, &first,
18659  &count, init_target_iterator);
18660  if (ret == 1)
18661  break;
18662  if (ret == -1)
18663  {
18664  internal_error_send_to_client (error);
18665  return;
18666  }
18667 
18668  ssh_credential = target_iterator_ssh_credential (&targets);
18669  smb_credential = target_iterator_smb_credential (&targets);
18670  esxi_credential = target_iterator_esxi_credential (&targets);
18671  snmp_credential = target_iterator_snmp_credential (&targets);
18672  ssh_credential_available = 1;
18674  && target_iterator_ssh_trash (&targets))
18675  {
18676  ssh_name = trash_credential_name (ssh_credential);
18677  ssh_uuid = trash_credential_uuid (ssh_credential);
18678  ssh_credential_available
18679  = trash_credential_readable (ssh_credential);
18680  }
18681  else if (ssh_credential)
18682  {
18683  credential_t found;
18684 
18685  ssh_name = credential_name (ssh_credential);
18686  ssh_uuid = credential_uuid (ssh_credential);
18688  (ssh_uuid,
18689  &found,
18690  "get_credentials"))
18691  abort ();
18692  ssh_credential_available = (found > 0);
18693  }
18694  else
18695  {
18696  ssh_name = NULL;
18697  ssh_uuid = NULL;
18698  }
18699  smb_credential_available = 1;
18701  && target_iterator_smb_trash (&targets))
18702  {
18703  smb_name = trash_credential_name (smb_credential);
18704  smb_uuid = trash_credential_uuid (smb_credential);
18705  smb_credential_available
18706  = trash_credential_readable (smb_credential);
18707  }
18708  else if (smb_credential)
18709  {
18710  credential_t found;
18711 
18712  smb_name = credential_name (smb_credential);
18713  smb_uuid = credential_uuid (smb_credential);
18715  (smb_uuid,
18716  &found,
18717  "get_credentials"))
18718  abort ();
18719  smb_credential_available = (found > 0);
18720  }
18721  else
18722  {
18723  smb_name = NULL;
18724  smb_uuid = NULL;
18725  }
18726  esxi_credential_available = 1;
18728  && target_iterator_esxi_trash (&targets))
18729  {
18730  esxi_name
18731  = trash_credential_name (esxi_credential);
18732  esxi_uuid
18733  = trash_credential_uuid (esxi_credential);
18734  esxi_credential_available
18735  = trash_credential_readable (esxi_credential);
18736  }
18737  else if (esxi_credential)
18738  {
18739  credential_t found;
18740 
18741  esxi_name = credential_name (esxi_credential);
18742  esxi_uuid = credential_uuid (esxi_credential);
18744  (esxi_uuid,
18745  &found,
18746  "get_credentials"))
18747  abort ();
18748  esxi_credential_available = (found > 0);
18749  }
18750  else
18751  {
18752  esxi_name = NULL;
18753  esxi_uuid = NULL;
18754  }
18755  snmp_credential_available = 1;
18757  && target_iterator_snmp_trash (&targets))
18758  {
18759  snmp_name
18760  = trash_credential_name (snmp_credential);
18761  snmp_uuid
18762  = trash_credential_uuid (snmp_credential);
18763  snmp_credential_available
18764  = trash_credential_readable (snmp_credential);
18765  }
18766  else if (snmp_credential)
18767  {
18768  credential_t found;
18769 
18770  snmp_name = credential_name (snmp_credential);
18771  snmp_uuid = credential_uuid (snmp_credential);
18773  (snmp_uuid,
18774  &found,
18775  "get_credentials"))
18776  abort ();
18777  snmp_credential_available = (found > 0);
18778  }
18779  else
18780  {
18781  snmp_name = NULL;
18782  snmp_uuid = NULL;
18783  }
18785  port_list_name = target_iterator_port_list_name (&targets);
18786  port_list_trash = target_iterator_port_list_trash (&targets);
18787  ssh_port = target_iterator_ssh_port (&targets);
18788 
18789  port_list_available = 1;
18790  if (port_list_trash)
18791  port_list_available = trash_port_list_readable_uuid
18792  (port_list_uuid);
18793  else if (port_list_uuid)
18794  {
18795  port_list_t found;
18797  &found,
18798  "get_port_lists"))
18799  abort ();
18800  port_list_available = (found > 0);
18801  }
18802 
18803  SEND_GET_COMMON (target, &get_targets_data->get, &targets);
18804 
18805  hosts = target_iterator_hosts (&targets);
18806  exclude_hosts = target_iterator_exclude_hosts (&targets);
18807  max_hosts = manage_count_hosts_max (hosts, exclude_hosts, 0);
18808  reverse_lookup_only = target_iterator_reverse_lookup_only
18809  (&targets);
18810  reverse_lookup_unify = target_iterator_reverse_lookup_unify
18811  (&targets);
18812 
18813  SENDF_TO_CLIENT_OR_FAIL ("<hosts>%s</hosts>"
18814  "<exclude_hosts>%s</exclude_hosts>"
18815  "<max_hosts>%i</max_hosts>"
18816  "<port_list id=\"%s\">"
18817  "<name>%s</name>"
18818  "<trash>%i</trash>",
18819  hosts,
18820  exclude_hosts ? exclude_hosts : "",
18821  max_hosts,
18823  port_list_name ? port_list_name : "",
18824  port_list_trash);
18825 
18826  if (port_list_available == 0)
18827  SEND_TO_CLIENT_OR_FAIL ("<permissions/>");
18828 
18829  SENDF_TO_CLIENT_OR_FAIL ("</port_list>"
18830  "<ssh_credential id=\"%s\">"
18831  "<name>%s</name>"
18832  "<port>%s</port>"
18833  "<trash>%i</trash>",
18834  ssh_uuid ? ssh_uuid : "",
18835  ssh_name ? ssh_name : "",
18836  ssh_port ? ssh_port : "",
18838  && target_iterator_ssh_trash (&targets)));
18839 
18840  if (ssh_credential_available == 0)
18841  SEND_TO_CLIENT_OR_FAIL ("<permissions/>");
18842 
18843  SENDF_TO_CLIENT_OR_FAIL ("</ssh_credential>"
18844  "<smb_credential id=\"%s\">"
18845  "<name>%s</name>"
18846  "<trash>%i</trash>",
18847  smb_uuid ? smb_uuid : "",
18848  smb_name ? smb_name : "",
18850  && target_iterator_smb_trash (&targets)));
18851 
18852  if (smb_credential_available == 0)
18853  SEND_TO_CLIENT_OR_FAIL ("<permissions/>");
18854 
18855  SENDF_TO_CLIENT_OR_FAIL ("</smb_credential>"
18856  "<esxi_credential id=\"%s\">"
18857  "<name>%s</name>"
18858  "<trash>%i</trash>",
18859  esxi_uuid ? esxi_uuid : "",
18860  esxi_name ? esxi_name : "",
18862  && target_iterator_esxi_trash (&targets)));
18863 
18864  if (esxi_credential_available == 0)
18865  SEND_TO_CLIENT_OR_FAIL ("<permissions/>");
18866 
18867  SENDF_TO_CLIENT_OR_FAIL ("</esxi_credential>"
18868  "<snmp_credential id=\"%s\">"
18869  "<name>%s</name>"
18870  "<trash>%i</trash>",
18871  snmp_uuid ? snmp_uuid : "",
18872  snmp_name ? snmp_name : "",
18874  && target_iterator_snmp_trash (&targets)));
18875 
18876  if (snmp_credential_available == 0)
18877  SEND_TO_CLIENT_OR_FAIL ("<permissions/>");
18878 
18879  SENDF_TO_CLIENT_OR_FAIL ("</snmp_credential>"
18880  "<reverse_lookup_only>"
18881  "%s"
18882  "</reverse_lookup_only>"
18883  "<reverse_lookup_unify>"
18884  "%s"
18885  "</reverse_lookup_unify>"
18886  "<alive_tests>%s</alive_tests>",
18887  reverse_lookup_only,
18888  reverse_lookup_unify,
18889  target_iterator_alive_tests (&targets));
18890 
18892  SENDF_TO_CLIENT_OR_FAIL ("<port_range>%s</port_range>",
18894  (get_iterator_resource (&targets)));
18895 
18896  if (get_targets_data->tasks)
18897  {
18898  iterator_t tasks;
18899 
18900  SEND_TO_CLIENT_OR_FAIL ("<tasks>");
18901  init_target_task_iterator (&tasks,
18902  get_iterator_resource (&targets));
18903  while (next (&tasks))
18904  {
18905  if (target_task_iterator_readable (&tasks) == 0)
18906  /* Only show tasks the user may see. */
18907  continue;
18908 
18909  SENDF_TO_CLIENT_OR_FAIL ("<task id=\"%s\">"
18910  "<name>%s</name>",
18911  target_task_iterator_uuid (&tasks),
18912  target_task_iterator_name (&tasks));
18913  if (target_task_iterator_readable (&tasks))
18914  SEND_TO_CLIENT_OR_FAIL ("</task>");
18915  else
18916  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
18917  "</task>");
18918  }
18919  cleanup_iterator (&tasks);
18920  SEND_TO_CLIENT_OR_FAIL ("</tasks>");
18921  }
18922 
18923  SEND_TO_CLIENT_OR_FAIL ("</target>");
18924  count++;
18925  free (ssh_name);
18926  free (ssh_uuid);
18927  free (smb_name);
18928  free (smb_uuid);
18929  free (esxi_name);
18930  free (esxi_uuid);
18931  }
18932  cleanup_iterator (&targets);
18933  filtered = get_targets_data->get.id
18934  ? 1
18936  SEND_GET_END ("target", &get_targets_data->get, count, filtered);
18937  }
18938  get_targets_data_reset (get_targets_data);
18939  set_client_state (CLIENT_AUTHENTIC);
18940 }
18941 
18948 static void
18949 handle_get_tasks (omp_parser_t *omp_parser, GError **error)
18950 {
18951  iterator_t tasks;
18952  int count, filtered, ret, first;
18953  get_data_t *get;
18954  const char *filter;
18955  gchar *overrides, *min_qod_str, *clean_filter;
18956  int apply_overrides, min_qod;
18957 
18959  {
18960  SEND_TO_CLIENT_OR_FAIL
18961  (XML_ERROR_SYNTAX ("get_task",
18962  "GET_TASKS details given with trash"));
18963  get_tasks_data_reset (get_tasks_data);
18964  set_client_state (CLIENT_AUTHENTIC);
18965  return;
18966  }
18967 
18968  INIT_GET (task, Task);
18969 
18971  ret = init_task_iterator (&tasks, &get_tasks_data->get);
18972  if (ret)
18973  {
18974  switch (ret)
18975  {
18976  case 1:
18977  if (send_find_error_to_client ("get_tasks",
18978  "task",
18980  omp_parser))
18981  {
18982  error_send_to_client (error);
18983  return;
18984  }
18985  break;
18986  case 2:
18987  if (send_find_error_to_client
18988  ("get_tasks", "task", get_tasks_data->get.filt_id,
18989  omp_parser))
18990  {
18991  error_send_to_client (error);
18992  return;
18993  }
18994  break;
18995  case -1:
18996  SEND_TO_CLIENT_OR_FAIL
18997  (XML_INTERNAL_ERROR ("get_tasks"));
18998  break;
18999  }
19000  get_tasks_data_reset (get_tasks_data);
19001  set_client_state (CLIENT_AUTHENTIC);
19002  return;
19003  }
19004 
19005  SEND_GET_START ("task");
19006 
19007  get = &get_tasks_data->get;
19008  if (get->filt_id && strcmp (get->filt_id, "0"))
19009  {
19010  filter = filter_term (get->filt_id);
19011  if (filter == NULL)
19012  {
19013  error_send_to_client (error);
19014  return;
19015  }
19016  }
19017  else
19018  filter = NULL;
19019  clean_filter = manage_clean_filter (filter ? filter : get->filter);
19020  overrides = filter_term_value (clean_filter, "apply_overrides");
19021  min_qod_str = filter_term_value (clean_filter, "min_qod");
19022  g_free (clean_filter);
19023  apply_overrides = overrides
19024  ? strcmp (overrides, "0")
19026  g_free (overrides);
19027  if (min_qod_str == NULL
19028  || sscanf (min_qod_str, "%d", &min_qod) != 1)
19029  min_qod = MIN_QOD_DEFAULT;
19030  SENDF_TO_CLIENT_OR_FAIL ("<apply_overrides>%i</apply_overrides>",
19031  apply_overrides);
19032 
19033  while (1)
19034  {
19035  task_t index;
19036  gchar *progress_xml;
19037  target_t target;
19038  scanner_t scanner;
19039  const char *first_report_id, *last_report_id;
19040  char *config_name, *config_uuid;
19041  gchar *config_name_escaped;
19042  char *task_target_uuid, *task_target_name;
19043  gchar *task_target_name_escaped;
19044  char *task_schedule_uuid, *task_schedule_name;
19045  gchar *task_schedule_name_escaped;
19046  char *task_scanner_uuid, *task_scanner_name;
19047  gchar *task_scanner_name_escaped;
19048  gchar *first_report, *last_report;
19049  gchar *second_last_report_id, *second_last_report;
19050  gchar *current_report;
19051  report_t running_report;
19052  schedule_t schedule;
19053  time_t next_time;
19054  char *owner, *observers;
19055  int target_in_trash, schedule_in_trash, scanner_in_trash;
19056  int debugs, holes = 0, infos = 0, logs, warnings = 0;
19057  int holes_2 = 0, infos_2 = 0, warnings_2 = 0;
19058  int false_positives, task_scanner_type;
19059  int schedule_available, target_available, config_available;
19060  int scanner_available;
19061  double severity = 0, severity_2 = 0;
19062  gchar *response;
19063  iterator_t alerts, groups, roles;
19064  gchar *in_assets, *max_checks, *max_hosts, *source_iface;
19065  gchar *auto_delete, *auto_delete_data, *assets_apply_overrides;
19066  gchar *assets_min_qod;
19067 
19068  ret = get_next (&tasks, &get_tasks_data->get, &first, &count,
19070  if (ret == 1)
19071  break;
19072  if (ret == -1)
19073  {
19074  internal_error_send_to_client (error);
19075  return;
19076  }
19077 
19078  index = get_iterator_resource (&tasks);
19079  target = task_target (index);
19080 
19082  {
19083  SENDF_TO_CLIENT_OR_FAIL ("<task id=\"%s\">"
19084  "<name>%s</name>",
19085  get_iterator_uuid (&tasks),
19086  get_iterator_name (&tasks));
19087 
19088  schedule_available = 1;
19089  schedule = task_schedule (index);
19090  if (schedule)
19091  {
19092  schedule_in_trash = task_schedule_in_trash (index);
19093  if (schedule_in_trash)
19094  {
19095  task_schedule_uuid = schedule_uuid (schedule);
19096  task_schedule_name = schedule_name (schedule);
19097  schedule_available = trash_schedule_readable (schedule);
19098  }
19099  else
19100  {
19101  schedule_t found;
19102  task_schedule_uuid = schedule_uuid (schedule);
19103  task_schedule_name = schedule_name (schedule);
19105  &found,
19106  "get_schedules"))
19107  g_error ("%s: GET_TASKS: error finding"
19108  " task schedule, aborting",
19109  __FUNCTION__);
19110  schedule_available = (found > 0);
19111  }
19112  }
19113  else
19114  {
19115  task_schedule_uuid = (char*) g_strdup ("");
19116  task_schedule_name = (char*) g_strdup ("");
19117  schedule_in_trash = 0;
19118  }
19119 
19120  if (schedule_available && schedule)
19121  {
19122  time_t first_time, next_time;
19123  int period, period_months, duration;
19124 
19125  if (schedule_info (schedule, &first_time, &next_time, &period,
19126  &period_months, &duration) == 0)
19127  SENDF_TO_CLIENT_OR_FAIL ("<schedule id=\"%s\">"
19128  "<name>%s</name>"
19129  "<next_time>%s</next_time>"
19130  "<trash>%d</trash>"
19131  "<first_time>%s</first_time>"
19132  "<period>%d</period>"
19133  "<period_months>"
19134  "%d"
19135  "</period_months>"
19136  "<duration>%d</duration>"
19137  "</schedule>"
19138  "<schedule_periods>"
19139  "%d"
19140  "</schedule_periods>",
19142  task_schedule_name,
19143  next_time
19144  ? iso_time (&next_time)
19145  : "over",
19146  schedule_in_trash,
19147  first_time
19148  ? iso_time (&first_time)
19149  : "",
19150  period,
19151  period_months,
19152  duration,
19153  task_schedule_periods (index));
19154  }
19155  else
19156  {
19158 
19159  SENDF_TO_CLIENT_OR_FAIL ("<schedule id=\"%s\">"
19160  "<name>%s</name>"
19161  "<next_time>%s</next_time>"
19162  "<trash>%d</trash>"
19163  "</schedule>",
19165  task_schedule_name,
19166  next_time
19167  ? iso_time (&next_time)
19168  : "over",
19169  schedule_in_trash);
19170  }
19171 
19172  SENDF_TO_CLIENT_OR_FAIL ("</task>");
19173 
19174  }
19175  else
19176  {
19177  SEND_GET_COMMON (task, &get_tasks_data->get, &tasks);
19178  target_in_trash = task_target_in_trash (index);
19179  if ((target == 0)
19180  && (task_iterator_run_status (&tasks)
19181  == TASK_STATUS_RUNNING))
19182  {
19183  progress_xml = g_strdup_printf
19184  ("%i",
19185  task_upload_progress (index));
19186  running_report = 0;
19187  }
19188  else
19189  {
19190  int progress;
19191  gchar *host_xml;
19192 
19193  running_report = task_iterator_current_report (&tasks);
19194  progress
19195  = report_progress (running_report, index, &host_xml);
19196  progress_xml
19197  = g_strdup_printf ("%i%s", progress, host_xml);
19198  g_free (host_xml);
19199  }
19200 
19201  if (running_report)
19202  {
19203  gchar *timestamp;
19204  char *scan_start, *scan_end, *current_report_id;
19205 
19206  current_report_id = report_uuid (running_report);
19207 
19208  if (report_timestamp (current_report_id, &timestamp))
19209  g_error ("%s: GET_TASKS: error getting timestamp"
19210  " of report, aborting",
19211  __FUNCTION__);
19212 
19213  scan_start = scan_start_time_uuid (current_report_id),
19214  scan_end = scan_end_time_uuid (current_report_id),
19215 
19216  current_report = g_strdup_printf ("<current_report>"
19217  "<report id=\"%s\">"
19218  "<timestamp>"
19219  "%s"
19220  "</timestamp>"
19221  "<scan_start>"
19222  "%s"
19223  "</scan_start>"
19224  "<scan_end>"
19225  "%s"
19226  "</scan_end>"
19227  "</report>"
19228  "</current_report>",
19229  current_report_id,
19230  timestamp,
19231  scan_start,
19232  scan_end);
19233  free (current_report_id);
19234  free (scan_start);
19235  free (scan_end);
19236  g_free (timestamp);
19237  }
19238  else
19239  current_report = g_strdup ("");
19240 
19241  first_report_id = task_iterator_first_report (&tasks);
19242  if (first_report_id)
19243  {
19244  gchar *timestamp;
19245  char *scan_start, *scan_end;
19246 
19247  // TODO Could skip this count for tasks page.
19248  if (report_counts (first_report_id,
19249  &debugs, &holes_2, &infos_2, &logs,
19250  &warnings_2, &false_positives,
19251  &severity_2, apply_overrides,
19252  0, min_qod))
19253  g_error ("%s: GET_TASKS: error getting counts for"
19254  " first report, aborting",
19255  __FUNCTION__);
19256 
19257  if (report_timestamp (first_report_id, &timestamp))
19258  g_error ("%s: GET_TASKS: failed to get timestamp of"
19259  " first report, aborting",
19260  __FUNCTION__);
19261 
19262  scan_start = scan_start_time_uuid (first_report_id);
19263  scan_end = scan_end_time_uuid (first_report_id);
19264 
19265  first_report = g_strdup_printf ("<first_report>"
19266  "<report id=\"%s\">"
19267  "<timestamp>"
19268  "%s"
19269  "</timestamp>"
19270  "<scan_start>%s</scan_start>"
19271  "<scan_end>%s</scan_end>"
19272  "<result_count>"
19273  "<debug>%i</debug>"
19274  "<hole>%i</hole>"
19275  "<info>%i</info>"
19276  "<log>%i</log>"
19277  "<warning>%i</warning>"
19278  "<false_positive>"
19279  "%i"
19280  "</false_positive>"
19281  "</result_count>"
19282  "<severity>"
19283  "%1.1f"
19284  "</severity>"
19285  "</report>"
19286  "</first_report>",
19287  first_report_id,
19288  timestamp,
19289  scan_start,
19290  scan_end,
19291  debugs,
19292  holes_2,
19293  infos_2,
19294  logs,
19295  warnings_2,
19296  false_positives,
19297  severity_2);
19298  free (scan_start);
19299  free (scan_end);
19300  g_free (timestamp);
19301  }
19302  else
19303  first_report = g_strdup ("");
19304 
19305  second_last_report_id = task_second_last_report_id (index);
19306  if (second_last_report_id)
19307  {
19308  gchar *timestamp;
19309  char *scan_start, *scan_end;
19310 
19311  /* If the first report is the second last report then skip
19312  * doing the count again. */
19313  if (((first_report_id == NULL)
19314  || (strcmp (second_last_report_id, first_report_id)))
19315  && report_counts (second_last_report_id,
19316  &debugs, &holes_2, &infos_2,
19317  &logs, &warnings_2,
19318  &false_positives, &severity_2,
19319  apply_overrides,
19320  0, min_qod))
19321  g_error ("%s: GET_TASKS: error getting counts for"
19322  " second report, aborting",
19323  __FUNCTION__);
19324 
19325  if (report_timestamp (second_last_report_id, &timestamp))
19326  g_error ("%s: GET_TASKS: error getting timestamp of"
19327  " second report, aborting",
19328  __FUNCTION__);
19329 
19330  scan_start = scan_start_time_uuid (second_last_report_id);
19331  scan_end = scan_end_time_uuid (second_last_report_id);
19332 
19333  second_last_report = g_strdup_printf
19334  ("<second_last_report>"
19335  "<report id=\"%s\">"
19336  "<timestamp>%s</timestamp>"
19337  "<scan_start>%s</scan_start>"
19338  "<scan_end>%s</scan_end>"
19339  "<result_count>"
19340  "<debug>%i</debug>"
19341  "<hole>%i</hole>"
19342  "<info>%i</info>"
19343  "<log>%i</log>"
19344  "<warning>%i</warning>"
19345  "<false_positive>"
19346  "%i"
19347  "</false_positive>"
19348  "</result_count>"
19349  "<severity>%1.1f</severity>"
19350  "</report>"
19351  "</second_last_report>",
19352  second_last_report_id,
19353  timestamp,
19354  scan_start,
19355  scan_end,
19356  debugs,
19357  holes_2,
19358  infos_2,
19359  logs,
19360  warnings_2,
19361  false_positives,
19362  severity_2);
19363  free (scan_start);
19364  free (scan_end);
19365  g_free (timestamp);
19366  }
19367  else
19368  second_last_report = g_strdup ("");
19369 
19370  last_report_id = task_iterator_last_report (&tasks);
19371  if (last_report_id)
19372  {
19373  gchar *timestamp;
19374  char *scan_start, *scan_end;
19375 
19376  /* If the last report is the first report or the second
19377  * last report, then reuse the counts from before. */
19378  if ((first_report_id == NULL)
19379  || (second_last_report_id == NULL)
19380  || (strcmp (last_report_id, first_report_id)
19381  && strcmp (last_report_id,
19382  second_last_report_id)))
19383  {
19384  if (report_counts
19385  (last_report_id,
19386  &debugs, &holes, &infos, &logs,
19387  &warnings, &false_positives, &severity,
19388  apply_overrides,
19389  0, min_qod))
19390  g_error ("%s: GET_TASKS: error getting counts for"
19391  " last report, aborting",
19392  __FUNCTION__);
19393  }
19394  else
19395  {
19396  holes = holes_2;
19397  infos = infos_2;
19398  warnings = warnings_2;
19399  severity = severity_2;
19400  }
19401 
19402  if (report_timestamp (last_report_id, &timestamp))
19403  g_error ("%s: GET_TASKS: error getting timestamp for"
19404  " last report, aborting",
19405  __FUNCTION__);
19406 
19407  scan_start = scan_start_time_uuid (last_report_id);
19408  scan_end = scan_end_time_uuid (last_report_id);
19409 
19410  last_report = g_strdup_printf ("<last_report>"
19411  "<report id=\"%s\">"
19412  "<timestamp>%s</timestamp>"
19413  "<scan_start>%s</scan_start>"
19414  "<scan_end>%s</scan_end>"
19415  "<result_count>"
19416  "<debug>%i</debug>"
19417  "<hole>%i</hole>"
19418  "<info>%i</info>"
19419  "<log>%i</log>"
19420  "<warning>%i</warning>"
19421  "<false_positive>"
19422  "%i"
19423  "</false_positive>"
19424  "</result_count>"
19425  "<severity>"
19426  "%1.1f"
19427  "</severity>"
19428  "</report>"
19429  "</last_report>",
19430  last_report_id,
19431  timestamp,
19432  scan_start,
19433  scan_end,
19434  debugs,
19435  holes,
19436  infos,
19437  logs,
19438  warnings,
19439  false_positives,
19440  severity);
19441  free (scan_start);
19442  free (scan_end);
19443  g_free (timestamp);
19444  }
19445  else
19446  last_report = g_strdup ("");
19447 
19448  g_free (second_last_report_id);
19449 
19450  owner = task_owner_name (index);
19451  observers = task_observers (index);
19452  config_name = task_config_name (index);
19453  config_uuid = task_config_uuid (index);
19454  target_available = 1;
19455  if (target_in_trash)
19456  {
19457  task_target_uuid = trash_target_uuid (target);
19458  task_target_name = trash_target_name (target);
19459  target_available = trash_target_readable (target);
19460  }
19461  else if (target)
19462  {
19463  target_t found;
19464  task_target_uuid = target_uuid (target);
19465  task_target_name = target_name (target);
19466  if (find_target_with_permission (task_target_uuid,
19467  &found,
19468  "get_targets"))
19469  g_error ("%s: GET_TASKS: error finding task target,"
19470  " aborting",
19471  __FUNCTION__);
19472  target_available = (found > 0);
19473  }
19474  else
19475  {
19476  task_target_uuid = NULL;
19477  task_target_name = NULL;
19478  }
19479  config_available = 1;
19480  if (task_config_in_trash (index))
19481  config_available = trash_config_readable_uuid (config_uuid);
19482  else if (config_uuid)
19483  {
19484  config_t found;
19486  &found,
19487  "get_configs"))
19488  g_error ("%s: GET_TASKS: error finding task config,"
19489  " aborting",
19490  __FUNCTION__);
19491  config_available = (found > 0);
19492  }
19493  schedule_available = 1;
19494  schedule = task_schedule (index);
19495  if (schedule)
19496  {
19497  schedule_in_trash = task_schedule_in_trash (index);
19498  if (schedule_in_trash)
19499  {
19500  task_schedule_uuid = schedule_uuid (schedule);
19501  task_schedule_name = schedule_name (schedule);
19502  schedule_available = trash_schedule_readable (schedule);
19503  }
19504  else
19505  {
19506  schedule_t found;
19507  task_schedule_uuid = schedule_uuid (schedule);
19508  task_schedule_name = schedule_name (schedule);
19510  &found,
19511  "get_schedules"))
19512  g_error ("%s: GET_TASKS: error finding"
19513  " task schedule, aborting",
19514  __FUNCTION__);
19515  schedule_available = (found > 0);
19516  }
19517  }
19518  else
19519  {
19520  task_schedule_uuid = (char*) g_strdup ("");
19521  task_schedule_name = (char*) g_strdup ("");
19522  schedule_in_trash = 0;
19523  }
19524  scanner_available = 1;
19525  scanner = task_iterator_scanner (&tasks);
19526  if (scanner)
19527  {
19528  scanner_in_trash = task_scanner_in_trash (index);
19529 
19530  task_scanner_uuid = scanner_uuid (scanner);
19531  task_scanner_name = scanner_name (scanner);
19532  task_scanner_type = scanner_type (scanner);
19533  if (scanner_in_trash)
19534  scanner_available = trash_scanner_readable (scanner);
19535  else
19536  {
19537  scanner_t found;
19538 
19540  (task_scanner_uuid, &found, "get_scanners"))
19541  g_error ("%s: GET_TASKS: error finding"
19542  " task scanner, aborting",
19543  __FUNCTION__);
19544  scanner_available = (found > 0);
19545  }
19546  }
19547  else
19548  {
19549  /* Container tasks have no associated scanner. */
19550  task_scanner_uuid = g_strdup ("");
19551  task_scanner_name = g_strdup ("");
19552  task_scanner_type = 0;
19553  scanner_in_trash = 0;
19554  }
19556  config_name_escaped
19557  = config_name
19558  ? g_markup_escape_text (config_name, -1)
19559  : NULL;
19560  task_target_name_escaped
19561  = task_target_name
19562  ? g_markup_escape_text (task_target_name, -1)
19563  : NULL;
19564  task_scanner_name_escaped
19565  = task_scanner_name
19566  ? g_markup_escape_text (task_scanner_name, -1)
19567  : NULL;
19568  task_schedule_name_escaped
19569  = task_schedule_name
19570  ? g_markup_escape_text (task_schedule_name, -1)
19571  : NULL;
19572  response = g_strdup_printf
19573  ("<alterable>%i</alterable>"
19574  "<config id=\"%s\">"
19575  "<name>%s</name>"
19576  "<type>%i</type>"
19577  "<trash>%i</trash>"
19578  "%s"
19579  "</config>"
19580  "<target id=\"%s\">"
19581  "<name>%s</name>"
19582  "<trash>%i</trash>"
19583  "%s"
19584  "</target>"
19585  "<hosts_ordering>%s</hosts_ordering>"
19586  "<scanner id='%s'>"
19587  "<name>%s</name>"
19588  "<type>%d</type>"
19589  "<trash>%i</trash>"
19590  "%s"
19591  "</scanner>"
19592  "<status>%s</status>"
19593  "<progress>%s</progress>"
19594  "<report_count>"
19595  "%u<finished>%u</finished>"
19596  "</report_count>"
19597  "<trend>%s</trend>"
19598  "<schedule id=\"%s\">"
19599  "<name>%s</name>"
19600  "<next_time>%s</next_time>"
19601  "<trash>%i</trash>"
19602  "%s"
19603  "</schedule>"
19604  "<schedule_periods>%i</schedule_periods>"
19605  "%s%s%s%s",
19607  ? 0
19608  : task_alterable (index),
19609  config_uuid ?: "",
19610  config_name_escaped ?: "",
19611  config_type (task_config (index)),
19612  task_config_in_trash (index),
19613  config_available ? "" : "<permissions/>",
19614  task_target_uuid ?: "",
19615  task_target_name_escaped ?: "",
19616  target_in_trash,
19617  target_available ? "" : "<permissions/>",
19619  task_scanner_uuid,
19620  task_scanner_name_escaped,
19621  task_scanner_type,
19622  scanner_in_trash,
19623  scanner_available ? "" : "<permissions/>",
19625  progress_xml,
19626  task_iterator_total_reports (&tasks),
19629  (&tasks, holes, warnings, infos, severity,
19630  holes_2, warnings_2, infos_2, severity_2),
19632  task_schedule_name_escaped,
19633  (next_time == 0 ? "over" : iso_time (&next_time)),
19634  schedule_in_trash,
19635  schedule_available ? "" : "<permissions/>",
19636  task_schedule_periods (index),
19638  first_report,
19639  last_report,
19640  second_last_report);
19641  g_free (config_name);
19642  g_free (config_uuid);
19643  g_free (config_name_escaped);
19644  free (task_target_name);
19645  free (task_target_uuid);
19646  g_free (task_target_name_escaped);
19647  g_free (progress_xml);
19648  g_free (current_report);
19649  g_free (first_report);
19650  g_free (last_report);
19651  g_free (second_last_report);
19652  g_free (task_schedule_uuid);
19653  g_free (task_schedule_name);
19654  g_free (task_schedule_name_escaped);
19655  g_free (task_scanner_uuid);
19656  g_free (task_scanner_name);
19657  g_free (task_scanner_name_escaped);
19658  if (send_to_client (response,
19659  omp_parser->client_writer,
19660  omp_parser->client_writer_data))
19661  {
19662  g_free (response);
19663  cleanup_iterator (&tasks);
19664  error_send_to_client (error);
19665  cleanup_iterator (&tasks);
19666  return;
19667  }
19668  g_free (response);
19669 
19670  SENDF_TO_CLIENT_OR_FAIL
19671  ("<observers>%s",
19672  ((owner == NULL)
19673  || (strcmp (owner,
19674  current_credentials.username)))
19675  ? ""
19676  : observers);
19677  free (owner);
19678  free (observers);
19679 
19680  init_task_group_iterator (&groups, index);
19681  while (next (&groups))
19682  SENDF_TO_CLIENT_OR_FAIL
19683  ("<group id=\"%s\">"
19684  "<name>%s</name>"
19685  "</group>",
19686  task_group_iterator_uuid (&groups),
19687  task_group_iterator_name (&groups));
19688  cleanup_iterator (&groups);
19689 
19690  init_task_role_iterator (&roles, index);
19691  while (next (&roles))
19692  SENDF_TO_CLIENT_OR_FAIL
19693  ("<role id=\"%s\">"
19694  "<name>%s</name>"
19695  "</role>",
19696  task_role_iterator_uuid (&roles),
19697  task_role_iterator_name (&roles));
19698  cleanup_iterator (&roles);
19699 
19700  SENDF_TO_CLIENT_OR_FAIL ("</observers>");
19701 
19702  init_task_alert_iterator (&alerts, index, 0);
19703  while (next (&alerts))
19704  {
19705  alert_t found;
19706 
19708  (&alerts),
19709  &found,
19710  "get_alerts"))
19711  abort ();
19712 
19713  SENDF_TO_CLIENT_OR_FAIL
19714  ("<alert id=\"%s\">"
19715  "<name>%s</name>",
19716  task_alert_iterator_uuid (&alerts),
19717  task_alert_iterator_name (&alerts));
19718 
19719  if (found)
19720  SENDF_TO_CLIENT_OR_FAIL
19721  ("</alert>");
19722  else
19723  SENDF_TO_CLIENT_OR_FAIL
19724  ("<permissions/>"
19725  "</alert>");
19726  }
19727  cleanup_iterator (&alerts);
19728 
19730  || get_tasks_data->get.id)
19731  {
19732  SENDF_TO_CLIENT_OR_FAIL ("<average_duration>"
19733  "%d"
19734  "</average_duration>",
19735  task_average_scan_duration (index));
19736  }
19737 
19738  if (get_tasks_data->get.details)
19739  {
19740  /* The detailed version. */
19741 
19748  send_reports (index,
19749  apply_overrides,
19750  min_qod,
19751  omp_parser->client_writer,
19752  omp_parser->client_writer_data);
19753  }
19754 
19755  SENDF_TO_CLIENT_OR_FAIL ("<result_count>%i</result_count>",
19756  task_result_count (index, min_qod));
19757 
19758  in_assets = task_preference_value (index, "in_assets");
19759  assets_apply_overrides = task_preference_value
19760  (index, "assets_apply_overrides");
19761  assets_min_qod = task_preference_value (index, "assets_min_qod");
19762  max_checks = task_preference_value (index, "max_checks");
19763  max_hosts = task_preference_value (index, "max_hosts");
19764  source_iface = task_preference_value (index, "source_iface");
19765  auto_delete = task_preference_value (index, "auto_delete");
19766  auto_delete_data = task_preference_value (index, "auto_delete_data");
19767 
19768  SENDF_TO_CLIENT_OR_FAIL
19769  ("<preferences>"
19770  "<preference>"
19771  "<name>"
19772  "Maximum concurrently executed NVTs per host"
19773  "</name>"
19774  "<scanner_name>max_checks</scanner_name>"
19775  "<value>%s</value>"
19776  "</preference>"
19777  "<preference>"
19778  "<name>"
19779  "Maximum concurrently scanned hosts"
19780  "</name>"
19781  "<scanner_name>max_hosts</scanner_name>"
19782  "<value>%s</value>"
19783  "</preference>"
19784  "<preference>"
19785  "<name>"
19786  "Network Source Interface"
19787  "</name>"
19788  "<scanner_name>source_iface</scanner_name>"
19789  "<value>%s</value>"
19790  "</preference>"
19791  "<preference>"
19792  "<name>"
19793  "Add results to Asset Management"
19794  "</name>"
19795  "<scanner_name>in_assets</scanner_name>"
19796  "<value>%s</value>"
19797  "</preference>"
19798  "<preference>"
19799  "<name>"
19800  "Apply Overrides when adding Assets"
19801  "</name>"
19802  "<scanner_name>assets_apply_overrides</scanner_name>"
19803  "<value>%s</value>"
19804  "</preference>"
19805  "<preference>"
19806  "<name>"
19807  "Min QOD when adding Assets"
19808  "</name>"
19809  "<scanner_name>assets_min_qod</scanner_name>"
19810  "<value>%s</value>"
19811  "</preference>"
19812  "<preference>"
19813  "<name>"
19814  "Auto Delete Reports"
19815  "</name>"
19816  "<scanner_name>auto_delete</scanner_name>"
19817  "<value>%s</value>"
19818  "</preference>"
19819  "<preference>"
19820  "<name>"
19821  "Auto Delete Reports Data"
19822  "</name>"
19823  "<scanner_name>auto_delete_data</scanner_name>"
19824  "<value>%s</value>"
19825  "</preference>"
19826  "</preferences>"
19827  "</task>",
19828  max_checks ? max_checks : "4",
19829  max_hosts ? max_hosts : "20",
19830  source_iface ? source_iface : "",
19831  in_assets ? in_assets : "yes",
19832  assets_apply_overrides ? assets_apply_overrides : "yes",
19833  assets_min_qod
19834  ? assets_min_qod
19835  : G_STRINGIFY (MIN_QOD_DEFAULT),
19836  auto_delete ? auto_delete : "0",
19837  auto_delete_data ? auto_delete_data : "0");
19838 
19839  g_free (in_assets);
19840  g_free (max_checks);
19841  g_free (max_hosts);
19842  g_free (source_iface);
19843  }
19844 
19845  count++;
19846  }
19847  cleanup_iterator (&tasks);
19848  g_free (min_qod_str);
19849  filtered = get_tasks_data->get.id
19850  ? 1
19852  SEND_GET_END ("task", &get_tasks_data->get, count, filtered);
19853 
19854  get_tasks_data_reset (get_tasks_data);
19855  set_client_state (CLIENT_AUTHENTIC);
19856 }
19857 
19864 static void
19865 handle_get_users (omp_parser_t *omp_parser, GError **error)
19866 {
19867  iterator_t users;
19868  int count, filtered, ret, first;
19869 
19870  INIT_GET (user, User);
19871 
19872  ret = init_user_iterator (&users, &get_users_data->get);
19873  if (ret)
19874  {
19875  switch (ret)
19876  {
19877  case 1:
19878  if (send_find_error_to_client ("get_users",
19879  "user",
19881  omp_parser))
19882  {
19883  error_send_to_client (error);
19884  return;
19885  }
19886  break;
19887  case 2:
19888  if (send_find_error_to_client
19889  ("get_users", "user", get_users_data->get.filt_id,
19890  omp_parser))
19891  {
19892  error_send_to_client (error);
19893  return;
19894  }
19895  break;
19896  case -1:
19897  SEND_TO_CLIENT_OR_FAIL
19898  (XML_INTERNAL_ERROR ("get_users"));
19899  break;
19900  }
19901  get_users_data_reset (get_users_data);
19902  set_client_state (CLIENT_AUTHENTIC);
19903  return;
19904  }
19905 
19906  SEND_GET_START ("user");
19907  while (1)
19908  {
19909  iterator_t groups, roles;
19910  const char *hosts, *ifaces;
19911  int hosts_allow, ifaces_allow;
19912 
19913  ret = get_next (&users, &get_users_data->get, &first, &count,
19915  if (ret == 1)
19916  break;
19917  if (ret == -1)
19918  {
19919  internal_error_send_to_client (error);
19920  return;
19921  }
19922 
19923  SEND_GET_COMMON (user, &get_users_data->get, &users);
19924 
19925  hosts = user_iterator_hosts (&users);
19926  hosts_allow = user_iterator_hosts_allow (&users);
19927 
19928  SENDF_TO_CLIENT_OR_FAIL ("<hosts allow=\"%i\">%s</hosts>"
19929  "<sources><source>%s</source></sources>",
19930  hosts_allow,
19931  hosts ? hosts : "",
19932  user_iterator_method (&users)
19933  ? user_iterator_method (&users)
19934  : "file");
19935 
19936  /* Interfaces Access */
19937  ifaces = user_iterator_ifaces (&users);
19938  ifaces_allow = user_iterator_ifaces_allow (&users);
19939  SENDF_TO_CLIENT_OR_FAIL ("<ifaces allow=\"%i\">%s</ifaces>",
19940  ifaces_allow,
19941  ifaces ? ifaces : "");
19942 
19943  /* User Roles */
19944  init_user_role_iterator (&roles,
19945  get_iterator_resource (&users));
19946  while (next (&roles))
19947  {
19948  SENDF_TO_CLIENT_OR_FAIL ("<role id=\"%s\">"
19949  "<name>%s</name>",
19950  user_role_iterator_uuid (&roles),
19951  user_role_iterator_name (&roles));
19952  if (user_role_iterator_readable (&roles))
19953  SEND_TO_CLIENT_OR_FAIL ("</role>");
19954  else
19955  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
19956  "</role>");
19957  }
19958  cleanup_iterator (&roles);
19959 
19960  SEND_TO_CLIENT_OR_FAIL ("<groups>");
19961  init_user_group_iterator (&groups,
19962  get_iterator_resource (&users));
19963  while (next (&groups))
19964  {
19965  SENDF_TO_CLIENT_OR_FAIL ("<group id=\"%s\">"
19966  "<name>%s</name>",
19967  user_group_iterator_uuid (&groups),
19968  user_group_iterator_name (&groups));
19969  if (user_group_iterator_readable (&groups))
19970  SEND_TO_CLIENT_OR_FAIL ("</group>");
19971  else
19972  SEND_TO_CLIENT_OR_FAIL ("<permissions/>"
19973  "</group>");
19974  }
19975  cleanup_iterator (&groups);
19976  SEND_TO_CLIENT_OR_FAIL ("</groups>"
19977  "</user>");
19978  count++;
19979  }
19980  cleanup_iterator (&users);
19981  filtered = get_users_data->get.id
19982  ? 1
19984  SEND_GET_END ("user", &get_users_data->get, count, filtered);
19985 
19986  get_users_data_reset (get_users_data);
19987  set_client_state (CLIENT_AUTHENTIC);
19988 }
19989 
19996 static void
19997 handle_get_version (omp_parser_t *omp_parser, GError **error)
19998 {
19999  SEND_TO_CLIENT_OR_FAIL ("<get_version_response"
20000  " status=\"" STATUS_OK "\""
20001  " status_text=\"" STATUS_OK_TEXT "\">"
20002  "<version>" OMP_VERSION "</version>"
20003  "</get_version_response>");
20004  if (client_state == CLIENT_GET_VERSION_AUTHENTIC)
20005  set_client_state (CLIENT_AUTHENTIC);
20006  else
20007  set_client_state (CLIENT_TOP);
20008 }
20009 
20016 static void
20017 handle_sync_config (omp_parser_t *omp_parser, GError **error)
20018 {
20019  assert (current_credentials.username);
20021  {
20022  SEND_TO_CLIENT_OR_FAIL
20023  (XML_ERROR_SYNTAX ("sync_config",
20024  "SYNC_CONFIG requires a config_id attribute"));
20025  sync_config_data_reset (sync_config_data);
20026  set_client_state (CLIENT_AUTHENTIC);
20027  return;
20028  }
20030  {
20031  case 0:
20032  log_event ("config", "config", sync_config_data->config_id,
20033  "synchronized");
20034  SEND_TO_CLIENT_OR_FAIL (XML_OK ("sync_config"));
20035  break;
20036  case 1:
20037  if (send_find_error_to_client
20038  ("sync_config", "config", sync_config_data->config_id, omp_parser))
20039  {
20040  error_send_to_client (error);
20041  return;
20042  }
20043  log_event_fail ("config", "Config", sync_config_data->config_id,
20044  "synchronized");
20045  break;
20046  case 2:
20047  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
20048  ("sync_config", "Config not of type OSP"));
20049  log_event_fail ("config", "Config", sync_config_data->config_id,
20050  "synchronized");
20051  break;
20052  case 3:
20053  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
20054  ("sync_config", "Config has no scanner"));
20055  log_event_fail ("config", "Config", sync_config_data->config_id,
20056  "synchronized");
20057  break;
20058  case 4:
20059  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
20060  ("sync_config",
20061  "Couldn't get parameters from scanner"));
20062  log_event_fail ("config", "Config", sync_config_data->config_id,
20063  "synchronized");
20064  break;
20065  case 99:
20066  SEND_TO_CLIENT_OR_FAIL
20067  (XML_ERROR_SYNTAX ("sync_config", "Permission denied"));
20068  log_event_fail ("config", "Config", sync_config_data->config_id,
20069  "synchronized");
20070  break;
20071  case -1:
20072  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("sync_config"));
20073  log_event_fail ("config", "Config", sync_config_data->config_id,
20074  "synchronized");
20075  break;
20076  default:
20077  abort ();
20078  break;
20079  }
20080 
20081  sync_config_data_reset (sync_config_data);
20082  set_client_state (CLIENT_AUTHENTIC);
20083 }
20084 
20091 static void
20092 handle_create_scanner (omp_parser_t *omp_parser, GError **error)
20093 {
20094  scanner_t new_scanner;
20095 
20099  create_scanner_data->copy, &new_scanner))
20100  {
20101  case 0:
20102  {
20103  char *uuid;
20104  uuid = scanner_uuid (new_scanner);
20105  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_scanner"),
20106  uuid);
20107  log_event ("scanner", "scanner", uuid, "created");
20108  g_free (uuid);
20109  goto create_scanner_leave;
20110  }
20111  case 1:
20112  SEND_TO_CLIENT_OR_FAIL
20113  (XML_ERROR_SYNTAX ("create_scanner", "Scanner name exists already"));
20114  log_event_fail ("scanner", "Scanner", NULL, "created");
20115  goto create_scanner_leave;
20116  case 2:
20117  if (send_find_error_to_client ("create_scanner", "scanner",
20118  create_scanner_data->copy, omp_parser))
20119  {
20120  error_send_to_client (error);
20121  goto create_scanner_leave;
20122  }
20123  log_event_fail ("scanner", "Scanner", NULL, "created");
20124  goto create_scanner_leave;
20125  case 98:
20126  SEND_TO_CLIENT_OR_FAIL
20127  (XML_ERROR_SYNTAX ("create_scanner", "It is not possible to clone a "
20128  "CVE scanner "));
20129  log_event_fail ("scanner", "Scanner", NULL, "created");
20130  goto create_scanner_leave;
20131  case 99:
20132  SEND_TO_CLIENT_OR_FAIL
20133  (XML_ERROR_SYNTAX ("create_scanner", "Permission denied"));
20134  log_event_fail ("scanner", "Scanner", NULL, "created");
20135  goto create_scanner_leave;
20136  case -1:
20137  default:
20138  SEND_TO_CLIENT_OR_FAIL
20139  (XML_INTERNAL_ERROR ("create_scanner"));
20140  log_event_fail ("scanner", "Scanner", NULL, "created");
20141  goto create_scanner_leave;
20142  }
20143 
20147  {
20148  SEND_TO_CLIENT_OR_FAIL
20149  (XML_ERROR_SYNTAX ("create_scanner", "Missing entity"));
20150  goto create_scanner_leave;
20151  }
20152 
20154  && check_certificate (create_scanner_data->ca_pub))
20155  {
20156  SEND_TO_CLIENT_OR_FAIL
20157  (XML_ERROR_SYNTAX ("create_scanner", "Erroneous CA Certificate."));
20158  goto create_scanner_leave;
20159  }
20160  switch (create_scanner
20163  create_scanner_data->type, &new_scanner,
20165  {
20166  case 0:
20167  {
20168  char *uuid = scanner_uuid (new_scanner);
20169  SENDF_TO_CLIENT_OR_FAIL
20170  (XML_OK_CREATED_ID ("create_scanner"), uuid);
20171  log_event ("scanner", "Scanner", uuid, "created");
20172  g_free (uuid);
20173  break;
20174  }
20175  case 1:
20176  SEND_TO_CLIENT_OR_FAIL
20177  (XML_ERROR_SYNTAX ("create_scanner", "Scanner exists already"));
20178  log_event_fail ("scanner", "Scanner", NULL, "created");
20179  break;
20180  case 2:
20181  SEND_TO_CLIENT_OR_FAIL
20182  (XML_ERROR_SYNTAX ("create_scanner", "Invalid entity value"));
20183  log_event_fail ("scanner", "Scanner", NULL, "created");
20184  break;
20185  case 3:
20186  if (send_find_error_to_client ("create_scanner", "credential",
20188  omp_parser))
20189  {
20190  error_send_to_client (error);
20191  return;
20192  }
20193  log_event_fail ("scanner", "Scanner", NULL, "created");
20194  break;
20195  case 4:
20196  SEND_TO_CLIENT_OR_FAIL
20197  (XML_ERROR_SYNTAX ("create_scanner",
20198  "Credential must be of type 'up'"
20199  " (username + password)"));
20200  log_event_fail ("scanner", "Scanner", NULL, "created");
20201  break;
20202  case 5:
20203  SEND_TO_CLIENT_OR_FAIL
20204  (XML_ERROR_SYNTAX ("create_scanner",
20205  "Credential must be of type 'cc'"
20206  " (client certificate)"));
20207  log_event_fail ("scanner", "Scanner", NULL, "created");
20208  break;
20209  case 99:
20210  SEND_TO_CLIENT_OR_FAIL
20211  (XML_ERROR_SYNTAX ("create_scanner", "Permission denied"));
20212  log_event_fail ("scanner", "Scanner", NULL, "created");
20213  break;
20214  case -1:
20215  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_scanner"));
20216  log_event_fail ("scanner", "Scanner", NULL, "created");
20217  break;
20218  default:
20219  assert (0);
20220  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_scanner"));
20221  log_event_fail ("scanner", "Scanner", NULL, "created");
20222  break;
20223  }
20224 
20225 create_scanner_leave:
20226  create_scanner_data_reset (create_scanner_data);
20227  set_client_state (CLIENT_AUTHENTIC);
20228 }
20229 
20236 static void
20237 handle_modify_scanner (omp_parser_t *omp_parser, GError **error)
20238 {
20240  && check_certificate (modify_scanner_data->ca_pub))
20241  {
20242  SEND_TO_CLIENT_OR_FAIL
20243  (XML_ERROR_SYNTAX ("modify_scanner", "Erroneous CA Certificate."));
20244  goto modify_scanner_leave;
20245  }
20246 
20247  switch (modify_scanner
20252  {
20253  case 0:
20254  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_scanner"));
20255  log_event ("scanner", "Scanner", modify_scanner_data->scanner_id,
20256  "modified");
20257  break;
20258  case 1:
20259  if (send_find_error_to_client ("modify_scanner", "scanner",
20261  omp_parser))
20262  {
20263  error_send_to_client (error);
20264  return;
20265  }
20266  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20267  "modified");
20268  break;
20269  case 2:
20270  SEND_TO_CLIENT_OR_FAIL
20271  (XML_ERROR_SYNTAX ("modify_scanner",
20272  "scanner with new name exists already"));
20273  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20274  "modified");
20275  break;
20276  case 3:
20277  SEND_TO_CLIENT_OR_FAIL
20278  (XML_ERROR_SYNTAX ("modify_scanner", "Missing scanner_id"));
20279  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20280  "modified");
20281  break;
20282  case 4:
20283  SEND_TO_CLIENT_OR_FAIL
20284  (XML_ERROR_SYNTAX ("modify_scanner", "Invalid value"));
20285  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20286  "modified");
20287  break;
20288  case 5:
20289  if (send_find_error_to_client ("create_scanner", "credential",
20291  omp_parser))
20292  {
20293  error_send_to_client (error);
20294  return;
20295  }
20296  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20297  "modified");
20298  break;
20299  case 6:
20300  SEND_TO_CLIENT_OR_FAIL
20301  (XML_ERROR_SYNTAX ("modify_scanner",
20302  "Credential must be of type 'cc'"
20303  " (client certificate)"));
20304  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20305  "modified");
20306  break;
20307  case 7:
20308  SEND_TO_CLIENT_OR_FAIL
20309  (XML_ERROR_SYNTAX ("modify_scanner",
20310  "Credential must be of type 'up'"
20311  " (username + password)"));
20312  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20313  "modified");
20314  break;
20315  case 99:
20316  SEND_TO_CLIENT_OR_FAIL
20317  (XML_ERROR_SYNTAX ("modify_scanner", "Permission denied"));
20318  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20319  "modified");
20320  break;
20321  default:
20322  case -1:
20323  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_scanner"));
20324  log_event_fail ("scanner", "Scanner", modify_scanner_data->scanner_id,
20325  "modified");
20326  break;
20327  }
20328 modify_scanner_leave:
20329  modify_scanner_data_reset (modify_scanner_data);
20330  set_client_state (CLIENT_AUTHENTIC);
20331 }
20332 
20339 static void
20340 handle_modify_config (omp_parser_t *omp_parser, GError **error)
20341 {
20342  config_t config;
20343 
20344  if (acl_user_may ("modify_config") == 0)
20345  {
20346  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX ("modify_config",
20347  "Permission denied"));
20348  set_client_state (CLIENT_AUTHENTIC);
20349  goto modify_config_leave;
20350  }
20351 
20352  if (modify_config_data->config_id == NULL
20353  || strlen (modify_config_data->config_id) == 0)
20354  SEND_TO_CLIENT_OR_FAIL
20355  (XML_ERROR_SYNTAX ("modify_config",
20356  "MODIFY_CONFIG requires a config_id attribute"));
20358  /* This array implies FAMILY_SELECTION. */
20365  SEND_TO_CLIENT_OR_FAIL
20366  (XML_ERROR_SYNTAX ("modify_config",
20367  "MODIFY_CONFIG requires either a PREFERENCE or"
20368  " an NVT_SELECTION or a FAMILY_SELECTION"));
20369  else if (find_config (modify_config_data->config_id, &config))
20370  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_config"));
20371  else if (config == 0)
20372  {
20373  if (send_find_error_to_client ("modify_config", "config",
20374  modify_config_data->config_id, omp_parser))
20375  {
20376  error_send_to_client (error);
20377  return;
20378  }
20379  }
20381  {
20382  switch (manage_set_config_nvts
20385  {
20386  case 0:
20387  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_config"));
20388  log_event ("config", "Scan config",
20389  modify_config_data->config_id, "modified");
20390  goto modify_config_leave;
20391  case 1:
20392  SEND_TO_CLIENT_OR_FAIL
20393  (XML_ERROR_SYNTAX ("modify_config", "Config is in use"));
20394  log_event_fail ("config", "Scan Config",
20395  modify_config_data->config_id, "modified");
20396  goto modify_config_leave;
20397 
20398  case -1:
20399  SEND_TO_CLIENT_OR_FAIL
20400  (XML_ERROR_SYNTAX ("modify_config",
20401  "MODIFY_CONFIG PREFERENCE requires at"
20402  " least one of the VALUE and NVT elements"));
20403  goto modify_config_leave;
20404 
20405  default:
20406  SEND_TO_CLIENT_OR_FAIL
20407  (XML_INTERNAL_ERROR ("modify_config"));
20408  log_event_fail ("config", "Scan Config",
20409  modify_config_data->config_id, "modified");
20410  goto modify_config_leave;
20411  }
20412  }
20414  {
20415  /* There was a FAMILY_SELECTION. */
20416 
20422  {
20423  case 0:
20424  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_config"));
20425  log_event ("config", "Scan config",
20426  modify_config_data->config_id, "modified");
20427  goto modify_config_leave;
20428  case 1:
20429  SEND_TO_CLIENT_OR_FAIL
20430  (XML_ERROR_SYNTAX ("modify_config", "Config is in use"));
20431  log_event_fail ("config", "Scan Config",
20432  modify_config_data->config_id, "modified");
20433  goto modify_config_leave;
20434 
20435  case -1:
20436  SEND_TO_CLIENT_OR_FAIL
20437  (XML_ERROR_SYNTAX ("modify_config",
20438  "MODIFY_CONFIG PREFERENCE requires at"
20439  " least one of the VALUE and NVT elements"));
20440  goto modify_config_leave;
20441 
20442  default:
20443  SEND_TO_CLIENT_OR_FAIL
20444  (XML_INTERNAL_ERROR ("modify_config"));
20445  log_event_fail ("config", "Scan Config",
20446  modify_config_data->config_id, "modified");
20447  goto modify_config_leave;
20448  }
20449  }
20452  switch (manage_set_config
20455  {
20456  case 0:
20457  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_config"));
20458  goto modify_config_leave;
20459  case 1:
20460  SEND_TO_CLIENT_OR_FAIL
20461  (XML_ERROR_SYNTAX ("modify_config",
20462  "MODIFY_CONFIG name must be unique"));
20463  goto modify_config_leave;
20464  case 2:
20465  SEND_TO_CLIENT_OR_FAIL
20466  (XML_ERROR_SYNTAX ("modify_config",
20467  "MODIFY_CONFIG scanner not found"));
20468  goto modify_config_leave;
20469  case 3:
20470  SEND_TO_CLIENT_OR_FAIL
20471  (XML_ERROR_SYNTAX ("modify_config", "Config is in use"));
20472  log_event_fail ("config", "Scan Config",
20473  modify_config_data->config_id, "modified");
20474  goto modify_config_leave;
20475  case -1:
20476  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_config"));
20477  goto modify_config_leave;
20478  default:
20479  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_config"));
20480  goto modify_config_leave;
20481  }
20482  else if (modify_config_data->preference_name == NULL
20483  || strlen (modify_config_data->preference_name) == 0)
20484  SEND_TO_CLIENT_OR_FAIL
20485  (XML_ERROR_SYNTAX ("modify_config",
20486  "MODIFY_CONFIG PREFERENCE requires a NAME element"));
20487  else switch (manage_set_config_preference
20491  {
20492  case 0:
20493  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_config"));
20494  goto modify_config_leave;
20495  case 1:
20496  SEND_TO_CLIENT_OR_FAIL
20497  (XML_ERROR_SYNTAX ("modify_config", "Config is in use"));
20498  goto modify_config_leave;
20499  case 2:
20500  SEND_TO_CLIENT_OR_FAIL
20501  (XML_ERROR_SYNTAX ("modify_config", "Empty radio value"));
20502  goto modify_config_leave;
20503  case -1:
20504  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_config"));
20505  goto modify_config_leave;
20506  default:
20507  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_config"));
20508  goto modify_config_leave;
20509  }
20510 
20511 modify_config_leave:
20512  modify_config_data_reset (modify_config_data);
20513  set_client_state (CLIENT_AUTHENTIC);
20514 }
20515 
20516 extern char client_address[];
20517 
20535 static void
20536 omp_xml_handle_end_element (/* unused */ GMarkupParseContext* context,
20537  const gchar *element_name,
20538  gpointer user_data,
20539  GError **error)
20540 {
20541  omp_parser_t *omp_parser = (omp_parser_t*) user_data;
20542  int (*write_to_client) (const char *, void*)
20543  = (int (*) (const char *, void*)) omp_parser->client_writer;
20544  void* write_to_client_data = (void*) omp_parser->client_writer_data;
20545 
20546  int ret;
20547 
20548  g_debug (" XML end: %s\n", element_name);
20549 
20550  if (omp_parser->read_over > 1)
20551  {
20552  omp_parser->read_over--;
20553  }
20554  else if ((omp_parser->read_over == 1) && omp_parser->parent_state)
20555  {
20556  client_state = omp_parser->parent_state;
20557  omp_parser->parent_state = 0;
20558  omp_parser->read_over = 0;
20559  }
20560  else switch (client_state)
20561  {
20562  case CLIENT_TOP:
20563  assert (0);
20564  break;
20565 
20566  case CLIENT_AUTHENTICATE:
20567  switch (authenticate (&current_credentials))
20568  {
20569  case 0: /* Authentication succeeded. */
20570  if (load_tasks ())
20571  {
20572  g_warning ("%s: failed to load tasks\n", __FUNCTION__);
20573  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
20574  "Manager failed to load tasks.");
20575  free_credentials (&current_credentials);
20576  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("authenticate"));
20577  set_client_state (CLIENT_TOP);
20578  }
20579  else
20580  {
20581  const char *timezone, *severity;
20582  char *pw_warning;
20583 
20584  timezone = (current_credentials.timezone
20585  && strlen (current_credentials.timezone))
20586  ? current_credentials.timezone
20587  : "UTC";
20588 
20589  if (setenv ("TZ", timezone, 1) == -1)
20590  {
20591  free_credentials (&current_credentials);
20592  g_warning ("Timezone setting failure for %s",
20593  current_credentials.username);
20594  SEND_TO_CLIENT_OR_FAIL
20595  (XML_INTERNAL_ERROR ("authenticate"));
20596  set_client_state (CLIENT_TOP);
20597  break;
20598  }
20599  tzset ();
20600 
20601  manage_session_set_timezone (timezone);
20602 
20603  severity = setting_severity ();
20604  pw_warning = openvas_validate_password
20605  (current_credentials.password,
20606  current_credentials.username);
20607 
20608  if (pw_warning)
20609  SENDF_TO_CLIENT_OR_FAIL
20610  ("<authenticate_response"
20611  " status=\"" STATUS_OK "\""
20612  " status_text=\"" STATUS_OK_TEXT "\">"
20613  "<role>%s</role>"
20614  "<timezone>%s</timezone>"
20615  "<severity>%s</severity>"
20616  "<password_warning>%s</password_warning>"
20617  "</authenticate_response>",
20618  current_credentials.role
20619  ? current_credentials.role
20620  : "",
20621  timezone,
20622  severity,
20623  pw_warning ? pw_warning : "");
20624  else
20625  SENDF_TO_CLIENT_OR_FAIL
20626  ("<authenticate_response"
20627  " status=\"" STATUS_OK "\""
20628  " status_text=\"" STATUS_OK_TEXT "\">"
20629  "<role>%s</role>"
20630  "<timezone>%s</timezone>"
20631  "<severity>%s</severity>"
20632  "</authenticate_response>",
20633  current_credentials.role
20634  ? current_credentials.role
20635  : "",
20636  timezone,
20637  severity);
20638 
20639  free (pw_warning);
20640  set_client_state (CLIENT_AUTHENTIC);
20641  }
20642  break;
20643  case 1: /* Authentication failed. */
20644  g_warning ("Authentication failure for '%s' from %s",
20645  current_credentials.username ?: "", client_address);
20646  free_credentials (&current_credentials);
20647  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_AUTH_FAILED ("authenticate"));
20648  set_client_state (CLIENT_TOP);
20649  break;
20650  case 99: /* Authentication failed. */
20651  g_warning ("Authentication failure for '%s' from %s",
20652  current_credentials.username ?: "", client_address);
20653  free_credentials (&current_credentials);
20654  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX ("authenticate",
20655  "Permission denied"));
20656  set_client_state (CLIENT_TOP);
20657  break;
20658  case -1: /* Error while authenticating. */
20659  default:
20660  g_warning ("Authentication failure for '%s' from %s",
20661  current_credentials.username ?: "", client_address);
20662  free_credentials (&current_credentials);
20663  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("authenticate"));
20664  set_client_state (CLIENT_TOP);
20665  break;
20666  }
20667  break;
20668 
20670  assert (strcasecmp ("CREDENTIALS", element_name) == 0);
20671  set_client_state (CLIENT_AUTHENTICATE);
20672  break;
20673 
20675  assert (strcasecmp ("USERNAME", element_name) == 0);
20676  set_client_state (CLIENT_AUTHENTICATE_CREDENTIALS);
20677  break;
20678 
20680  assert (strcasecmp ("PASSWORD", element_name) == 0);
20681  set_client_state (CLIENT_AUTHENTICATE_CREDENTIALS);
20682  break;
20683 
20684  case CLIENT_AUTHENTIC:
20685  case CLIENT_COMMANDS:
20687  assert (strcasecmp ("COMMANDS", element_name) == 0);
20688  SENDF_TO_CLIENT_OR_FAIL ("</commands_response>");
20689  break;
20690 
20691  CASE_DELETE (AGENT, agent, "Agent");
20692  CASE_DELETE (ALERT, alert, "Alert");
20693 
20694  case CLIENT_DELETE_ASSET:
20695  assert (strcasecmp ("DELETE_ASSET", element_name) == 0);
20701  {
20702  case 0:
20703  SEND_TO_CLIENT_OR_FAIL (XML_OK ("delete_asset"));
20704  log_event ("asset", "Asset",
20705  delete_asset_data->asset_id, "deleted");
20706  break;
20707  case 1:
20708  SEND_TO_CLIENT_OR_FAIL
20709  (XML_ERROR_SYNTAX ("delete_asset",
20710  "Asset is in use"));
20711  log_event_fail ("asset", "Asset",
20713  "deleted");
20714  break;
20715  case 2:
20716  if (send_find_error_to_client
20717  ("delete_asset",
20718  "asset",
20720  omp_parser))
20721  {
20722  error_send_to_client (error);
20723  return;
20724  }
20725  log_event_fail ("asset", "Asset",
20727  "deleted");
20728  break;
20729  case 3:
20730  SEND_TO_CLIENT_OR_FAIL
20731  (XML_ERROR_SYNTAX ("delete_asset",
20732  "Attempt to delete a predefined asset"));
20733  log_event_fail ("asset", "Asset",
20735  "deleted");
20736  break;
20737  case 4:
20738  SEND_TO_CLIENT_OR_FAIL
20739  (XML_ERROR_SYNTAX ("delete_asset",
20740  "DELETE_ASSET requires an asset_id or a"
20741  "report_id"));
20742  log_event_fail ("asset", "Asset",
20744  "deleted");
20745  break;
20746  case 99:
20747  SEND_TO_CLIENT_OR_FAIL
20748  (XML_ERROR_SYNTAX ("delete_asset",
20749  "Permission denied"));
20750  log_event_fail ("asset", "Asset",
20752  "deleted");
20753  break;
20754  default:
20755  SEND_TO_CLIENT_OR_FAIL
20756  (XML_INTERNAL_ERROR ("delete_asset"));
20757  log_event_fail ("asset", "Asset",
20759  "deleted");
20760  }
20761  else
20762  SEND_TO_CLIENT_OR_FAIL
20763  (XML_ERROR_SYNTAX ("delete_asset",
20764  "DELETE_ASSET requires an asset_id attribute"));
20765  delete_asset_data_reset (delete_asset_data);
20766  set_client_state (CLIENT_AUTHENTIC);
20767  break;
20768 
20769  CASE_DELETE (CONFIG, config, "Config");
20770  CASE_DELETE (CREDENTIAL, credential, "Credential");
20771  CASE_DELETE (FILTER, filter, "Filter");
20772  CASE_DELETE (GROUP, group, "Group");
20773  CASE_DELETE (NOTE, note, "Note");
20774  CASE_DELETE (OVERRIDE, override, "Override");
20775  CASE_DELETE (PERMISSION, permission, "Permission");
20776  CASE_DELETE (PORT_LIST, port_list, "Port list");
20777  CASE_DELETE (PORT_RANGE, port_range, "Port range");
20778  CASE_DELETE (REPORT, report, "Report");
20779  CASE_DELETE (REPORT_FORMAT, report_format, "Report format");
20780  CASE_DELETE (ROLE, role, "Role");
20781  CASE_DELETE (SCANNER, scanner, "Scanner");
20782  CASE_DELETE (SCHEDULE, schedule, "Schedule");
20783  CASE_DELETE (TAG, tag, "Tag");
20784  CASE_DELETE (TARGET, target, "Target");
20785 
20786  case CLIENT_DELETE_TASK:
20788  {
20791  {
20792  case 0: /* Deleted. */
20793  SEND_TO_CLIENT_OR_FAIL (XML_OK ("delete_task"));
20794  log_event ("task", "Task", delete_task_data->task_id,
20795  "deleted");
20796  break;
20797  case 1: /* Delete requested. */
20798  SEND_TO_CLIENT_OR_FAIL (XML_OK_REQUESTED ("delete_task"));
20799  log_event ("task", "Task", delete_task_data->task_id,
20800  "requested for delete");
20801  break;
20802  case 2: /* Hidden task. */
20803  SEND_TO_CLIENT_OR_FAIL
20804  (XML_ERROR_SYNTAX ("delete_task",
20805  "Attempt to delete a hidden task"));
20806  log_event_fail ("task", "Task", delete_task_data->task_id,
20807  "deleted");
20808  break;
20809  case 3: /* Failed to find task. */
20810  if (send_find_error_to_client
20811  ("delete_task", "task", delete_task_data->task_id,
20812  omp_parser))
20813  {
20814  error_send_to_client (error);
20815  return;
20816  }
20817  break;
20818  case 99:
20819  SEND_TO_CLIENT_OR_FAIL
20820  (XML_ERROR_SYNTAX ("delete_task",
20821  "Permission denied"));
20822  log_event_fail ("task", "Task", delete_task_data->task_id,
20823  "deleted");
20824  break;
20825  default: /* Programming error. */
20826  assert (0);
20827  case -1:
20828  /* to_scanner is full. */
20832  g_debug ("delete_task failed\n");
20833  abort ();
20834  break;
20835  case -5:
20836  SEND_XML_SERVICE_DOWN ("delete_task");
20837  log_event_fail ("task", "Task",
20839  "deleted");
20840  break;
20841  case -7:
20842  SEND_TO_CLIENT_OR_FAIL
20843  (XML_ERROR_SYNTAX ("delete_task", "No CA certificate"));
20844  log_event_fail ("task", "Task",
20846  "deleted");
20847  break;
20848  }
20849  }
20850  else
20851  SEND_TO_CLIENT_OR_FAIL
20852  (XML_ERROR_SYNTAX ("delete_task",
20853  "DELETE_TASK requires a task_id attribute"));
20854  delete_task_data_reset (delete_task_data);
20855  set_client_state (CLIENT_AUTHENTIC);
20856  break;
20857 
20858  case CLIENT_DELETE_USER:
20859  assert (strcasecmp ("DELETE_USER", element_name) == 0);
20864  1,
20867  {
20868  case 0:
20869  SEND_TO_CLIENT_OR_FAIL (XML_OK ("delete_user"));
20870  log_event ("user", "User", delete_user_data->user_id,
20871  "deleted");
20872  break;
20873  case 2:
20874  if (send_find_error_to_client ("delete_user",
20875  "user",
20879  omp_parser))
20880  {
20881  error_send_to_client (error);
20882  return;
20883  }
20884  log_event_fail ("user", "User", delete_user_data->user_id,
20885  "deleted");
20886  break;
20887  case 3:
20888  SEND_TO_CLIENT_OR_FAIL
20889  (XML_ERROR_SYNTAX ("delete_user",
20890  "Attempt to delete a predefined"
20891  " user"));
20892  break;
20893  case 4:
20894  SEND_TO_CLIENT_OR_FAIL
20895  (XML_ERROR_SYNTAX ("delete_user",
20896  "User has an active task"));
20897  break;
20898  case 5:
20899  SEND_TO_CLIENT_OR_FAIL
20900  (XML_ERROR_SYNTAX ("delete_user",
20901  "Attempt to delete current user"));
20902  break;
20903  case 6:
20904  if (send_find_error_to_client ("delete_user", "inheriting user",
20906  omp_parser))
20907  {
20908  error_send_to_client (error);
20909  return;
20910  }
20911  break;
20912  case 7:
20913  SEND_TO_CLIENT_OR_FAIL
20914  (XML_ERROR_SYNTAX ("delete_user",
20915  "Inheritor is the same as the deleted"
20916  " user."));
20917  break;
20918  case 8:
20919  SEND_TO_CLIENT_OR_FAIL
20920  (XML_ERROR_SYNTAX ("delete_user",
20921  "Invalid inheritor."));
20922  break;
20923  case 9:
20924  SEND_TO_CLIENT_OR_FAIL
20925  (XML_ERROR_SYNTAX ("delete_user",
20926  "Resources owned by the user are still"
20927  " in use by others."));
20928  break;
20929  case 99:
20930  SEND_TO_CLIENT_OR_FAIL
20931  (XML_ERROR_SYNTAX ("delete_user",
20932  "Permission denied"));
20933  log_event_fail ("user", "User", delete_user_data->user_id,
20934  "deleted");
20935  break;
20936  default:
20937  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("delete_user"));
20938  log_event_fail ("user", "User", delete_user_data->user_id,
20939  "deleted");
20940  }
20941  else
20942  SEND_TO_CLIENT_OR_FAIL
20943  (XML_ERROR_SYNTAX ("delete_user",
20944  "DELETE_USER requires a user_id attribute"));
20945  delete_user_data_reset (delete_user_data);
20946  set_client_state (CLIENT_AUTHENTIC);
20947  break;
20948 
20949  case CLIENT_DESCRIBE_AUTH:
20950  {
20951  if (acl_user_may ("describe_auth") == 0)
20952  {
20953  SEND_TO_CLIENT_OR_FAIL
20954  (XML_ERROR_SYNTAX ("describe_auth",
20955  "Permission denied"));
20956  set_client_state (CLIENT_AUTHENTIC);
20957  break;
20958  }
20959 
20960  SEND_TO_CLIENT_OR_FAIL ("<describe_auth_response"
20961  " status=\"" STATUS_OK "\""
20962  " status_text=\"" STATUS_OK_TEXT "\">"
20963  "<group name=\"method:file\">"
20964  "<auth_conf_setting>"
20965  "<key>enable</key>"
20966  "<value>true</value>"
20967  "</auth_conf_setting>"
20968  "<auth_conf_setting>"
20969  "<key>order</key>"
20970  "<value>1</value>"
20971  "</auth_conf_setting>"
20972  "</group>");
20973 
20974  if (openvas_auth_ldap_enabled ())
20975  {
20976  gchar *ldap_host, *ldap_authdn, *ldap_cacert;
20977  int ldap_enabled, ldap_allow_plaintext;
20978  manage_get_ldap_info (&ldap_enabled, &ldap_host, &ldap_authdn,
20979  &ldap_allow_plaintext, &ldap_cacert);
20980  SENDF_TO_CLIENT_OR_FAIL
20981  ("<group name=\"method:ldap_connect\">"
20982  "<auth_conf_setting>"
20983  "<key>enable</key>"
20984  "<value>%s</value>"
20985  "</auth_conf_setting>"
20986  "<auth_conf_setting>"
20987  "<key>order</key>"
20988  "<value>0</value>"
20989  "</auth_conf_setting>"
20990  "<auth_conf_setting>"
20991  "<key>ldaphost</key>"
20992  "<value>%s</value>"
20993  "</auth_conf_setting>"
20994  "<auth_conf_setting>"
20995  "<key>authdn</key>"
20996  "<value>%s</value>"
20997  "</auth_conf_setting>"
20998  "<auth_conf_setting>"
20999  "<key>allow-plaintext</key>"
21000  "<value>%i</value>"
21001  "</auth_conf_setting>",
21002  ldap_enabled ? "true" : "false",
21003  ldap_host,
21004  ldap_authdn,
21005  ldap_allow_plaintext);
21006 
21007  g_free (ldap_host);
21008  g_free (ldap_authdn);
21009 
21010  if (ldap_cacert)
21011  {
21012  time_t activation_time, expiration_time;
21013  gchar *activation_time_str, *expiration_time_str;
21014  gchar *fingerprint, *issuer;
21015 
21016  SENDF_TO_CLIENT_OR_FAIL
21017  ("<auth_conf_setting>"
21018  "<key>cacert</key>"
21019  "<value>%s</value>",
21020  ldap_cacert);
21021 
21022  get_certificate_info (ldap_cacert, &activation_time,
21023  &expiration_time, &fingerprint,
21024  &issuer);
21025  g_warning ("got");
21026  activation_time_str = certificate_iso_time (activation_time);
21027  g_warning ("got");
21028  expiration_time_str = certificate_iso_time (expiration_time);
21029  g_warning ("got");
21030  SENDF_TO_CLIENT_OR_FAIL
21031  ("<certificate_info>"
21032  "<time_status>%s</time_status>"
21033  "<activation_time>%s</activation_time>"
21034  "<expiration_time>%s</expiration_time>"
21035  "<md5_fingerprint>%s</md5_fingerprint>"
21036  "<issuer>%s</issuer>"
21037  "</certificate_info>",
21038  certificate_time_status (activation_time, expiration_time),
21039  activation_time_str,
21040  expiration_time_str,
21041  fingerprint,
21042  issuer);
21043  g_warning ("free");
21044  g_free (activation_time_str);
21045  g_free (expiration_time_str);
21046  g_free (fingerprint);
21047  g_free (issuer);
21048 
21049  SEND_TO_CLIENT_OR_FAIL ("</auth_conf_setting>");
21050 
21051  g_free (ldap_cacert);
21052  }
21053 
21054  SEND_TO_CLIENT_OR_FAIL ("</group>");
21055  }
21056 
21057  if (openvas_auth_radius_enabled ())
21058  {
21059  char *radius_host, *radius_key;
21060  int radius_enabled;
21061  manage_get_radius_info (&radius_enabled, &radius_host,
21062  &radius_key);
21063  SENDF_TO_CLIENT_OR_FAIL
21064  ("<group name=\"method:radius_connect\">"
21065  "<auth_conf_setting>"
21066  "<key>enable</key>"
21067  "<value>%s</value>"
21068  "</auth_conf_setting>"
21069  "<auth_conf_setting>"
21070  "<key>radiushost</key>"
21071  "<value>%s</value>"
21072  "</auth_conf_setting>"
21073  "<auth_conf_setting>"
21074  "<key>radiuskey</key>"
21075  "<value>%s</value>"
21076  "</auth_conf_setting>"
21077  "</group>",
21078  radius_enabled ? "true" : "false", radius_host, radius_key);
21079  g_free (radius_host);
21080  g_free (radius_key);
21081  }
21082 
21083  SEND_TO_CLIENT_OR_FAIL ("</describe_auth_response>");
21084 
21085  set_client_state (CLIENT_AUTHENTIC);
21086  break;
21087  }
21088 
21089  case CLIENT_GET_AGENTS:
21090  assert (strcasecmp ("GET_AGENTS", element_name) == 0);
21091  return handle_get_agents (omp_parser, error);
21092 
21093  case CLIENT_GET_AGGREGATES:
21094  assert (strcasecmp ("GET_AGGREGATES", element_name) == 0);
21095  return handle_get_aggregates (omp_parser, error);
21096 
21097  CLOSE (CLIENT_GET_AGGREGATES, DATA_COLUMN);
21098  CLOSE (CLIENT_GET_AGGREGATES, SORT);
21099  CLOSE (CLIENT_GET_AGGREGATES, TEXT_COLUMN);
21100 
21101  case CLIENT_GET_ALERTS:
21102  assert (strcasecmp ("GET_ALERTS", element_name) == 0);
21103  return handle_get_alerts (omp_parser, error);
21104 
21105  case CLIENT_GET_ASSETS:
21106  assert (strcasecmp ("GET_ASSETS", element_name) == 0);
21107  return handle_get_assets (omp_parser, error);
21108 
21109  case CLIENT_GET_CONFIGS:
21110  assert (strcasecmp ("GET_CONFIGS", element_name) == 0);
21111  return handle_get_configs (omp_parser, error);
21112 
21114  assert (strcasecmp ("GET_CREDENTIALS", element_name) == 0);
21115  return handle_get_credentials (omp_parser, error);
21116 
21117  case CLIENT_GET_FEEDS:
21118  assert (strcasecmp ("GET_FEEDS", element_name) == 0);
21119  return handle_get_feeds (omp_parser, error);
21120 
21121  case CLIENT_GET_FILTERS:
21122  assert (strcasecmp ("GET_FILTERS", element_name) == 0);
21123  return handle_get_filters (omp_parser, error);
21124 
21125  case CLIENT_GET_GROUPS:
21126  assert (strcasecmp ("GET_GROUPS", element_name) == 0);
21127  return handle_get_groups (omp_parser, error);
21128 
21129  case CLIENT_GET_INFO:
21130  assert (strcasecmp ("GET_INFO", element_name) == 0);
21131  return handle_get_info (omp_parser, error);
21132 
21133  case CLIENT_GET_NOTES:
21134  assert (strcasecmp ("GET_NOTES", element_name) == 0);
21135  return handle_get_notes (omp_parser, error);
21136 
21137  case CLIENT_GET_NVTS:
21138  assert (strcasecmp ("GET_NVTS", element_name) == 0);
21139  return handle_get_nvts (omp_parser, error);
21140 
21142  assert (strcasecmp ("GET_NVT_FAMILIES", element_name) == 0);
21143  return handle_get_nvt_families (omp_parser, error);
21144 
21145  case CLIENT_GET_OVERRIDES:
21146  assert (strcasecmp ("GET_OVERRIDES", element_name) == 0);
21147  return handle_get_overrides (omp_parser, error);
21148 
21150  assert (strcasecmp ("GET_PERMISSIONS", element_name) == 0);
21151  return handle_get_permissions (omp_parser, error);
21152 
21153  case CLIENT_GET_PORT_LISTS:
21154  assert (strcasecmp ("GET_PORT_LISTS", element_name) == 0);
21155  return handle_get_port_lists (omp_parser, error);
21156 
21158  assert (strcasecmp ("GET_PREFERENCES", element_name) == 0);
21159  return handle_get_preferences (omp_parser, error);
21160 
21161  case CLIENT_GET_REPORTS:
21162  assert (strcasecmp ("GET_REPORTS", element_name) == 0);
21163  return handle_get_reports (omp_parser, error);
21164 
21166  assert (strcasecmp ("GET_REPORT_FORMATS", element_name) == 0);
21167  return handle_get_report_formats (omp_parser, error);
21168 
21169  case CLIENT_GET_RESULTS:
21170  assert (strcasecmp ("GET_RESULTS", element_name) == 0);
21171  return handle_get_results (omp_parser, error);
21172 
21173  case CLIENT_GET_ROLES:
21174  assert (strcasecmp ("GET_ROLES", element_name) == 0);
21175  return handle_get_roles (omp_parser, error);
21176 
21177  case CLIENT_GET_SCANNERS:
21178  assert (strcasecmp ("GET_SCANNERS", element_name) == 0);
21179  return handle_get_scanners (omp_parser, error);
21180 
21181  case CLIENT_GET_SCHEDULES:
21182  assert (strcasecmp ("GET_SCHEDULES", element_name) == 0);
21183  return handle_get_schedules (omp_parser, error);
21184 
21185  case CLIENT_GET_SETTINGS:
21186  assert (strcasecmp ("GET_SETTINGS", element_name) == 0);
21187  return handle_get_settings (omp_parser, error);
21188 
21190  assert (strcasecmp ("GET_SYSTEM_REPORTS", element_name) == 0);
21191  return handle_get_system_reports (omp_parser, error);
21192 
21193  case CLIENT_GET_TAGS:
21194  assert (strcasecmp ("GET_TAGS", element_name) == 0);
21195  return handle_get_tags (omp_parser, error);
21196 
21197  case CLIENT_GET_TARGETS:
21198  assert (strcasecmp ("GET_TARGETS", element_name) == 0);
21199  return handle_get_targets (omp_parser, error);
21200 
21201  case CLIENT_GET_TASKS:
21202  assert (strcasecmp ("GET_TASKS", element_name) == 0);
21203  return handle_get_tasks (omp_parser, error);
21204 
21205  case CLIENT_GET_USERS:
21206  assert (strcasecmp ("GET_USERS", element_name) == 0);
21207  return handle_get_users (omp_parser, error);
21208 
21209  case CLIENT_GET_VERSION:
21211  assert (strcasecmp ("GET_VERSION", element_name) == 0);
21212  return handle_get_version (omp_parser, error);
21213 
21214  case CLIENT_HELP:
21215  if (acl_user_may ("help") == 0)
21216  {
21217  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX ("help",
21218  "Permission denied"));
21219  help_data_reset (help_data);
21220  set_client_state (CLIENT_AUTHENTIC);
21221  break;
21222  }
21223 
21224  if (help_data->format == NULL
21225  || (strcmp (help_data->format, "text") == 0))
21226  {
21227  command_t *commands;
21228  SEND_TO_CLIENT_OR_FAIL ("<help_response"
21229  " status=\"" STATUS_OK "\""
21230  " status_text=\"" STATUS_OK_TEXT "\">\n");
21231  commands = omp_commands;
21232  while ((*commands).name)
21233  {
21234  if (command_disabled (omp_parser, (*commands).name) == 0)
21235  {
21236  int count;
21237  SENDF_TO_CLIENT_OR_FAIL (" %s",
21238  (*commands).name);
21239  for (count = 23 - strlen ((*commands).name);
21240  count > 0;
21241  count--)
21242  SEND_TO_CLIENT_OR_FAIL (" ");
21243  SENDF_TO_CLIENT_OR_FAIL ("%s\n",
21244  (*commands).summary);
21245  }
21246  commands++;
21247  }
21248  SEND_TO_CLIENT_OR_FAIL ("</help_response>");
21249  }
21250  else if (help_data->type && (strcmp (help_data->type, "brief") == 0))
21251  {
21252  command_t *commands;
21253  SEND_TO_CLIENT_OR_FAIL ("<help_response"
21254  " status=\"" STATUS_OK "\""
21255  " status_text=\"" STATUS_OK_TEXT "\">\n"
21256  "<schema"
21257  " format=\"XML\""
21258  " extension=\"xml\""
21259  " content_type=\"text/xml\">");
21260  commands = omp_commands;
21261  while ((*commands).name)
21262  {
21263  if ((command_disabled (omp_parser, (*commands).name) == 0)
21264  && ((current_credentials.uuid == NULL)
21265  || acl_user_may ((*commands).name)))
21266  SENDF_TO_CLIENT_OR_FAIL ("<command>"
21267  "<name>%s</name>"
21268  "<summary>%s</summary>"
21269  "</command>",
21270  (*commands).name,
21271  (*commands).summary);
21272  commands++;
21273  }
21274  SEND_TO_CLIENT_OR_FAIL ("</schema>"
21275  "</help_response>");
21276  }
21277  else
21278  {
21279  gchar *extension, *content_type, *output;
21280  gsize output_len;
21281 
21282  switch (manage_schema (help_data->format,
21283  &output,
21284  &output_len,
21285  &extension,
21286  &content_type))
21287  {
21288  case 0:
21289  break;
21290  case 1:
21291  assert (help_data->format);
21292  if (send_find_error_to_client ("help", "schema_format",
21293  help_data->format, omp_parser))
21294  {
21295  error_send_to_client (error);
21296  return;
21297  }
21298  help_data_reset (help_data);
21299  set_client_state (CLIENT_AUTHENTIC);
21300  return;
21301  break;
21302  case 2:
21303  SEND_TO_CLIENT_OR_FAIL
21304  (XML_ERROR_SYNTAX ("help",
21305  "Brief help is only available in XML."));
21306  help_data_reset (help_data);
21307  set_client_state (CLIENT_AUTHENTIC);
21308  return;
21309  break;
21310  default:
21311  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("help"));
21312  help_data_reset (help_data);
21313  set_client_state (CLIENT_AUTHENTIC);
21314  return;
21315  break;
21316  }
21317 
21318  SENDF_TO_CLIENT_OR_FAIL ("<help_response"
21319  " status=\"" STATUS_OK "\""
21320  " status_text=\"" STATUS_OK_TEXT "\">"
21321  "<schema"
21322  " format=\"%s\""
21323  " extension=\"%s\""
21324  " content_type=\"%s\">",
21325  help_data->format
21326  ? help_data->format
21327  : "XML",
21328  extension,
21329  content_type);
21330  g_free (extension);
21331  g_free (content_type);
21332 
21333  if (output && strlen (output))
21334  {
21335  /* Encode and send the output. */
21336 
21337  if (help_data->format
21338  && strcasecmp (help_data->format, "XML"))
21339  {
21340  gchar *base64;
21341 
21342  base64 = g_base64_encode ((guchar*) output, output_len);
21343  if (send_to_client (base64,
21344  write_to_client,
21345  write_to_client_data))
21346  {
21347  g_free (output);
21348  g_free (base64);
21349  error_send_to_client (error);
21350  return;
21351  }
21352  g_free (base64);
21353  }
21354  else
21355  {
21356  /* Special case the XML schema, bah. */
21357  if (send_to_client (output,
21358  write_to_client,
21359  write_to_client_data))
21360  {
21361  g_free (output);
21362  error_send_to_client (error);
21363  return;
21364  }
21365  }
21366  }
21367  g_free (output);
21368  SEND_TO_CLIENT_OR_FAIL ("</schema>"
21369  "</help_response>");
21370  }
21371  help_data_reset (help_data);
21372  set_client_state (CLIENT_AUTHENTIC);
21373  break;
21374 
21375  case CLIENT_CREATE_AGENT:
21376  {
21377  agent_t agent;
21378 
21379  assert (strcasecmp ("CREATE_AGENT", element_name) == 0);
21380 
21381  if (create_agent_data->copy)
21382  switch (copy_agent (create_agent_data->name,
21385  &agent))
21386  {
21387  case 0:
21388  {
21389  char *uuid;
21390  uuid = agent_uuid (agent);
21391  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_agent"),
21392  uuid);
21393  log_event ("agent", "Agent", uuid, "created");
21394  free (uuid);
21395  break;
21396  }
21397  case 1:
21398  SEND_TO_CLIENT_OR_FAIL
21399  (XML_ERROR_SYNTAX ("create_agent",
21400  "Agent exists already"));
21401  log_event_fail ("agent", "Agent", NULL, "created");
21402  break;
21403  case 2:
21404  if (send_find_error_to_client ("create_agent", "agent",
21406  omp_parser))
21407  {
21408  error_send_to_client (error);
21409  return;
21410  }
21411  log_event_fail ("agent", "Agent", NULL, "created");
21412  break;
21413  case 99:
21414  SEND_TO_CLIENT_OR_FAIL
21415  (XML_ERROR_SYNTAX ("create_agent",
21416  "Permission denied"));
21417  log_event_fail ("agent", "Agent", NULL, "created");
21418  break;
21419  case -1:
21420  default:
21421  SEND_TO_CLIENT_OR_FAIL
21422  (XML_INTERNAL_ERROR ("create_agent"));
21423  log_event_fail ("agent", "Agent", NULL, "created");
21424  break;
21425  }
21426  else if (create_agent_data->name == NULL)
21427  SEND_TO_CLIENT_OR_FAIL
21428  (XML_ERROR_SYNTAX ("create_agent",
21429  "CREATE_AGENT requires a NAME"));
21430  else if (strlen (create_agent_data->name) == 0)
21431  {
21432  SEND_TO_CLIENT_OR_FAIL
21433  (XML_ERROR_SYNTAX ("create_agent",
21434  "CREATE_AGENT name must be at"
21435  " least one character long"));
21436  }
21437  else if (strlen (create_agent_data->installer) == 0)
21438  {
21439  SEND_TO_CLIENT_OR_FAIL
21440  (XML_ERROR_SYNTAX ("create_agent",
21441  "CREATE_AGENT installer must be at"
21442  " least one byte long"));
21443  }
21444  else switch (create_agent (create_agent_data->name,
21451  &agent))
21452  {
21453  case 0:
21454  {
21455  char *uuid;
21456  uuid = agent_uuid (agent);
21457  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_agent"),
21458  uuid);
21459  log_event ("agent", "Agent", uuid, "created");
21460  g_free (uuid);
21461  break;
21462  }
21463  case 1:
21464  SEND_TO_CLIENT_OR_FAIL
21465  (XML_ERROR_SYNTAX ("create_agent",
21466  "Agent exists already"));
21467  break;
21468  case 2:
21469  SEND_TO_CLIENT_OR_FAIL
21470  (XML_ERROR_SYNTAX ("create_agent",
21471  "Name may only contain alphanumeric"
21472  " characters"));
21473  break;
21474  case 99:
21475  SEND_TO_CLIENT_OR_FAIL
21476  (XML_ERROR_SYNTAX ("create_agent",
21477  "Permission denied"));
21478  break;
21479  default:
21480  assert (0);
21481  case -1:
21482  SEND_TO_CLIENT_OR_FAIL
21483  (XML_INTERNAL_ERROR ("create_agent"));
21484  break;
21485  }
21486  create_agent_data_reset (create_agent_data);
21487  set_client_state (CLIENT_AUTHENTIC);
21488  break;
21489  }
21490  CLOSE (CLIENT_CREATE_AGENT, COMMENT);
21491  CLOSE (CLIENT_CREATE_AGENT, COPY);
21492  CLOSE (CLIENT_CREATE_AGENT, HOWTO_INSTALL);
21493  CLOSE (CLIENT_CREATE_AGENT, HOWTO_USE);
21494  CLOSE (CLIENT_CREATE_AGENT, INSTALLER);
21496  CLOSE (CLIENT_CREATE_AGENT_INSTALLER, SIGNATURE);
21498 
21499  case CLIENT_CREATE_ASSET:
21500  {
21501  resource_t asset;
21502 
21503  assert (strcasecmp ("CREATE_ASSET", element_name) == 0);
21504 
21505  if (create_asset_data->report_id == NULL
21506  && create_asset_data->name == NULL)
21507  SEND_TO_CLIENT_OR_FAIL
21508  (XML_ERROR_SYNTAX ("create_asset",
21509  "CREATE_ASSET requires a report ID or host"
21510  " name"));
21511  else if (create_asset_data->report_id)
21514  {
21515  case 0:
21516  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED ("create_asset"));
21517  log_event ("asset", "Asset", NULL, "created");
21518  break;
21519  case 1:
21520  SEND_TO_CLIENT_OR_FAIL
21521  (XML_ERROR_SYNTAX ("create_asset",
21522  "Asset exists already"));
21523  log_event_fail ("asset", "Asset", NULL, "created");
21524  break;
21525  case 2:
21526  SEND_TO_CLIENT_OR_FAIL
21527  (XML_ERROR_SYNTAX ("create_asset",
21528  "Name may only contain alphanumeric"
21529  " characters"));
21530  log_event_fail ("asset", "Asset", NULL, "created");
21531  break;
21532  case 99:
21533  SEND_TO_CLIENT_OR_FAIL
21534  (XML_ERROR_SYNTAX ("create_asset",
21535  "Permission denied"));
21536  log_event_fail ("asset", "Asset", NULL, "created");
21537  break;
21538  default:
21539  assert (0);
21540  case -1:
21541  SEND_TO_CLIENT_OR_FAIL
21542  (XML_INTERNAL_ERROR ("create_asset"));
21543  log_event_fail ("asset", "Asset", NULL, "created");
21544  break;
21545  }
21546  else switch (create_asset_host (create_asset_data->name,
21548  &asset))
21549  {
21550  case 0:
21551  {
21552  char *uuid;
21553  uuid = host_uuid (asset);
21554  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_asset"),
21555  uuid);
21556  log_event ("asset", "Asset", uuid, "created");
21557  g_free (uuid);
21558  break;
21559  }
21560  case 1:
21561  SEND_TO_CLIENT_OR_FAIL
21562  (XML_ERROR_SYNTAX ("create_asset",
21563  "Asset exists already"));
21564  log_event_fail ("asset", "Asset", NULL, "created");
21565  break;
21566  case 2:
21567  SEND_TO_CLIENT_OR_FAIL
21568  (XML_ERROR_SYNTAX ("create_asset",
21569  "Name may only contain alphanumeric"
21570  " characters"));
21571  log_event_fail ("asset", "Asset", NULL, "created");
21572  break;
21573  case 99:
21574  SEND_TO_CLIENT_OR_FAIL
21575  (XML_ERROR_SYNTAX ("create_asset",
21576  "Permission denied"));
21577  log_event_fail ("asset", "Asset", NULL, "created");
21578  break;
21579  default:
21580  assert (0);
21581  case -1:
21582  SEND_TO_CLIENT_OR_FAIL
21583  (XML_INTERNAL_ERROR ("create_asset"));
21584  log_event_fail ("asset", "Asset", NULL, "created");
21585  break;
21586  }
21587  create_asset_data_reset (create_asset_data);
21588  set_client_state (CLIENT_AUTHENTIC);
21589  break;
21590  }
21591  CLOSE (CLIENT_CREATE_ASSET, REPORT);
21592  CLOSE (CLIENT_CREATE_ASSET, ASSET);
21593  CLOSE (CLIENT_CREATE_ASSET_ASSET, COMMENT);
21598 
21599  case CLIENT_CREATE_CONFIG:
21600  {
21601  config_t new_config;
21602 
21603  assert (strcasecmp ("CREATE_CONFIG", element_name) == 0);
21604  assert (import_config_data->import
21605  || (create_config_data->name != NULL));
21606 
21607  /* For now the import element, GET_CONFIGS_RESPONSE, overrides
21608  * any other elements. */
21609 
21611  {
21612  char *name;
21613  array_terminate (import_config_data->nvt_selectors);
21614  array_terminate (import_config_data->preferences);
21620  &new_config,
21621  &name))
21622  {
21623  case 0:
21624  {
21625  gchar *uuid = config_uuid (new_config);
21626  SENDF_TO_CLIENT_OR_FAIL
21627  ("<create_config_response"
21628  " status=\"" STATUS_OK_CREATED "\""
21629  " status_text=\"" STATUS_OK_CREATED_TEXT "\""
21630  " id=\"%s\">"
21631  /* This is a hack for the GSA, which should really
21632  * do a GET_CONFIG with the ID to get the name. */
21633  "<config id=\"%s\"><name>%s</name></config>"
21634  "</create_config_response>",
21635  uuid,
21636  uuid,
21637  name);
21638  log_event ("config", "Scan config", uuid, "created");
21639  g_free (uuid);
21640  free (name);
21641  break;
21642  }
21643  case 1:
21644  SEND_TO_CLIENT_OR_FAIL
21645  (XML_ERROR_SYNTAX ("create_config",
21646  "Config exists already"));
21647  log_event_fail ("config", "Scan config", NULL, "created");
21648  break;
21649  case 99:
21650  SEND_TO_CLIENT_OR_FAIL
21651  (XML_ERROR_SYNTAX ("create_config",
21652  "Permission denied"));
21653  log_event_fail ("config", "Scan config", NULL, "created");
21654  break;
21655  case -1:
21656  SEND_TO_CLIENT_OR_FAIL
21657  (XML_INTERNAL_ERROR ("create_config"));
21658  log_event_fail ("config", "Scan config", NULL, "created");
21659  break;
21660  case -2:
21661  SEND_TO_CLIENT_OR_FAIL
21662  (XML_ERROR_SYNTAX ("create_config",
21663  "CREATE_CONFIG import name must be at"
21664  " least one character long"));
21665  log_event_fail ("config", "Scan config", NULL, "created");
21666  break;
21667  case -3:
21668  SEND_TO_CLIENT_OR_FAIL
21669  (XML_ERROR_SYNTAX ("create_config",
21670  "Error in NVT_SELECTORS element."));
21671  log_event_fail ("config", "Scan config", NULL, "created");
21672  break;
21673  case -4:
21674  SEND_TO_CLIENT_OR_FAIL
21675  (XML_ERROR_SYNTAX ("create_config",
21676  "Error in PREFERENCES element."));
21677  log_event_fail ("config", "Scan config", NULL, "created");
21678  break;
21679  }
21680  }
21681  else if (create_config_data->scanner)
21682  {
21683  char *uuid = NULL;
21684 
21687  create_config_data->comment, &uuid))
21688  {
21689  case 0:
21690  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID
21691  ("create_config"), uuid);
21692  log_event ("config", "Scan config", uuid, "created");
21693  break;
21694  case 1:
21695  SENDF_TO_CLIENT_OR_FAIL
21696  (XML_ERROR_SYNTAX ("create_config",
21697  "Failed to find scanner"));
21698  break;
21699  case 2:
21700  SENDF_TO_CLIENT_OR_FAIL
21701  (XML_ERROR_SYNTAX ("create_config",
21702  "Scanner not of type OSP"));
21703  break;
21704  case 3:
21705  SENDF_TO_CLIENT_OR_FAIL
21706  (XML_ERROR_SYNTAX ("create_config",
21707  "Config name exists already"));
21708  break;
21709  case 4:
21710  SENDF_TO_CLIENT_OR_FAIL
21711  (XML_ERROR_SYNTAX ("create_config",
21712  "Failed to get params from scanner"
21713  " - the scanner may be offline or not"
21714  " configured correctly"));
21715  break;
21716  case 99:
21717  SEND_TO_CLIENT_OR_FAIL
21718  (XML_ERROR_SYNTAX ("create_config",
21719  "Permission denied"));
21720  log_event_fail ("config", "Scan config", NULL, "created");
21721  break;
21722  case -1:
21723  default:
21724  SEND_TO_CLIENT_OR_FAIL
21725  (XML_INTERNAL_ERROR ("create_config"));
21726  log_event_fail ("config", "Scan config", NULL, "created");
21727  break;
21728  }
21729  g_free (uuid);
21730  }
21731  else if (strlen (create_config_data->name) == 0
21732  && (create_config_data->copy == NULL
21733  || strlen (create_config_data->copy) == 0))
21734  {
21735  log_event_fail ("config", "Scan config", NULL, "created");
21736  SEND_TO_CLIENT_OR_FAIL
21737  (XML_ERROR_SYNTAX ("create_config",
21738  "CREATE_CONFIG name and base config to copy"
21739  " must be at least one character long"));
21740  }
21741  else if (create_config_data->copy == NULL)
21742  {
21743  log_event_fail ("config", "Scan config", NULL, "created");
21744  SEND_TO_CLIENT_OR_FAIL
21745  (XML_ERROR_SYNTAX ("create_config",
21746  "CREATE_CONFIG requires a COPY element"));
21747  }
21748  else switch (copy_config (create_config_data->name,
21751  &new_config))
21752  {
21753  case 0:
21754  {
21755  char *uuid = config_uuid (new_config);
21756  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_config"),
21757  uuid);
21758  log_event ("config", "Scan config", uuid, "created");
21759  free (uuid);
21760  break;
21761  }
21762  case 1:
21763  SEND_TO_CLIENT_OR_FAIL
21764  (XML_ERROR_SYNTAX ("create_config",
21765  "Config exists already"));
21766  log_event_fail ("config", "Scan config", NULL, "created");
21767  break;
21768  case 2:
21769  if (send_find_error_to_client ("create_config", "config",
21771  omp_parser))
21772  {
21773  error_send_to_client (error);
21774  return;
21775  }
21776  log_event_fail ("config", "Config", NULL, "created");
21777  break;
21778  case 99:
21779  SEND_TO_CLIENT_OR_FAIL
21780  (XML_ERROR_SYNTAX ("create_config",
21781  "Permission denied"));
21782  log_event_fail ("config", "Scan config", NULL, "created");
21783  break;
21784  case -1:
21785  default:
21786  SEND_TO_CLIENT_OR_FAIL
21787  (XML_INTERNAL_ERROR ("create_config"));
21788  log_event_fail ("config", "Scan config", NULL, "created");
21789  break;
21790  }
21791  create_config_data_reset (create_config_data);
21792  set_client_state (CLIENT_AUTHENTIC);
21793  break;
21794  }
21795  CLOSE (CLIENT_CREATE_CONFIG, COMMENT);
21796  CLOSE (CLIENT_CREATE_CONFIG, COPY);
21797  CLOSE (CLIENT_CREATE_CONFIG, SCANNER);
21799 
21800  case CLIENT_C_C_GCR:
21801  assert (strcasecmp ("GET_CONFIGS_RESPONSE", element_name) == 0);
21802  set_client_state (CLIENT_CREATE_CONFIG);
21803  break;
21804  CLOSE (CLIENT_C_C_GCR, CONFIG);
21805  CLOSE (CLIENT_C_C_GCR_CONFIG, COMMENT);
21807  CLOSE (CLIENT_C_C_GCR_CONFIG, NVT_SELECTORS);
21809  {
21810  int include;
21811 
21812  assert (strcasecmp ("NVT_SELECTOR", element_name) == 0);
21813 
21815  && strcmp (import_config_data->nvt_selector_include, "0") == 0)
21816  include = 0;
21817  else
21818  include = 1;
21819 
21820  array_add (import_config_data->nvt_selectors,
21821  nvt_selector_new
21824  include,
21826 
21832 
21833  set_client_state (CLIENT_C_C_GCR_CONFIG_NVT_SELECTORS);
21834  break;
21835  }
21840  CLOSE (CLIENT_C_C_GCR_CONFIG, PREFERENCES);
21842  assert (strcasecmp ("PREFERENCE", element_name) == 0);
21843  array_terminate (import_config_data->preference_alts);
21844 
21845  char* preference_hr_name;
21846  if (import_config_data->type == NULL
21847  || strcmp (import_config_data->type, "0") == 0)
21848  {
21849  // Classic OpenVAS config preference
21850  preference_hr_name = NULL;
21851  }
21853  {
21854  // OSP config preference with hr_name given
21855  preference_hr_name
21857  }
21858  else
21859  {
21860  // Old OSP config without hr_name
21861  preference_hr_name
21863  }
21864 
21865  array_add (import_config_data->preferences,
21866  preference_new (import_config_data->preference_name,
21873  preference_hr_name));
21882  set_client_state (CLIENT_C_C_GCR_CONFIG_PREFERENCES);
21883  break;
21885  assert (strcasecmp ("ALT", element_name) == 0);
21886  array_add (import_config_data->preference_alts,
21890  break;
21898  CLOSE (CLIENT_C_C_GCR_CONFIG, TYPE);
21899 
21900  case CLIENT_CREATE_ALERT:
21901  {
21902  event_t event;
21903  alert_condition_t condition;
21904  alert_method_t method;
21905  alert_t new_alert;
21906 
21907  assert (strcasecmp ("CREATE_ALERT", element_name) == 0);
21908  assert (create_alert_data->name != NULL);
21909  assert (create_alert_data->condition != NULL);
21910  assert (create_alert_data->method != NULL);
21911  assert (create_alert_data->event != NULL);
21912 
21913  array_terminate (create_alert_data->condition_data);
21914  array_terminate (create_alert_data->event_data);
21915  array_terminate (create_alert_data->method_data);
21916 
21917  if (create_alert_data->copy)
21918  switch (copy_alert (create_alert_data->name,
21921  &new_alert))
21922  {
21923  case 0:
21924  {
21925  char *uuid;
21926  uuid = alert_uuid (new_alert);
21927  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_alert"),
21928  uuid);
21929  log_event ("alert", "Alert", uuid, "created");
21930  free (uuid);
21931  break;
21932  }
21933  case 1:
21934  SEND_TO_CLIENT_OR_FAIL
21935  (XML_ERROR_SYNTAX ("create_alert",
21936  "Alert exists already"));
21937  log_event_fail ("alert", "Alert", NULL, "created");
21938  break;
21939  case 2:
21940  if (send_find_error_to_client ("create_alert", "alert",
21942  omp_parser))
21943  {
21944  error_send_to_client (error);
21945  return;
21946  }
21947  log_event_fail ("alert", "Alert", NULL, "created");
21948  break;
21949  case 99:
21950  SEND_TO_CLIENT_OR_FAIL
21951  (XML_ERROR_SYNTAX ("create_alert",
21952  "Permission denied"));
21953  log_event_fail ("alert", "Alert", NULL, "created");
21954  break;
21955  case -1:
21956  default:
21957  SEND_TO_CLIENT_OR_FAIL
21958  (XML_INTERNAL_ERROR ("create_alert"));
21959  log_event_fail ("alert", "Alert", NULL, "created");
21960  break;
21961  }
21962  else if (strlen (create_alert_data->name) == 0)
21963  SEND_TO_CLIENT_OR_FAIL
21964  (XML_ERROR_SYNTAX ("create_alert",
21965  "CREATE_ALERT requires NAME element which"
21966  " is at least one character long"));
21967  else if (strlen (create_alert_data->condition) == 0)
21968  SEND_TO_CLIENT_OR_FAIL
21969  (XML_ERROR_SYNTAX ("create_alert",
21970  "CREATE_ALERT requires a value in a"
21971  " CONDITION element"));
21972  else if (strlen (create_alert_data->event) == 0)
21973  SEND_TO_CLIENT_OR_FAIL
21974  (XML_ERROR_SYNTAX ("create_alert",
21975  "CREATE_ALERT requires a value in an"
21976  " EVENT element"));
21977  else if (strlen (create_alert_data->method) == 0)
21978  SEND_TO_CLIENT_OR_FAIL
21979  (XML_ERROR_SYNTAX ("create_alert",
21980  "CREATE_ALERT requires a value in a"
21981  " METHOD element"));
21982  else if ((condition = alert_condition_from_name
21984  == 0)
21985  SEND_TO_CLIENT_OR_FAIL
21986  (XML_ERROR_SYNTAX ("create_alert",
21987  "Failed to recognise condition name"));
21988  else if ((event = event_from_name (create_alert_data->event))
21989  == 0)
21990  SEND_TO_CLIENT_OR_FAIL
21991  (XML_ERROR_SYNTAX ("create_alert",
21992  "Failed to recognise event name"));
21993  else if ((method = alert_method_from_name
21995  == 0)
21996  SEND_TO_CLIENT_OR_FAIL
21997  (XML_ERROR_SYNTAX ("create_alert",
21998  "Failed to recognise method name"));
21999  else
22000  {
22004  event,
22006  condition,
22008  method,
22010  &new_alert))
22011  {
22012  case 0:
22013  {
22014  char *uuid;
22015  uuid = alert_uuid (new_alert);
22016  SENDF_TO_CLIENT_OR_FAIL
22017  (XML_OK_CREATED_ID ("create_alert"), uuid);
22018  log_event ("alert", "Alert", uuid, "created");
22019  free (uuid);
22020  break;
22021  }
22022  case 1:
22023  SEND_TO_CLIENT_OR_FAIL
22024  (XML_ERROR_SYNTAX ("create_alert",
22025  "Alert exists already"));
22026  log_event_fail ("alert", "Alert", NULL, "created");
22027  break;
22028  case 2:
22029  SEND_TO_CLIENT_OR_FAIL
22030  (XML_ERROR_SYNTAX ("create_alert",
22031  "Validation of email address failed"));
22032  log_event_fail ("alert", "Alert", NULL, "created");
22033  break;
22034  case 3:
22035  if (send_find_error_to_client ("create_alert", "filter",
22037  omp_parser))
22038  {
22039  error_send_to_client (error);
22040  return;
22041  }
22042  log_event_fail ("alert", "Alert", NULL, "created");
22043  break;
22044  case 4:
22045  SEND_TO_CLIENT_OR_FAIL
22046  (XML_ERROR_SYNTAX ("create_alert",
22047  "Filter type must be result if"
22048  " specified"));
22049  log_event_fail ("alert", "Alert", NULL, "created");
22050  break;
22051  case 5:
22052  SEND_TO_CLIENT_OR_FAIL
22053  (XML_ERROR_SYNTAX ("create_alert",
22054  "Invalid or unexpected condition data"
22055  " name"));
22056  log_event_fail ("alert", "Alert", NULL, "created");
22057  break;
22058  case 6:
22059  SEND_TO_CLIENT_OR_FAIL
22060  (XML_ERROR_SYNTAX ("create_alert",
22061  "Syntax error in condition data"));
22062  log_event_fail ("alert", "Alert", NULL, "created");
22063  break;
22064  case 7:
22065  SEND_TO_CLIENT_OR_FAIL
22066  (XML_ERROR_SYNTAX ("create_alert",
22067  "Email subject too long"));
22068  log_event_fail ("alert", "Alert", NULL, "created");
22069  break;
22070  case 8:
22071  SEND_TO_CLIENT_OR_FAIL
22072  (XML_ERROR_SYNTAX ("create_alert",
22073  "Email message too long"));
22074  log_event_fail ("alert", "Alert", NULL, "created");
22075  break;
22076  case 9:
22077  SEND_TO_CLIENT_OR_FAIL
22078  (XML_ERROR_SYNTAX ("create_alert",
22079  "Failed to find filter for condition"));
22080  log_event_fail ("alert", "Alert", NULL, "created");
22081  break;
22082  case 12:
22083  SEND_TO_CLIENT_OR_FAIL
22084  (XML_ERROR_SYNTAX ("create_alert",
22085  "Error in Send host"));
22086  log_event_fail ("alert", "Alert", NULL, "created");
22087  break;
22088  case 13:
22089  SEND_TO_CLIENT_OR_FAIL
22090  (XML_ERROR_SYNTAX ("create_alert",
22091  "Error in Send port"));
22092  log_event_fail ("alert", "Alert", NULL, "created");
22093  break;
22094  case 14:
22095  SEND_TO_CLIENT_OR_FAIL
22096  (XML_ERROR_SYNTAX ("create_alert",
22097  "Failed to find report format for Send"
22098  " method"));
22099  log_event_fail ("alert", "Alert", NULL, "created");
22100  break;
22101  case 15:
22102  SEND_TO_CLIENT_OR_FAIL
22103  (XML_ERROR_SYNTAX ("create_alert",
22104  "Error in SCP host"));
22105  log_event_fail ("alert", "Alert", NULL, "created");
22106  break;
22107  case 17:
22108  SEND_TO_CLIENT_OR_FAIL
22109  (XML_ERROR_SYNTAX ("create_alert",
22110  "Failed to find report format for SCP"
22111  " method"));
22112  log_event_fail ("alert", "Alert", NULL, "created");
22113  break;
22114  case 18:
22115  SEND_TO_CLIENT_OR_FAIL
22116  (XML_ERROR_SYNTAX ("create_alert",
22117  "Error in SCP credential"));
22118  log_event_fail ("alert", "Alert", NULL, "created");
22119  break;
22120  case 19:
22121  SEND_TO_CLIENT_OR_FAIL
22122  (XML_ERROR_SYNTAX ("create_alert",
22123  "Error in SCP path"));
22124  log_event_fail ("alert", "Alert", NULL, "created");
22125  break;
22126  case 20:
22127  SEND_TO_CLIENT_OR_FAIL
22128  (XML_ERROR_SYNTAX ("create_alert",
22129  "Method does not match event type"));
22130  log_event_fail ("alert", "Alert", NULL, "created");
22131  break;
22132  case 21:
22133  SEND_TO_CLIENT_OR_FAIL
22134  (XML_ERROR_SYNTAX ("create_alert",
22135  "Condition does not match event type"));
22136  log_event_fail ("alert", "Alert", NULL, "created");
22137  break;
22138  case 31:
22139  SEND_TO_CLIENT_OR_FAIL
22140  (XML_ERROR_SYNTAX ("create_alert",
22141  "Unexpected event data name"));
22142  log_event_fail ("alert", "Alert", NULL, "created");
22143  break;
22144  case 32:
22145  SEND_TO_CLIENT_OR_FAIL
22146  (XML_ERROR_SYNTAX ("create_alert",
22147  "Syntax error in event data"));
22148  log_event_fail ("alert", "Alert", NULL, "created");
22149  break;
22150  case 40:
22151  SEND_TO_CLIENT_OR_FAIL
22152  (XML_ERROR_SYNTAX ("create_alert",
22153  "Error in SMB credential"));
22154  log_event_fail ("alert", "Alert", NULL, "created");
22155  break;
22156  case 41:
22157  SEND_TO_CLIENT_OR_FAIL
22158  (XML_ERROR_SYNTAX ("create_alert",
22159  "Error in SMB share path"));
22160  log_event_fail ("alert", "Alert", NULL, "created");
22161  break;
22162  case 42:
22163  SEND_TO_CLIENT_OR_FAIL
22164  (XML_ERROR_SYNTAX ("create_alert",
22165  "Error in SMB file path"));
22166  log_event_fail ("alert", "Alert", NULL, "created");
22167  break;
22168  case 50:
22169  SEND_TO_CLIENT_OR_FAIL
22170  (XML_ERROR_SYNTAX ("create_alert",
22171  "Error in TippingPoint credential"));
22172  log_event_fail ("alert", "Alert", NULL, "created");
22173  break;
22174  case 51:
22175  SEND_TO_CLIENT_OR_FAIL
22176  (XML_ERROR_SYNTAX ("create_alert",
22177  "Error in TippingPoint hostname"));
22178  log_event_fail ("alert", "Alert", NULL, "created");
22179  break;
22180  case 52:
22181  SEND_TO_CLIENT_OR_FAIL
22182  (XML_ERROR_SYNTAX ("create_alert",
22183  "Error in TippingPoint TLS"
22184  " certificate"));
22185  log_event_fail ("alert", "Alert", NULL, "created");
22186  break;
22187  case 53:
22188  SEND_TO_CLIENT_OR_FAIL
22189  (XML_ERROR_SYNTAX ("create_alert",
22190  "TippingPoint TLS workaround must be"
22191  " set to 0 or 1"));
22192  log_event_fail ("alert", "Alert", NULL, "created");
22193  break;
22194  case 99:
22195  SEND_TO_CLIENT_OR_FAIL
22196  (XML_ERROR_SYNTAX ("create_alert",
22197  "Permission denied"));
22198  log_event_fail ("alert", "Alert", NULL, "created");
22199  break;
22200  default:
22201  assert (0);
22202  case -1:
22203  SEND_TO_CLIENT_OR_FAIL
22204  (XML_INTERNAL_ERROR ("create_alert"));
22205  log_event_fail ("alert", "Alert", NULL, "created");
22206  break;
22207  }
22208  }
22209  create_alert_data_reset (create_alert_data);
22210  set_client_state (CLIENT_AUTHENTIC);
22211  break;
22212  }
22213  CLOSE (CLIENT_CREATE_ALERT, COMMENT);
22214  CLOSE (CLIENT_CREATE_ALERT, COPY);
22215  CLOSE (CLIENT_CREATE_ALERT, CONDITION);
22216  CLOSE (CLIENT_CREATE_ALERT, EVENT);
22217  CLOSE (CLIENT_CREATE_ALERT, FILTER);
22218  CLOSE (CLIENT_CREATE_ALERT, METHOD);
22220 
22222  {
22223  gchar *string;
22224 
22225  assert (strcasecmp ("DATA", element_name) == 0);
22227  assert (create_alert_data->part_data);
22228  assert (create_alert_data->part_name);
22229 
22230  string = g_strconcat (create_alert_data->part_name,
22231  "0",
22233  NULL);
22234  string[strlen (create_alert_data->part_name)] = '\0';
22235  array_add (create_alert_data->condition_data, string);
22236 
22237  openvas_free_string_var (&create_alert_data->part_data);
22238  openvas_free_string_var (&create_alert_data->part_name);
22239  openvas_append_string (&create_alert_data->part_data, "");
22240  openvas_append_string (&create_alert_data->part_name, "");
22241  set_client_state (CLIENT_CREATE_ALERT_CONDITION);
22242  break;
22243  }
22245  assert (strcasecmp ("NAME", element_name) == 0);
22246  set_client_state (CLIENT_CREATE_ALERT_CONDITION_DATA);
22247  break;
22248 
22250  {
22251  gchar *string;
22252 
22253  assert (strcasecmp ("DATA", element_name) == 0);
22254  assert (create_alert_data->event_data);
22255  assert (create_alert_data->part_data);
22256  assert (create_alert_data->part_name);
22257 
22258  string = g_strconcat (create_alert_data->part_name,
22259  "0",
22261  NULL);
22262  string[strlen (create_alert_data->part_name)] = '\0';
22263  array_add (create_alert_data->event_data, string);
22264 
22265  openvas_free_string_var (&create_alert_data->part_data);
22266  openvas_free_string_var (&create_alert_data->part_name);
22267  openvas_append_string (&create_alert_data->part_data, "");
22268  openvas_append_string (&create_alert_data->part_name, "");
22269  set_client_state (CLIENT_CREATE_ALERT_EVENT);
22270  break;
22271  }
22273 
22275  {
22276  gchar *string;
22277 
22278  assert (strcasecmp ("DATA", element_name) == 0);
22279  assert (create_alert_data->method_data);
22280  assert (create_alert_data->part_data);
22281  assert (create_alert_data->part_name);
22282 
22283  string = g_strconcat (create_alert_data->part_name,
22284  "0",
22286  NULL);
22287  string[strlen (create_alert_data->part_name)] = '\0';
22288  array_add (create_alert_data->method_data, string);
22289 
22290  openvas_free_string_var (&create_alert_data->part_data);
22291  openvas_free_string_var (&create_alert_data->part_name);
22292  openvas_append_string (&create_alert_data->part_data, "");
22293  openvas_append_string (&create_alert_data->part_name, "");
22294  set_client_state (CLIENT_CREATE_ALERT_METHOD);
22295  break;
22296  }
22298 
22300  {
22301  credential_t new_credential;
22302 
22303  assert (strcasecmp ("CREATE_CREDENTIAL", element_name) == 0);
22304  assert (create_credential_data->name != NULL);
22305 
22310  &new_credential))
22311  {
22312  case 0:
22313  {
22314  char *uuid;
22315  uuid = credential_uuid (new_credential);
22316  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_credential"),
22317  uuid);
22318  log_event ("credential", "Credential", uuid, "created");
22319  free (uuid);
22320  break;
22321  }
22322  case 1:
22323  SEND_TO_CLIENT_OR_FAIL
22324  (XML_ERROR_SYNTAX ("create_credential",
22325  "Credential exists already"));
22326  log_event_fail ("credential", "Credential", NULL, "created");
22327  break;
22328  case 2:
22329  if (send_find_error_to_client ("create_credential",
22330  "credential",
22332  omp_parser))
22333  {
22334  error_send_to_client (error);
22335  return;
22336  }
22337  log_event_fail ("credential", "Credential", NULL, "created");
22338  break;
22339  case 99:
22340  SEND_TO_CLIENT_OR_FAIL
22341  (XML_ERROR_SYNTAX ("create_credential",
22342  "Permission denied"));
22343  log_event_fail ("credential", "Credential", NULL, "created");
22344  break;
22345  case -1:
22346  default:
22347  SEND_TO_CLIENT_OR_FAIL
22348  (XML_INTERNAL_ERROR ("create_credential"));
22349  log_event_fail ("credential", "Credential", NULL, "created");
22350  break;
22351  }
22352  else if (strlen (create_credential_data->name) == 0)
22353  {
22354  SEND_TO_CLIENT_OR_FAIL
22355  (XML_ERROR_SYNTAX ("create_credential",
22356  "CREATE_CREDENTIAL name must be at"
22357  " least one character long"));
22358  }
22359  else if (create_credential_data->login
22360  && strlen (create_credential_data->login) == 0)
22361  {
22362  SEND_TO_CLIENT_OR_FAIL
22363  (XML_ERROR_SYNTAX ("create_credential",
22364  "CREATE_CREDENTIAL login must be at"
22365  " least one character long"));
22366  }
22367  else if (create_credential_data->key
22368  && create_credential_data->key_private == NULL)
22369  {
22370  SEND_TO_CLIENT_OR_FAIL
22371  (XML_ERROR_SYNTAX ("create_credential",
22372  "CREATE_CREDENTIAL KEY requires a PRIVATE"
22373  " key"));
22374  }
22375  else if (create_credential_data->key
22377  && check_private_key (create_credential_data->key_private))
22378  {
22379  SEND_TO_CLIENT_OR_FAIL
22380  (XML_ERROR_SYNTAX ("create_credential",
22381  "Erroneous Private Key."));
22382  }
22384  && check_certificate (create_credential_data->certificate))
22385  {
22386  SEND_TO_CLIENT_OR_FAIL
22387  (XML_ERROR_SYNTAX ("create_credential",
22388  "Erroneous Certificate."));
22389  }
22390  else switch (create_credential
22405  &new_credential))
22406  {
22407  case 0:
22408  {
22409  char *uuid = credential_uuid (new_credential);
22410  SENDF_TO_CLIENT_OR_FAIL
22411  (XML_OK_CREATED_ID ("create_credential"), uuid);
22412  log_event ("credential", "Credential", uuid, "created");
22413  free (uuid);
22414  break;
22415  }
22416  case 1:
22417  SEND_TO_CLIENT_OR_FAIL
22418  (XML_ERROR_SYNTAX ("create_credential",
22419  "Credential exists already"));
22420  break;
22421  case 2:
22422  SEND_TO_CLIENT_OR_FAIL
22423  (XML_ERROR_SYNTAX ("create_credential",
22424  "Login may only contain alphanumeric"
22425  " characters if autogenerating"
22426  " credential"));
22427  break;
22428  case 3:
22429  SEND_TO_CLIENT_OR_FAIL
22430  (XML_ERROR_SYNTAX ("create_credential",
22431  "Erroneous private key or associated"
22432  " passphrase"));
22433  break;
22434  case 4:
22435  SEND_TO_CLIENT_OR_FAIL
22436  (XML_ERROR_SYNTAX ("create_credential",
22437  "Erroneous credential type"));
22438  break;
22439  case 5:
22440  SEND_TO_CLIENT_OR_FAIL
22441  (XML_ERROR_SYNTAX ("create_credential",
22442  "Selected type requires a login username"));
22443  break;
22444  case 6:
22445  SEND_TO_CLIENT_OR_FAIL
22446  (XML_ERROR_SYNTAX ("create_credential",
22447  "Selected type requires a password"));
22448  break;
22449  case 7:
22450  SEND_TO_CLIENT_OR_FAIL
22451  (XML_ERROR_SYNTAX ("create_credential",
22452  "Selected type requires a private key"));
22453  break;
22454  case 8:
22455  SEND_TO_CLIENT_OR_FAIL
22456  (XML_ERROR_SYNTAX ("create_credential",
22457  "Selected type requires a certificate"));
22458  break;
22459  case 10:
22460  SEND_TO_CLIENT_OR_FAIL
22461  (XML_ERROR_SYNTAX ("create_credential",
22462  "Selected type cannot be generated"
22463  " automatically"));
22464  break;
22465  case 11:
22466  SEND_TO_CLIENT_OR_FAIL
22467  (XML_ERROR_SYNTAX ("create_credential",
22468  "Selected type requires a community and/or"
22469  " username + password"));
22470  case 12:
22471  SEND_TO_CLIENT_OR_FAIL
22472  (XML_ERROR_SYNTAX ("create_credential",
22473  "Selected type requires an"
22474  " auth_algorithm"));
22475  case 13:
22476  SEND_TO_CLIENT_OR_FAIL
22477  (XML_ERROR_SYNTAX ("create_credential",
22478  "Selected type requires a"
22479  " password in a privacy element"));
22480  case 14:
22481  SEND_TO_CLIENT_OR_FAIL
22482  (XML_ERROR_SYNTAX ("create_credential",
22483  "Selected type requires an"
22484  " algorithm in a privacy element"));
22485  case 15:
22486  SEND_TO_CLIENT_OR_FAIL
22487  (XML_ERROR_SYNTAX ("create_credential",
22488  "auth algorithm must be 'md5' or 'sha1'"));
22489  case 16:
22490  SEND_TO_CLIENT_OR_FAIL
22491  (XML_ERROR_SYNTAX ("create_credential",
22492  "privacy algorithm must be 'aes'"
22493  " or 'des'"));
22494  case 17:
22495  SEND_TO_CLIENT_OR_FAIL
22496  (XML_ERROR_SYNTAX ("create_credential",
22497  "Erroneous certificate"));
22498  break;
22499  case 99:
22500  SEND_TO_CLIENT_OR_FAIL
22501  (XML_ERROR_SYNTAX ("create_credential",
22502  "Permission denied"));
22503  break;
22504  default:
22505  assert (0);
22506  case -1:
22507  SEND_TO_CLIENT_OR_FAIL
22508  (XML_INTERNAL_ERROR ("create_credential"));
22509  break;
22510  }
22511  create_credential_data_reset (create_credential_data);
22512  set_client_state (CLIENT_AUTHENTIC);
22513  break;
22514  }
22515  CLOSE (CLIENT_CREATE_CREDENTIAL, ALLOW_INSECURE);
22516  CLOSE (CLIENT_CREATE_CREDENTIAL, AUTH_ALGORITHM);
22517  CLOSE (CLIENT_CREATE_CREDENTIAL, CERTIFICATE);
22518  CLOSE (CLIENT_CREATE_CREDENTIAL, COMMENT);
22519  CLOSE (CLIENT_CREATE_CREDENTIAL, COMMUNITY);
22526  CLOSE (CLIENT_CREATE_CREDENTIAL, PASSWORD);
22527  CLOSE (CLIENT_CREATE_CREDENTIAL, PRIVACY);
22531 
22532  case CLIENT_CREATE_FILTER:
22533  {
22534  filter_t new_filter;
22535 
22536  assert (strcasecmp ("CREATE_FILTER", element_name) == 0);
22537  assert (create_filter_data->term != NULL);
22538 
22539  if (create_filter_data->copy)
22540  /* TODO make_unique (same for targets). */
22544  &new_filter))
22545  {
22546  case 0:
22547  {
22548  char *uuid;
22549  uuid = filter_uuid (new_filter);
22550  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_filter"),
22551  uuid);
22552  log_event ("filter", "Filter", uuid, "created");
22553  free (uuid);
22554  break;
22555  }
22556  case 1:
22557  SEND_TO_CLIENT_OR_FAIL
22558  (XML_ERROR_SYNTAX ("create_filter",
22559  "Filter exists already"));
22560  log_event_fail ("filter", "Filter", NULL, "created");
22561  break;
22562  case 2:
22563  if (send_find_error_to_client ("create_filter", "filter",
22565  omp_parser))
22566  {
22567  error_send_to_client (error);
22568  return;
22569  }
22570  log_event_fail ("filter", "Filter", NULL, "created");
22571  break;
22572  case 99:
22573  SEND_TO_CLIENT_OR_FAIL
22574  (XML_ERROR_SYNTAX ("create_filter",
22575  "Permission denied"));
22576  log_event_fail ("filter", "Filter", NULL, "created");
22577  break;
22578  case -1:
22579  default:
22580  SEND_TO_CLIENT_OR_FAIL
22581  (XML_INTERNAL_ERROR ("create_filter"));
22582  log_event_fail ("filter", "Filter", NULL, "created");
22583  break;
22584  }
22585  else if (create_filter_data->name == NULL)
22586  SEND_TO_CLIENT_OR_FAIL
22587  (XML_ERROR_SYNTAX ("create_filter",
22588  "CREATE_FILTER requires a NAME"));
22589  else if (strlen (create_filter_data->name) == 0)
22590  SEND_TO_CLIENT_OR_FAIL
22591  (XML_ERROR_SYNTAX ("create_filter",
22592  "CREATE_FILTER name must be at"
22593  " least one character long"));
22594  else switch (create_filter
22600  && strcmp (create_filter_data->make_name_unique, "0"),
22601  &new_filter))
22602  {
22603  case 0:
22604  {
22605  char *uuid = filter_uuid (new_filter);
22606  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_filter"),
22607  uuid);
22608  log_event ("filter", "Filter", uuid, "created");
22609  free (uuid);
22610  break;
22611  }
22612  case 1:
22613  SEND_TO_CLIENT_OR_FAIL
22614  (XML_ERROR_SYNTAX ("create_filter",
22615  "Filter exists already"));
22616  log_event_fail ("filter", "Filter", NULL, "created");
22617  break;
22618  case 2:
22619  SEND_TO_CLIENT_OR_FAIL
22620  (XML_ERROR_SYNTAX ("create_filter",
22621  "Type must be a valid OMP type"));
22622  log_event_fail ("filter", "Filter", NULL, "created");
22623  break;
22624  case 99:
22625  SEND_TO_CLIENT_OR_FAIL
22626  (XML_ERROR_SYNTAX ("create_filter",
22627  "Permission denied"));
22628  log_event_fail ("filter", "Filter", NULL, "created");
22629  break;
22630  default:
22631  SEND_TO_CLIENT_OR_FAIL
22632  (XML_INTERNAL_ERROR ("create_filter"));
22633  log_event_fail ("filter", "Filter", NULL, "created");
22634  break;
22635  }
22636 
22637  create_filter_data_reset (create_filter_data);
22638  set_client_state (CLIENT_AUTHENTIC);
22639  break;
22640  }
22641  CLOSE (CLIENT_CREATE_FILTER, COMMENT);
22642  CLOSE (CLIENT_CREATE_FILTER, COPY);
22644  CLOSE (CLIENT_CREATE_FILTER, TERM);
22645  CLOSE (CLIENT_CREATE_FILTER, TYPE);
22646 
22647  CLOSE (CLIENT_CREATE_FILTER_NAME, MAKE_UNIQUE);
22648 
22649  case CLIENT_CREATE_GROUP:
22650  {
22651  group_t new_group;
22652 
22653  assert (strcasecmp ("CREATE_GROUP", element_name) == 0);
22654  assert (create_group_data->users != NULL);
22655 
22656  if (create_group_data->copy)
22657  switch (copy_group (create_group_data->name,
22660  &new_group))
22661  {
22662  case 0:
22663  {
22664  char *uuid;
22665  uuid = group_uuid (new_group);
22666  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_group"),
22667  uuid);
22668  log_event ("group", "Group", uuid, "created");
22669  free (uuid);
22670  break;
22671  }
22672  case 1:
22673  SEND_TO_CLIENT_OR_FAIL
22674  (XML_ERROR_SYNTAX ("create_group",
22675  "Group exists already"));
22676  log_event_fail ("group", "Group", NULL, "created");
22677  break;
22678  case 2:
22679  if (send_find_error_to_client ("create_group", "group",
22681  omp_parser))
22682  {
22683  error_send_to_client (error);
22684  return;
22685  }
22686  log_event_fail ("group", "Group", NULL, "created");
22687  break;
22688  case 4:
22689  SEND_TO_CLIENT_OR_FAIL
22690  (XML_ERROR_SYNTAX ("create_group",
22691  "Syntax error in group name"));
22692  log_event_fail ("group", "Group", NULL, "created");
22693  break;
22694  case 99:
22695  SEND_TO_CLIENT_OR_FAIL
22696  (XML_ERROR_SYNTAX ("create_group",
22697  "Permission denied"));
22698  log_event_fail ("group", "Group", NULL, "created");
22699  break;
22700  case -1:
22701  default:
22702  SEND_TO_CLIENT_OR_FAIL
22703  (XML_INTERNAL_ERROR ("create_group"));
22704  log_event_fail ("group", "Group", NULL, "created");
22705  break;
22706  }
22707  else if (create_group_data->name == NULL)
22708  SEND_TO_CLIENT_OR_FAIL
22709  (XML_ERROR_SYNTAX ("create_group",
22710  "CREATE_GROUP requires a NAME"));
22711  else if (strlen (create_group_data->name) == 0)
22712  SEND_TO_CLIENT_OR_FAIL
22713  (XML_ERROR_SYNTAX ("create_group",
22714  "CREATE_GROUP name must be at"
22715  " least one character long"));
22716  else switch (create_group
22721  &new_group))
22722  {
22723  case 0:
22724  {
22725  char *uuid = group_uuid (new_group);
22726  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_group"),
22727  uuid);
22728  log_event ("group", "Group", uuid, "created");
22729  free (uuid);
22730  break;
22731  }
22732  case 1:
22733  SEND_TO_CLIENT_OR_FAIL
22734  (XML_ERROR_SYNTAX ("create_group",
22735  "Group exists already"));
22736  log_event_fail ("group", "Group", NULL, "created");
22737  break;
22738  case 2:
22739  SEND_TO_CLIENT_OR_FAIL
22740  (XML_ERROR_SYNTAX ("create_group",
22741  "Failed to find user"));
22742  log_event_fail ("group", "Group", NULL, "created");
22743  break;
22744  case 4:
22745  SEND_TO_CLIENT_OR_FAIL
22746  (XML_ERROR_SYNTAX ("create_group",
22747  "Error in user name"));
22748  log_event_fail ("group", "Group", NULL, "created");
22749  break;
22750  case 99:
22751  SEND_TO_CLIENT_OR_FAIL
22752  (XML_ERROR_SYNTAX ("create_group",
22753  "Permission denied"));
22754  log_event_fail ("group", "Group", NULL, "created");
22755  break;
22756  default:
22757  SEND_TO_CLIENT_OR_FAIL
22758  (XML_INTERNAL_ERROR ("create_group"));
22759  log_event_fail ("group", "Group", NULL, "created");
22760  break;
22761  }
22762 
22763  create_group_data_reset (create_group_data);
22764  set_client_state (CLIENT_AUTHENTIC);
22765  break;
22766  }
22767  CLOSE (CLIENT_CREATE_GROUP, COMMENT);
22768  CLOSE (CLIENT_CREATE_GROUP, COPY);
22770  CLOSE (CLIENT_CREATE_GROUP, SPECIALS);
22772  CLOSE (CLIENT_CREATE_GROUP, USERS);
22773 
22774  case CLIENT_CREATE_NOTE:
22775  {
22776  task_t task = 0;
22777  result_t result = 0;
22778  note_t new_note;
22779  int max;
22780 
22781  assert (strcasecmp ("CREATE_NOTE", element_name) == 0);
22782 
22783  if (create_note_data->copy)
22784  switch (copy_note (create_note_data->copy, &new_note))
22785  {
22786  case 0:
22787  {
22788  char *uuid;
22789  note_uuid (new_note, &uuid);
22790  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_note"),
22791  uuid);
22792  log_event ("note", "Note", uuid, "created");
22793  free (uuid);
22794  break;
22795  }
22796  case 1:
22797  SEND_TO_CLIENT_OR_FAIL
22798  (XML_ERROR_SYNTAX ("create_note",
22799  "Note exists already"));
22800  log_event_fail ("note", "Note", NULL, "created");
22801  break;
22802  case 2:
22803  if (send_find_error_to_client ("create_note", "note",
22805  omp_parser))
22806  {
22807  error_send_to_client (error);
22808  return;
22809  }
22810  log_event_fail ("note", "Note", NULL, "created");
22811  break;
22812  case 99:
22813  SEND_TO_CLIENT_OR_FAIL
22814  (XML_ERROR_SYNTAX ("create_note",
22815  "Permission denied"));
22816  log_event_fail ("note", "Note", NULL, "created");
22817  break;
22818  case -1:
22819  default:
22820  SEND_TO_CLIENT_OR_FAIL
22821  (XML_INTERNAL_ERROR ("create_note"));
22822  log_event_fail ("note", "Note", NULL, "created");
22823  break;
22824  }
22825  else if (create_note_data->nvt_oid == NULL)
22826  SEND_TO_CLIENT_OR_FAIL
22827  (XML_ERROR_SYNTAX ("create_note",
22828  "CREATE_NOTE requires an NVT entity"));
22829  else if (create_note_data->text == NULL)
22830  SEND_TO_CLIENT_OR_FAIL
22831  (XML_ERROR_SYNTAX ("create_note",
22832  "CREATE_NOTE requires a TEXT entity"));
22833  else if (create_note_data->hosts
22834  && ((max = manage_count_hosts (create_note_data->hosts, NULL))
22835  == -1))
22836  SEND_TO_CLIENT_OR_FAIL
22837  (XML_ERROR_SYNTAX ("create_note",
22838  "Error in host specification"));
22839  else if (create_note_data->hosts && (max > manage_max_hosts ()))
22840  SEND_TO_CLIENT_OR_FAIL
22841  (XML_ERROR_SYNTAX ("create_note",
22842  "Host specification exceeds maximum number of"
22843  " hosts"));
22844  else if (create_note_data->task_id
22846  &task,
22847  NULL))
22848  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_note"));
22849  else if (create_note_data->task_id && task == 0)
22850  {
22851  if (send_find_error_to_client ("create_note", "task",
22853  omp_parser))
22854  {
22855  error_send_to_client (error);
22856  return;
22857  }
22858  }
22859  else if (create_note_data->result_id
22861  &result,
22862  NULL))
22863  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_note"));
22864  else if (create_note_data->result_id && result == 0)
22865  {
22866  if (send_find_error_to_client ("create_note", "result",
22868  omp_parser))
22869  {
22870  error_send_to_client (error);
22871  return;
22872  }
22873  }
22874  else switch (create_note (create_note_data->active,
22881  task,
22882  result,
22883  &new_note))
22884  {
22885  case 0:
22886  {
22887  char *uuid;
22888  note_uuid (new_note, &uuid);
22889  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_note"),
22890  uuid);
22891  log_event ("note", "Note", uuid, "created");
22892  free (uuid);
22893  break;
22894  }
22895  case 1:
22896  if (send_find_error_to_client ("create_note", "nvt",
22898  omp_parser))
22899  {
22900  error_send_to_client (error);
22901  return;
22902  }
22903  break;
22904  case 2:
22905  SEND_TO_CLIENT_OR_FAIL
22906  (XML_ERROR_SYNTAX ("create_note",
22907  "Error in port specification"));
22908  log_event_fail ("note", "Note", NULL, "created");
22909  break;
22910  case 99:
22911  SEND_TO_CLIENT_OR_FAIL
22912  (XML_ERROR_SYNTAX ("create_note",
22913  "Permission denied"));
22914  break;
22915  case -1:
22916  SEND_TO_CLIENT_OR_FAIL
22917  (XML_INTERNAL_ERROR ("create_note"));
22918  break;
22919  default:
22920  assert (0);
22921  SEND_TO_CLIENT_OR_FAIL
22922  (XML_INTERNAL_ERROR ("create_note"));
22923  break;
22924  }
22925  create_note_data_reset (create_note_data);
22926  set_client_state (CLIENT_AUTHENTIC);
22927  break;
22928  }
22929  CLOSE (CLIENT_CREATE_NOTE, ACTIVE);
22930  CLOSE (CLIENT_CREATE_NOTE, COPY);
22931  CLOSE (CLIENT_CREATE_NOTE, HOSTS);
22932  CLOSE (CLIENT_CREATE_NOTE, NVT);
22933  CLOSE (CLIENT_CREATE_NOTE, PORT);
22934  CLOSE (CLIENT_CREATE_NOTE, SEVERITY);
22935  CLOSE (CLIENT_CREATE_NOTE, RESULT);
22936  CLOSE (CLIENT_CREATE_NOTE, TASK);
22937  CLOSE (CLIENT_CREATE_NOTE, TEXT);
22938  CLOSE (CLIENT_CREATE_NOTE, THREAT);
22939 
22941  {
22942  task_t task = 0;
22943  result_t result = 0;
22944  override_t new_override;
22945  int max;
22946 
22947  assert (strcasecmp ("CREATE_OVERRIDE", element_name) == 0);
22948 
22950  switch (copy_override (create_override_data->copy, &new_override))
22951  {
22952  case 0:
22953  {
22954  char *uuid;
22955  override_uuid (new_override, &uuid);
22956  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_override"),
22957  uuid);
22958  log_event ("override", "Override", uuid, "created");
22959  free (uuid);
22960  break;
22961  }
22962  case 1:
22963  SEND_TO_CLIENT_OR_FAIL
22964  (XML_ERROR_SYNTAX ("create_override",
22965  "Override exists already"));
22966  log_event_fail ("override", "Override", NULL, "created");
22967  break;
22968  case 2:
22969  if (send_find_error_to_client ("create_override", "override",
22971  omp_parser))
22972  {
22973  error_send_to_client (error);
22974  return;
22975  }
22976  log_event_fail ("override", "Override", NULL, "created");
22977  break;
22978  case 99:
22979  SEND_TO_CLIENT_OR_FAIL
22980  (XML_ERROR_SYNTAX ("create_override",
22981  "Permission denied"));
22982  log_event_fail ("override", "Override", NULL, "created");
22983  break;
22984  case -1:
22985  default:
22986  SEND_TO_CLIENT_OR_FAIL
22987  (XML_INTERNAL_ERROR ("create_override"));
22988  log_event_fail ("override", "Override", NULL, "created");
22989  break;
22990  }
22991  else if (create_override_data->nvt_oid == NULL)
22992  SEND_TO_CLIENT_OR_FAIL
22993  (XML_ERROR_SYNTAX ("create_override",
22994  "CREATE_OVERRIDE requires an NVT entity"));
22995  else if (create_override_data->text == NULL)
22996  SEND_TO_CLIENT_OR_FAIL
22997  (XML_ERROR_SYNTAX ("create_override",
22998  "CREATE_OVERRIDE requires a TEXT entity"));
22999  else if (create_override_data->hosts
23001  NULL))
23002  == -1))
23003  SEND_TO_CLIENT_OR_FAIL
23004  (XML_ERROR_SYNTAX ("create_override",
23005  "Error in host specification"));
23006  else if (create_override_data->hosts && (max > manage_max_hosts ()))
23007  SEND_TO_CLIENT_OR_FAIL
23008  (XML_ERROR_SYNTAX ("create_override",
23009  "Host specification exceeds maximum number"
23010  " of hosts"));
23011  else if (create_override_data->new_threat == NULL
23012  && create_override_data->new_severity == NULL)
23013  SEND_TO_CLIENT_OR_FAIL
23014  (XML_ERROR_SYNTAX ("create_override",
23015  "CREATE_OVERRIDE requires a NEW_THREAT"
23016  " or NEW_SEVERITY entity"));
23017  else if (create_override_data->task_id
23019  &task,
23020  NULL))
23021  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_override"));
23022  else if (create_override_data->task_id && task == 0)
23023  {
23024  if (send_find_error_to_client ("create_override", "task",
23026  omp_parser))
23027  {
23028  error_send_to_client (error);
23029  return;
23030  }
23031  }
23034  &result,
23035  NULL))
23036  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_override"));
23037  else if (create_override_data->result_id && result == 0)
23038  {
23039  if (send_find_error_to_client ("create_override", "result",
23041  omp_parser))
23042  {
23043  error_send_to_client (error);
23044  return;
23045  }
23046  }
23056  task,
23057  result,
23058  &new_override))
23059  {
23060  case 0:
23061  {
23062  char *uuid;
23063  override_uuid (new_override, &uuid);
23064  SENDF_TO_CLIENT_OR_FAIL
23065  (XML_OK_CREATED_ID ("create_override"), uuid);
23066  log_event ("override", "Override", uuid, "created");
23067  free (uuid);
23068  break;
23069  }
23070  case 1:
23071  if (send_find_error_to_client ("create_override", "nvt",
23073  omp_parser))
23074  {
23075  error_send_to_client (error);
23076  return;
23077  }
23078  break;
23079  case 2:
23080  SEND_TO_CLIENT_OR_FAIL
23081  (XML_ERROR_SYNTAX ("create_override",
23082  "Error in port specification"));
23083  log_event_fail ("override", "Override", NULL, "created");
23084  break;
23085  case 3:
23086  SEND_TO_CLIENT_OR_FAIL
23087  (XML_ERROR_SYNTAX ("create_override",
23088  "Error in new_severity specification"));
23089  log_event_fail ("override", "Override", NULL, "created");
23090  break;
23091  case 99:
23092  SEND_TO_CLIENT_OR_FAIL
23093  (XML_ERROR_SYNTAX ("create_override",
23094  "Permission denied"));
23095  break;
23096  case -1:
23097  SEND_TO_CLIENT_OR_FAIL
23098  (XML_INTERNAL_ERROR ("create_override"));
23099  break;
23100  default:
23101  assert (0);
23102  SEND_TO_CLIENT_OR_FAIL
23103  (XML_INTERNAL_ERROR ("create_override"));
23104  break;
23105  }
23106  create_override_data_reset (create_override_data);
23107  set_client_state (CLIENT_AUTHENTIC);
23108  break;
23109  }
23110  CLOSE (CLIENT_CREATE_OVERRIDE, ACTIVE);
23111  CLOSE (CLIENT_CREATE_OVERRIDE, COPY);
23112  CLOSE (CLIENT_CREATE_OVERRIDE, HOSTS);
23113  CLOSE (CLIENT_CREATE_OVERRIDE, NEW_SEVERITY);
23114  CLOSE (CLIENT_CREATE_OVERRIDE, NEW_THREAT);
23116  CLOSE (CLIENT_CREATE_OVERRIDE, PORT);
23117  CLOSE (CLIENT_CREATE_OVERRIDE, SEVERITY);
23118  CLOSE (CLIENT_CREATE_OVERRIDE, RESULT);
23119  CLOSE (CLIENT_CREATE_OVERRIDE, TASK);
23120  CLOSE (CLIENT_CREATE_OVERRIDE, TEXT);
23121  CLOSE (CLIENT_CREATE_OVERRIDE, THREAT);
23122 
23124  {
23125  permission_t new_permission;
23126 
23127  assert (strcasecmp ("CREATE_PERMISSION", element_name) == 0);
23128 
23132  &new_permission))
23133  {
23134  case 0:
23135  {
23136  char *uuid;
23137  uuid = permission_uuid (new_permission);
23138  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_permission"),
23139  uuid);
23140  log_event ("permission", "Permission", uuid, "created");
23141  free (uuid);
23142  break;
23143  }
23144  case 1:
23145  SEND_TO_CLIENT_OR_FAIL
23146  (XML_ERROR_SYNTAX ("create_permission",
23147  "Permission exists already"));
23148  log_event_fail ("permission", "Permission", NULL, "created");
23149  break;
23150  case 2:
23151  if (send_find_error_to_client ("create_permission",
23152  "permission",
23154  omp_parser))
23155  {
23156  error_send_to_client (error);
23157  return;
23158  }
23159  log_event_fail ("permission", "Permission", NULL, "created");
23160  break;
23161  case 99:
23162  SEND_TO_CLIENT_OR_FAIL
23163  (XML_ERROR_SYNTAX ("create_permission",
23164  "Permission denied"));
23165  log_event_fail ("permission", "Permission", NULL, "created");
23166  break;
23167  case -1:
23168  default:
23169  SEND_TO_CLIENT_OR_FAIL
23170  (XML_INTERNAL_ERROR ("create_permission"));
23171  log_event_fail ("permission", "Permission", NULL, "created");
23172  break;
23173  }
23174  else if (create_permission_data->name == NULL)
23175  SEND_TO_CLIENT_OR_FAIL
23176  (XML_ERROR_SYNTAX ("create_permission",
23177  "CREATE_PERMISSION requires a NAME"));
23178  else if (strlen (create_permission_data->name) == 0)
23179  SEND_TO_CLIENT_OR_FAIL
23180  (XML_ERROR_SYNTAX ("create_permission",
23181  "CREATE_PERMISSION name must be at"
23182  " least one character long"));
23183  else switch (create_permission
23190  &new_permission))
23191  {
23192  case 0:
23193  {
23194  char *uuid = permission_uuid (new_permission);
23195  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID
23196  ("create_permission"),
23197  uuid);
23198  log_event ("permission", "Permission", uuid, "created");
23199  free (uuid);
23200  break;
23201  }
23202  case 2:
23203  if (send_find_error_to_client
23204  ("create_permission", "subject",
23205  create_permission_data->subject_id, omp_parser))
23206  {
23207  error_send_to_client (error);
23208  return;
23209  }
23210  log_event_fail ("permission", "Permission", NULL, "created");
23211  break;
23212  case 3:
23213  if (send_find_error_to_client
23214  ("create_permission", "resource",
23215  create_permission_data->resource_id, omp_parser))
23216  {
23217  error_send_to_client (error);
23218  return;
23219  }
23220  log_event_fail ("permission", "Permission", NULL, "created");
23221  break;
23222  case 5:
23223  SEND_TO_CLIENT_OR_FAIL
23224  (XML_ERROR_SYNTAX ("create_permission",
23225  "Error in RESOURCE"));
23226  log_event_fail ("permission", "Permission", NULL, "created");
23227  break;
23228  case 6:
23229  SEND_TO_CLIENT_OR_FAIL
23230  (XML_ERROR_SYNTAX ("create_permission",
23231  "Error in SUBJECT"));
23232  log_event_fail ("permission", "Permission", NULL, "created");
23233  break;
23234  case 7:
23235  SEND_TO_CLIENT_OR_FAIL
23236  (XML_ERROR_SYNTAX ("create_permission",
23237  "Error in NAME"));
23238  log_event_fail ("permission", "Permission", NULL, "created");
23239  break;
23240  case 8:
23241  SEND_TO_CLIENT_OR_FAIL
23242  (XML_ERROR_SYNTAX ("create_permission",
23243  "Attempt to create permission on"
23244  " permission"));
23245  log_event_fail ("permission", "Permission", NULL, "created");
23246  break;
23247  case 9:
23248  SEND_TO_CLIENT_OR_FAIL
23249  (XML_ERROR_SYNTAX ("create_permission",
23250  "Permission does not accept a resource"));
23251  log_event_fail ("permission", "Permission", NULL, "created");
23252  break;
23253  case 99:
23254  SEND_TO_CLIENT_OR_FAIL
23255  (XML_ERROR_SYNTAX ("create_permission",
23256  "Permission denied"));
23257  log_event_fail ("permission", "Permission", NULL, "created");
23258  break;
23259  case -1:
23260  default:
23261  SEND_TO_CLIENT_OR_FAIL
23262  (XML_INTERNAL_ERROR ("create_permission"));
23263  log_event_fail ("permission", "Permission", NULL, "created");
23264  break;
23265  }
23266 
23267  create_permission_data_reset (create_permission_data);
23268  set_client_state (CLIENT_AUTHENTIC);
23269  break;
23270  }
23271  CLOSE (CLIENT_CREATE_PERMISSION, COMMENT);
23274  CLOSE (CLIENT_CREATE_PERMISSION, RESOURCE);
23276  CLOSE (CLIENT_CREATE_PERMISSION, SUBJECT);
23278 
23280  {
23281  port_list_t new_port_list;
23282  array_t *manage_ranges;
23283 
23284  assert (strcasecmp ("CREATE_PORT_LIST", element_name) == 0);
23285 
23286  manage_ranges = NULL;
23287 
23288  /* The import element, GET_PORT_LISTS_RESPONSE, overrides any other
23289  * elements. */
23290 
23292  {
23293  array_terminate (create_port_list_data->ranges);
23294 
23295  if (create_port_list_data->name == NULL)
23296  SEND_TO_CLIENT_OR_FAIL
23297  (XML_ERROR_SYNTAX ("create_port_list",
23298  "CREATE_PORT_LIST"
23299  " GET_PORT_LISTS_RESPONSE requires a"
23300  " NAME element"));
23301  else if (strlen (create_port_list_data->name) == 0)
23302  SEND_TO_CLIENT_OR_FAIL
23303  (XML_ERROR_SYNTAX ("create_port_list",
23304  "CREATE_PORT_LIST"
23305  " GET_PORT_LISTS_RESPONSE NAME must be"
23306  " at least one character long"));
23307  else if (create_port_list_data->id == NULL)
23308  SEND_TO_CLIENT_OR_FAIL
23309  (XML_ERROR_SYNTAX ("create_port_list",
23310  "CREATE_PORT_LIST"
23311  " GET_PORT_LISTS_RESPONSE requires an"
23312  " ID attribute"));
23313  else if (strlen (create_port_list_data->id) == 0)
23314  SEND_TO_CLIENT_OR_FAIL
23315  (XML_ERROR_SYNTAX ("create_port_list",
23316  "CREATE_PORT_LIST"
23317  " GET_PORT_LISTS_RESPONSE ID must be"
23318  " at least one character long"));
23319  else if (!is_uuid (create_port_list_data->id))
23320  SEND_TO_CLIENT_OR_FAIL
23321  (XML_ERROR_SYNTAX ("create_port_list",
23322  "CREATE_PORT_LIST"
23323  " GET_PORT_LISTS_RESPONSE ID must be"
23324  " a UUID"));
23325  else if ((manage_ranges = convert_to_manage_ranges
23327  == NULL)
23328  SEND_TO_CLIENT_OR_FAIL
23329  (XML_ERROR_SYNTAX ("create_port_list",
23330  "Error in GET_PORT_LISTS_RESPONSE ranges"));
23331  else switch (create_port_list
23335  NULL,
23336  manage_ranges,
23337  &new_port_list))
23338  {
23339  case 1:
23340  SEND_TO_CLIENT_OR_FAIL
23341  (XML_ERROR_SYNTAX ("create_port_list",
23342  "Port list exists already"));
23343  log_event_fail ("port_list", "Port List", NULL, "created");
23344  break;
23345  case 2:
23346  SEND_TO_CLIENT_OR_FAIL
23347  (XML_ERROR_SYNTAX ("create_port_list",
23348  "Port list exists already, in"
23349  " trashcan"));
23350  log_event_fail ("port_list", "Port List", NULL, "created");
23351  break;
23352  case 99:
23353  SEND_TO_CLIENT_OR_FAIL
23354  (XML_ERROR_SYNTAX ("create_port_list",
23355  "Permission denied"));
23356  log_event_fail ("port_list", "Port List", NULL, "created");
23357  break;
23358  case -1:
23359  SEND_TO_CLIENT_OR_FAIL
23360  (XML_INTERNAL_ERROR ("create_port_list"));
23361  log_event_fail ("port_list", "Port List", NULL, "created");
23362  break;
23363  default:
23364  {
23365  char *uuid = port_list_uuid (new_port_list);
23366  SENDF_TO_CLIENT_OR_FAIL
23367  (XML_OK_CREATED_ID ("create_port_list"),
23368  uuid);
23369  log_event ("port_list", "Port List", uuid, "created");
23370  free (uuid);
23371  break;
23372  }
23373  }
23374  /* Range fields are freed by the reset function below. */
23375  array_free (manage_ranges);
23376  }
23377  else if (create_port_list_data->copy)
23381  &new_port_list))
23382  {
23383  case 0:
23384  {
23385  char *uuid;
23386  uuid = port_list_uuid (new_port_list);
23387  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID
23388  ("create_port_list"),
23389  uuid);
23390  log_event ("port_list", "Port List", uuid, "created");
23391  free (uuid);
23392  break;
23393  }
23394  case 1:
23395  SEND_TO_CLIENT_OR_FAIL
23396  (XML_ERROR_SYNTAX ("create_port_list",
23397  "Port List exists already"));
23398  log_event_fail ("port_list", "Port List", NULL, "created");
23399  break;
23400  case 2:
23401  if (send_find_error_to_client ("create_port_list",
23402  "port_list",
23404  omp_parser))
23405  {
23406  error_send_to_client (error);
23407  return;
23408  }
23409  log_event_fail ("port_list", "Port List", NULL, "created");
23410  break;
23411  case 99:
23412  SEND_TO_CLIENT_OR_FAIL
23413  (XML_ERROR_SYNTAX ("create_port_list",
23414  "Permission denied"));
23415  log_event_fail ("port_list", "Port List", NULL, "created");
23416  break;
23417  case -1:
23418  default:
23419  SEND_TO_CLIENT_OR_FAIL
23420  (XML_INTERNAL_ERROR ("create_port_list"));
23421  log_event_fail ("port_list", "Port List", NULL, "created");
23422  break;
23423  }
23424  else if (create_port_list_data->name == NULL)
23425  SEND_TO_CLIENT_OR_FAIL
23426  (XML_ERROR_SYNTAX ("create_port_list",
23427  "CREATE_PORT_LIST requires a NAME"));
23428  else if (strlen (create_port_list_data->name) == 0)
23429  SEND_TO_CLIENT_OR_FAIL
23430  (XML_ERROR_SYNTAX ("create_port_list",
23431  "CREATE_PORT_LIST name must be at"
23432  " least one character long"));
23433  else switch (create_port_list
23434  (NULL,
23438  NULL,
23439  &new_port_list))
23440  {
23441  case 1:
23442  SEND_TO_CLIENT_OR_FAIL
23443  (XML_ERROR_SYNTAX ("create_port_list",
23444  "Port list exists already"));
23445  log_event_fail ("port_list", "Port List", NULL, "created");
23446  break;
23447  case 4:
23448  SEND_TO_CLIENT_OR_FAIL
23449  (XML_ERROR_SYNTAX ("create_port_list",
23450  "Error in port range"));
23451  log_event_fail ("port_list", "Port List", NULL, "created");
23452  break;
23453  case 99:
23454  SEND_TO_CLIENT_OR_FAIL
23455  (XML_ERROR_SYNTAX ("create_port_list",
23456  "Permission denied"));
23457  log_event_fail ("port_list", "Port List", NULL, "created");
23458  break;
23459  case -1:
23460  SEND_TO_CLIENT_OR_FAIL
23461  (XML_INTERNAL_ERROR ("create_port_list"));
23462  log_event_fail ("port_list", "Port List", NULL, "created");
23463  break;
23464  default:
23465  {
23466  char *uuid = port_list_uuid (new_port_list);
23467  SENDF_TO_CLIENT_OR_FAIL
23468  (XML_OK_CREATED_ID ("create_port_list"), uuid);
23469  log_event ("port_list", "Port List", uuid, "created");
23470  free (uuid);
23471  break;
23472  }
23473  }
23474 
23475  create_port_list_data_reset (create_port_list_data);
23476  set_client_state (CLIENT_AUTHENTIC);
23477  break;
23478  }
23479  CLOSE (CLIENT_CREATE_PORT_LIST, COMMENT);
23481  case CLIENT_CPL_GPLR:
23482  assert (strcasecmp ("GET_PORT_LISTS_RESPONSE", element_name) == 0);
23483  set_client_state (CLIENT_CREATE_PORT_LIST);
23484  break;
23486  CLOSE (CLIENT_CREATE_PORT_LIST, PORT_RANGE);
23487 
23488  CLOSE (CLIENT_CPL_GPLR, PORT_LIST);
23489  CLOSE (CLIENT_CPL_GPLR_PORT_LIST, COMMENT);
23490  CLOSE (CLIENT_CPL_GPLR_PORT_LIST, IN_USE);
23493  CLOSE (CLIENT_CPL_GPLR_PORT_LIST, PORT_RANGE);
23494  CLOSE (CLIENT_CPL_GPLR_PORT_LIST, PORT_RANGES);
23495 
23497  {
23498  assert (strcasecmp ("PORT_RANGE", element_name) == 0);
23499  assert (create_port_list_data->ranges);
23500 
23501  array_add (create_port_list_data->ranges,
23503  create_port_list_data->range = NULL;
23504  set_client_state (CLIENT_CPL_GPLR_PORT_LIST_PORT_RANGES);
23505  break;
23506  }
23511 
23513  {
23514  port_range_t new_port_range;
23515 
23516  assert (strcasecmp ("CREATE_PORT_RANGE", element_name) == 0);
23517 
23518  if (create_port_range_data->start == NULL
23519  || create_port_range_data->end == NULL
23521  SEND_TO_CLIENT_OR_FAIL
23522  (XML_ERROR_SYNTAX ("create_port_range",
23523  "CREATE_PORT_RANGE requires a START, END and"
23524  " PORT_LIST ID"));
23525  else switch (create_port_range
23531  &new_port_range))
23532  {
23533  case 1:
23534  SEND_TO_CLIENT_OR_FAIL
23535  (XML_ERROR_SYNTAX ("create_port_range",
23536  "Port range START must be a number"
23537  " 1-65535"));
23538  log_event_fail ("port_range", "Port Range", NULL, "created");
23539  break;
23540  case 2:
23541  SEND_TO_CLIENT_OR_FAIL
23542  (XML_ERROR_SYNTAX ("create_port_range",
23543  "Port range END must be a number"
23544  " 1-65535"));
23545  log_event_fail ("port_range", "Port Range", NULL, "created");
23546  break;
23547  case 3:
23548  if (send_find_error_to_client
23549  ("create_port_range", "port_range",
23550  create_port_range_data->port_list_id, omp_parser))
23551  {
23552  error_send_to_client (error);
23553  return;
23554  }
23555  log_event_fail ("port_range", "Port Range", NULL, "created");
23556  break;
23557  case 4:
23558  SEND_TO_CLIENT_OR_FAIL
23559  (XML_ERROR_SYNTAX ("create_port_range",
23560  "Port range TYPE must be TCP or UDP"));
23561  log_event_fail ("port_range", "Port Range", NULL, "created");
23562  break;
23563  case 5:
23564  SEND_TO_CLIENT_OR_FAIL
23565  (XML_ERROR_SYNTAX ("create_port_range",
23566  "Port list is in use"));
23567  break;
23568  case 6:
23569  SEND_TO_CLIENT_OR_FAIL
23570  (XML_ERROR_SYNTAX ("create_port_range",
23571  "New range overlaps an existing"
23572  " range"));
23573  break;
23574  case 99:
23575  SEND_TO_CLIENT_OR_FAIL
23576  (XML_ERROR_SYNTAX ("create_port_range",
23577  "Permission denied"));
23578  break;
23579  case -1:
23580  SEND_TO_CLIENT_OR_FAIL
23581  (XML_INTERNAL_ERROR ("create_port_range"));
23582  log_event_fail ("port_range", "Port Range", NULL, "created");
23583  break;
23584  default:
23585  {
23586  char *uuid;
23587  uuid = port_range_uuid (new_port_range);
23588  SENDF_TO_CLIENT_OR_FAIL
23589  (XML_OK_CREATED_ID ("create_port_range"), uuid);
23590  log_event ("port_range", "Port range", uuid, "created");
23591  free (uuid);
23592  break;
23593  }
23594  }
23595 
23596  create_port_range_data_reset (create_port_range_data);
23597  set_client_state (CLIENT_AUTHENTIC);
23598  break;
23599  }
23600  CLOSE (CLIENT_CREATE_PORT_RANGE, COMMENT);
23604  CLOSE (CLIENT_CREATE_PORT_RANGE, PORT_LIST);
23605 
23606  case CLIENT_CREATE_REPORT:
23607  {
23608  char *uuid;
23609 
23610  assert (strcasecmp ("CREATE_REPORT", element_name) == 0);
23611 
23612  array_terminate (create_report_data->results);
23613  array_terminate (create_report_data->host_ends);
23614  array_terminate (create_report_data->host_starts);
23615  array_terminate (create_report_data->details);
23616 
23617  if (create_report_data->results == NULL)
23618  SEND_TO_CLIENT_OR_FAIL
23619  (XML_ERROR_SYNTAX ("create_report",
23620  "CREATE_REPORT requires a REPORT element"));
23621  else if (create_report_data->type
23622  && strcmp (create_report_data->type, "scan"))
23623  SEND_TO_CLIENT_OR_FAIL
23624  (XML_ERROR_SYNTAX ("create_report",
23625  "CREATE_REPORT type must be 'scan'"));
23626  else switch (create_report
23637  &uuid))
23638  {
23639  case 99:
23640  SEND_TO_CLIENT_OR_FAIL
23641  (XML_ERROR_SYNTAX ("create_report",
23642  "Permission denied"));
23643  log_event_fail ("report", "Report", NULL, "created");
23644  break;
23645  case -1:
23646  case -2:
23647  SEND_TO_CLIENT_OR_FAIL
23648  (XML_INTERNAL_ERROR ("create_report"));
23649  log_event_fail ("report", "Report", NULL, "created");
23650  break;
23651  case -3:
23652  SEND_TO_CLIENT_OR_FAIL
23653  (XML_ERROR_SYNTAX ("create_report",
23654  "CREATE_REPORT TASK_NAME is required"));
23655  log_event_fail ("report", "Report", NULL, "created");
23656  break;
23657  case -4:
23658  log_event_fail ("report", "Report", NULL, "created");
23659  if (send_find_error_to_client
23660  ("create_report", "task",
23661  create_report_data->task_id, omp_parser))
23662  {
23663  error_send_to_client (error);
23664  return;
23665  }
23666  break;
23667  case -5:
23668  SEND_TO_CLIENT_OR_FAIL
23669  (XML_ERROR_SYNTAX ("create_report",
23670  "CREATE_REPORT TASK must be a container"));
23671  log_event_fail ("report", "Report", NULL, "created");
23672  break;
23673  case -6:
23674  SEND_TO_CLIENT_OR_FAIL
23675  (XML_ERROR_SYNTAX ("create_report",
23676  "Permission to add to Assets denied"));
23677  log_event_fail ("report", "Report", NULL, "created");
23678  break;
23679  default:
23680  {
23681  SENDF_TO_CLIENT_OR_FAIL
23682  (XML_OK_CREATED_ID ("create_report"),
23683  uuid);
23684  log_event ("report", "Report", uuid, "created");
23685  free (uuid);
23686  break;
23687  }
23688  }
23689 
23690  omp_parser->importing = 0;
23691  create_report_data_reset (create_report_data);
23692  set_client_state (CLIENT_AUTHENTIC);
23693  break;
23694  }
23695  CLOSE (CLIENT_CREATE_REPORT, IN_ASSETS);
23696  CLOSE (CLIENT_CREATE_REPORT, REPORT);
23698  assert (strcasecmp ("REPORT", element_name) == 0);
23700  set_client_state (CLIENT_CREATE_REPORT_REPORT);
23701  else
23702  set_client_state (CLIENT_CREATE_REPORT);
23703  break;
23707  assert (strcasecmp ("HOST_END", element_name) == 0);
23708 
23710  {
23711  create_report_result_t *result;
23712 
23713  assert (create_report_data->host_ends);
23715 
23716  result = g_malloc (sizeof (create_report_result_t));
23719 
23720  array_add (create_report_data->host_ends, result);
23721 
23722  create_report_data->host_end = NULL;
23724  }
23725  else
23726  openvas_free_string_var (&create_report_data->host_end);
23727 
23728  set_client_state (CLIENT_CREATE_REPORT_RR);
23729  break;
23731  assert (strcasecmp ("HOST_START", element_name) == 0);
23732 
23734  {
23735  create_report_result_t *result;
23736 
23737  assert (create_report_data->host_starts);
23738  assert (create_report_data->host_start);
23740 
23741  result = g_malloc (sizeof (create_report_result_t));
23744 
23745  array_add (create_report_data->host_starts, result);
23746 
23749  }
23750  else
23751  openvas_free_string_var (&create_report_data->host_start);
23752 
23753  set_client_state (CLIENT_CREATE_REPORT_RR);
23754  break;
23757  CLOSE_READ_OVER (CLIENT_CREATE_REPORT_RR, REPORT_FORMAT);
23758  CLOSE (CLIENT_CREATE_REPORT_RR, RESULTS);
23759  CLOSE_READ_OVER (CLIENT_CREATE_REPORT_RR, SCAN_RUN_STATUS);
23760  CLOSE (CLIENT_CREATE_REPORT_RR, SCAN_END);
23761  CLOSE (CLIENT_CREATE_REPORT_RR, SCAN_START);
23764  CLOSE_READ_OVER (CLIENT_CREATE_REPORT_RR, RESULT_COUNT);
23765 
23768 
23770  {
23771  openvas_free_string_var (&create_report_data->ip);
23772  set_client_state (CLIENT_CREATE_REPORT_RR);
23773  break;
23774  }
23775 
23779 
23781  {
23782  assert (strcasecmp ("DETAIL", element_name) == 0);
23783  assert (create_report_data->details);
23784 
23785  if (create_report_data->ip)
23786  {
23787  host_detail_t *detail;
23788 
23789  detail = g_malloc (sizeof (host_detail_t));
23790  detail->ip = g_strdup (create_report_data->ip);
23791  detail->name = create_report_data->detail_name;
23796 
23797  array_add (create_report_data->details, detail);
23798 
23804  }
23805 
23806  set_client_state (CLIENT_CREATE_REPORT_RR_H);
23807  break;
23808  }
23809 
23813 
23817  assert (strcasecmp ("DESCRIPTION", element_name) == 0);
23818  set_client_state (CLIENT_CREATE_REPORT_RR_H_DETAIL_SOURCE);
23819  break;
23820 
23822  {
23823  create_report_result_t *result;
23824 
23825  assert (strcasecmp ("RESULT", element_name) == 0);
23826  assert (create_report_data->results);
23827 
23830 
23831  if (create_report_data->result_severity == NULL)
23832  {
23833  if (create_report_data->result_threat == NULL)
23834  create_report_data->result_severity = strdup ("");
23835  else if (strcasecmp (create_report_data->result_threat,
23836  "High") == 0)
23837  create_report_data->result_severity = strdup ("10.0");
23838  else if (strcasecmp (create_report_data->result_threat,
23839  "Medium") == 0)
23840  create_report_data->result_severity = strdup ("5.0");
23841  else if (strcasecmp (create_report_data->result_threat,
23842  "Low") == 0)
23843  create_report_data->result_severity = strdup ("2.0");
23844  else if (strcasecmp (create_report_data->result_threat,
23845  "Log") == 0)
23846  create_report_data->result_severity = strdup ("0.0");
23847  else if (strcasecmp (create_report_data->result_threat,
23848  "False Positive") == 0)
23849  create_report_data->result_severity = strdup ("-1.0");
23850  else
23851  create_report_data->result_severity = strdup ("");
23852  }
23853 
23854  result = g_malloc (sizeof (create_report_result_t));
23856  result->host = create_report_data->result_host;
23858  result->scan_nvt_version
23860  result->port = create_report_data->result_port;
23861  result->qod = create_report_data->result_qod;
23865 
23866  array_add (create_report_data->results, result);
23867 
23877 
23878  set_client_state (CLIENT_CREATE_REPORT_RR_RESULTS);
23879  break;
23880  }
23887  MODIFICATION_TIME);
23891  CLOSE (CLIENT_CREATE_REPORT_RR_RESULTS_RESULT, ORIGINAL_SEVERITY);
23892  CLOSE (CLIENT_CREATE_REPORT_RR_RESULTS_RESULT, ORIGINAL_THREAT);
23899  CLOSE (CLIENT_CREATE_REPORT_RR_RESULTS_RESULT, SCAN_NVT_VERSION);
23902 
23910 
23912 
23913  CLOSE (CLIENT_CREATE_REPORT, TASK);
23914  CLOSE (CLIENT_CREATE_REPORT_TASK, COMMENT);
23916 
23918  {
23919  report_format_t new_report_format;
23920 
23921  assert (strcasecmp ("CREATE_REPORT_FORMAT", element_name) == 0);
23922 
23924  {
23927  &new_report_format))
23928  {
23929  case 0:
23930  {
23931  char *uuid;
23932  uuid = report_format_uuid (new_report_format);
23933  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID
23934  ("create_report_format"),
23935  uuid);
23936  log_event ("report_format", "Report Format", uuid, "created");
23937  free (uuid);
23938  break;
23939  }
23940  case 1:
23941  SEND_TO_CLIENT_OR_FAIL
23942  (XML_ERROR_SYNTAX ("create_report_format",
23943  "Report Format exists already"));
23944  log_event_fail ("report_format", "Report Format", NULL,
23945  "created");
23946  break;
23947  case 2:
23948  if (send_find_error_to_client ("create_report_format",
23949  "report_format",
23951  omp_parser))
23952  {
23953  error_send_to_client (error);
23954  return;
23955  }
23956  log_event_fail ("report_format", "Report Format", NULL,
23957  "created");
23958  break;
23959  case 99:
23960  SEND_TO_CLIENT_OR_FAIL
23961  (XML_ERROR_SYNTAX ("create_report_format",
23962  "Permission denied"));
23963  log_event_fail ("report_format", "Report Format", NULL,
23964  "created");
23965  break;
23966  case -1:
23967  default:
23968  SEND_TO_CLIENT_OR_FAIL
23969  (XML_INTERNAL_ERROR ("create_report_format"));
23970  log_event_fail ("report_format", "Report Format", NULL,
23971  "created");
23972  break;
23973  }
23974  }
23976  {
23977  array_terminate (create_report_format_data->files);
23978  array_terminate (create_report_format_data->params);
23979  array_terminate (create_report_format_data->params_options);
23980 
23981  if (create_report_format_data->name == NULL)
23982  SEND_TO_CLIENT_OR_FAIL
23983  (XML_ERROR_SYNTAX ("create_report_format",
23984  "CREATE_REPORT_FORMAT"
23985  " GET_REPORT_FORMATS_RESPONSE requires a"
23986  " NAME element"));
23987  else if (strlen (create_report_format_data->name) == 0)
23988  SEND_TO_CLIENT_OR_FAIL
23989  (XML_ERROR_SYNTAX ("create_report_format",
23990  "CREATE_REPORT_FORMAT"
23991  " GET_REPORT_FORMATS_RESPONSE NAME must be"
23992  " at least one character long"));
23993  else if (create_report_format_data->id == NULL)
23994  SEND_TO_CLIENT_OR_FAIL
23995  (XML_ERROR_SYNTAX ("create_report_format",
23996  "CREATE_REPORT_FORMAT"
23997  " GET_REPORT_FORMATS_RESPONSE requires an"
23998  " ID attribute"));
23999  else if (strlen (create_report_format_data->id) == 0)
24000  SEND_TO_CLIENT_OR_FAIL
24001  (XML_ERROR_SYNTAX ("create_report_format",
24002  "CREATE_REPORT_FORMAT"
24003  " GET_REPORT_FORMATS_RESPONSE ID must be"
24004  " at least one character long"));
24005  else if (!is_uuid (create_report_format_data->id))
24006  SEND_TO_CLIENT_OR_FAIL
24007  (XML_ERROR_SYNTAX ("create_report_format",
24008  "CREATE_REPORT_FORMAT"
24009  " GET_REPORT_FORMATS_RESPONSE ID must be"
24010  " a UUID"));
24011  else switch (create_report_format
24018  0,
24023  &new_report_format))
24024  {
24025  case -1:
24026  SEND_TO_CLIENT_OR_FAIL
24027  (XML_INTERNAL_ERROR ("create_report_format"));
24028  log_event_fail ("report_format", "Report Format", NULL,
24029  "created");
24030  break;
24031  case 1:
24032  SEND_TO_CLIENT_OR_FAIL
24033  (XML_ERROR_SYNTAX ("create_report_format",
24034  "Report format exists already"));
24035  log_event_fail ("report_format", "Report Format", NULL,
24036  "created");
24037  break;
24038  case 2:
24039  SEND_TO_CLIENT_OR_FAIL
24040  (XML_ERROR_SYNTAX ("create_report_format",
24041  "Every FILE must have a name"
24042  " attribute"));
24043  log_event_fail ("report_format", "Report Format", NULL,
24044  "created");
24045  break;
24046  case 3:
24047  SEND_TO_CLIENT_OR_FAIL
24048  (XML_ERROR_SYNTAX ("create_report_format",
24049  "Parameter value validation failed"));
24050  log_event_fail ("report_format", "Report Format", NULL,
24051  "created");
24052  break;
24053  case 4:
24054  SEND_TO_CLIENT_OR_FAIL
24055  (XML_ERROR_SYNTAX ("create_report_format",
24056  "Parameter default validation failed"));
24057  log_event_fail ("report_format", "Report Format", NULL,
24058  "created");
24059  break;
24060  case 5:
24061  SEND_TO_CLIENT_OR_FAIL
24062  (XML_ERROR_SYNTAX ("create_report_format",
24063  "CREATE_REPORT_FORMAT PARAM requires a"
24064  " DEFAULT element"));
24065  log_event_fail ("report_format", "Report Format", NULL,
24066  "created");
24067  break;
24068  case 6:
24069  SEND_TO_CLIENT_OR_FAIL
24070  (XML_ERROR_SYNTAX ("create_report_format",
24071  "CREATE_REPORT_FORMAT PARAM MIN or MAX"
24072  " out of range"));
24073  log_event_fail ("report_format", "Report Format", NULL,
24074  "created");
24075  break;
24076  case 7:
24077  SEND_TO_CLIENT_OR_FAIL
24078  (XML_ERROR_SYNTAX ("create_report_format",
24079  "CREATE_REPORT_FORMAT PARAM requires a"
24080  " TYPE element"));
24081  log_event_fail ("report_format", "Report Format", NULL,
24082  "created");
24083  break;
24084  case 8:
24085  SEND_TO_CLIENT_OR_FAIL
24086  (XML_ERROR_SYNTAX ("create_report_format",
24087  "Duplicate PARAM name"));
24088  log_event_fail ("report_format", "Report Format", NULL,
24089  "created");
24090  break;
24091  case 9:
24092  SEND_TO_CLIENT_OR_FAIL
24093  (XML_ERROR_SYNTAX ("create_report_format",
24094  "Bogus PARAM type"));
24095  log_event_fail ("report_format", "Report Format", NULL,
24096  "created");
24097  break;
24098  case 99:
24099  SEND_TO_CLIENT_OR_FAIL
24100  (XML_ERROR_SYNTAX ("create_report_format",
24101  "Permission denied"));
24102  log_event_fail ("report_format", "Report Format", NULL,
24103  "created");
24104  break;
24105  default:
24106  {
24107  char *uuid = report_format_uuid (new_report_format);
24108  SENDF_TO_CLIENT_OR_FAIL
24109  (XML_OK_CREATED_ID ("create_report_format"),
24110  uuid);
24111  log_event ("report_format", "Report Format", uuid, "created");
24112  free (uuid);
24113  break;
24114  }
24115  }
24116  }
24117  else
24118  SEND_TO_CLIENT_OR_FAIL
24119  (XML_ERROR_SYNTAX ("create_report_format",
24120  "CREATE_REPORT_FORMAT requires a"
24121  " GET_REPORT_FORMATS element"));
24122 
24123  create_report_format_data_reset (create_report_format_data);
24124  set_client_state (CLIENT_AUTHENTIC);
24125  break;
24126  }
24128  case CLIENT_CRF_GRFR:
24129  assert (strcasecmp ("GET_REPORT_FORMATS_RESPONSE", element_name) == 0);
24130  set_client_state (CLIENT_CREATE_REPORT_FORMAT);
24131  break;
24132  CLOSE (CLIENT_CRF_GRFR, REPORT_FORMAT);
24133  CLOSE (CLIENT_CRF_GRFR_REPORT_FORMAT, CONTENT_TYPE);
24134  CLOSE (CLIENT_CRF_GRFR_REPORT_FORMAT, DESCRIPTION);
24135  CLOSE (CLIENT_CRF_GRFR_REPORT_FORMAT, EXTENSION);
24137  {
24138  gchar *string;
24139 
24140  assert (strcasecmp ("FILE", element_name) == 0);
24141  assert (create_report_format_data->files);
24142  assert (create_report_format_data->file);
24144 
24145  string = g_strconcat (create_report_format_data->file_name,
24146  "0",
24148  NULL);
24149  string[strlen (create_report_format_data->file_name)] = '\0';
24150  array_add (create_report_format_data->files, string);
24151  openvas_free_string_var (&create_report_format_data->file);
24152  openvas_free_string_var (&create_report_format_data->file_name);
24153  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT);
24154  break;
24155  }
24159  {
24161 
24162  assert (strcasecmp ("PARAM", element_name) == 0);
24166 
24167  param = g_malloc (sizeof (*param));
24168  param->fallback
24171  : NULL;
24172  param->name = g_strdup (create_report_format_data->param_name);
24173  param->type
24176  : NULL;
24177  param->type_max
24180  : NULL;
24181  param->type_min
24184  : NULL;
24185  param->value = g_strdup (create_report_format_data->param_value);
24186 
24187  array_add (create_report_format_data->params, param);
24188  openvas_free_string_var (&create_report_format_data->param_default);
24189  openvas_free_string_var (&create_report_format_data->param_name);
24190  openvas_free_string_var (&create_report_format_data->param_type);
24191  openvas_free_string_var (&create_report_format_data->param_type_max);
24192  openvas_free_string_var (&create_report_format_data->param_type_min);
24193  openvas_free_string_var (&create_report_format_data->param_value);
24194 
24195  array_terminate (create_report_format_data->param_options);
24198 
24199  set_client_state (CLIENT_CRF_GRFR_REPORT_FORMAT);
24200  break;
24201  }
24207  CLOSE (CLIENT_CRF_GRFR_REPORT_FORMAT, PREDEFINED);
24208  CLOSE (CLIENT_CRF_GRFR_REPORT_FORMAT, SIGNATURE);
24211 
24213  REPORT_FORMAT);
24214 
24216  REPORT_FORMAT);
24217 
24219  assert (strcasecmp ("OPTION", element_name) == 0);
24224  break;
24225 
24228 
24229  case CLIENT_CREATE_ROLE:
24230  {
24231  role_t new_role;
24232 
24233  assert (strcasecmp ("CREATE_ROLE", element_name) == 0);
24234  assert (create_role_data->users != NULL);
24235 
24236  if (create_role_data->copy)
24237  switch (copy_role (create_role_data->name,
24240  &new_role))
24241  {
24242  case 0:
24243  {
24244  char *uuid;
24245  uuid = role_uuid (new_role);
24246  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_role"),
24247  uuid);
24248  log_event ("role", "Role", uuid, "created");
24249  free (uuid);
24250  break;
24251  }
24252  case 1:
24253  SEND_TO_CLIENT_OR_FAIL
24254  (XML_ERROR_SYNTAX ("create_role",
24255  "Role exists already"));
24256  log_event_fail ("role", "Role", NULL, "created");
24257  break;
24258  case 2:
24259  if (send_find_error_to_client ("create_role", "role",
24261  omp_parser))
24262  {
24263  error_send_to_client (error);
24264  return;
24265  }
24266  log_event_fail ("role", "Role", NULL, "created");
24267  break;
24268  case 4:
24269  SEND_TO_CLIENT_OR_FAIL
24270  (XML_ERROR_SYNTAX ("create_role",
24271  "Syntax error in role name"));
24272  log_event_fail ("role", "Role", NULL, "created");
24273  break;
24274  case 99:
24275  SEND_TO_CLIENT_OR_FAIL
24276  (XML_ERROR_SYNTAX ("create_role",
24277  "Permission denied"));
24278  log_event_fail ("role", "Role", NULL, "created");
24279  break;
24280  case -1:
24281  SEND_TO_CLIENT_OR_FAIL
24282  (XML_INTERNAL_ERROR ("create_role"));
24283  log_event_fail ("role", "Role", NULL, "created");
24284  break;
24285  }
24286  else if (create_role_data->name == NULL)
24287  SEND_TO_CLIENT_OR_FAIL
24288  (XML_ERROR_SYNTAX ("create_role",
24289  "CREATE_ROLE requires a NAME"));
24290  else if (strlen (create_role_data->name) == 0)
24291  SEND_TO_CLIENT_OR_FAIL
24292  (XML_ERROR_SYNTAX ("create_role",
24293  "CREATE_ROLE name must be at"
24294  " least one character long"));
24295  else switch (create_role
24299  &new_role))
24300  {
24301  case 0:
24302  {
24303  char *uuid = role_uuid (new_role);
24304  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_role"),
24305  uuid);
24306  log_event ("role", "Role", NULL, "created");
24307  free (uuid);
24308  break;
24309  }
24310  case 1:
24311  SEND_TO_CLIENT_OR_FAIL
24312  (XML_ERROR_SYNTAX ("create_role",
24313  "Role exists already"));
24314  log_event_fail ("role", "Role", NULL, "created");
24315  break;
24316  case 2:
24317  SEND_TO_CLIENT_OR_FAIL
24318  (XML_ERROR_SYNTAX ("create_role",
24319  "Failed to find user"));
24320  log_event_fail ("role", "Role", NULL, "created");
24321  break;
24322  case 4:
24323  SEND_TO_CLIENT_OR_FAIL
24324  (XML_ERROR_SYNTAX ("create_role",
24325  "Error in user name"));
24326  log_event_fail ("group", "Group", NULL, "created");
24327  break;
24328  case 99:
24329  SEND_TO_CLIENT_OR_FAIL
24330  (XML_ERROR_SYNTAX ("create_role",
24331  "Permission denied"));
24332  log_event_fail ("role", "Role", NULL, "created");
24333  break;
24334  default:
24335  SEND_TO_CLIENT_OR_FAIL
24336  (XML_INTERNAL_ERROR ("create_role"));
24337  log_event_fail ("role", "Role", NULL, "created");
24338  break;
24339  }
24340 
24341  create_role_data_reset (create_role_data);
24342  set_client_state (CLIENT_AUTHENTIC);
24343  break;
24344  }
24345  CLOSE (CLIENT_CREATE_ROLE, COMMENT);
24346  CLOSE (CLIENT_CREATE_ROLE, COPY);
24348  CLOSE (CLIENT_CREATE_ROLE, USERS);
24349 
24350  case CLIENT_CREATE_SCANNER:
24351  assert (strcasecmp ("CREATE_SCANNER", element_name) == 0);
24352  return handle_create_scanner (omp_parser, error);
24353  CLOSE (CLIENT_CREATE_SCANNER, COMMENT);
24354  CLOSE (CLIENT_CREATE_SCANNER, COPY);
24356  CLOSE (CLIENT_CREATE_SCANNER, HOST);
24357  CLOSE (CLIENT_CREATE_SCANNER, PORT);
24358  CLOSE (CLIENT_CREATE_SCANNER, TYPE);
24359  CLOSE (CLIENT_CREATE_SCANNER, CA_PUB);
24360  CLOSE (CLIENT_CREATE_SCANNER, CREDENTIAL);
24361 
24363  {
24364  time_t first_time, period, period_months, duration;
24365  schedule_t new_schedule;
24366 
24367  period_months = 0;
24368 
24369  assert (strcasecmp ("CREATE_SCHEDULE", element_name) == 0);
24370 
24375  &new_schedule))
24376  {
24377  case 0:
24378  {
24379  char *uuid;
24380  uuid = schedule_uuid (new_schedule);
24381  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_schedule"),
24382  uuid);
24383  log_event ("schedule", "Schedule", uuid, "created");
24384  free (uuid);
24385  break;
24386  }
24387  case 1:
24388  SEND_TO_CLIENT_OR_FAIL
24389  (XML_ERROR_SYNTAX ("create_schedule",
24390  "Schedule exists already"));
24391  log_event_fail ("schedule", "Schedule", NULL, "created");
24392  break;
24393  case 2:
24394  if (send_find_error_to_client ("create_schedule", "schedule",
24396  omp_parser))
24397  {
24398  error_send_to_client (error);
24399  return;
24400  }
24401  log_event_fail ("schedule", "Schedule", NULL, "created");
24402  break;
24403  case 99:
24404  SEND_TO_CLIENT_OR_FAIL
24405  (XML_ERROR_SYNTAX ("create_schedule",
24406  "Permission denied"));
24407  log_event_fail ("schedule", "Schedule", NULL, "created");
24408  break;
24409  case -1:
24410  default:
24411  SEND_TO_CLIENT_OR_FAIL
24412  (XML_INTERNAL_ERROR ("create_schedule"));
24413  log_event_fail ("schedule", "Schedule", NULL, "created");
24414  break;
24415  }
24416  else if (create_schedule_data->name == NULL)
24417  SEND_TO_CLIENT_OR_FAIL
24418  (XML_ERROR_SYNTAX ("create_schedule",
24419  "CREATE_SCHEDULE requires a NAME entity"));
24420  else if ((first_time = time_from_strings
24427  == -1)
24428  SEND_TO_CLIENT_OR_FAIL
24429  (XML_ERROR_SYNTAX ("create_schedule",
24430  "Failed to create time from FIRST_TIME"
24431  " elements"));
24432  else if ((period = interval_from_strings
24435  &period_months))
24436  == -3)
24437  SEND_TO_CLIENT_OR_FAIL
24438  (XML_ERROR_SYNTAX ("create_schedule",
24439  "PERIOD out of range"));
24440  else if (period < -1)
24441  SEND_TO_CLIENT_OR_FAIL
24442  (XML_ERROR_SYNTAX ("create_schedule",
24443  "Failed to create interval from PERIOD"));
24444  else if ((duration = interval_from_strings
24447  NULL))
24448  == -3)
24449  SEND_TO_CLIENT_OR_FAIL
24450  (XML_ERROR_SYNTAX ("create_schedule",
24451  "DURATION out of range"));
24452  else if (duration < -1)
24453  SEND_TO_CLIENT_OR_FAIL
24454  (XML_ERROR_SYNTAX ("create_schedule",
24455  "Failed to create interval from DURATION"));
24456 #if 0
24457  /* The actual time of a period in months can vary, so it's extremely
24458  * hard to do this check. The schedule will still work fine if the
24459  * duration is longer than the period. */
24460  else if (period_months
24461  && (duration > (period_months * 60 * 60 * 24 * 28)))
24462  SEND_TO_CLIENT_OR_FAIL
24463  (XML_ERROR_SYNTAX ("create_schedule",
24464  "Duration too long for number of months"));
24465 #endif
24466  else if (period && (duration > period))
24467  SEND_TO_CLIENT_OR_FAIL
24468  (XML_ERROR_SYNTAX ("create_schedule",
24469  "Duration is longer than period"));
24470  else switch (create_schedule (create_schedule_data->name,
24472  first_time,
24473  period == -1 ? 0 : period,
24474  period_months,
24475  duration == -1 ? 0 : duration,
24477  &new_schedule))
24478  {
24479  case 0:
24480  {
24481  char *uuid = schedule_uuid (new_schedule);
24482  SENDF_TO_CLIENT_OR_FAIL
24483  (XML_OK_CREATED_ID ("create_schedule"), uuid);
24484  log_event ("schedule", "Schedule", uuid, "created");
24485  free (uuid);
24486  break;
24487  }
24488  case 1:
24489  SEND_TO_CLIENT_OR_FAIL
24490  (XML_ERROR_SYNTAX ("create_schedule",
24491  "Schedule exists already"));
24492  log_event_fail ("schedule", "Schedule", NULL, "created");
24493  break;
24494  case 99:
24495  SEND_TO_CLIENT_OR_FAIL
24496  (XML_ERROR_SYNTAX ("create_schedule",
24497  "Permission denied"));
24498  log_event_fail ("schedule", "Schedule", NULL, "created");
24499  break;
24500  case -1:
24501  SEND_TO_CLIENT_OR_FAIL
24502  (XML_INTERNAL_ERROR ("create_schedule"));
24503  log_event_fail ("schedule", "Schedule", NULL, "created");
24504  break;
24505  default:
24506  assert (0);
24507  SEND_TO_CLIENT_OR_FAIL
24508  (XML_INTERNAL_ERROR ("create_schedule"));
24509  log_event_fail ("schedule", "Schedule", NULL, "created");
24510  break;
24511  }
24512  create_schedule_data_reset (create_schedule_data);
24513  set_client_state (CLIENT_AUTHENTIC);
24514  break;
24515  }
24516  CLOSE (CLIENT_CREATE_SCHEDULE, COMMENT);
24517  CLOSE (CLIENT_CREATE_SCHEDULE, COPY);
24518  CLOSE (CLIENT_CREATE_SCHEDULE, DURATION);
24519  CLOSE (CLIENT_CREATE_SCHEDULE, FIRST_TIME);
24521  CLOSE (CLIENT_CREATE_SCHEDULE, PERIOD);
24522  CLOSE (CLIENT_CREATE_SCHEDULE, TIMEZONE);
24523 
24524  CLOSE (CLIENT_CREATE_SCHEDULE_FIRST_TIME, DAY_OF_MONTH);
24529 
24531 
24533 
24534  case CLIENT_CREATE_TAG:
24535  {
24536  tag_t new_tag;
24537 
24538  assert (strcasecmp ("CREATE_TAG", element_name) == 0);
24539 
24540  if (create_tag_data->copy)
24541  switch (copy_tag (create_tag_data->name,
24544  &new_tag))
24545  {
24546  case 0:
24547  {
24548  char *uuid;
24549  uuid = tag_uuid (new_tag);
24550  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_tag"),
24551  uuid);
24552  log_event ("tag", "Tag", uuid, "created");
24553  free (uuid);
24554  break;
24555  }
24556  case 1:
24557  SEND_TO_CLIENT_OR_FAIL
24558  (XML_ERROR_SYNTAX ("create_tag",
24559  "Tag exists already"));
24560  log_event_fail ("tag", "Tag", NULL, "created");
24561  break;
24562  case 2:
24563  if (send_find_error_to_client ("create_tag", "tag",
24565  omp_parser))
24566  {
24567  error_send_to_client (error);
24568  return;
24569  }
24570  log_event_fail ("tag", "Tag", NULL, "created");
24571  break;
24572  case 99:
24573  SEND_TO_CLIENT_OR_FAIL
24574  (XML_ERROR_SYNTAX ("create_tag",
24575  "Permission denied"));
24576  log_event_fail ("tag", "Tag", NULL, "created");
24577  break;
24578  case -1:
24579  default:
24580  SEND_TO_CLIENT_OR_FAIL
24581  (XML_INTERNAL_ERROR ("create_tag"));
24582  log_event_fail ("tag", "Tag", NULL, "created");
24583  break;
24584  }
24585  else if (create_tag_data->name == NULL)
24586  SEND_TO_CLIENT_OR_FAIL
24587  (XML_ERROR_SYNTAX ("create_tag",
24588  "CREATE_TAG requires"
24589  " a NAME element"));
24590  else if (strlen (create_tag_data->name) == 0)
24591  SEND_TO_CLIENT_OR_FAIL
24592  (XML_ERROR_SYNTAX ("create_tag",
24593  "CREATE_TAG name must be"
24594  " at least one character long"));
24595  else if (create_tag_data->resource_id == NULL)
24596  SEND_TO_CLIENT_OR_FAIL
24597  (XML_ERROR_SYNTAX ("create_tag",
24598  "CREATE_TAG requires"
24599  " a RESOURCE element with id attribute"));
24600  else if (create_tag_data->resource_type == NULL)
24601  SEND_TO_CLIENT_OR_FAIL
24602  (XML_ERROR_SYNTAX ("create_tag",
24603  "RESOURCE in CREATE_TAG requires"
24604  " a TYPE element"));
24606  SEND_TO_CLIENT_OR_FAIL
24607  (XML_ERROR_SYNTAX ("create_tag",
24608  "TYPE in CREATE_TAG/RESOURCE must be"
24609  " a valid resource type."));
24610  else if (strcasecmp (create_tag_data->resource_type, "tag") == 0)
24611  SEND_TO_CLIENT_OR_FAIL
24612  (XML_ERROR_SYNTAX ("create_tag",
24613  "TYPE type in CREATE_TAG/RESOURCE must not"
24614  " be 'tag'."));
24615  else if (create_tag_data->resource_id
24616  && strlen (create_tag_data->resource_id) > 0
24619  SEND_TO_CLIENT_OR_FAIL
24620  (XML_ERROR_SYNTAX ("create_tag",
24621  "RESOURCE id must refer to an existing"
24622  " resource or be empty."));
24623  else
24624  {
24625  switch (create_tag (create_tag_data->name,
24631  &new_tag))
24632  {
24633  case 0:
24634  {
24635  char *uuid;
24636  uuid = tag_uuid (new_tag);
24637  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_tag"),
24638  uuid);
24639  log_event ("tag", "Tag", uuid, "created");
24640  free (uuid);
24641  break;
24642  }
24643  case 99:
24644  SEND_TO_CLIENT_OR_FAIL
24645  (XML_ERROR_SYNTAX ("create_tag",
24646  "Permission denied"));
24647  log_event_fail ("tag", "Tag", NULL, "created");
24648  break;
24649  case -1:
24650  SEND_TO_CLIENT_OR_FAIL
24651  (XML_INTERNAL_ERROR ("create_tag"));
24652  log_event_fail ("tag", "Tag", NULL, "created");
24653  break;
24654  }
24655  }
24656  g_debug ("trying reset");
24657  create_tag_data_reset (create_tag_data);
24658  g_debug ("trying set client state");
24659  set_client_state (CLIENT_AUTHENTIC);
24660 
24661  break;
24662  }
24663 
24664  CLOSE (CLIENT_CREATE_TAG, ACTIVE);
24665  CLOSE (CLIENT_CREATE_TAG, RESOURCE);
24666  CLOSE (CLIENT_CREATE_TAG, COPY);
24667  CLOSE (CLIENT_CREATE_TAG, COMMENT);
24669  CLOSE (CLIENT_CREATE_TAG, VALUE);
24670 
24672 
24673  case CLIENT_CREATE_TARGET:
24674  {
24675  credential_t ssh_credential = 0, smb_credential = 0;
24676  credential_t esxi_credential = 0, snmp_credential = 0;
24677  target_t new_target;
24678 
24679  assert (strcasecmp ("CREATE_TARGET", element_name) == 0);
24680 
24681  if (create_target_data->copy)
24685  &new_target))
24686  {
24687  case 0:
24688  {
24689  char *uuid;
24690  uuid = target_uuid (new_target);
24691  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_target"),
24692  uuid);
24693  log_event ("target", "Target", uuid, "created");
24694  free (uuid);
24695  break;
24696  }
24697  case 1:
24698  SEND_TO_CLIENT_OR_FAIL
24699  (XML_ERROR_SYNTAX ("create_target",
24700  "Target exists already"));
24701  log_event_fail ("target", "Target", NULL, "created");
24702  break;
24703  case 2:
24704  if (send_find_error_to_client ("create_target", "target",
24706  omp_parser))
24707  {
24708  error_send_to_client (error);
24709  return;
24710  }
24711  log_event_fail ("target", "Target", NULL, "created");
24712  break;
24713  case 99:
24714  SEND_TO_CLIENT_OR_FAIL
24715  (XML_ERROR_SYNTAX ("create_target",
24716  "Permission denied"));
24717  log_event_fail ("target", "Target", NULL, "created");
24718  break;
24719  case -1:
24720  default:
24721  SEND_TO_CLIENT_OR_FAIL
24722  (XML_INTERNAL_ERROR ("create_target"));
24723  log_event_fail ("target", "Target", NULL, "created");
24724  break;
24725  }
24726  else if (create_target_data->name == NULL)
24727  SEND_TO_CLIENT_OR_FAIL
24728  (XML_ERROR_SYNTAX ("create_target",
24729  "CREATE_TARGET requires a NAME"));
24730  else if (strlen (create_target_data->name) == 0)
24731  SEND_TO_CLIENT_OR_FAIL
24732  (XML_ERROR_SYNTAX ("create_target",
24733  "CREATE_TARGET name must be at"
24734  " least one character long"));
24735  else if (create_target_data->asset_hosts_filter == NULL
24736  && create_target_data->hosts == NULL)
24737  SEND_TO_CLIENT_OR_FAIL
24738  (XML_ERROR_SYNTAX ("create_target",
24739  " CREATE_TARGET requires a host"));
24740  else if (create_target_data->asset_hosts_filter == NULL
24741  && strlen (create_target_data->hosts) == 0)
24743  SEND_TO_CLIENT_OR_FAIL
24744  (XML_ERROR_SYNTAX ("create_target",
24745  "CREATE_TARGET hosts must be at least one"
24746  " character long"));
24750  &ssh_credential,
24751  "get_credentials"))
24752  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24753  else if (create_target_data->ssh_credential_id == NULL
24757  &ssh_credential,
24758  "get_credentials"))
24759  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24762  && ssh_credential == 0)
24763  {
24764  if (send_find_error_to_client
24765  ("create_target", "Credential",
24769  omp_parser))
24770  {
24771  error_send_to_client (error);
24772  return;
24773  }
24774  }
24778  &smb_credential,
24779  "get_credentials"))
24780  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24781  else if (create_target_data->smb_credential_id == NULL
24785  &smb_credential,
24786  "get_credentials"))
24787  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24790  && smb_credential == 0)
24791  {
24792  if (send_find_error_to_client
24793  ("create_target", "Credential",
24797  omp_parser))
24798  {
24799  error_send_to_client (error);
24800  return;
24801  }
24802  }
24806  &esxi_credential,
24807  "get_credentials"))
24808  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24809  else if (create_target_data->esxi_credential_id == NULL
24813  &esxi_credential,
24814  "get_credentials"))
24815  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24818  && esxi_credential == 0)
24819  {
24820  if (send_find_error_to_client
24821  ("create_target", "Credential",
24825  omp_parser))
24826  {
24827  error_send_to_client (error);
24828  return;
24829  }
24830  }
24834  &snmp_credential,
24835  "get_credentials"))
24836  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24838  && snmp_credential == 0)
24839  {
24840  if (send_find_error_to_client
24841  ("create_target", "Credential",
24843  omp_parser))
24844  {
24845  error_send_to_client (error);
24846  return;
24847  }
24848  }
24849  /* Create target from host string. */
24850  else switch (create_target
24858  ssh_credential,
24862  smb_credential,
24863  esxi_credential,
24864  snmp_credential,
24869  && strcmp (create_target_data->make_name_unique, "0"))
24870  ? 1 : 0,
24871  &new_target))
24872  {
24873  case 1:
24874  SEND_TO_CLIENT_OR_FAIL
24875  (XML_ERROR_SYNTAX ("create_target",
24876  "Target exists already"));
24877  log_event_fail ("target", "Target", NULL, "created");
24878  break;
24879  case 2:
24880  SEND_TO_CLIENT_OR_FAIL
24881  (XML_ERROR_SYNTAX ("create_target",
24882  "Error in host specification"));
24883  log_event_fail ("target", "Target", NULL, "created");
24884  break;
24885  case 3:
24886  SEND_TO_CLIENT_OR_FAIL
24887  (XML_ERROR_SYNTAX ("create_target",
24888  "Host specification exceeds maximum number"
24889  " of hosts"));
24890  log_event_fail ("target", "Target", NULL, "created");
24891  break;
24892  case 4:
24893  SEND_TO_CLIENT_OR_FAIL
24894  (XML_ERROR_SYNTAX ("create_target",
24895  "Error in port range"));
24896  log_event_fail ("target", "Target", NULL, "created");
24897  break;
24898  case 5:
24899  SEND_TO_CLIENT_OR_FAIL
24900  (XML_ERROR_SYNTAX ("create_target",
24901  "Error in SSH port"));
24902  log_event_fail ("target", "Target", NULL, "created");
24903  break;
24904  case 6:
24905  log_event_fail ("target", "Target", NULL, "created");
24906  if (send_find_error_to_client
24907  ("create_target", "port_list",
24908  create_target_data->port_list_id, omp_parser))
24909  {
24910  error_send_to_client (error);
24911  return;
24912  }
24913  break;
24914  case 7:
24915  SEND_TO_CLIENT_OR_FAIL
24916  (XML_ERROR_SYNTAX ("create_target",
24917  "Error in alive test"));
24918  log_event_fail ("target", "Target", NULL, "created");
24919  break;
24920  case 8:
24921  SEND_TO_CLIENT_OR_FAIL
24922  (XML_ERROR_SYNTAX ("create_target",
24923  "SSH credential must be of type"
24924  " 'up' or 'usk'"));
24925  log_event_fail ("target", "Target", NULL, "created");
24926  break;
24927  case 9:
24928  SEND_TO_CLIENT_OR_FAIL
24929  (XML_ERROR_SYNTAX ("create_target",
24930  "SMB credential must be of type"
24931  " 'up'"));
24932  log_event_fail ("target", "Target", NULL, "created");
24933  break;
24934  case 10:
24935  SEND_TO_CLIENT_OR_FAIL
24936  (XML_ERROR_SYNTAX ("create_target",
24937  "ESXi credential must be of type"
24938  " 'up'"));
24939  log_event_fail ("target", "Target", NULL, "created");
24940  break;
24941  case 11:
24942  SEND_TO_CLIENT_OR_FAIL
24943  (XML_ERROR_SYNTAX ("create_target",
24944  "SNMP credential must be of type"
24945  " 'snmp'"));
24946  log_event_fail ("target", "Target", NULL, "created");
24947  break;
24948  case 99:
24949  SEND_TO_CLIENT_OR_FAIL
24950  (XML_ERROR_SYNTAX ("create_target",
24951  "Permission denied"));
24952  log_event_fail ("target", "Target", NULL, "created");
24953  break;
24954  case -1:
24955  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_target"));
24956  log_event_fail ("target", "Target", NULL, "created");
24957  break;
24958  default:
24959  {
24960  char *uuid = target_uuid (new_target);
24961  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_target"),
24962  uuid);
24963  log_event ("target", "Target", uuid, "created");
24964  free (uuid);
24965  break;
24966  }
24967  }
24968 
24969  create_target_data_reset (create_target_data);
24970  set_client_state (CLIENT_AUTHENTIC);
24971  break;
24972  }
24973  CLOSE (CLIENT_CREATE_TARGET, ASSET_HOSTS);
24974  CLOSE (CLIENT_CREATE_TARGET, COMMENT);
24975  CLOSE (CLIENT_CREATE_TARGET, ESXI_CREDENTIAL);
24976  CLOSE (CLIENT_CREATE_TARGET, ESXI_LSC_CREDENTIAL);
24977  CLOSE (CLIENT_CREATE_TARGET, EXCLUDE_HOSTS);
24978  CLOSE (CLIENT_CREATE_TARGET, REVERSE_LOOKUP_ONLY);
24979  CLOSE (CLIENT_CREATE_TARGET, REVERSE_LOOKUP_UNIFY);
24980  CLOSE (CLIENT_CREATE_TARGET, ALIVE_TESTS);
24981  CLOSE (CLIENT_CREATE_TARGET, COPY);
24982  CLOSE (CLIENT_CREATE_TARGET, HOSTS);
24984  CLOSE (CLIENT_CREATE_TARGET, PORT_LIST);
24985  CLOSE (CLIENT_CREATE_TARGET, PORT_RANGE);
24986  CLOSE (CLIENT_CREATE_TARGET, SSH_CREDENTIAL);
24987  CLOSE (CLIENT_CREATE_TARGET, SSH_LSC_CREDENTIAL);
24988  CLOSE (CLIENT_CREATE_TARGET, SMB_CREDENTIAL);
24989  CLOSE (CLIENT_CREATE_TARGET, SMB_LSC_CREDENTIAL);
24990  CLOSE (CLIENT_CREATE_TARGET, SNMP_CREDENTIAL);
24991 
24992  CLOSE (CLIENT_CREATE_TARGET_NAME, MAKE_UNIQUE);
24993 
24995 
24997 
24998  case CLIENT_CREATE_TASK:
24999  {
25000  config_t config = 0;
25001  target_t target = 0;
25002  scanner_t scanner = 0;
25003  char *tsk_uuid = NULL, *name;
25004  guint index;
25005 
25006  /* @todo Buffer the entire task creation and pass everything to a
25007  * libmanage function, so that libmanage can do the locking
25008  * properly instead of exposing the task_t. Probably easier
25009  * after removing the option to create a task from an RC
25010  * file. */
25011 
25012  assert (strcasecmp ("CREATE_TASK", element_name) == 0);
25013  assert (create_task_data->task != (task_t) 0);
25014 
25015  /* The task already exists in the database at this point, so on
25016  * failure be sure to call request_delete_task to remove the
25017  * task. */
25021  if (create_task_data->copy)
25022  {
25023  int ret;
25024  gchar *name, *comment;
25025  task_t new_task;
25026 
25027  name = task_name (create_task_data->task);
25028  comment = task_comment (create_task_data->task);
25029  ret = copy_task (name,
25030  comment,
25033  && strcmp (create_task_data->alterable, "0"))
25034  ? 1
25035  : 0,
25036  &new_task);
25037  g_free (name);
25038  g_free (comment);
25039  /* Remove the task that was created while parsing elements. */
25041  switch (ret)
25042  {
25043  case 0:
25044  {
25045  char *uuid;
25046  task_uuid (new_task, &uuid);
25047  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_task"),
25048  uuid);
25049  log_event ("task", "Task", uuid, "created");
25050  free (uuid);
25051  break;
25052  }
25053  case 1:
25054  SEND_TO_CLIENT_OR_FAIL
25055  (XML_ERROR_SYNTAX ("create_task",
25056  "Task exists already"));
25057  log_event_fail ("task", "Task", NULL, "created");
25058  break;
25059  case 2:
25060  if (send_find_error_to_client ("create_task", "task",
25062  omp_parser))
25063  {
25064  error_send_to_client (error);
25065  return;
25066  }
25067  log_event_fail ("task", "Task", NULL, "created");
25068  break;
25069  case 99:
25070  SEND_TO_CLIENT_OR_FAIL
25071  (XML_ERROR_SYNTAX ("create_task",
25072  "Permission denied"));
25073  log_event_fail ("task", "Task", NULL, "created");
25074  break;
25075  case -1:
25076  SEND_TO_CLIENT_OR_FAIL
25077  (XML_INTERNAL_ERROR ("create_task"));
25078  log_event_fail ("task", "Task", NULL, "created");
25079  break;
25080  }
25081  create_task_data_reset (create_task_data);
25082  set_client_state (CLIENT_AUTHENTIC);
25083  break;
25084  }
25085 
25086  if (create_task_data->scanner_id == NULL)
25088 
25089  /* Check permissions. */
25090 
25091  if (acl_user_may ("create_task") == 0)
25092  {
25093  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX ("create_task",
25094  "Permission denied"));
25095  goto create_task_fail;
25096  }
25097 
25098  /* Get the task ID. */
25099 
25100  if (task_uuid (create_task_data->task, &tsk_uuid))
25101  {
25102  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_task"));
25103  goto create_task_fail;
25104  }
25105 
25106  /* Check for the right combination of target and config. */
25107 
25108  if (create_task_data->target_id == NULL)
25109  {
25110  SEND_TO_CLIENT_OR_FAIL
25111  (XML_ERROR_SYNTAX ("create_task",
25112  "CREATE_TASK requires a target"));
25113  goto create_task_fail;
25114  }
25115 
25116  if (strcmp (create_task_data->target_id, "0") == 0)
25117  {
25118  /* Container task. */
25119 
25121  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_task"),
25122  tsk_uuid);
25123  make_task_complete (tsk_uuid);
25124  log_event ("task", "Task", tsk_uuid, "created");
25125  g_free (tsk_uuid);
25126  create_task_data_reset (create_task_data);
25127  set_client_state (CLIENT_AUTHENTIC);
25128  break;
25129  }
25130 
25131  if (create_task_data->config_id == NULL)
25132  {
25133  SEND_TO_CLIENT_OR_FAIL
25134  (XML_ERROR_SYNTAX ("create_task",
25135  "CREATE_TASK requires a config"));
25136  goto create_task_fail;
25137  }
25138 
25139  /* Set any alert. */
25140 
25141  assert (create_task_data->alerts);
25142  index = create_task_data->alerts->len;
25143  while (index--)
25144  {
25145  alert_t alert;
25146  gchar *alert_id;
25147 
25148  alert_id = (gchar*) g_ptr_array_index (create_task_data->alerts,
25149  index);
25150  if (strcmp (alert_id, "0") == 0)
25151  continue;
25152  if (find_alert_with_permission (alert_id, &alert, "get_alerts"))
25153  {
25154  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_task"));
25155  goto create_task_fail;
25156  }
25157  if (alert == 0)
25158  {
25159  SEND_TO_CLIENT_OR_FAIL
25160  (XML_ERROR_SYNTAX ("create_task",
25161  "CREATE_TASK alert must exist"));
25162  goto create_task_fail;
25163  }
25165  }
25166 
25167  /* Set alterable state. */
25168 
25170  && strcmp (create_task_data->alterable, "0"))
25172 
25173  /* Set any schedule. */
25174 
25176  {
25177  schedule_t schedule;
25178  int periods;
25179 
25182  : 0;
25184  &schedule,
25185  "get_schedules"))
25186  {
25187  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_task"));
25188  goto create_task_fail;
25189  }
25190  if (schedule == 0)
25191  {
25192  SEND_TO_CLIENT_OR_FAIL
25193  (XML_ERROR_SYNTAX ("create_task",
25194  "CREATE_TASK schedule must exist"));
25195  goto create_task_fail;
25196  }
25215  set_task_schedule (create_task_data->task, schedule, periods);
25216  }
25218  && strlen (create_task_data->schedule_periods))
25222 
25223  /* Set any observers. */
25224 
25226  {
25227  int fail;
25230  switch (fail)
25231  {
25232  case 0:
25233  break;
25234  case 1:
25235  case 2:
25236  SEND_TO_CLIENT_OR_FAIL
25237  (XML_ERROR_SYNTAX ("create_task",
25238  "User name error in observers"));
25239  goto create_task_fail;
25240  case -1:
25241  default:
25242  SEND_TO_CLIENT_OR_FAIL
25243  (XML_INTERNAL_ERROR ("create_task"));
25244  goto create_task_fail;
25245  }
25246  }
25247 
25248  /* Set any observer groups. */
25249 
25250  if (create_task_data->groups->len)
25251  {
25252  int fail;
25253  gchar *fail_group_id;
25254 
25255  switch ((fail = set_task_groups (create_task_data->task,
25257  &fail_group_id)))
25258  {
25259  case 0:
25260  break;
25261  case 1:
25262  if (send_find_error_to_client
25263  ("create_task", "group", fail_group_id, omp_parser))
25264  {
25265  error_send_to_client (error);
25266  return;
25267  }
25268  log_event_fail ("task", "Task", NULL, "created");
25269  goto create_task_fail;
25270  case -1:
25271  default:
25272  SEND_TO_CLIENT_OR_FAIL
25273  (XML_INTERNAL_ERROR ("create_task"));
25274  log_event_fail ("task", "Task", NULL, "created");
25275  goto create_task_fail;
25276  }
25277  }
25278 
25279  /* Check for name. */
25280 
25281  name = task_name (create_task_data->task);
25282  if (name == NULL)
25283  {
25284  SEND_TO_CLIENT_OR_FAIL
25285  (XML_ERROR_SYNTAX ("create_task",
25286  "CREATE_TASK requires a name attribute"));
25287  goto create_task_fail;
25288  }
25289 
25291  &scanner,
25292  "get_scanners"))
25293  {
25294  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_task"));
25295  goto create_task_fail;
25296  }
25297  if (create_task_data->scanner_id && scanner == 0)
25298  {
25299  if (send_find_error_to_client ("create_task", "scanner",
25301  omp_parser))
25302  error_send_to_client (error);
25303  goto create_task_fail;
25304  }
25305  if ((scanner == 0) || (scanner_type (scanner) != SCANNER_TYPE_CVE))
25306  {
25308  &config,
25309  "get_configs"))
25310  {
25311  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_task"));
25312  goto create_task_fail;
25313  }
25314  if (config == 0)
25315  {
25316  if (send_find_error_to_client ("create_task", "config",
25318  omp_parser))
25319  error_send_to_client (error);
25320  goto create_task_fail;
25321  }
25322 
25323  if (!create_task_check_config_scanner (config, scanner))
25324  {
25325  SEND_TO_CLIENT_OR_FAIL
25326  (XML_ERROR_SYNTAX ("create_task",
25327  "Scanner and config mismatched types."));
25328  goto create_task_fail;
25329  }
25330  }
25332  &target,
25333  "get_targets"))
25334  {
25335  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_task"));
25336  goto create_task_fail;
25337  }
25338  if (target == 0)
25339  {
25340  if (send_find_error_to_client ("create_task", "target",
25342  omp_parser))
25343  error_send_to_client (error);
25344  goto create_task_fail;
25345  }
25346 
25355  {
25356  case 0:
25357  break;
25358  case 1:
25359  SEND_TO_CLIENT_OR_FAIL
25360  (XML_ERROR_SYNTAX ("create_task",
25361  "Invalid auto_delete value"));
25362  goto create_task_fail;
25363  case 2:
25364  SENDF_TO_CLIENT_OR_FAIL
25365  (XML_ERROR_SYNTAX ("create_task",
25366  "Auto Delete count out of range"
25367  " (must be from %d to %d)"),
25369  goto create_task_fail;
25370  default:
25371  SEND_TO_CLIENT_OR_FAIL
25372  (XML_INTERNAL_ERROR ("create_task"));
25373  goto create_task_fail;
25374  }
25375 
25376  /* Send success response. */
25377 
25378  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_task"),
25379  tsk_uuid);
25380  make_task_complete (tsk_uuid);
25381  log_event ("task", "Task", tsk_uuid, "created");
25382  g_free (tsk_uuid);
25383  create_task_data_reset (create_task_data);
25384  set_client_state (CLIENT_AUTHENTIC);
25385  break;
25386 
25387  create_task_fail:
25389  g_free (tsk_uuid);
25390  create_task_data_reset (create_task_data);
25391  set_client_state (CLIENT_AUTHENTIC);
25392  break;
25393  }
25394  CLOSE (CLIENT_CREATE_TASK, ALTERABLE);
25395  CLOSE (CLIENT_CREATE_TASK, COMMENT);
25396  CLOSE (CLIENT_CREATE_TASK, HOSTS_ORDERING);
25397  CLOSE (CLIENT_CREATE_TASK, SCANNER);
25398  CLOSE (CLIENT_CREATE_TASK, CONFIG);
25399  CLOSE (CLIENT_CREATE_TASK, COPY);
25400  CLOSE (CLIENT_CREATE_TASK, ALERT);
25402  CLOSE (CLIENT_CREATE_TASK, OBSERVERS);
25403  CLOSE (CLIENT_CREATE_TASK, PREFERENCES);
25404  CLOSE (CLIENT_CREATE_TASK, TARGET);
25405  CLOSE (CLIENT_CREATE_TASK, SCHEDULE);
25406  CLOSE (CLIENT_CREATE_TASK, SCHEDULE_PERIODS);
25407 
25409 
25411  assert (strcasecmp ("PREFERENCE", element_name) == 0);
25412  array_add (create_task_data->preferences,
25414  create_task_data->preference = NULL;
25415  set_client_state (CLIENT_CREATE_TASK_PREFERENCES);
25416  break;
25418  assert (strcasecmp ("SCANNER_NAME", element_name) == 0);
25419  set_client_state (CLIENT_CREATE_TASK_PREFERENCES_PREFERENCE);
25420  break;
25422 
25423  case CLIENT_CREATE_USER:
25424  {
25425  gchar *errdesc;
25426  gchar *fail_group_id, *fail_role_id;
25427  user_t new_user;
25428 
25429  assert (strcasecmp ("CREATE_USER", element_name) == 0);
25430 
25431  errdesc = NULL;
25432  if (create_user_data->copy)
25433  switch (copy_user (create_user_data->name,
25434  NULL,
25436  &new_user))
25437  {
25438  case 0:
25439  {
25440  char *uuid;
25441  uuid = user_uuid (new_user);
25442  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_user"),
25443  uuid);
25444  log_event ("user", "User", uuid, "created");
25445  free (uuid);
25446  break;
25447  }
25448  case 1:
25449  SEND_TO_CLIENT_OR_FAIL
25450  (XML_ERROR_SYNTAX ("create_user",
25451  "User exists already"));
25452  log_event_fail ("user", "User", NULL, "created");
25453  break;
25454  case 2:
25455  if (send_find_error_to_client ("create_user", "user",
25457  omp_parser))
25458  {
25459  error_send_to_client (error);
25460  return;
25461  }
25462  log_event_fail ("user", "User", NULL, "created");
25463  break;
25464  case 99:
25465  SEND_TO_CLIENT_OR_FAIL
25466  (XML_ERROR_SYNTAX ("create_user",
25467  "Permission denied"));
25468  log_event_fail ("user", "User", NULL, "created");
25469  break;
25470  case -1:
25471  default:
25472  SEND_TO_CLIENT_OR_FAIL
25473  (XML_INTERNAL_ERROR ("create_user"));
25474  log_event_fail ("user", "User", NULL, "created");
25475  break;
25476  }
25477  else if (create_user_data->name == NULL
25478  || strlen (create_user_data->name) == 0)
25479  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
25480  ("create_user",
25481  "CREATE_USER requires a name"));
25482  else
25483  switch (create_user
25492  &fail_group_id,
25494  &fail_role_id,
25495  &errdesc,
25496  &new_user,
25497  1))
25498  {
25499  case 0:
25500  {
25501  char *uuid;
25502  uuid = user_uuid (new_user);
25503  SENDF_TO_CLIENT_OR_FAIL (XML_OK_CREATED_ID ("create_user"),
25504  uuid);
25505  log_event ("user", "User", create_user_data->name, "created");
25506  free (uuid);
25507  break;
25508  }
25509  case 1:
25510  if (send_find_error_to_client
25511  ("create_user", "group", fail_group_id, omp_parser))
25512  {
25513  error_send_to_client (error);
25514  return;
25515  }
25516  log_event_fail ("user", "User", NULL, "created");
25517  break;
25518  case 2:
25519  if (send_find_error_to_client
25520  ("create_user", "role", fail_role_id, omp_parser))
25521  {
25522  error_send_to_client (error);
25523  return;
25524  }
25525  log_event_fail ("user", "User", NULL, "created");
25526  break;
25527  case 3:
25528  SEND_TO_CLIENT_OR_FAIL
25529  (XML_ERROR_SYNTAX ("create_user",
25530  "Error in host specification"));
25531  log_event_fail ("user", "User", NULL, "created");
25532  break;
25533  case 99:
25534  SEND_TO_CLIENT_OR_FAIL
25535  (XML_ERROR_SYNTAX ("create_user",
25536  "Permission denied"));
25537  log_event_fail ("user", "User", NULL, "created");
25538  break;
25539  case -2:
25540  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
25541  ("create_user", "User already exists"));
25542  log_event_fail ("user", "User", NULL, "created");
25543  break;
25544  case -3:
25545  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
25546  ("create_user", "Error in SOURCE"));
25547  log_event_fail ("user", "User", NULL, "created");
25548  break;
25549  case -1:
25550  if (errdesc)
25551  {
25552  char *buf = make_xml_error_syntax ("create_user", errdesc);
25553  SEND_TO_CLIENT_OR_FAIL (buf);
25554  g_free (buf);
25555  break;
25556  }
25557  /* Fall through. */
25558  default:
25559  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("create_user"));
25560  log_event_fail ("user", "User", NULL, "created");
25561  break;
25562  }
25563  create_user_data_reset (create_user_data);
25564  set_client_state (CLIENT_AUTHENTIC);
25565  g_free (errdesc);
25566  break;
25567  }
25568  CLOSE (CLIENT_CREATE_USER, COPY);
25569  CLOSE (CLIENT_CREATE_USER, GROUPS);
25571  CLOSE (CLIENT_CREATE_USER, HOSTS);
25572  CLOSE (CLIENT_CREATE_USER, IFACES);
25574  CLOSE (CLIENT_CREATE_USER, PASSWORD);
25575  CLOSE (CLIENT_CREATE_USER, ROLE);
25577  assert (strcasecmp ("SOURCES", element_name) == 0);
25578  array_terminate (create_user_data->sources);
25579  set_client_state (CLIENT_CREATE_USER);
25580  break;
25582  assert (strcasecmp ("SOURCE", element_name) == 0);
25584  array_add (create_user_data->sources,
25585  g_strdup (create_user_data->current_source));
25586  g_free (create_user_data->current_source);
25588  set_client_state (CLIENT_CREATE_USER_SOURCES);
25589  break;
25590 
25591  case CLIENT_EMPTY_TRASHCAN:
25592  switch (manage_empty_trashcan ())
25593  {
25594  case 0:
25595  SEND_TO_CLIENT_OR_FAIL (XML_OK ("empty_trashcan"));
25596  log_event ("trashcan", "Trashcan", NULL, "emptied");
25597  break;
25598  case 99:
25599  SEND_TO_CLIENT_OR_FAIL
25600  (XML_ERROR_SYNTAX ("empty_trashcan",
25601  "Permission denied"));
25602  break;
25603  default: /* Programming error. */
25604  assert (0);
25605  case -1:
25606  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("empty_trashcan"));
25607  break;
25608  }
25609  set_client_state (CLIENT_AUTHENTIC);
25610  break;
25611 
25612  case CLIENT_MODIFY_AGENT:
25613  {
25614  assert (strcasecmp ("MODIFY_AGENT", element_name) == 0);
25615 
25616  switch (modify_agent
25620  {
25621  case 0:
25622  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_agent"));
25623  log_event ("agent", "Agent", modify_agent_data->agent_id,
25624  "modified");
25625  break;
25626  case 1:
25627  if (send_find_error_to_client ("modify_agent", "agent",
25629  omp_parser))
25630  {
25631  error_send_to_client (error);
25632  return;
25633  }
25634  log_event_fail ("agent", "Agent", modify_agent_data->agent_id,
25635  "modified");
25636  break;
25637  case 2:
25638  SEND_TO_CLIENT_OR_FAIL
25639  (XML_ERROR_SYNTAX ("modify_agent",
25640  "agent with new name exists already"));
25641  log_event_fail ("agent", "Agent", modify_agent_data->agent_id,
25642  "modified");
25643  break;
25644  case 3:
25645  SEND_TO_CLIENT_OR_FAIL
25646  (XML_ERROR_SYNTAX ("modify_agent",
25647  "MODIFY_agent requires a agent_id"));
25648  log_event_fail ("agent", "Agent", modify_agent_data->agent_id,
25649  "modified");
25650  break;
25651  case 99:
25652  SEND_TO_CLIENT_OR_FAIL
25653  (XML_ERROR_SYNTAX ("modify_agent",
25654  "Permission denied"));
25655  log_event_fail ("agent", "Agent", modify_agent_data->agent_id,
25656  "modified");
25657  break;
25658  default:
25659  case -1:
25660  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_agent"));
25661  log_event_fail ("agent", "Agent", modify_agent_data->agent_id,
25662  "modified");
25663  break;
25664  }
25665 
25666  modify_agent_data_reset (modify_agent_data);
25667  set_client_state (CLIENT_AUTHENTIC);
25668  break;
25669  }
25670  CLOSE (CLIENT_MODIFY_AGENT, COMMENT);
25672 
25673  case CLIENT_MODIFY_ALERT:
25674  {
25675  event_t event;
25676  alert_condition_t condition;
25677  alert_method_t method;
25678 
25679  assert (strcasecmp ("MODIFY_ALERT", element_name) == 0);
25680 
25681  event = EVENT_ERROR;
25682  condition = ALERT_CONDITION_ERROR;
25683  method = ALERT_METHOD_ERROR;
25684 
25685  array_terminate (modify_alert_data->event_data);
25686  array_terminate (modify_alert_data->condition_data);
25687  array_terminate (modify_alert_data->method_data);
25688 
25689  if (strlen (modify_alert_data->event)
25690  && (event = event_from_name (modify_alert_data->event)) == 0)
25691  SEND_TO_CLIENT_OR_FAIL
25692  (XML_ERROR_SYNTAX ("modify_alert",
25693  "Failed to recognise event name"));
25694  else if (strlen (modify_alert_data->condition) &&
25695  (condition = alert_condition_from_name
25697  == 0)
25698  SEND_TO_CLIENT_OR_FAIL
25699  (XML_ERROR_SYNTAX ("modify_alert",
25700  "Failed to recognise condition name"));
25701  else if (strlen (modify_alert_data->method) &&
25702  (method = alert_method_from_name
25704  == 0)
25705  SEND_TO_CLIENT_OR_FAIL
25706  (XML_ERROR_SYNTAX ("modify_alert",
25707  "Failed to recognise method name"));
25708  else switch (modify_alert
25713  event,
25715  condition,
25717  method,
25719  {
25720  case 0:
25721  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_alert"));
25722  log_event ("alert", "Alert", modify_alert_data->alert_id,
25723  "modified");
25724  break;
25725  case 1:
25726  if (send_find_error_to_client ("modify_alert", "alert",
25728  omp_parser))
25729  {
25730  error_send_to_client (error);
25731  return;
25732  }
25733  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25734  "modified");
25735  break;
25736  case 2:
25737  SEND_TO_CLIENT_OR_FAIL
25738  (XML_ERROR_SYNTAX ("modify_alert",
25739  "alert with new name exists already"));
25740  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25741  "modified");
25742  break;
25743  case 3:
25744  SEND_TO_CLIENT_OR_FAIL
25745  (XML_ERROR_SYNTAX ("modify_alert",
25746  "MODIFY_alert requires an alert_id"));
25747  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25748  "modified");
25749  break;
25750  case 4:
25751  if (send_find_error_to_client ("modify_alert", "filter",
25753  omp_parser))
25754  {
25755  error_send_to_client (error);
25756  return;
25757  }
25758  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25759  "modified");
25760  break;
25761  case 5:
25762  SEND_TO_CLIENT_OR_FAIL
25763  (XML_ERROR_SYNTAX ("modify_alert",
25764  "Filter type must be result if"
25765  " specified"));
25766  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25767  "modified");
25768  break;
25769  case 6:
25770  SEND_TO_CLIENT_OR_FAIL
25771  (XML_ERROR_SYNTAX ("modify_alert",
25772  "Validation of email address failed"));
25773  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25774  "modified");
25775  break;
25776  case 7:
25777  SEND_TO_CLIENT_OR_FAIL
25778  (XML_ERROR_SYNTAX ("modify_alert",
25779  "Invalid or unexpected condition data"
25780  " name"));
25781  log_event_fail ("alert", "Alert", NULL, "modified");
25782  break;
25783  case 8:
25784  SEND_TO_CLIENT_OR_FAIL
25785  (XML_ERROR_SYNTAX ("modify_alert",
25786  "Syntax error in condition data"));
25787  log_event_fail ("alert", "Alert", NULL, "modified");
25788  break;
25789  case 9:
25790  SEND_TO_CLIENT_OR_FAIL
25791  (XML_ERROR_SYNTAX ("modify_alert",
25792  "Email subject too long"));
25793  log_event_fail ("alert", "Alert", NULL, "modified");
25794  break;
25795  case 10:
25796  SEND_TO_CLIENT_OR_FAIL
25797  (XML_ERROR_SYNTAX ("modify_alert",
25798  "Email message too long"));
25799  log_event_fail ("alert", "Alert", NULL, "modified");
25800  break;
25801  case 11:
25802  SEND_TO_CLIENT_OR_FAIL
25803  (XML_ERROR_SYNTAX ("modify_alert",
25804  "Failed to find filter for condition"));
25805  log_event_fail ("alert", "Alert", NULL, "modified");
25806  break;
25807  case 12:
25808  SEND_TO_CLIENT_OR_FAIL
25809  (XML_ERROR_SYNTAX ("modify_alert",
25810  "Error in Send host"));
25811  log_event_fail ("alert", "Alert", NULL, "modify");
25812  break;
25813  case 13:
25814  SEND_TO_CLIENT_OR_FAIL
25815  (XML_ERROR_SYNTAX ("modify_alert",
25816  "Error in Send port"));
25817  log_event_fail ("alert", "Alert", NULL, "modify");
25818  break;
25819  case 14:
25820  SEND_TO_CLIENT_OR_FAIL
25821  (XML_ERROR_SYNTAX ("modify_alert",
25822  "Failed to find report format for Send"
25823  " method"));
25824  log_event_fail ("alert", "Alert", NULL, "modify");
25825  break;
25826  case 15:
25827  SEND_TO_CLIENT_OR_FAIL
25828  (XML_ERROR_SYNTAX ("modify_alert",
25829  "Error in SCP host"));
25830  log_event_fail ("alert", "Alert", NULL, "modify");
25831  break;
25832  case 17:
25833  SEND_TO_CLIENT_OR_FAIL
25834  (XML_ERROR_SYNTAX ("modify_alert",
25835  "Failed to find report format for SCP"
25836  " method"));
25837  log_event_fail ("alert", "Alert", NULL, "modify");
25838  break;
25839  case 18:
25840  SEND_TO_CLIENT_OR_FAIL
25841  (XML_ERROR_SYNTAX ("modify_alert",
25842  "Error in SCP credential"));
25843  log_event_fail ("alert", "Alert", NULL, "modify");
25844  break;
25845  case 19:
25846  SEND_TO_CLIENT_OR_FAIL
25847  (XML_ERROR_SYNTAX ("modify_alert",
25848  "Error in SCP path"));
25849  log_event_fail ("alert", "Alert", NULL, "modify");
25850  break;
25851  case 20:
25852  SEND_TO_CLIENT_OR_FAIL
25853  (XML_ERROR_SYNTAX ("modify_alert",
25854  "Method does not match event type"));
25855  log_event_fail ("alert", "Alert", NULL, "modify");
25856  break;
25857  case 21:
25858  SEND_TO_CLIENT_OR_FAIL
25859  (XML_ERROR_SYNTAX ("modify_alert",
25860  "Condition does not match event type"));
25861  log_event_fail ("alert", "Alert", NULL, "modify");
25862  break;
25863  case 31:
25864  SEND_TO_CLIENT_OR_FAIL
25865  (XML_ERROR_SYNTAX ("modify_alert",
25866  "Unexpected event data name"));
25867  log_event_fail ("alert", "Alert", NULL, "modified");
25868  break;
25869  case 32:
25870  SEND_TO_CLIENT_OR_FAIL
25871  (XML_ERROR_SYNTAX ("modify_alert",
25872  "Syntax error in event data"));
25873  log_event_fail ("alert", "Alert", NULL, "modified");
25874  break;
25875  case 40:
25876  SEND_TO_CLIENT_OR_FAIL
25877  (XML_ERROR_SYNTAX ("modify_alert",
25878  "Error in SMB credential"));
25879  log_event_fail ("alert", "Alert", NULL, "modified");
25880  break;
25881  case 41:
25882  SEND_TO_CLIENT_OR_FAIL
25883  (XML_ERROR_SYNTAX ("modify_alert",
25884  "Error in SMB share path"));
25885  log_event_fail ("alert", "Alert", NULL, "modified");
25886  break;
25887  case 42:
25888  SEND_TO_CLIENT_OR_FAIL
25889  (XML_ERROR_SYNTAX ("modify_alert",
25890  "Error in SMB file path"));
25891  log_event_fail ("alert", "Alert", NULL, "modified");
25892  break;
25893  case 50:
25894  SEND_TO_CLIENT_OR_FAIL
25895  (XML_ERROR_SYNTAX ("create_alert",
25896  "Error in TippingPoint credential"));
25897  log_event_fail ("alert", "Alert", NULL, "created");
25898  break;
25899  case 51:
25900  SEND_TO_CLIENT_OR_FAIL
25901  (XML_ERROR_SYNTAX ("create_alert",
25902  "Error in TippingPoint hostname"));
25903  log_event_fail ("alert", "Alert", NULL, "created");
25904  break;
25905  case 52:
25906  SEND_TO_CLIENT_OR_FAIL
25907  (XML_ERROR_SYNTAX ("create_alert",
25908  "Error in TippingPoint TLS"
25909  " certificate"));
25910  log_event_fail ("alert", "Alert", NULL, "created");
25911  break;
25912  case 53:
25913  SEND_TO_CLIENT_OR_FAIL
25914  (XML_ERROR_SYNTAX ("create_alert",
25915  "TippingPoint TLS workaround must be"
25916  " set to 0 or 1"));
25917  log_event_fail ("alert", "Alert", NULL, "created");
25918  break;
25919  case 99:
25920  SEND_TO_CLIENT_OR_FAIL
25921  (XML_ERROR_SYNTAX ("modify_alert",
25922  "Permission denied"));
25923  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25924  "modified");
25925  break;
25926  default:
25927  case -1:
25928  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_alert"));
25929  log_event_fail ("alert", "Alert", modify_alert_data->alert_id,
25930  "modified");
25931  break;
25932  }
25933 
25934  modify_alert_data_reset (modify_alert_data);
25935  set_client_state (CLIENT_AUTHENTIC);
25936  break;
25937  }
25938  CLOSE (CLIENT_MODIFY_ALERT, COMMENT);
25940  CLOSE (CLIENT_MODIFY_ALERT, FILTER);
25941  CLOSE (CLIENT_MODIFY_ALERT, EVENT);
25942  CLOSE (CLIENT_MODIFY_ALERT, CONDITION);
25943  CLOSE (CLIENT_MODIFY_ALERT, METHOD);
25944 
25946  {
25947  gchar *string;
25948 
25949  assert (strcasecmp ("DATA", element_name) == 0);
25950  assert (modify_alert_data->event_data);
25951  assert (modify_alert_data->part_data);
25952  assert (modify_alert_data->part_name);
25953 
25954  string = g_strconcat (modify_alert_data->part_name,
25955  "0",
25957  NULL);
25958  string[strlen (modify_alert_data->part_name)] = '\0';
25959  array_add (modify_alert_data->event_data, string);
25960 
25961  openvas_free_string_var (&modify_alert_data->part_data);
25962  openvas_free_string_var (&modify_alert_data->part_name);
25963  openvas_append_string (&modify_alert_data->part_data, "");
25964  openvas_append_string (&modify_alert_data->part_name, "");
25965  set_client_state (CLIENT_MODIFY_ALERT_EVENT);
25966  break;
25967  }
25969 
25971  {
25972  gchar *string;
25973 
25974  assert (strcasecmp ("DATA", element_name) == 0);
25976  assert (modify_alert_data->part_data);
25977  assert (modify_alert_data->part_name);
25978 
25979  string = g_strconcat (modify_alert_data->part_name,
25980  "0",
25982  NULL);
25983  string[strlen (modify_alert_data->part_name)] = '\0';
25984  array_add (modify_alert_data->condition_data, string);
25985 
25986  openvas_free_string_var (&modify_alert_data->part_data);
25987  openvas_free_string_var (&modify_alert_data->part_name);
25988  openvas_append_string (&modify_alert_data->part_data, "");
25989  openvas_append_string (&modify_alert_data->part_name, "");
25990  set_client_state (CLIENT_MODIFY_ALERT_CONDITION);
25991  break;
25992  }
25994 
25996  {
25997  gchar *string;
25998 
25999  assert (strcasecmp ("DATA", element_name) == 0);
26000  assert (modify_alert_data->method_data);
26001  assert (modify_alert_data->part_data);
26002  assert (modify_alert_data->part_name);
26003 
26004  string = g_strconcat (modify_alert_data->part_name,
26005  "0",
26007  NULL);
26008  string[strlen (modify_alert_data->part_name)] = '\0';
26009  array_add (modify_alert_data->method_data, string);
26010 
26011  openvas_free_string_var (&modify_alert_data->part_data);
26012  openvas_free_string_var (&modify_alert_data->part_name);
26013  openvas_append_string (&modify_alert_data->part_data, "");
26014  openvas_append_string (&modify_alert_data->part_name, "");
26015  set_client_state (CLIENT_MODIFY_ALERT_METHOD);
26016  break;
26017  }
26019 
26020  case CLIENT_MODIFY_ASSET:
26021  {
26022  assert (strcasecmp ("MODIFY_ASSET", element_name) == 0);
26023 
26024  switch (modify_asset
26027  {
26028  case 0:
26029  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_asset"));
26030  log_event ("asset", "Asset", modify_asset_data->asset_id,
26031  "modified");
26032  break;
26033  case 1:
26034  if (send_find_error_to_client ("modify_asset", "asset",
26036  omp_parser))
26037  {
26038  error_send_to_client (error);
26039  return;
26040  }
26041  log_event_fail ("asset", "Asset", modify_asset_data->asset_id,
26042  "modified");
26043  break;
26044  case 2:
26045  SEND_TO_CLIENT_OR_FAIL
26046  (XML_ERROR_SYNTAX ("modify_asset",
26047  "asset with new name exists already"));
26048  log_event_fail ("asset", "Asset", modify_asset_data->asset_id,
26049  "modified");
26050  break;
26051  case 3:
26052  SEND_TO_CLIENT_OR_FAIL
26053  (XML_ERROR_SYNTAX ("modify_asset",
26054  "MODIFY_asset requires a asset_id"));
26055  log_event_fail ("asset", "Asset", modify_asset_data->asset_id,
26056  "modified");
26057  break;
26058  case 99:
26059  SEND_TO_CLIENT_OR_FAIL
26060  (XML_ERROR_SYNTAX ("modify_asset",
26061  "Permission denied"));
26062  log_event_fail ("asset", "Asset", modify_asset_data->asset_id,
26063  "modified");
26064  break;
26065  default:
26066  case -1:
26067  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_asset"));
26068  log_event_fail ("asset", "Asset", modify_asset_data->asset_id,
26069  "modified");
26070  break;
26071  }
26072 
26073  modify_asset_data_reset (modify_asset_data);
26074  set_client_state (CLIENT_AUTHENTIC);
26075  break;
26076  }
26077  CLOSE (CLIENT_MODIFY_ASSET, COMMENT);
26078 
26079  case CLIENT_MODIFY_AUTH:
26080  {
26081  GSList *item;
26082 
26083  assert (strcasecmp ("MODIFY_AUTH", element_name) == 0);
26084 
26085  if (acl_user_may ("modify_auth") == 0)
26086  {
26087  SEND_TO_CLIENT_OR_FAIL
26088  (XML_ERROR_SYNTAX ("modify_auth",
26089  "Permission denied"));
26091  set_client_state (CLIENT_AUTHENTIC);
26092  break;
26093  }
26094 
26095  item = modify_auth_data->groups;
26096  while (item)
26097  {
26098  auth_group_t *auth_group;
26099  gchar *group;
26100 
26101  auth_group = (auth_group_t *) item->data;
26102  group = auth_group->group_name;
26103  if (group == NULL)
26104  {
26105  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
26106  ("modify_auth",
26107  "GROUP requires a name attribute"));
26108  set_client_state (CLIENT_AUTHENTIC);
26110  break;
26111  }
26112  if (strcmp (group, "method:ldap_connect") == 0)
26113  {
26114  GSList *setting;
26115  gchar *ldap_host, *ldap_authdn, *ldap_cacert;
26116  int ldap_enabled, ldap_plaintext;
26117 
26118  ldap_enabled = ldap_plaintext = -1;
26119  ldap_host = ldap_authdn = ldap_cacert = NULL;
26120  setting = auth_group->settings;
26121  while (setting)
26122  {
26123  auth_conf_setting_t *kvp =
26124  (auth_conf_setting_t *) setting->data;
26125 
26126  if (kvp->key == NULL || kvp->value == NULL)
26127  /* Skip this one. */;
26128  else if (strcmp (kvp->key, "enable") == 0)
26129  ldap_enabled = (strcmp (kvp->value, "true") == 0);
26130  else if (strcmp (kvp->key, "ldaphost") == 0)
26131  ldap_host = g_strdup (kvp->value);
26132  else if (strcmp (kvp->key, "authdn") == 0)
26133  ldap_authdn = g_strdup (kvp->value);
26134  else if (strcmp (kvp->key, "allow-plaintext") == 0)
26135  ldap_plaintext = (strcmp (kvp->value, "true") == 0);
26136  else if (strcmp (kvp->key, "cacert") == 0)
26137  ldap_cacert = g_strdup (kvp->value);
26138 
26139  setting = g_slist_next (setting);
26140  }
26141 
26142  manage_set_ldap_info (ldap_enabled, ldap_host, ldap_authdn,
26143  ldap_plaintext, ldap_cacert);
26144  }
26145  if (strcmp (group, "method:radius_connect") == 0)
26146  {
26147  GSList *setting;
26148  char *radius_host, *radius_key;
26149  int radius_enabled;
26150 
26151  radius_enabled = -1;
26152  radius_host = radius_key = NULL;
26153  setting = auth_group->settings;
26154  while (setting)
26155  {
26156  auth_conf_setting_t *kvp =
26157  (auth_conf_setting_t *) setting->data;
26158 
26159  if (kvp->key == NULL || kvp->value == NULL)
26160  /* Skip this one. */;
26161  else if (strcmp (kvp->key, "enable") == 0)
26162  radius_enabled = (strcmp (kvp->value, "true") == 0);
26163  else if (strcmp (kvp->key, "radiushost") == 0)
26164  radius_host = g_strdup (kvp->value);
26165  else if (strcmp (kvp->key, "radiuskey") == 0)
26166  radius_key = g_strdup (kvp->value);
26167 
26168  setting = g_slist_next (setting);
26169  }
26170 
26171  manage_set_radius_info (radius_enabled, radius_host,
26172  radius_key);
26173  }
26174  item = g_slist_next (item);
26175  }
26176 
26177  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_auth"));
26179  set_client_state (CLIENT_AUTHENTIC);
26180 
26181  break;
26182  }
26183 
26185  {
26186  assert (strcasecmp ("GROUP", element_name) == 0);
26187 
26188  /* Add settings to group. */
26190  {
26191  auth_group_t *new_group;
26192  assert (modify_auth_data->groups);
26193  new_group = modify_auth_data->groups->data;
26194  assert (new_group);
26196  }
26197 
26199  set_client_state (CLIENT_MODIFY_AUTH);
26200  break;
26201  }
26203  {
26204  auth_conf_setting_t *setting;
26205 
26206  assert (strcasecmp ("AUTH_CONF_SETTING", element_name) == 0);
26207 
26208  setting = g_malloc0 (sizeof (auth_conf_setting_t));
26209  setting->key = modify_auth_data->key;
26210  modify_auth_data->key = NULL;
26211  setting->value = modify_auth_data->value;
26212  modify_auth_data->value = NULL;
26213 
26214  /* Add setting to settings. */
26216  = g_slist_prepend (modify_auth_data->curr_group_settings, setting);
26217 
26218  set_client_state (CLIENT_MODIFY_AUTH_GROUP);
26219  break;
26220  }
26223 
26224  case CLIENT_MODIFY_CONFIG:
26225  assert (strcasecmp ("MODIFY_CONFIG", element_name) == 0);
26226  return handle_modify_config (omp_parser, error);
26227  CLOSE (CLIENT_MODIFY_CONFIG, COMMENT);
26228  CLOSE (CLIENT_MODIFY_CONFIG, SCANNER);
26229 
26231  assert (strcasecmp ("FAMILY_SELECTION", element_name) == 0);
26235  array_terminate (modify_config_data->families_growing_all);
26236  array_terminate (modify_config_data->families_static_all);
26237  array_terminate (modify_config_data->families_growing_empty);
26238  set_client_state (CLIENT_MODIFY_CONFIG);
26239  break;
26242  assert (strcasecmp ("NVT_SELECTION", element_name) == 0);
26244  array_terminate (modify_config_data->nvt_selection);
26245  set_client_state (CLIENT_MODIFY_CONFIG);
26246  break;
26247  CLOSE (CLIENT_MODIFY_CONFIG, PREFERENCE);
26248 
26250  assert (strcasecmp ("FAMILY", element_name) == 0);
26252  {
26254  {
26256  /* Growing 1 and select all 1. */
26259  else
26260  /* Growing 1 and select all 0. */
26263  }
26264  else
26265  {
26267  /* Growing 0 and select all 1. */
26270  /* Else growing 0 and select all 0. */
26271  }
26272  }
26274  set_client_state (CLIENT_MODIFY_CONFIG_FAMILY_SELECTION);
26275  break;
26277  assert (strcasecmp ("GROWING", element_name) == 0);
26279  {
26282  openvas_free_string_var
26284  }
26285  else
26287  set_client_state (CLIENT_MODIFY_CONFIG_FAMILY_SELECTION);
26288  break;
26289 
26291  assert (strcasecmp ("ALL", element_name) == 0);
26293  {
26296  openvas_free_string_var
26298  }
26299  else
26302  break;
26305  assert (strcasecmp ("GROWING", element_name) == 0);
26307  {
26310  openvas_free_string_var
26312  }
26313  else
26316  break;
26317 
26320  assert (strcasecmp ("NVT", element_name) == 0);
26322  array_add (modify_config_data->nvt_selection,
26325  set_client_state (CLIENT_MODIFY_CONFIG_NVT_SELECTION);
26326  break;
26327 
26331  assert (strcasecmp ("VALUE", element_name) == 0);
26332  /* Init, so it's the empty string when the value is empty. */
26333  openvas_append_string (&modify_config_data->preference_value, "");
26334  set_client_state (CLIENT_MODIFY_CONFIG_PREFERENCE);
26335  break;
26336 
26338  {
26339  assert (strcasecmp ("MODIFY_CREDENTIAL", element_name) == 0);
26340 
26341  switch (modify_credential
26357  {
26358  case 0:
26359  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_credential"));
26360  log_event ("credential", "Credential",
26362  "modified");
26363  break;
26364  case 1:
26365  if (send_find_error_to_client
26366  ("modify_credential", "credential",
26368  omp_parser))
26369  {
26370  error_send_to_client (error);
26371  return;
26372  }
26373  log_event_fail ("credential", "Credential",
26375  "modified");
26376  break;
26377  case 2:
26378  SEND_TO_CLIENT_OR_FAIL
26379  (XML_ERROR_SYNTAX ("modify_credential",
26380  "credential with new name"
26381  " exists already"));
26382  log_event_fail ("credential", "Credential",
26384  "modified");
26385  break;
26386  case 3:
26387  SEND_TO_CLIENT_OR_FAIL
26388  (XML_ERROR_SYNTAX ("modify_credential",
26389  "MODIFY_credential requires a"
26390  " credential_id"));
26391  log_event_fail ("credential", "Credential",
26393  "modified");
26394  break;
26395  case 4:
26396  SEND_TO_CLIENT_OR_FAIL
26397  (XML_ERROR_SYNTAX ("modify_credential",
26398  "Login name must not be empty and contain"
26399  " only alphanumeric characters"));
26400  log_event_fail ("credential", "Credential",
26402  "modified");
26403  break;
26404  case 5:
26405  SEND_TO_CLIENT_OR_FAIL
26406  (XML_ERROR_SYNTAX ("modify_credential",
26407  "Invalid or empty certificate"));
26408  log_event_fail ("credential", "Credential",
26410  "modified");
26411  break;
26412  case 6:
26413  SEND_TO_CLIENT_OR_FAIL
26414  (XML_ERROR_SYNTAX ("modify_credential",
26415  "Invalid or empty auth_algorithm"));
26416  log_event_fail ("credential", "Credential",
26418  "modified");
26419  break;
26420  case 7:
26421  SEND_TO_CLIENT_OR_FAIL
26422  (XML_ERROR_SYNTAX ("modify_credential",
26423  "Invalid or empty privacy_algorithm"));
26424  log_event_fail ("credential", "Credential",
26426  "modified");
26427  break;
26428  case 8:
26429  SEND_TO_CLIENT_OR_FAIL
26430  (XML_ERROR_SYNTAX ("modify_credential",
26431  "Invalid or empty private key"));
26432  log_event_fail ("credential", "Credential",
26434  "modified");
26435  break;
26436  case 99:
26437  SEND_TO_CLIENT_OR_FAIL
26438  (XML_ERROR_SYNTAX ("modify_credential",
26439  "Permission denied"));
26440  log_event_fail ("credential", "Credential",
26442  "modified");
26443  break;
26444  default:
26445  case -1:
26446  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_credential"));
26447  log_event_fail ("credential", "Credential",
26449  "modified");
26450  break;
26451  }
26452 
26453  modify_credential_data_reset (modify_credential_data);
26454  set_client_state (CLIENT_AUTHENTIC);
26455  break;
26456  }
26457  modify_credential_data_reset (modify_credential_data);
26458  set_client_state (CLIENT_AUTHENTIC);
26459  break;
26460  CLOSE (CLIENT_MODIFY_CREDENTIAL, ALLOW_INSECURE);
26461  CLOSE (CLIENT_MODIFY_CREDENTIAL, AUTH_ALGORITHM);
26462  CLOSE (CLIENT_MODIFY_CREDENTIAL, CERTIFICATE);
26463  CLOSE (CLIENT_MODIFY_CREDENTIAL, COMMENT);
26464  CLOSE (CLIENT_MODIFY_CREDENTIAL, COMMUNITY);
26470  CLOSE (CLIENT_MODIFY_CREDENTIAL, PASSWORD);
26471  CLOSE (CLIENT_MODIFY_CREDENTIAL, PRIVACY);
26474 
26475  case CLIENT_MODIFY_FILTER:
26476  {
26477  assert (strcasecmp ("MODIFY_FILTER", element_name) == 0);
26478 
26479  switch (modify_filter
26485  {
26486  case 0:
26487  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_filter"));
26488  log_event ("filter", "Filter", modify_filter_data->filter_id,
26489  "modified");
26490  break;
26491  case 1:
26492  if (send_find_error_to_client ("modify_filter", "filter",
26494  omp_parser))
26495  {
26496  error_send_to_client (error);
26497  return;
26498  }
26499  log_event_fail ("filter", "Filter",
26500  modify_filter_data->filter_id, "modified");
26501  break;
26502  case 2:
26503  SEND_TO_CLIENT_OR_FAIL
26504  (XML_ERROR_SYNTAX ("modify_filter",
26505  "Filter with new name exists already"));
26506  log_event_fail ("filter", "Filter",
26507  modify_filter_data->filter_id, "modified");
26508  break;
26509  case 3:
26510  SEND_TO_CLIENT_OR_FAIL
26511  (XML_ERROR_SYNTAX ("modify_filter",
26512  "Error in type name"));
26513  log_event_fail ("filter", "Filter",
26514  modify_filter_data->filter_id, "modified");
26515  break;
26516  case 4:
26517  SEND_TO_CLIENT_OR_FAIL
26518  (XML_ERROR_SYNTAX ("modify_filter",
26519  "MODIFY_FILTER requires a filter_id"));
26520  log_event_fail ("filter", "Filter",
26521  modify_filter_data->filter_id, "modified");
26522  break;
26523  case 5:
26524  SEND_TO_CLIENT_OR_FAIL
26525  (XML_ERROR_SYNTAX ("modify_filter",
26526  "Filter is used by an alert so type must be"
26527  " 'result' if specified"));
26528  log_event_fail ("filter", "Filter",
26529  modify_filter_data->filter_id, "modified");
26530  break;
26531  case 99:
26532  SEND_TO_CLIENT_OR_FAIL
26533  (XML_ERROR_SYNTAX ("modify_filter",
26534  "Permission denied"));
26535  log_event_fail ("filter", "Filter",
26536  modify_filter_data->filter_id, "modified");
26537  break;
26538  default:
26539  case -1:
26540  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_filter"));
26541  log_event_fail ("filter", "Filter",
26542  modify_filter_data->filter_id, "modified");
26543  break;
26544  }
26545 
26546  modify_filter_data_reset (modify_filter_data);
26547  set_client_state (CLIENT_AUTHENTIC);
26548  break;
26549  }
26550  CLOSE (CLIENT_MODIFY_FILTER, COMMENT);
26552  CLOSE (CLIENT_MODIFY_FILTER, TYPE);
26553  CLOSE (CLIENT_MODIFY_FILTER, TERM);
26554 
26555  case CLIENT_MODIFY_GROUP:
26556  {
26557  assert (strcasecmp ("MODIFY_GROUP", element_name) == 0);
26558 
26559  switch (modify_group
26564  {
26565  case 0:
26566  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_group"));
26567  log_event ("group", "Group", modify_group_data->group_id,
26568  "modified");
26569  break;
26570  case 1:
26571  if (send_find_error_to_client ("modify_group", "group",
26573  omp_parser))
26574  {
26575  error_send_to_client (error);
26576  return;
26577  }
26578  log_event_fail ("group", "Group",
26579  modify_group_data->group_id, "modified");
26580  break;
26581  case 2:
26582  SEND_TO_CLIENT_OR_FAIL
26583  (XML_ERROR_SYNTAX ("modify_group",
26584  "Failed to find user"));
26585  log_event_fail ("group", "Group",
26586  modify_group_data->group_id, "modified");
26587  break;
26588  case 3:
26589  SEND_TO_CLIENT_OR_FAIL
26590  (XML_ERROR_SYNTAX ("modify_group",
26591  "MODIFY_GROUP requires a group_id"
26592  " attribute"));
26593  log_event_fail ("group", "Group",
26594  modify_group_data->group_id, "modified");
26595  break;
26596  case 4:
26597  SEND_TO_CLIENT_OR_FAIL
26598  (XML_ERROR_SYNTAX ("modify_group",
26599  "Error in user name"));
26600  log_event_fail ("group", "Group",
26601  modify_group_data->group_id, "modified");
26602  break;
26603  case 5:
26604  SEND_TO_CLIENT_OR_FAIL
26605  (XML_ERROR_SYNTAX ("modify_group",
26606  "Group with new name exists already"));
26607  log_event_fail ("group", "Group",
26608  modify_group_data->group_id, "modified");
26609  break;
26610  case 99:
26611  SEND_TO_CLIENT_OR_FAIL
26612  (XML_ERROR_SYNTAX ("modify_group",
26613  "Permission denied"));
26614  log_event_fail ("group", "Group",
26615  modify_group_data->group_id, "modified");
26616  break;
26617  default:
26618  case -1:
26619  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_group"));
26620  log_event_fail ("group", "Group",
26621  modify_group_data->group_id, "modified");
26622  break;
26623  }
26624 
26625  modify_group_data_reset (modify_group_data);
26626  set_client_state (CLIENT_AUTHENTIC);
26627  break;
26628  }
26629  CLOSE (CLIENT_MODIFY_GROUP, COMMENT);
26631  CLOSE (CLIENT_MODIFY_GROUP, USERS);
26632 
26633  case CLIENT_MODIFY_NOTE:
26634  {
26635  task_t task = 0;
26636  result_t result = 0;
26637  note_t note = 0;
26638 
26639  assert (strcasecmp ("MODIFY_NOTE", element_name) == 0);
26640 
26641  if (acl_user_may ("modify_note") == 0)
26642  {
26643  SEND_TO_CLIENT_OR_FAIL
26644  (XML_ERROR_SYNTAX ("modify_note",
26645  "Permission denied"));
26646  modify_note_data_reset (modify_note_data);
26647  set_client_state (CLIENT_AUTHENTIC);
26648  break;
26649  }
26650 
26651  if (modify_note_data->note_id == NULL)
26652  SEND_TO_CLIENT_OR_FAIL
26653  (XML_ERROR_SYNTAX ("modify_note",
26654  "MODIFY_NOTE requires a note_id attribute"));
26655  else if (modify_note_data->text == NULL)
26656  SEND_TO_CLIENT_OR_FAIL
26657  (XML_ERROR_SYNTAX ("modify_note",
26658  "MODIFY_NOTE requires a TEXT entity"));
26659  // FIX move find_* down into manage_sql.c modify_note
26661  "modify_note"))
26662  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_note"));
26663  else if (note == 0)
26664  {
26665  if (send_find_error_to_client ("modify_note", "note",
26667  omp_parser))
26668  {
26669  error_send_to_client (error);
26670  return;
26671  }
26672  }
26673  else if (modify_note_data->task_id
26675  &task,
26676  NULL))
26677  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_note"));
26678  else if (modify_note_data->task_id
26679  && task == 0
26681  ->task_id,
26682  &task,
26683  NULL))
26684  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_note"));
26685  else if (modify_note_data->task_id && task == 0)
26686  {
26687  if (send_find_error_to_client ("modify_note", "task",
26689  omp_parser))
26690  {
26691  error_send_to_client (error);
26692  return;
26693  }
26694  }
26695  else if (modify_note_data->result_id
26697  &result,
26698  NULL))
26699  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_note"));
26700  else if (modify_note_data->result_id && result == 0)
26701  {
26702  if (send_find_error_to_client ("modify_note", "result",
26704  omp_parser))
26705  {
26706  error_send_to_client (error);
26707  return;
26708  }
26709  }
26710  else switch (modify_note (note,
26717  task,
26718  result))
26719  {
26720  case 0:
26721  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_note"));
26722  break;
26723  case -1:
26724  SEND_TO_CLIENT_OR_FAIL
26725  (XML_INTERNAL_ERROR ("modify_note"));
26726  break;
26727  case 2:
26728  SEND_TO_CLIENT_OR_FAIL
26729  (XML_ERROR_SYNTAX ("modify_note",
26730  "Error in port specification"));
26731  log_event_fail ("note", "Note", modify_note_data->note_id,
26732  "modified");
26733  break;
26734  case 3:
26735  SEND_TO_CLIENT_OR_FAIL
26736  (XML_ERROR_SYNTAX ("modify_note",
26737  "Error in severity specification"));
26738  log_event_fail ("note", "Note", modify_note_data->note_id,
26739  "modified");
26740  break;
26741  default:
26742  assert (0);
26743  SEND_TO_CLIENT_OR_FAIL
26744  (XML_INTERNAL_ERROR ("modify_note"));
26745  break;
26746  }
26747  modify_note_data_reset (modify_note_data);
26748  set_client_state (CLIENT_AUTHENTIC);
26749  break;
26750  }
26751  CLOSE (CLIENT_MODIFY_NOTE, ACTIVE);
26752  CLOSE (CLIENT_MODIFY_NOTE, HOSTS);
26753  CLOSE (CLIENT_MODIFY_NOTE, PORT);
26754  CLOSE (CLIENT_MODIFY_NOTE, RESULT);
26755  CLOSE (CLIENT_MODIFY_NOTE, SEVERITY);
26756  CLOSE (CLIENT_MODIFY_NOTE, TASK);
26757  CLOSE (CLIENT_MODIFY_NOTE, TEXT);
26758  CLOSE (CLIENT_MODIFY_NOTE, THREAT);
26759 
26761  {
26762  task_t task = 0;
26763  result_t result = 0;
26764  override_t override = 0;
26765 
26766  assert (strcasecmp ("MODIFY_OVERRIDE", element_name) == 0);
26767 
26768  if (acl_user_may ("modify_override") == 0)
26769  {
26770  SEND_TO_CLIENT_OR_FAIL
26771  (XML_ERROR_SYNTAX ("modify_override",
26772  "Permission denied"));
26773  modify_override_data_reset (modify_override_data);
26774  set_client_state (CLIENT_AUTHENTIC);
26775  break;
26776  }
26777 
26778  if (modify_override_data->override_id == NULL)
26779  SEND_TO_CLIENT_OR_FAIL
26780  (XML_ERROR_SYNTAX ("modify_override",
26781  "MODIFY_OVERRIDE requires a override_id attribute"));
26782  else if (modify_override_data->text == NULL)
26783  SEND_TO_CLIENT_OR_FAIL
26784  (XML_ERROR_SYNTAX ("modify_override",
26785  "MODIFY_OVERRIDE requires a TEXT entity"));
26787  (modify_override_data->override_id, &override,
26788  "modify_override"))
26789  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_override"));
26790  else if (override == 0)
26791  {
26792  if (send_find_error_to_client ("modify_override", "override",
26794  omp_parser))
26795  {
26796  error_send_to_client (error);
26797  return;
26798  }
26799  }
26800  else if (modify_override_data->task_id
26802  &task,
26803  NULL))
26804  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_override"));
26805  else if (modify_override_data->task_id
26806  && task == 0
26808  ->task_id,
26809  &task,
26810  NULL))
26811  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_override"));
26812  else if (modify_override_data->task_id && task == 0)
26813  {
26814  if (send_find_error_to_client ("modify_override", "task",
26816  omp_parser))
26817  {
26818  error_send_to_client (error);
26819  return;
26820  }
26821  }
26824  &result,
26825  NULL))
26826  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_override"));
26827  else if (modify_override_data->result_id && result == 0)
26828  {
26829  if (send_find_error_to_client ("modify_override", "result",
26831  omp_parser))
26832  {
26833  error_send_to_client (error);
26834  return;
26835  }
26836  }
26837  else switch (modify_override (override,
26846  task,
26847  result))
26848  {
26849  case 0:
26850  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_override"));
26851  break;
26852  case 1:
26853  SEND_TO_CLIENT_OR_FAIL
26854  (XML_ERROR_SYNTAX ("modify_override",
26855  "ACTIVE must be an integer >= -2"));
26856  break;
26857  case 2:
26858  SEND_TO_CLIENT_OR_FAIL
26859  (XML_ERROR_SYNTAX ("modify_override",
26860  "Error in port specification"));
26861  log_event_fail ("override", "Override",
26863  "modified");
26864  break;
26865  case 3:
26866  SEND_TO_CLIENT_OR_FAIL
26867  (XML_ERROR_SYNTAX ("modify_override",
26868  "Error in severity specification"));
26869  log_event_fail ("override", "Override",
26871  "modified");
26872  break;
26873  case -1:
26874  SEND_TO_CLIENT_OR_FAIL
26875  (XML_INTERNAL_ERROR ("modify_override"));
26876  break;
26877  default:
26878  assert (0);
26879  SEND_TO_CLIENT_OR_FAIL
26880  (XML_INTERNAL_ERROR ("modify_override"));
26881  break;
26882  }
26883  modify_override_data_reset (modify_override_data);
26884  set_client_state (CLIENT_AUTHENTIC);
26885  break;
26886  }
26887  CLOSE (CLIENT_MODIFY_OVERRIDE, ACTIVE);
26888  CLOSE (CLIENT_MODIFY_OVERRIDE, HOSTS);
26889  CLOSE (CLIENT_MODIFY_OVERRIDE, NEW_SEVERITY);
26890  CLOSE (CLIENT_MODIFY_OVERRIDE, NEW_THREAT);
26891  CLOSE (CLIENT_MODIFY_OVERRIDE, PORT);
26892  CLOSE (CLIENT_MODIFY_OVERRIDE, RESULT);
26893  CLOSE (CLIENT_MODIFY_OVERRIDE, SEVERITY);
26894  CLOSE (CLIENT_MODIFY_OVERRIDE, TASK);
26895  CLOSE (CLIENT_MODIFY_OVERRIDE, TEXT);
26896  CLOSE (CLIENT_MODIFY_OVERRIDE, THREAT);
26897 
26899  {
26900  assert (strcasecmp ("MODIFY_PERMISSION", element_name) == 0);
26901 
26903  SEND_TO_CLIENT_OR_FAIL
26904  (XML_ERROR_SYNTAX ("modify_permission",
26905  "MODIFY_PERMISSION requires a permission_id attribute"));
26906  else switch (modify_permission
26914  {
26915  case 1:
26916  SEND_TO_CLIENT_OR_FAIL
26917  (XML_ERROR_SYNTAX ("modify_permission",
26918  "Permission exists already"));
26919  log_event_fail ("permission", "Permission",
26921  "modified");
26922  break;
26923  case 2:
26924  if (send_find_error_to_client
26925  ("modify_permission", "subject",
26926  modify_permission_data->subject_id, omp_parser))
26927  {
26928  error_send_to_client (error);
26929  return;
26930  }
26931  log_event_fail ("permission", "Permission",
26933  "modified");
26934  break;
26935  case 3:
26936  if (send_find_error_to_client
26937  ("modify_permission", "resource",
26938  modify_permission_data->resource_id, omp_parser))
26939  {
26940  error_send_to_client (error);
26941  return;
26942  }
26943  log_event_fail ("permission", "Permission",
26945  "modified");
26946  break;
26947  case 4:
26948  SEND_TO_CLIENT_OR_FAIL
26949  (XML_ERROR_SYNTAX ("modify_permission",
26950  "MODIFY_PERMISSION requires a PERMISSION"
26951  " ID"));
26952  log_event_fail ("permission", "Permission",
26954  "modified");
26955  break;
26956  case 5:
26957  SEND_TO_CLIENT_OR_FAIL
26958  (XML_ERROR_SYNTAX ("modify_permission",
26959  "Error in RESOURCE"));
26960  log_event_fail ("permission", "Permission",
26962  "modified");
26963  break;
26964  case 6:
26965  SEND_TO_CLIENT_OR_FAIL
26966  (XML_ERROR_SYNTAX ("modify_permission",
26967  "Error in SUBJECT"));
26968  log_event_fail ("permission", "Permission",
26970  "modified");
26971  break;
26972  case 7:
26973  SEND_TO_CLIENT_OR_FAIL
26974  (XML_ERROR_SYNTAX ("modify_permission",
26975  "Error in NAME"));
26976  log_event_fail ("permission", "Permission",
26978  "modified");
26979  break;
26980  case 8:
26981  SEND_TO_CLIENT_OR_FAIL
26982  (XML_ERROR_SYNTAX ("modify_permission",
26983  "NAME required to find resource"));
26984  log_event_fail ("permission", "Permission",
26986  "modified");
26987  break;
26988  case 9:
26989  SEND_TO_CLIENT_OR_FAIL
26990  (XML_ERROR_SYNTAX ("modify_permission",
26991  "Permission does not accept a resource"));
26992  log_event_fail ("permission", "Permission", NULL, "modified");
26993  break;
26994  case 99:
26995  SEND_TO_CLIENT_OR_FAIL
26996  (XML_ERROR_SYNTAX ("modify_permission",
26997  "Permission denied"));
26998  log_event_fail ("permission", "Permission",
27000  "modified");
27001  break;
27002  case -1:
27003  SEND_TO_CLIENT_OR_FAIL
27004  (XML_INTERNAL_ERROR ("modify_permission"));
27005  log_event_fail ("permission", "Permission",
27007  "modified");
27008  break;
27009  default:
27010  {
27011  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_permission"));
27012  log_event ("permission", "Permission",
27013  modify_permission_data->permission_id, "modified");
27014  break;
27015  }
27016  }
27017 
27018  modify_permission_data_reset (modify_permission_data);
27019  set_client_state (CLIENT_AUTHENTIC);
27020  break;
27021  }
27022  CLOSE (CLIENT_MODIFY_PERMISSION, COMMENT);
27023  CLOSE (CLIENT_MODIFY_PERMISSION, SUBJECT);
27026  CLOSE (CLIENT_MODIFY_PERMISSION, RESOURCE);
27028 
27030  {
27031  assert (strcasecmp ("MODIFY_PORT_LIST", element_name) == 0);
27032 
27033  switch (modify_port_list
27037  {
27038  case 0:
27039  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_port_list"));
27040  log_event ("port_list", "Port List",
27041  modify_port_list_data->port_list_id, "modified");
27042  break;
27043  case 1:
27044  if (send_find_error_to_client ("modify_port_list", "port_list",
27046  omp_parser))
27047  {
27048  error_send_to_client (error);
27049  return;
27050  }
27051  log_event_fail ("port_list", "Port List",
27053  "modified");
27054  break;
27055  case 2:
27056  SEND_TO_CLIENT_OR_FAIL
27057  (XML_ERROR_SYNTAX ("modify_port_list",
27058  "Port List with new name exists already"));
27059  log_event_fail ("port_list", "Port List",
27061  "modified");
27062  break;
27063  case 3:
27064  SEND_TO_CLIENT_OR_FAIL
27065  (XML_ERROR_SYNTAX ("modify_port_list",
27066  "modify_port_list requires a port_list_id"));
27067  log_event_fail ("port_list", "Port List",
27069  "modified");
27070  break;
27071  case 99:
27072  SEND_TO_CLIENT_OR_FAIL
27073  (XML_ERROR_SYNTAX ("modify_port_list",
27074  "Permission denied"));
27075  log_event_fail ("port_list", "Port List",
27077  "modified");
27078  break;
27079  default:
27080  case -1:
27081  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_port_list"));
27082  log_event_fail ("port_list", "Port List",
27084  "modified");
27085  break;
27086  }
27087 
27088  modify_port_list_data_reset (modify_port_list_data);
27089  set_client_state (CLIENT_AUTHENTIC);
27090  break;
27091  }
27092  CLOSE (CLIENT_MODIFY_PORT_LIST, COMMENT);
27094 
27095  case CLIENT_MODIFY_REPORT:
27096  {
27097  assert (strcasecmp ("MODIFY_REPORT", element_name) == 0);
27098 
27099  switch (modify_report
27102  {
27103  case 0:
27104  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_report"));
27105  log_event ("report", "Report", modify_report_data->report_id,
27106  "modified");
27107  break;
27108  case 1:
27109  if (send_find_error_to_client ("modify_report", "report",
27111  omp_parser))
27112  {
27113  error_send_to_client (error);
27114  return;
27115  }
27116  log_event_fail ("report", "Report",
27118  "modified");
27119  break;
27120  case 2:
27121  SEND_TO_CLIENT_OR_FAIL
27122  (XML_ERROR_SYNTAX ("modify_report",
27123  "MODIFY_report requires a report_id"));
27124  log_event_fail ("report", "Report",
27126  "modified");
27127  break;
27128  case 3:
27129  SEND_TO_CLIENT_OR_FAIL
27131  ("modify_report",
27132  "MODIFY_REPORT requires a COMMENT element"));
27133  break;
27134  case 99:
27135  SEND_TO_CLIENT_OR_FAIL
27136  (XML_ERROR_SYNTAX ("modify_report",
27137  "Permission denied"));
27138  log_event_fail ("report", "Report",
27140  "modified");
27141  break;
27142  default:
27143  case -1:
27144  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_report"));
27145  log_event_fail ("report", "Report",
27147  "modified");
27148  break;
27149  }
27150 
27151  modify_report_data_reset (modify_report_data);
27152  set_client_state (CLIENT_AUTHENTIC);
27153  break;
27154  }
27155  CLOSE (CLIENT_MODIFY_REPORT, COMMENT);
27156 
27158  {
27159  assert (strcasecmp ("MODIFY_REPORT_FORMAT", element_name) == 0);
27160 
27161  switch (modify_report_format
27168  NULL))
27169  {
27170  case 0:
27171  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_report_format"));
27172  log_event ("report_format", "Report Format",
27174  "modified");
27175  break;
27176  case 1:
27177  if (send_find_error_to_client
27178  ("modify_report_format", "report_format",
27180  omp_parser))
27181  {
27182  error_send_to_client (error);
27183  return;
27184  }
27185  log_event_fail ("report_format", "Report Format",
27187  "modified");
27188  break;
27189  case 2:
27190  SEND_TO_CLIENT_OR_FAIL
27192  ("modify_report_format",
27193  "MODIFY_report_format requires a report_format_id"));
27194  log_event_fail ("report_format", "Report Format",
27196  "modified");
27197  break;
27198  case 3:
27199  if (send_find_error_to_client
27200  ("modify_report_format", "report format param",
27201  modify_report_format_data->param_name, omp_parser))
27202  {
27203  error_send_to_client (error);
27204  return;
27205  }
27206  log_event_fail ("report_format", "Report Format",
27208  "modified");
27209  break;
27210  case 4:
27211  SEND_TO_CLIENT_OR_FAIL
27212  (XML_ERROR_SYNTAX ("modify_report_format",
27213  "Parameter validation failed"));
27214  log_event_fail ("report_format", "Report Format",
27216  "modified");
27217  break;
27218  case 99:
27219  SEND_TO_CLIENT_OR_FAIL
27220  (XML_ERROR_SYNTAX ("modify_report_format",
27221  "Permission denied"));
27222  log_event_fail ("report_format", "Report Format",
27224  "modified");
27225  break;
27226  default:
27227  case -1:
27228  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR
27229  ("modify_report_format"));
27230  log_event_fail ("report_format", "Report Format",
27232  "modified");
27233  break;
27234  }
27235 
27236  modify_report_format_data_reset (modify_report_format_data);
27237  set_client_state (CLIENT_AUTHENTIC);
27238  break;
27239  }
27246 
27247  case CLIENT_MODIFY_ROLE:
27248  {
27249  assert (strcasecmp ("MODIFY_ROLE", element_name) == 0);
27250 
27251  switch (modify_role
27256  {
27257  case 0:
27258  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_role"));
27259  log_event ("role", "Role", modify_role_data->role_id,
27260  "modified");
27261  break;
27262  case 1:
27263  if (send_find_error_to_client ("modify_role", "role",
27265  omp_parser))
27266  {
27267  error_send_to_client (error);
27268  return;
27269  }
27270  log_event_fail ("role", "Role",
27271  modify_role_data->role_id, "modified");
27272  break;
27273  case 2:
27274  SEND_TO_CLIENT_OR_FAIL
27275  (XML_ERROR_SYNTAX ("modify_role",
27276  "Failed to find user"));
27277  log_event_fail ("role", "Role",
27278  modify_role_data->role_id, "modified");
27279  break;
27280  case 3:
27281  SEND_TO_CLIENT_OR_FAIL
27282  (XML_ERROR_SYNTAX ("modify_role",
27283  "MODIFY_ROLE requires a role_id"
27284  " attribute"));
27285  log_event_fail ("role", "Role",
27286  modify_role_data->role_id, "modified");
27287  break;
27288  case 4:
27289  SEND_TO_CLIENT_OR_FAIL
27290  (XML_ERROR_SYNTAX ("modify_role",
27291  "Error in user name"));
27292  log_event_fail ("role", "Role",
27293  modify_role_data->role_id, "modified");
27294  break;
27295  case 5:
27296  SEND_TO_CLIENT_OR_FAIL
27297  (XML_ERROR_SYNTAX ("modify_role",
27298  "Role with new name exists already"));
27299  log_event_fail ("role", "Role",
27300  modify_role_data->role_id, "modified");
27301  break;
27302  case 99:
27303  SEND_TO_CLIENT_OR_FAIL
27304  (XML_ERROR_SYNTAX ("modify_role",
27305  "Permission denied"));
27306  log_event_fail ("role", "Role",
27307  modify_role_data->role_id, "modified");
27308  break;
27309  default:
27310  case -1:
27311  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_role"));
27312  log_event_fail ("role", "Role",
27313  modify_role_data->role_id, "modified");
27314  break;
27315  }
27316 
27317  modify_role_data_reset (modify_role_data);
27318  set_client_state (CLIENT_AUTHENTIC);
27319  break;
27320  }
27321  CLOSE (CLIENT_MODIFY_ROLE, COMMENT);
27323  CLOSE (CLIENT_MODIFY_ROLE, USERS);
27324 
27325  case CLIENT_MODIFY_SCANNER:
27326  assert (strcasecmp ("MODIFY_SCANNER", element_name) == 0);
27327  return handle_modify_scanner (omp_parser, error);
27328  CLOSE (CLIENT_MODIFY_SCANNER, TYPE);
27329  CLOSE (CLIENT_MODIFY_SCANNER, PORT);
27330  CLOSE (CLIENT_MODIFY_SCANNER, HOST);
27331  CLOSE (CLIENT_MODIFY_SCANNER, COMMENT);
27333  CLOSE (CLIENT_MODIFY_SCANNER, CA_PUB);
27334  CLOSE (CLIENT_MODIFY_SCANNER, CREDENTIAL);
27335 
27337  {
27338  time_t first_time, period, period_months, duration;
27339 
27340  assert (strcasecmp ("MODIFY_SCHEDULE", element_name) == 0);
27341 
27342  period_months = 0;
27343 
27344  /* Only change schedule "first time" if given. */
27350 
27351  if (first_time
27352  && ((first_time
27353  = time_from_strings
27360  == -1))
27361  SEND_TO_CLIENT_OR_FAIL
27362  (XML_ERROR_SYNTAX ("modify_schedule",
27363  "Failed to create time from FIRST_TIME"
27364  " elements"));
27365  else if ((period = interval_from_strings
27368  &period_months))
27369  == -3)
27370  SEND_TO_CLIENT_OR_FAIL
27371  (XML_ERROR_SYNTAX ("modify_schedule",
27372  "PERIOD out of range"));
27373  else if (period < -1)
27374  SEND_TO_CLIENT_OR_FAIL
27375  (XML_ERROR_SYNTAX ("modify_schedule",
27376  "Failed to create interval from PERIOD"));
27377  else if ((duration = interval_from_strings
27380  NULL))
27381  == -3)
27382  SEND_TO_CLIENT_OR_FAIL
27383  (XML_ERROR_SYNTAX ("modify_schedule",
27384  "DURATION out of range"));
27385  else if (duration < -1)
27386  SEND_TO_CLIENT_OR_FAIL
27387  (XML_ERROR_SYNTAX ("modify_schedule",
27388  "Failed to create interval from DURATION"));
27389 #if 0
27390  /* The actual time of a period in months can vary, so it's extremely
27391  * hard to do this check. The schedule will still work fine if the
27392  * duration is longer than the period. */
27393  else if (period_months
27394  && (duration > (period_months * 60 * 60 * 24 * 28)))
27395  SEND_TO_CLIENT_OR_FAIL
27396  (XML_ERROR_SYNTAX ("modify_schedule",
27397  "Duration too long for number of months"));
27398 #endif
27399  else if (period && (duration > period))
27400  SEND_TO_CLIENT_OR_FAIL
27401  (XML_ERROR_SYNTAX ("modify_schedule",
27402  "Duration is longer than period"));
27403  else switch (modify_schedule
27407  first_time,
27408  period == -1 ? 0 : period,
27409  period_months,
27410  duration == -1 ? 0 : duration,
27412  {
27413  case 0:
27414  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_schedule"));
27415  log_event ("schedule", "Schedule",
27416  modify_schedule_data->schedule_id, "modified");
27417  break;
27418  case 1:
27419  if (send_find_error_to_client ("modify_schedule", "schedule",
27421  omp_parser))
27422  {
27423  error_send_to_client (error);
27424  return;
27425  }
27426  log_event_fail ("schedule", "Schedule",
27428  "modified");
27429  break;
27430  case 2:
27431  SEND_TO_CLIENT_OR_FAIL
27432  (XML_ERROR_SYNTAX ("modify_schedule",
27433  "Schedule with new name exists already"));
27434  log_event_fail ("schedule", "Schedule",
27436  "modified");
27437  break;
27438  case 3:
27439  SEND_TO_CLIENT_OR_FAIL
27440  (XML_ERROR_SYNTAX ("modify_schedule",
27441  "Error in type name"));
27442  log_event_fail ("schedule", "Schedule",
27444  "modified");
27445  break;
27446  case 4:
27447  SEND_TO_CLIENT_OR_FAIL
27448  (XML_ERROR_SYNTAX ("modify_schedule",
27449  "MODIFY_SCHEDULE requires a schedule_id"));
27450  log_event_fail ("schedule", "Schedule",
27452  "modified");
27453  break;
27454  case 99:
27455  SEND_TO_CLIENT_OR_FAIL
27456  (XML_ERROR_SYNTAX ("modify_schedule",
27457  "Permission denied"));
27458  log_event_fail ("schedule", "Schedule",
27460  "modified");
27461  break;
27462  default:
27463  case -1:
27464  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_schedule"));
27465  log_event_fail ("schedule", "Schedule",
27467  "modified");
27468  break;
27469  }
27470 
27471  modify_schedule_data_reset (modify_schedule_data);
27472  set_client_state (CLIENT_AUTHENTIC);
27473  break;
27474  }
27475  CLOSE (CLIENT_MODIFY_SCHEDULE, COMMENT);
27476  CLOSE (CLIENT_MODIFY_SCHEDULE, DURATION);
27477  CLOSE (CLIENT_MODIFY_SCHEDULE, FIRST_TIME);
27479  CLOSE (CLIENT_MODIFY_SCHEDULE, PERIOD);
27480  CLOSE (CLIENT_MODIFY_SCHEDULE, TIMEZONE);
27481 
27482  CLOSE (CLIENT_MODIFY_SCHEDULE_FIRST_TIME, DAY_OF_MONTH);
27487 
27489 
27491 
27492  case CLIENT_MODIFY_SETTING:
27493  {
27494  gchar *errdesc = NULL;
27495 
27496  if (((modify_setting_data->name == NULL)
27497  && (modify_setting_data->setting_id == NULL))
27498  || (modify_setting_data->value == NULL))
27499  SEND_TO_CLIENT_OR_FAIL
27500  (XML_ERROR_SYNTAX ("modify_setting",
27501  "MODIFY_SETTING requires a NAME or setting_id"
27502  " and a VALUE"));
27506  &errdesc))
27507  {
27508  case 0:
27509  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_setting"));
27510  break;
27511  case 1:
27512  SEND_TO_CLIENT_OR_FAIL
27513  (XML_ERROR_SYNTAX ("modify_setting",
27514  "Failed to find setting"));
27515  break;
27516  case 2:
27517  SEND_TO_CLIENT_OR_FAIL
27518  (XML_ERROR_SYNTAX ("modify_setting",
27519  "Value validation failed"));
27520  break;
27521  case 99:
27522  SEND_TO_CLIENT_OR_FAIL
27523  (XML_ERROR_SYNTAX ("modify_setting",
27524  "Permission denied"));
27525  break;
27526  case -1:
27527  if (errdesc)
27528  {
27529  char *buf = make_xml_error_syntax ("modify_setting",
27530  errdesc);
27531  SEND_TO_CLIENT_OR_FAIL (buf);
27532  g_free (buf);
27533  break;
27534  }
27535  /* Fall through. */
27536  default:
27537  SEND_TO_CLIENT_OR_FAIL
27538  (XML_INTERNAL_ERROR ("modify_setting"));
27539  break;
27540  }
27541  g_free (errdesc);
27542  }
27543  modify_setting_data_reset (modify_setting_data);
27544  set_client_state (CLIENT_AUTHENTIC);
27545  break;
27547  CLOSE (CLIENT_MODIFY_SETTING, VALUE);
27548 
27549  case CLIENT_MODIFY_TAG:
27550  {
27551  assert (strcasecmp ("MODIFY_TAG", element_name) == 0);
27552 
27553  if (modify_tag_data->tag_id == NULL)
27554  SEND_TO_CLIENT_OR_FAIL
27555  (XML_ERROR_SYNTAX ("modify_tag",
27556  "MODIFY_TAG requires a tag_id attribute"));
27557  else if (modify_tag_data->name
27558  && strcmp(modify_tag_data->name, "") == 0)
27559  SEND_TO_CLIENT_OR_FAIL
27560  (XML_ERROR_SYNTAX ("modify_tag",
27561  "name in MODIFY_TAG must be at least one"
27562  " character long or omitted completely"));
27563  else if (modify_tag_data->resource_type &&
27565  SEND_TO_CLIENT_OR_FAIL
27566  (XML_ERROR_SYNTAX ("modify_tag",
27567  "TYPE in MODIFY_TAG/RESOURCE must be"
27568  " a valid resource type."));
27569  else if (modify_tag_data->resource_type
27570  && strcasecmp (modify_tag_data->resource_type, "tag") == 0)
27571  SEND_TO_CLIENT_OR_FAIL
27572  (XML_ERROR_SYNTAX ("modify_tag",
27573  "TYPE type in MODIFY_TAG/RESOURCE must not"
27574  " be 'tag'."));
27575  else if (modify_tag_data->resource_id
27576  && strlen (modify_tag_data->resource_id) > 0
27580  modify_tag_data->resource_id) == 0))
27581  SEND_TO_CLIENT_OR_FAIL
27582  (XML_ERROR_SYNTAX ("modify_tag",
27583  "RESOURCE id must refer to an"
27584  " existing resource or be empty."));
27585  else switch (modify_tag (modify_tag_data->tag_id,
27592  {
27593  case 0:
27594  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_tag"));
27595  log_event ("tag", "Tag", modify_tag_data->tag_id,
27596  "modified");
27597  break;
27598  case 1:
27599  if (send_find_error_to_client ("modify_tag", "tag",
27601  omp_parser))
27602  {
27603  error_send_to_client (error);
27604  return;
27605  }
27606  log_event_fail ("tag", "Tag", modify_tag_data->tag_id,
27607  "modified");
27608  break;
27609  case 2:
27610  SEND_TO_CLIENT_OR_FAIL
27611  (XML_ERROR_SYNTAX ("modify_tag",
27612  "MODIFY_TAG requires a tag_id"));
27613  log_event_fail ("tag", "Tag", modify_tag_data->tag_id,
27614  "modified");
27615  case 99:
27616  SEND_TO_CLIENT_OR_FAIL
27617  (XML_ERROR_SYNTAX ("modify_tag",
27618  "Permission denied"));
27619  log_event_fail ("tag", "Tag", modify_tag_data->tag_id,
27620  "modified");
27621  break;
27622  default:
27623  SEND_TO_CLIENT_OR_FAIL
27624  (XML_INTERNAL_ERROR ("modify_tag"));
27625  log_event_fail ("tag", "Tag", modify_tag_data->tag_id,
27626  "modified");
27627  break;
27628  }
27629 
27630  modify_tag_data_reset (modify_tag_data);
27631  set_client_state (CLIENT_AUTHENTIC);
27632  break;
27633  }
27634 
27635  CLOSE (CLIENT_MODIFY_TAG, ACTIVE);
27636  CLOSE (CLIENT_MODIFY_TAG, RESOURCE);
27637  CLOSE (CLIENT_MODIFY_TAG, COMMENT);
27639  CLOSE (CLIENT_MODIFY_TAG, VALUE);
27640 
27642 
27643  case CLIENT_MODIFY_TARGET:
27644  {
27645  assert (strcasecmp ("MODIFY_TARGET", element_name) == 0);
27646 
27647  if (modify_target_data->target_id == NULL)
27648  SEND_TO_CLIENT_OR_FAIL
27649  (XML_ERROR_SYNTAX ("modify_target",
27650  "MODIFY_TARGET requires a target_id"
27651  " attribute"));
27652  else switch (modify_target
27675  {
27676  case 1:
27677  SEND_TO_CLIENT_OR_FAIL
27678  (XML_ERROR_SYNTAX ("modify_target",
27679  "Target exists already"));
27680  log_event_fail ("target", "Target",
27682  "modified");
27683  break;
27684  case 2:
27685  SEND_TO_CLIENT_OR_FAIL
27686  (XML_ERROR_SYNTAX ("modify_target",
27687  "Error in host specification"));
27688  log_event_fail ("target", "Target",
27690  "modified");
27691  break;
27692  case 3:
27693  SEND_TO_CLIENT_OR_FAIL
27694  (XML_ERROR_SYNTAX ("modify_target",
27695  "Host specification exceeds maximum number"
27696  " of hosts"));
27697  log_event_fail ("target", "Target",
27699  "modified");
27700  break;
27701  case 4:
27702  SEND_TO_CLIENT_OR_FAIL
27703  (XML_ERROR_SYNTAX ("modify_target",
27704  "Error in port range"));
27705  log_event_fail ("target", "Target",
27707  "modified");
27708  break;
27709  case 5:
27710  SEND_TO_CLIENT_OR_FAIL
27711  (XML_ERROR_SYNTAX ("modify_target",
27712  "Error in SSH port"));
27713  log_event_fail ("target", "Target",
27715  "modified");
27716  break;
27717  case 6:
27718  log_event_fail ("target", "Target",
27720  "modified");
27721  if (send_find_error_to_client
27722  ("modify_target", "port_list",
27723  modify_target_data->port_list_id, omp_parser))
27724  {
27725  error_send_to_client (error);
27726  return;
27727  }
27728  break;
27729  case 7:
27730  log_event_fail ("target", "Target",
27732  "modified");
27733  if (send_find_error_to_client
27734  ("modify_target", "Credential",
27738  omp_parser))
27739  {
27740  error_send_to_client (error);
27741  return;
27742  }
27743  break;
27744  case 8:
27745  log_event_fail ("target", "Target",
27747  "modified");
27748  if (send_find_error_to_client
27749  ("modify_target", "Credential",
27753  omp_parser))
27754  {
27755  error_send_to_client (error);
27756  return;
27757  }
27758  break;
27759  case 9:
27760  log_event_fail ("target", "Target",
27762  "modified");
27763  if (send_find_error_to_client
27764  ("modify_target", "target", modify_target_data->target_id,
27765  omp_parser))
27766  {
27767  error_send_to_client (error);
27768  return;
27769  }
27770  break;
27771  case 10:
27772  SEND_TO_CLIENT_OR_FAIL
27773  (XML_ERROR_SYNTAX ("modify_target",
27774  "Error in alive test"));
27775  log_event_fail ("target", "Target",
27777  "modified");
27778  break;
27779  case 11:
27780  SEND_TO_CLIENT_OR_FAIL
27781  (XML_ERROR_SYNTAX ("modify_target",
27782  "MODIFY_TARGET name must be at"
27783  " least one character long"));
27784  log_event_fail ("target", "Target",
27786  "modified");
27787  break;
27788  case 12:
27789  SEND_TO_CLIENT_OR_FAIL
27790  (XML_ERROR_SYNTAX ("modify_target",
27791  "MODIFY_TARGET EXCLUDE_HOSTS requires"
27792  " a HOSTS"));
27793  log_event_fail ("target", "Target",
27795  "modified");
27796  break;
27797  case 13:
27798  SEND_TO_CLIENT_OR_FAIL
27799  (XML_ERROR_SYNTAX ("modify_target",
27800  "MODIFY_TARGET with a HOSTS requires an"
27801  " EXCLUDE_HOSTS"));
27802  log_event_fail ("target", "Target",
27804  "modified");
27805  break;
27806  case 14:
27807  SEND_TO_CLIENT_OR_FAIL
27808  (XML_ERROR_SYNTAX ("modify_target",
27809  "MODIFY_TARGET HOSTS must be at least one"
27810  "character long"));
27811  log_event_fail ("target", "Target",
27813  "modified");
27814  break;
27815  case 15:
27816  SEND_TO_CLIENT_OR_FAIL
27817  (XML_ERROR_SYNTAX ("modify_target",
27818  "Target is in use"));
27819  log_event_fail ("target", "Target",
27821  "modified");
27822  break;
27823  case 16:
27824  log_event_fail ("target", "Target",
27826  "modified");
27827  if (send_find_error_to_client
27828  ("modify_target", "Credential",
27832  omp_parser))
27833  {
27834  error_send_to_client (error);
27835  return;
27836  }
27837  break;
27838  case 17:
27839  log_event_fail ("target", "Target",
27841  "modified");
27842  if (send_find_error_to_client
27843  ("modify_target", "Credential",
27845  omp_parser))
27846  {
27847  error_send_to_client (error);
27848  return;
27849  }
27850  break;
27851  case 18:
27852  SEND_TO_CLIENT_OR_FAIL
27853  (XML_ERROR_SYNTAX ("modify_target",
27854  "SSH credential must be of type"
27855  " 'up' or 'usk'"));
27856  log_event_fail ("target", "Target",
27857  modify_target_data->target_id, "modified");
27858  break;
27859  case 19:
27860  SEND_TO_CLIENT_OR_FAIL
27861  (XML_ERROR_SYNTAX ("modify_target",
27862  "SMB credential must be of type"
27863  " 'up'"));
27864  log_event_fail ("target", "Target",
27865  modify_target_data->target_id, "modified");
27866  break;
27867  case 20:
27868  SEND_TO_CLIENT_OR_FAIL
27869  (XML_ERROR_SYNTAX ("modify_target",
27870  "ESXi credential must be of type"
27871  " 'up'"));
27872  log_event_fail ("target", "Target",
27873  modify_target_data->target_id, "modified");
27874  break;
27875  case 21:
27876  SEND_TO_CLIENT_OR_FAIL
27877  (XML_ERROR_SYNTAX ("modify_target",
27878  "SNMP credential must be of type"
27879  " 'snmp'"));
27880  log_event_fail ("target", "Target",
27881  modify_target_data->target_id, "modified");
27882  break;
27883  case 99:
27884  SEND_TO_CLIENT_OR_FAIL
27885  (XML_ERROR_SYNTAX ("modify_target",
27886  "Permission denied"));
27887  log_event_fail ("target", "Target",
27889  "modified");
27890  break;
27891  case -1:
27892  SEND_TO_CLIENT_OR_FAIL
27893  (XML_INTERNAL_ERROR ("modify_target"));
27894  log_event_fail ("target", "Target",
27896  "modified");
27897  break;
27898  default:
27899  {
27900  SENDF_TO_CLIENT_OR_FAIL (XML_OK ("modify_target"));
27901  log_event ("target", "Target", modify_target_data->target_id,
27902  "modified");
27903  break;
27904  }
27905  }
27906 
27907  modify_target_data_reset (modify_target_data);
27908  set_client_state (CLIENT_AUTHENTIC);
27909  break;
27910  }
27911  CLOSE (CLIENT_MODIFY_TARGET, ESXI_CREDENTIAL);
27912  CLOSE (CLIENT_MODIFY_TARGET, ESXI_LSC_CREDENTIAL);
27913  CLOSE (CLIENT_MODIFY_TARGET, EXCLUDE_HOSTS);
27914  CLOSE (CLIENT_MODIFY_TARGET, REVERSE_LOOKUP_ONLY);
27915  CLOSE (CLIENT_MODIFY_TARGET, REVERSE_LOOKUP_UNIFY);
27916  CLOSE (CLIENT_MODIFY_TARGET, ALIVE_TESTS);
27917  CLOSE (CLIENT_MODIFY_TARGET, COMMENT);
27918  CLOSE (CLIENT_MODIFY_TARGET, HOSTS);
27920  CLOSE (CLIENT_MODIFY_TARGET, PORT_LIST);
27921  CLOSE (CLIENT_MODIFY_TARGET, SSH_CREDENTIAL);
27922  CLOSE (CLIENT_MODIFY_TARGET, SSH_LSC_CREDENTIAL);
27923  CLOSE (CLIENT_MODIFY_TARGET, SMB_CREDENTIAL);
27924  CLOSE (CLIENT_MODIFY_TARGET, SMB_LSC_CREDENTIAL);
27925  CLOSE (CLIENT_MODIFY_TARGET, SNMP_CREDENTIAL);
27926 
27928 
27930 
27931  case CLIENT_MODIFY_TASK:
27932  assert (strcasecmp ("MODIFY_TASK", element_name) == 0);
27933 
27934  if (acl_user_may ("modify_task") == 0)
27935  {
27936  SEND_TO_CLIENT_OR_FAIL
27937  (XML_ERROR_SYNTAX ("modify_task",
27938  "Permission denied"));
27939  modify_task_data_reset (modify_task_data);
27940  set_client_state (CLIENT_AUTHENTIC);
27941  break;
27942  }
27943 
27946  {
27947  task_t task = 0;
27949  &task,
27950  "modify_task"))
27951  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_task"));
27952  else if (task == 0)
27953  {
27954  if (send_find_error_to_client ("modify_task", "task",
27956  omp_parser))
27957  {
27958  error_send_to_client (error);
27959  return;
27960  }
27961  }
27962  else if (modify_task_data->action
27964  || modify_task_data->alerts->len
27965  || modify_task_data->groups->len
27966  || modify_task_data->name))
27967  SEND_TO_CLIENT_OR_FAIL
27968  (XML_ERROR_SYNTAX ("modify_task",
27969  "Too many parameters at once"));
27970  else if ((task_target (task) == 0)
27971  && (modify_task_data->alerts->len
27973  SEND_TO_CLIENT_OR_FAIL
27974  (XML_ERROR_SYNTAX ("modify_task",
27975  "For container tasks only name, comment and"
27976  " observers can be modified"));
27977  else if ((ret = modify_task_check_config_scanner
27978  (task, modify_task_data->config_id,
27980  {
27981  switch (ret)
27982  {
27983  case 1:
27984  SEND_TO_CLIENT_OR_FAIL
27985  (XML_ERROR_SYNTAX ("modify_task",
27986  "Config and Scanner types mismatch"));
27987  break;
27988  case 2:
27989  if (send_find_error_to_client
27990  ("modify_task", "config",
27992  omp_parser))
27993  {
27994  error_send_to_client (error);
27995  return;
27996  }
27997  break;
27998  case 3:
27999  if (send_find_error_to_client
28000  ("modify_task", "scanner",
28002  omp_parser))
28003  {
28004  error_send_to_client (error);
28005  return;
28006  }
28007  break;
28008  default:
28009  assert (0);
28010  /* fallthrough */
28011  case -1:
28012  SEND_TO_CLIENT_OR_FAIL
28013  (XML_INTERNAL_ERROR ("modify_task"));
28014  break;
28015  }
28016  }
28017  else if (modify_task_data->action)
28018  {
28019  if (modify_task_data->file_name == NULL)
28020  SEND_TO_CLIENT_OR_FAIL
28021  (XML_ERROR_SYNTAX ("modify_task",
28022  "MODIFY_TASK FILE requires a name"
28023  " attribute"));
28024  else if (strcmp (modify_task_data->action, "update") == 0)
28025  {
28030  : "");
28031  log_event ("task", "Task", modify_task_data->task_id,
28032  "modified");
28033  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_task"));
28034  }
28035  else if (strcmp (modify_task_data->action, "remove") == 0)
28036  {
28038  log_event ("task", "Task", modify_task_data->task_id,
28039  "modified");
28040  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_task"));
28041  }
28042  else
28043  {
28044  SEND_TO_CLIENT_OR_FAIL
28045  (XML_ERROR_SYNTAX ("modify_task",
28046  "MODIFY_TASK action must be"
28047  " \"update\" or \"remove\""));
28048  log_event_fail ("task", "Task",
28050  "modified");
28051  }
28052  }
28053  else
28054  {
28055  int fail = 0, type_of_scanner;
28056  scanner_t scanner;
28057 
28065  if (modify_task_data->name)
28066  {
28067  fail = set_task_parameter (task,
28068  "NAME",
28070  modify_task_data->name = NULL;
28071  if (fail)
28072  {
28073  SEND_TO_CLIENT_OR_FAIL
28074  (XML_INTERNAL_ERROR ("modify_task"));
28075  log_event_fail ("task", "Task",
28077  "modified");
28078  }
28079  }
28080 
28081  if (fail == 0 && modify_task_data->comment)
28082  {
28083  fail = set_task_parameter (task,
28084  "COMMENT",
28086  modify_task_data->comment = NULL;
28087  if (fail)
28088  {
28089  SEND_TO_CLIENT_OR_FAIL
28090  (XML_INTERNAL_ERROR ("modify_task"));
28091  log_event_fail ("task", "Task",
28093  "modified");
28094  }
28095  }
28096 
28097  scanner = 0;
28098  if (fail == 0 && modify_task_data->scanner_id)
28099  {
28100  if (strcmp (modify_task_data->scanner_id, "0") == 0)
28101  {
28102  /* Leave it as is. */
28103  }
28104  else if ((fail = (task_run_status (task)
28105  != TASK_STATUS_NEW
28106  && (task_alterable (task) == 0))))
28107  SEND_TO_CLIENT_OR_FAIL
28109  ("modify_task", "Status must be New to edit Scanner"));
28110  else if ((fail = find_scanner_with_permission
28112  &scanner,
28113  "get_scanners")))
28114  SEND_TO_CLIENT_OR_FAIL
28115  (XML_INTERNAL_ERROR ("modify_task"));
28116  else if (scanner == 0)
28117  {
28118  if (send_find_error_to_client
28119  ("modify_task", "scanner",
28120  modify_task_data->scanner_id, omp_parser))
28121  {
28122  error_send_to_client (error);
28123  return;
28124  }
28125  fail = 1;
28126  }
28127  else
28128  set_task_scanner (task, scanner);
28129  }
28130 
28131  if (scanner == 0)
28132  type_of_scanner = scanner_type (task_scanner (task));
28133  else
28134  type_of_scanner = scanner_type (scanner);
28135 
28136  if (fail == 0
28137  && type_of_scanner != SCANNER_TYPE_CVE
28139  {
28140  config_t config = 0;
28141 
28142  if (strcmp (modify_task_data->config_id, "0") == 0)
28143  {
28144  /* Leave it as it is. */
28145  }
28146  else if ((fail = ((task_run_status (task)
28147  != TASK_STATUS_NEW)
28148  && (task_alterable (task) == 0))))
28149  SEND_TO_CLIENT_OR_FAIL
28150  (XML_ERROR_SYNTAX ("modify_task",
28151  "Status must be New to edit Config"));
28152  else if ((fail = find_config_with_permission
28154  &config,
28155  "get_configs")))
28156  SEND_TO_CLIENT_OR_FAIL
28157  (XML_INTERNAL_ERROR ("modify_task"));
28158  else if (config == 0)
28159  {
28160  if (send_find_error_to_client
28161  ("modify_task", "config",
28162  modify_task_data->config_id, omp_parser))
28163  {
28164  error_send_to_client (error);
28165  return;
28166  }
28167  fail = 1;
28168  }
28169  else
28170  set_task_config (task, config);
28171  }
28172 
28173  if (fail == 0 && modify_task_data->observers)
28174  {
28175  fail = set_task_observers (task,
28177  switch (fail)
28178  {
28179  case 0:
28180  break;
28181  case 1:
28182  case 2:
28183  SEND_TO_CLIENT_OR_FAIL
28184  (XML_ERROR_SYNTAX ("modify_task",
28185  "User name error"));
28186  log_event_fail ("task", "Task",
28188  "modified");
28189  break;
28190  case -1:
28191  default:
28192  SEND_TO_CLIENT_OR_FAIL
28193  (XML_INTERNAL_ERROR ("modify_task"));
28194  log_event_fail ("task", "Task",
28196  "modified");
28197  }
28198  }
28199 
28200  if (fail == 0 && modify_task_data->alerts->len)
28201  {
28202  gchar *fail_alert_id;
28203  switch ((fail = set_task_alerts (task,
28205  &fail_alert_id)))
28206  {
28207  case 0:
28208  break;
28209  case 1:
28210  if (send_find_error_to_client
28211  ("modify_task", "alert", fail_alert_id,
28212  omp_parser))
28213  {
28214  error_send_to_client (error);
28215  return;
28216  }
28217  fail = 1;
28218  log_event_fail ("task", "Task",
28220  "modified");
28221  break;
28222  case -1:
28223  default:
28224  SEND_TO_CLIENT_OR_FAIL
28225  (XML_INTERNAL_ERROR ("modify_task"));
28226  log_event_fail ("task", "Task",
28228  "modified");
28229  }
28230  }
28231 
28232  if (fail == 0 && modify_task_data->alterable)
28233  {
28234  if (task_run_status (task) != TASK_STATUS_NEW)
28235  {
28236  SEND_TO_CLIENT_OR_FAIL
28237  (XML_ERROR_SYNTAX ("modify_task",
28238  "Task must be New to modify"
28239  " Alterable state"));
28240  fail = 1;
28241  }
28242  else
28243  set_task_alterable (task,
28244  strcmp (modify_task_data->alterable,
28245  "0"));
28246  }
28247 
28248  if (fail == 0 && modify_task_data->groups->len)
28249  {
28250  gchar *fail_group_id;
28251  switch ((fail = set_task_groups (task,
28253  &fail_group_id)))
28254  {
28255  case 0:
28256  break;
28257  case 1:
28258  if (send_find_error_to_client
28259  ("modify_task", "group", fail_group_id,
28260  omp_parser))
28261  {
28262  error_send_to_client (error);
28263  return;
28264  }
28265  fail = 1;
28266  log_event_fail ("task", "Task",
28268  "modified");
28269  break;
28270  case -1:
28271  default:
28272  SEND_TO_CLIENT_OR_FAIL
28273  (XML_INTERNAL_ERROR ("modify_task"));
28274  log_event_fail ("task", "Task",
28276  "modified");
28277  }
28278  }
28279 
28280  if (fail == 0 && modify_task_data->schedule_id)
28281  {
28282  schedule_t schedule = 0;
28283  int periods;
28284 
28287  : 0;
28288 
28289  if (strcmp (modify_task_data->schedule_id, "0") == 0)
28290  {
28291  set_task_schedule (task, 0, periods);
28292  }
28293  else if ((fail = find_schedule_with_permission
28295  &schedule,
28296  "get_schedules")))
28297  SEND_TO_CLIENT_OR_FAIL
28298  (XML_INTERNAL_ERROR ("modify_task"));
28299  else if (schedule == 0)
28300  {
28301  if (send_find_error_to_client
28302  ("modify_task", "schedule",
28303  modify_task_data->schedule_id, omp_parser))
28304  {
28305  error_send_to_client (error);
28306  return;
28307  }
28308  fail = 1;
28309  }
28310  else if (set_task_schedule (task, schedule, periods))
28311  {
28312  SEND_TO_CLIENT_OR_FAIL
28313  (XML_INTERNAL_ERROR ("modify_task"));
28314  fail = 1;
28315  }
28316  }
28317  else if (fail == 0
28319  && strlen (modify_task_data->schedule_periods))
28323 
28324  if (fail == 0 && modify_task_data->target_id)
28325  {
28326  target_t target = 0;
28327 
28328  if (strcmp (modify_task_data->target_id, "0") == 0)
28329  {
28330  /* Leave it as it is. */
28331  }
28332  else if ((fail = (task_run_status (task)
28333  != TASK_STATUS_NEW
28334  && (task_alterable (task) == 0))))
28335  SEND_TO_CLIENT_OR_FAIL
28336  (XML_ERROR_SYNTAX ("modify_task",
28337  "Status must be New to edit Target"));
28338  else if ((fail = find_target_with_permission
28340  &target,
28341  "get_targets")))
28342  SEND_TO_CLIENT_OR_FAIL
28343  (XML_INTERNAL_ERROR ("modify_task"));
28344  else if (target == 0)
28345  {
28346  if (send_find_error_to_client
28347  ("modify_task", "target",
28348  modify_task_data->target_id, omp_parser))
28349  {
28350  error_send_to_client (error);
28351  return;
28352  }
28353  fail = 1;
28354  }
28355  else
28356  set_task_target (task, target);
28357  }
28358 
28359  if (fail == 0 && modify_task_data->preferences)
28360  switch (set_task_preferences (task,
28362  {
28363  case 0:
28364  break;
28365  case 1:
28366  SEND_TO_CLIENT_OR_FAIL
28367  (XML_ERROR_SYNTAX ("modify_task",
28368  "Invalid auto_delete value"));
28369  fail = 1;
28370  break;
28371  case 2:
28372  SENDF_TO_CLIENT_OR_FAIL
28373  (XML_ERROR_SYNTAX ("modify_task",
28374  "Auto Delete count out of range"
28375  " (must be from %d to %d)"),
28377  fail = 1;
28378  break;
28379  default:
28380  SEND_TO_CLIENT_OR_FAIL
28381  (XML_INTERNAL_ERROR ("modify_task"));
28382  fail = 1;
28383  }
28384 
28385  if (fail == 0 && modify_task_data->hosts_ordering)
28388 
28389  if (fail == 0)
28390  {
28391  log_event ("task", "Task", modify_task_data->task_id,
28392  "modified");
28393  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_task"));
28394  }
28395  }
28396  }
28397  else
28398  SEND_TO_CLIENT_OR_FAIL
28399  (XML_ERROR_SYNTAX ("modify_task",
28400  "MODIFY_TASK requires a task_id attribute"));
28401  modify_task_data_reset (modify_task_data);
28402  set_client_state (CLIENT_AUTHENTIC);
28403  break;
28404  CLOSE (CLIENT_MODIFY_TASK, ALTERABLE);
28405  CLOSE (CLIENT_MODIFY_TASK, COMMENT);
28406  CLOSE (CLIENT_MODIFY_TASK, HOSTS_ORDERING);
28407  CLOSE (CLIENT_MODIFY_TASK, SCANNER);
28408  CLOSE (CLIENT_MODIFY_TASK, CONFIG);
28409  CLOSE (CLIENT_MODIFY_TASK, ALERT);
28411  CLOSE (CLIENT_MODIFY_TASK, OBSERVERS);
28412  CLOSE (CLIENT_MODIFY_TASK, PREFERENCES);
28413  CLOSE (CLIENT_MODIFY_TASK, SCHEDULE);
28414  CLOSE (CLIENT_MODIFY_TASK, SCHEDULE_PERIODS);
28415  CLOSE (CLIENT_MODIFY_TASK, TARGET);
28416  CLOSE (CLIENT_MODIFY_TASK, FILE);
28417 
28419 
28421  assert (strcasecmp ("PREFERENCE", element_name) == 0);
28422  array_add (modify_task_data->preferences,
28424  modify_task_data->preference = NULL;
28425  set_client_state (CLIENT_MODIFY_TASK_PREFERENCES);
28426  break;
28428  assert (strcasecmp ("SCANNER_NAME", element_name) == 0);
28429  set_client_state (CLIENT_MODIFY_TASK_PREFERENCES_PREFERENCE);
28430  break;
28432 
28433  case CLIENT_MODIFY_USER:
28434  {
28435  assert (strcasecmp ("MODIFY_USER", element_name) == 0);
28436 
28437  if ((modify_user_data->name == NULL
28438  && modify_user_data->user_id == NULL)
28439  || (modify_user_data->name
28440  && (strlen (modify_user_data->name) == 0))
28442  && (strlen (modify_user_data->user_id) == 0)))
28443  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
28444  ("modify_user",
28445  "MODIFY_USER requires NAME or user_id"));
28446  else
28447  {
28448  gchar *fail_group_id, *fail_role_id, *errdesc;
28449 
28450  errdesc = NULL;
28451 
28452  switch (modify_user
28459  /* Leave the password as it is. */
28460  : NULL),
28466  modify_user_data->groups, &fail_group_id,
28467  modify_user_data->roles, &fail_role_id,
28468  &errdesc))
28469  {
28470  case 0:
28471  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_user"));
28472  break;
28473  case 1:
28474  if (send_find_error_to_client
28475  ("modify_user", "group", fail_group_id, omp_parser))
28476  {
28477  error_send_to_client (error);
28478  return;
28479  }
28480  break;
28481  case 2:
28482  if (send_find_error_to_client
28483  ("modify_user", "user",
28485  omp_parser))
28486  {
28487  error_send_to_client (error);
28488  return;
28489  }
28490  break;
28491  case 3:
28492  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_user"));
28493  log_event ("user", "User", modify_user_data->name,
28494  "raised to Admin role");
28495  break;
28496  case 4:
28497  SEND_TO_CLIENT_OR_FAIL (XML_OK ("modify_user"));
28498  log_event ("user", "User", modify_user_data->name,
28499  "downgraded from Admin role");
28500  break;
28501  case 5:
28502  if (send_find_error_to_client
28503  ("modify_user", "role", fail_role_id, omp_parser))
28504  {
28505  error_send_to_client (error);
28506  return;
28507  }
28508  break;
28509  case 6:
28510  SEND_TO_CLIENT_OR_FAIL
28511  (XML_ERROR_SYNTAX ("modify_user",
28512  "Error in host specification"));
28513  log_event_fail ("user", "User", NULL, "modified");
28514  break;
28515  case 7:
28516  SEND_TO_CLIENT_OR_FAIL
28517  (XML_ERROR_SYNTAX ("modify_user",
28518  "Error in user name"));
28519  log_event_fail ("user", "User", NULL, "modified");
28520  break;
28521  case 8:
28522  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
28523  ("modify_user",
28524  "User with name exists already"));
28525  log_event_fail ("user", "User", NULL, "modified");
28526  break;
28527  case 99:
28528  SEND_TO_CLIENT_OR_FAIL
28529  (XML_ERROR_SYNTAX ("modify_user",
28530  "Permission denied"));
28531  break;
28532  case -2:
28533  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
28534  ("modify_user", "Unknown role"));
28535  break;
28536  case -3:
28537  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX
28538  ("modify_user", "Error in SOURCES"));
28539  break;
28540  case -1:
28541  if (errdesc)
28542  {
28543  char *buf = make_xml_error_syntax ("modify_user", errdesc);
28544  SEND_TO_CLIENT_OR_FAIL (buf);
28545  g_free (buf);
28546  break;
28547  }
28548  /* Fall through. */
28549  default:
28550  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("modify_user"));
28551  break;
28552  }
28553  g_free (errdesc);
28554  }
28555  modify_user_data_reset (modify_user_data);
28556  set_client_state (CLIENT_AUTHENTIC);
28557  break;
28558  }
28559  CLOSE (CLIENT_MODIFY_USER, GROUPS);
28561  CLOSE (CLIENT_MODIFY_USER, HOSTS);
28562  CLOSE (CLIENT_MODIFY_USER, IFACES);
28564  CLOSE (CLIENT_MODIFY_USER, NEW_NAME);
28565  CLOSE (CLIENT_MODIFY_USER, PASSWORD);
28566  CLOSE (CLIENT_MODIFY_USER, ROLE);
28568  assert (strcasecmp ("SOURCES", element_name) == 0);
28569  array_terminate (modify_user_data->sources);
28570  set_client_state (CLIENT_MODIFY_USER);
28571  break;
28573  assert (strcasecmp ("SOURCE", element_name) == 0);
28574  array_add (modify_user_data->sources,
28575  g_strdup (modify_user_data->current_source));
28576  g_free (modify_user_data->current_source);
28578  set_client_state (CLIENT_MODIFY_USER_SOURCES);
28579  break;
28580 
28581  case CLIENT_MOVE_TASK:
28582  if (move_task_data->task_id == NULL
28583  || strcmp (move_task_data->task_id, "") == 0)
28584  {
28585  SEND_TO_CLIENT_OR_FAIL
28586  (XML_ERROR_SYNTAX ("move_task",
28587  "MOVE_TASK requires a non-empty task_id"
28588  " attribute"));
28589  break;
28590  }
28591 
28592  if (move_task_data->slave_id == NULL)
28593  {
28594  SEND_TO_CLIENT_OR_FAIL
28595  (XML_ERROR_SYNTAX ("move_task",
28596  "MOVE_TASK requires a slave_id attribute"));
28597  break;
28598  }
28599 
28600  switch (move_task (move_task_data->task_id,
28602  {
28603  case 0:
28604  SEND_TO_CLIENT_OR_FAIL (XML_OK ("move_task"));
28605  break;
28606  case 1:
28607  /* Forked task process: success. */
28608  forked = 1;
28609  current_error = 2;
28610  g_debug (" %s: move_task fork success\n", __FUNCTION__);
28611  g_set_error (error,
28612  G_MARKUP_ERROR,
28613  G_MARKUP_ERROR_INVALID_CONTENT,
28614  "Dummy error for current_error");
28615  break;
28616  case 2:
28617  if (send_find_error_to_client ("move_task",
28618  "Task",
28620  omp_parser))
28621  {
28622  error_send_to_client (error);
28623  return;
28624  }
28625  break;
28626  case 3:
28627  if (send_find_error_to_client ("move_task",
28628  "Slave",
28630  omp_parser))
28631  {
28632  error_send_to_client (error);
28633  return;
28634  }
28635  break;
28636  case 4:
28637  SEND_TO_CLIENT_OR_FAIL
28638  (XML_ERROR_SYNTAX ("move_task",
28639  "Task must use an OpenVAS scanner to assign"
28640  " a slave."));
28641  break;
28642  case 5:
28643  SEND_TO_CLIENT_OR_FAIL
28644  (XML_ERROR_SYNTAX ("move_task",
28645  "Task cannot be stopped at the moment."));
28646  break;
28647  case 6:
28648  SEND_TO_CLIENT_OR_FAIL
28649  (XML_ERROR_SYNTAX ("move_task",
28650  "Scanner does not allow stopping"
28651  " the Task."));
28652  break;
28653  case 7:
28654  SEND_TO_CLIENT_OR_FAIL
28655  (XML_ERROR_SYNTAX ("move_task",
28656  "Destination scanner does not support"
28657  " slaves."));
28658  break;
28659  case 98:
28660  SEND_TO_CLIENT_OR_FAIL
28661  (XML_ERROR_SYNTAX ("move_task",
28662  "Permission to stop and resume denied"));
28663  break;
28664  case 99:
28665  SEND_TO_CLIENT_OR_FAIL
28666  (XML_ERROR_SYNTAX ("move_task",
28667  "Permission denied"));
28668  break;
28669  default: /* Programming error. */
28670  SEND_TO_CLIENT_OR_FAIL
28671  (XML_INTERNAL_ERROR ("move_task"));
28672  assert (0);
28673  break;
28674  }
28675  move_task_data_reset (move_task_data);
28676  set_client_state (CLIENT_AUTHENTIC);
28677  break;
28678 
28679  case CLIENT_TEST_ALERT:
28681  {
28682  gchar *script_message = NULL;
28684  &script_message))
28685  {
28686  case 0:
28687  SEND_TO_CLIENT_OR_FAIL (XML_OK ("test_alert"));
28688  break;
28689  case 1:
28690  if (send_find_error_to_client
28691  ("test_alert", "alert", test_alert_data->alert_id,
28692  omp_parser))
28693  {
28694  error_send_to_client (error);
28695  return;
28696  }
28697  break;
28698  case 99:
28699  SEND_TO_CLIENT_OR_FAIL
28700  (XML_ERROR_SYNTAX ("test_alert",
28701  "Permission denied"));
28702  break;
28703  case 2:
28704  case -1:
28705  SEND_TO_CLIENT_OR_FAIL
28706  (XML_INTERNAL_ERROR ("test_alert"));
28707  break;
28708  case -2:
28709  SEND_TO_CLIENT_OR_FAIL
28710  (XML_ERROR_SYNTAX ("test_alert",
28711  "Failed to find report format for"
28712  " alert"));
28713  break;
28714  case -3:
28715  SEND_TO_CLIENT_OR_FAIL
28716  (XML_ERROR_SYNTAX ("test_alert",
28717  "Failed to find filter for alert"));
28718  break;
28719  case -4:
28720  SEND_TO_CLIENT_OR_FAIL
28721  (XML_ERROR_SYNTAX ("test_alert",
28722  "Failed to find credential for alert"));
28723  break;
28724  case -5:
28725  if (script_message)
28726  {
28727  gchar *msg;
28728  msg = g_markup_printf_escaped
28729  ("<test_alert_response status=\"400\""
28730  " status_text=\"Alert script failed\">"
28731  "<status_details>%s</status_details>"
28732  "</test_alert_response>",
28733  script_message);
28734 
28735  if (send_to_client (msg, omp_parser->client_writer,
28736  omp_parser->client_writer_data))
28737  {
28738  error_send_to_client (error);
28739  g_free (msg);
28740  return;
28741  }
28742  }
28743  else
28744  {
28745  SEND_TO_CLIENT_OR_FAIL
28746  (XML_ERROR_SYNTAX ("test_alert",
28747  "Alert script failed"));
28748  }
28749  break;
28750  default: /* Programming error. */
28751  assert (0);
28752  SEND_TO_CLIENT_OR_FAIL
28753  (XML_INTERNAL_ERROR ("test_alert"));
28754  break;
28755  }
28756  }
28757  else
28758  SEND_TO_CLIENT_OR_FAIL
28759  (XML_ERROR_SYNTAX ("test_alert",
28760  "TEST_ALERT requires an alert_id"
28761  " attribute"));
28762  test_alert_data_reset (test_alert_data);
28763  set_client_state (CLIENT_AUTHENTIC);
28764  break;
28765 
28766  case CLIENT_RESTORE:
28767  if (restore_data->id)
28768  {
28769  switch (manage_restore (restore_data->id))
28770  {
28771  case 0:
28772  SEND_TO_CLIENT_OR_FAIL (XML_OK ("restore"));
28773  log_event ("resource", "Resource", restore_data->id,
28774  "restored");
28775  break;
28776  case 1:
28777  SEND_TO_CLIENT_OR_FAIL
28778  (XML_ERROR_SYNTAX ("restore",
28779  "Resource refers into trashcan"));
28780  break;
28781  case 2:
28782  if (send_find_error_to_client ("restore", "resource",
28783  restore_data->id, omp_parser))
28784  {
28785  error_send_to_client (error);
28786  return;
28787  }
28788  break;
28789  case 3:
28790  SEND_TO_CLIENT_OR_FAIL
28791  (XML_ERROR_SYNTAX ("restore",
28792  "A resource with this name exists"
28793  " already"));
28794  break;
28795  case 4:
28796  SEND_TO_CLIENT_OR_FAIL
28797  (XML_ERROR_SYNTAX ("restore",
28798  "A resource with this UUID exists"
28799  " already"));
28800  break;
28801  case 99:
28802  SEND_TO_CLIENT_OR_FAIL
28803  (XML_ERROR_SYNTAX ("restore",
28804  "Permission denied"));
28805  break;
28806  default: /* Programming error. */
28807  assert (0);
28808  case -1:
28809  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("restore"));
28810  break;
28811  }
28812  }
28813  else
28814  SEND_TO_CLIENT_OR_FAIL
28815  (XML_ERROR_SYNTAX ("restore",
28816  "RESTORE requires an id attribute"));
28817  restore_data_reset (restore_data);
28818  set_client_state (CLIENT_AUTHENTIC);
28819  break;
28820 
28821  case CLIENT_RESUME_TASK:
28823  {
28824  if (forked == 2)
28825  /* Prevent the forked child from forking again, as then both
28826  * forked children would be using the same server session. */
28827  abort ();
28828  else
28829  {
28830  char *report_id;
28831  switch (resume_task (resume_task_data->task_id, &report_id))
28832  {
28833  case 0:
28834  {
28835  gchar *msg;
28836  msg = g_strdup_printf
28837  ("<resume_task_response"
28838  " status=\"" STATUS_OK_REQUESTED "\""
28839  " status_text=\""
28841  "\">"
28842  "<report_id>%s</report_id>"
28843  "</resume_task_response>",
28844  report_id);
28845  free (report_id);
28846  if (send_to_client (msg,
28847  write_to_client,
28848  write_to_client_data))
28849  {
28850  g_free (msg);
28851  error_send_to_client (error);
28852  return;
28853  }
28854  g_free (msg);
28855  }
28856  forked = 1;
28857  log_event ("task", "Task",
28859  "resumed");
28860  break;
28861  case 1:
28862  SEND_TO_CLIENT_OR_FAIL
28863  (XML_ERROR_SYNTAX ("resume_task",
28864  "Task is active already"));
28865  log_event_fail ("task", "Task",
28867  "resumed");
28868  break;
28869  case 22:
28870  SEND_TO_CLIENT_OR_FAIL
28871  (XML_ERROR_SYNTAX ("resume_task",
28872  "Task must be in Stopped state"));
28873  log_event_fail ("task", "Task",
28875  "resumed");
28876  break;
28877  case 2:
28878  /* Forked task process: success. */
28879  current_error = 2;
28880  g_debug (" %s: resume_task fork success\n", __FUNCTION__);
28881  g_set_error (error,
28882  G_MARKUP_ERROR,
28883  G_MARKUP_ERROR_INVALID_CONTENT,
28884  "Dummy error for current_error");
28885  break;
28886  case 4:
28887  SEND_TO_CLIENT_OR_FAIL
28888  (XML_ERROR_SYNTAX ("resume_task",
28889  "Resuming not supported"));
28890  log_event_fail ("task", "Task",
28892  "resumed");
28893  break;
28894  case 3: /* Find failed. */
28895  if (send_find_error_to_client
28896  ("resume_task", "task", resume_task_data->task_id,
28897  omp_parser))
28898  {
28899  error_send_to_client (error);
28900  return;
28901  }
28902  break;
28903  case 99:
28904  SEND_TO_CLIENT_OR_FAIL
28905  (XML_ERROR_SYNTAX ("resume_task",
28906  "Permission denied"));
28907  log_event_fail ("task", "Task",
28909  "resumed");
28910  break;
28911  case -10:
28912  /* Forked task process: error. */
28913  current_error = -10;
28914  g_debug (" %s: resume_task fork error\n", __FUNCTION__);
28915  g_set_error (error,
28916  G_MARKUP_ERROR,
28917  G_MARKUP_ERROR_INVALID_CONTENT,
28918  "Dummy error for current_error");
28919  break;
28920  case -6:
28921  SEND_TO_CLIENT_OR_FAIL
28922  (XML_ERROR_SYNTAX ("resume_task",
28923  "There is already a task running in"
28924  " this process"));
28925  log_event_fail ("task", "Task",
28927  "resumed");
28928  break;
28929  case -2:
28930  /* Task target lacks hosts. This is checked when the
28931  * target is created. */
28932  assert (0);
28933  /* fallthrough */
28934  case -4:
28935  /* Task lacks target. This is checked when the task is
28936  * created anyway. */
28937  assert (0);
28938  /* fallthrough */
28939  case -1:
28940  case -3: /* Failed to create report. */
28941  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("resume_task"));
28942  log_event_fail ("task", "Task",
28944  "resumed");
28945  break;
28946  case -5:
28947  SEND_XML_SERVICE_DOWN ("resume_task");
28948  log_event_fail ("task", "Task",
28950  "resumed");
28951  break;
28952  case -7:
28953  SEND_TO_CLIENT_OR_FAIL
28954  (XML_ERROR_SYNTAX ("resume_task", "No CA certificate"));
28955  log_event_fail ("task", "Task",
28957  "resumed");
28958  break;
28959  default: /* Programming error. */
28960  assert (0);
28961  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("resume_task"));
28962  log_event_fail ("task", "Task",
28964  "resumed");
28965  break;
28966  }
28967  }
28968  }
28969  else
28970  SEND_TO_CLIENT_OR_FAIL
28971  (XML_ERROR_SYNTAX ("resume_task",
28972  "RESUME_TASK requires a task_id"
28973  " attribute"));
28974  resume_task_data_reset (resume_task_data);
28975  set_client_state (CLIENT_AUTHENTIC);
28976  break;
28977 
28978  case CLIENT_RUN_WIZARD:
28979  if (run_wizard_data->name)
28980  {
28981  gchar *command_error, *command_error_code;
28982  gchar *response = NULL;
28983  int read_only;
28984 
28985  read_only = (run_wizard_data->read_only
28986  && strcmp (run_wizard_data->read_only, "")
28987  && strcmp (run_wizard_data->read_only, "0"));
28988 
28990  (int (*) (void *, gchar *, gchar **))
28991  process_omp,
28992  omp_parser,
28994  read_only,
28996  &command_error,
28997  &command_error_code,
28998  &response))
28999  {
29000  case 3:
29001  /* Parent after a start_task fork. */
29002  forked = 1;
29003  case 0:
29004  {
29005  gchar *msg;
29006  msg = g_strdup_printf
29007  ("<run_wizard_response"
29008  " status=\"%s\""
29009  " status_text=\"%s\">"
29010  "%s%s%s"
29011  "</run_wizard_response>",
29012  command_error_code ? command_error_code
29014  command_error ? command_error
29016  response ? "<response>" : "",
29017  response ? response : "",
29018  response ? "</response>" : "");
29019  if (send_to_client (msg,
29020  write_to_client,
29021  write_to_client_data))
29022  {
29023  g_free (msg);
29024  g_free (response);
29025  error_send_to_client (error);
29026  return;
29027  }
29028  g_free (msg);
29029  g_free (response);
29030  if (run_wizard_data->read_only == 0)
29031  log_event ("wizard", "Wizard", run_wizard_data->name,
29032  "run");
29033  break;
29034  }
29035 
29036  case 1:
29037  {
29038  SEND_TO_CLIENT_OR_FAIL
29039  (XML_ERROR_SYNTAX ("run_wizard",
29040  "NAME characters must be alphanumeric"
29041  " or underscore"));
29042  run_wizard_data_reset (run_wizard_data);
29043  set_client_state (CLIENT_AUTHENTIC);
29044  break;
29045  }
29046 
29047  case 2:
29048  {
29049  /* Process forked to run a task. */
29050  current_error = 2;
29051  g_debug (" %s: run_wizard fork success\n", __FUNCTION__);
29052  g_set_error (error,
29053  G_MARKUP_ERROR,
29054  G_MARKUP_ERROR_INVALID_CONTENT,
29055  "Dummy error for current_error");
29056  break;
29057  }
29058 
29059  case 4:
29060  case 6:
29061  {
29062  gchar *msg;
29063  msg = g_strdup_printf
29064  ("<run_wizard_response"
29065  " status=\"%s\""
29066  " status_text=\"%s\"/>",
29067  command_error_code ? command_error_code
29069  command_error ? command_error : "Internal Error");
29070  if (command_error)
29071  g_free (command_error);
29072  if (send_to_client (msg,
29073  write_to_client,
29074  write_to_client_data))
29075  {
29076  g_free (msg);
29077  error_send_to_client (error);
29078  return;
29079  }
29080  g_free (msg);
29081  log_event_fail ("wizard", "Wizard", run_wizard_data->name,
29082  "run");
29083  break;
29084  }
29085 
29086  case 5:
29087  {
29088  SEND_TO_CLIENT_OR_FAIL
29089  (XML_ERROR_SYNTAX ("run_wizard",
29090  "Wizard is not marked as read only"));
29091  break;
29092  }
29093 
29094  case 99:
29095  {
29096  SEND_TO_CLIENT_OR_FAIL
29097  (XML_ERROR_SYNTAX ("run_wizard",
29098  "Permission denied"));
29099  break;
29100  }
29101 
29102  case -1:
29103  {
29104  /* Internal error. */
29105  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("run_wizard"));
29106  log_event_fail ("wizard", "Wizard", run_wizard_data->name,
29107  "run");
29108  break;
29109  }
29110 
29111  case -2:
29112  {
29113  gchar *msg;
29114  /* to_scanner buffer full. */
29115  msg = g_strdup_printf
29116  ("<run_wizard_response"
29117  " status=\"" STATUS_INTERNAL_ERROR "\""
29118  " status_text=\""
29120  ": Wizard filled up to_scanner buffer\">"
29121  "</run_wizard_response>");
29122  if (send_to_client (msg,
29123  write_to_client,
29124  write_to_client_data))
29125  {
29126  g_free (msg);
29127  error_send_to_client (error);
29128  return;
29129  }
29130  g_free (msg);
29131  log_event_fail ("wizard", "Wizard", run_wizard_data->name,
29132  "run: to_scanner buffer full");
29133  break;
29134  }
29135 
29136  case -10:
29137  {
29138  /* Process forked to run a task. Task start failed. */
29139  current_error = -10;
29140  g_debug (" %s: run_wizard fork error\n", __FUNCTION__);
29141  g_set_error (error,
29142  G_MARKUP_ERROR,
29143  G_MARKUP_ERROR_INVALID_CONTENT,
29144  "Dummy error for current_error");
29145  break;
29146  }
29147  }
29148  }
29149  else
29150  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_SYNTAX ("run_wizard",
29151  "RUN_WIZARD requires a NAME"
29152  " element"));
29153  run_wizard_data_reset (run_wizard_data);
29154  set_client_state (CLIENT_AUTHENTIC);
29155  break;
29156 
29157  CLOSE (CLIENT_RUN_WIZARD, MODE);
29159  CLOSE (CLIENT_RUN_WIZARD, PARAMS);
29162 
29164  assert (strcasecmp ("PARAM", element_name) == 0);
29166  run_wizard_data->param = NULL;
29167  set_client_state (CLIENT_RUN_WIZARD_PARAMS);
29168  break;
29169 
29170  case CLIENT_START_TASK:
29171  if (start_task_data->task_id)
29172  {
29173  if (forked == 2)
29174  /* Prevent the forked child from forking again, as then both
29175  * forked children would be using the same server session. */
29176  abort ();
29177  else
29178  {
29179  char *report_id = NULL;
29180 
29181  switch (start_task (start_task_data->task_id, &report_id))
29182  {
29183  case 0:
29184  {
29185  gchar *msg;
29186  msg = g_strdup_printf
29187  ("<start_task_response"
29188  " status=\"" STATUS_OK_REQUESTED "\""
29189  " status_text=\""
29191  "\">"
29192  "<report_id>%s</report_id>"
29193  "</start_task_response>",
29194  report_id ?: "0");
29195  g_free (report_id);
29196  if (send_to_client (msg,
29197  write_to_client,
29198  write_to_client_data))
29199  {
29200  g_free (msg);
29201  error_send_to_client (error);
29202  return;
29203  }
29204  g_free (msg);
29205  log_event ("task", "Task", start_task_data->task_id,
29206  "requested to start");
29207  }
29208  forked = 1;
29209  break;
29210  case 1:
29211  SEND_TO_CLIENT_OR_FAIL
29212  (XML_ERROR_SYNTAX ("start_task",
29213  "Task is active already"));
29214  log_event_fail ("task", "Task",
29216  "started");
29217  break;
29218  case 2:
29219  /* Forked task process: success. */
29220  current_error = 2;
29221  g_debug (" %s: start_task fork success\n", __FUNCTION__);
29222  g_set_error (error,
29223  G_MARKUP_ERROR,
29224  G_MARKUP_ERROR_INVALID_CONTENT,
29225  "Dummy error for current_error");
29226  break;
29227  case 3: /* Find failed. */
29228  if (send_find_error_to_client ("start_task", "task",
29230  omp_parser))
29231  {
29232  error_send_to_client (error);
29233  return;
29234  }
29235  break;
29236  case 99:
29237  SEND_TO_CLIENT_OR_FAIL
29238  (XML_ERROR_SYNTAX ("start_task",
29239  "Permission denied"));
29240  log_event_fail ("task", "Task",
29242  "started");
29243  break;
29244  case -2:
29245  /* Task lacks target. This is true for container
29246  * tasks. */
29247  SEND_TO_CLIENT_OR_FAIL
29248  (XML_ERROR_SYNTAX ("start_task",
29249  "Task must have a target"));
29250  log_event_fail ("task", "Task",
29252  "started");
29253  break;
29254  case -4:
29255  /* Task target lacks hosts. This is checked when the
29256  * target is created. */
29257  assert (0);
29258  /* fallthrough */
29259  case -9:
29260  /* Fork failed. */
29261  /* fallthrough */
29262  case -3: /* Failed to create report. */
29263  case -1:
29264  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("start_task"));
29265  log_event_fail ("task", "Task",
29267  "started");
29268  break;
29269  case -5:
29270  SEND_XML_SERVICE_DOWN ("start_task");
29271  log_event_fail ("task", "Task",
29273  "started");
29274  break;
29275  case -6:
29276  SEND_TO_CLIENT_OR_FAIL
29277  (XML_ERROR_SYNTAX ("start_task",
29278  "There is already a task running in"
29279  " this process"));
29280  log_event_fail ("task", "Task",
29282  "started");
29283  break;
29284  case -7:
29285  SEND_TO_CLIENT_OR_FAIL
29286  (XML_ERROR_SYNTAX ("start_task", "No CA certificate"));
29287  log_event_fail ("task", "Task",
29289  "started");
29290  break;
29291  case -10:
29292  /* Forked task process: error. */
29293  current_error = -10;
29294  g_debug (" %s: start_task fork error\n", __FUNCTION__);
29295  g_set_error (error,
29296  G_MARKUP_ERROR,
29297  G_MARKUP_ERROR_INVALID_CONTENT,
29298  "Dummy error for current_error");
29299  break;
29300  default: /* Programming error. */
29301  assert (0);
29302  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("start_task"));
29303  log_event_fail ("task", "Task",
29305  "started");
29306  break;
29307  }
29308  }
29309  }
29310  else
29311  SEND_TO_CLIENT_OR_FAIL
29312  (XML_ERROR_SYNTAX ("start_task",
29313  "START_TASK requires a task_id attribute"));
29314  start_task_data_reset (start_task_data);
29315  set_client_state (CLIENT_AUTHENTIC);
29316  break;
29317 
29318  case CLIENT_STOP_TASK:
29319  if (stop_task_data->task_id)
29320  {
29321  switch (stop_task (stop_task_data->task_id))
29322  {
29323  case 0: /* Stopped. */
29324  SEND_TO_CLIENT_OR_FAIL (XML_OK ("stop_task"));
29325  log_event ("task", "Task", stop_task_data->task_id,
29326  "stopped");
29327  break;
29328  case 1: /* Stop requested. */
29329  SEND_TO_CLIENT_OR_FAIL (XML_OK_REQUESTED ("stop_task"));
29330  log_event ("task", "Task", stop_task_data->task_id,
29331  "requested to stop");
29332  break;
29333  case 3: /* Find failed. */
29334  if (send_find_error_to_client ("stop_task", "task",
29336  omp_parser))
29337  {
29338  error_send_to_client (error);
29339  return;
29340  }
29341  break;
29342  case 99:
29343  SEND_TO_CLIENT_OR_FAIL
29344  (XML_ERROR_SYNTAX ("stop_task",
29345  "Permission denied"));
29346  log_event_fail ("task", "Task",
29348  "stopped");
29349  break;
29350  case -5:
29351  SEND_XML_SERVICE_DOWN ("stop_task");
29352  log_event_fail ("task", "Task",
29354  "stopped");
29355  break;
29356  case -7:
29357  SEND_TO_CLIENT_OR_FAIL
29358  (XML_ERROR_SYNTAX ("stop_task", "No CA certificate"));
29359  log_event_fail ("task", "Task",
29361  "stopped");
29362  break;
29363  default: /* Programming error. */
29364  assert (0);
29365  case -1:
29366  /* to_scanner is full. */
29369  abort ();
29370  }
29371  }
29372  else
29373  SEND_TO_CLIENT_OR_FAIL
29374  (XML_ERROR_SYNTAX ("stop_task",
29375  "STOP_TASK requires a task_id attribute"));
29376  stop_task_data_reset (stop_task_data);
29377  set_client_state (CLIENT_AUTHENTIC);
29378  break;
29379 
29380  case CLIENT_SYNC_CERT:
29381  assert (current_credentials.username);
29382  if (forked == 2)
29383  /* Prevent the forked child from forking again, as then both
29384  * forked children would be using the same server session. */
29385  abort (); // FIX respond with error or something
29386  else
29387  switch (openvas_sync_feed (cert_sync_script, current_credentials.username, CERT_FEED))
29388  {
29389  case 0:
29390  SEND_TO_CLIENT_OR_FAIL (XML_OK_REQUESTED ("sync_cert"));
29391  forked = 1;
29392  break;
29393  case 1:
29394  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_BUSY ("sync_cert"));
29395  break;
29396  case 2:
29397  /* Forked sync process: success. */
29398  current_error = 4;
29399  g_debug (" %s: sync_cert fork success\n", __FUNCTION__);
29400  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29401  "Dummy error for current_error");
29402  break;
29403  case 11:
29404  /* Forked sync process: success busy. */
29405  current_error = 4;
29406  g_debug (" %s: sync_cert fork success busy\n", __FUNCTION__);
29407  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29408  "Dummy error for current_error");
29409  break;
29410  case 99:
29411  SEND_TO_CLIENT_OR_FAIL
29412  (XML_ERROR_SYNTAX ("sync_cert",
29413  "Permission denied"));
29414  break;
29415  case -10:
29416  /* Forked sync process: error. */
29417  current_error = -10;
29418  g_debug (" %s: sync_cert fork error\n", __FUNCTION__);
29419  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29420  "Dummy error for current_error");
29421  break;
29422  default:
29423  assert (0);
29424  case -1:
29425  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("sync_cert"));
29426  break;
29427  }
29428  set_client_state (CLIENT_AUTHENTIC);
29429  break;
29430 
29431  case CLIENT_SYNC_FEED:
29432  assert (current_credentials.username);
29433  if (forked == 2)
29434  /* Prevent the forked child from forking again, as then both
29435  * forked children would be using the same server session. */
29436  abort (); // FIX respond with error or something
29437  else
29438  switch (openvas_sync_feed (nvt_sync_script, current_credentials.username,
29439  NVT_FEED))
29440  {
29441  case 0:
29442  SEND_TO_CLIENT_OR_FAIL (XML_OK_REQUESTED ("sync_feed"));
29443  forked = 1;
29444  break;
29445  case 1:
29446  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_BUSY ("sync_feed"));
29447  break;
29448  case 2:
29449  /* Forked sync process: success. */
29450  current_error = 4;
29451  g_debug (" %s: sync_feed fork success\n", __FUNCTION__);
29452  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29453  "Dummy error for current_error");
29454  break;
29455  case 11:
29456  /* Forked sync process: success busy. */
29457  current_error = 4;
29458  g_debug (" %s: sync_feed fork success busy\n", __FUNCTION__);
29459  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29460  "Dummy error for current_error");
29461  break;
29462  case -10:
29463  /* Forked sync process: error. */
29464  current_error = -10;
29465  g_debug (" %s: sync_feed fork error\n", __FUNCTION__);
29466  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29467  "Dummy error for current_error");
29468  break;
29469  case 99:
29470  SEND_TO_CLIENT_OR_FAIL
29471  (XML_ERROR_SYNTAX ("sync_feed",
29472  "Permission denied"));
29473  break;
29474  default:
29475  assert (0);
29476  case -1:
29477  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("sync_feed"));
29478  break;
29479  }
29480  set_client_state (CLIENT_AUTHENTIC);
29481  break;
29482 
29483  case CLIENT_SYNC_CONFIG:
29484  assert (strcasecmp ("SYNC_CONFIG", element_name) == 0);
29485  return handle_sync_config (omp_parser, error);
29486 
29487  case CLIENT_SYNC_SCAP:
29488  assert (current_credentials.username);
29489  if (forked == 2)
29490  /* Prevent the forked child from forking again, as then both
29491  * forked children would be using the same server session. */
29492  abort (); // FIX respond with error or something
29493  else
29494  switch (openvas_sync_feed (scap_sync_script, current_credentials.username, SCAP_FEED))
29495  {
29496  case 0:
29497  SEND_TO_CLIENT_OR_FAIL (XML_OK_REQUESTED ("sync_scap"));
29498  forked = 1;
29499  break;
29500  case 1:
29501  SEND_TO_CLIENT_OR_FAIL (XML_ERROR_BUSY ("sync_scap"));
29502  break;
29503  case 2:
29504  /* Forked sync process: success. */
29505  current_error = 4;
29506  g_debug (" %s: sync_scap fork success\n", __FUNCTION__);
29507  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29508  "Dummy error for current_error");
29509  break;
29510  case 11:
29511  /* Forked sync process: success busy. */
29512  current_error = 4;
29513  g_debug (" %s: sync_scap fork success busy\n", __FUNCTION__);
29514  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29515  "Dummy error for current_error");
29516  break;
29517  case 99:
29518  SEND_TO_CLIENT_OR_FAIL
29519  (XML_ERROR_SYNTAX ("sync_scap",
29520  "Permission denied"));
29521  break;
29522  case -10:
29523  /* Forked sync process: error. */
29524  current_error = -10;
29525  g_debug (" %s: sync_scap fork error\n", __FUNCTION__);
29526  g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
29527  "Dummy error for current_error");
29528  break;
29529  default:
29530  assert (0);
29531  case -1:
29532  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR ("sync_scap"));
29533  break;
29534  }
29535  set_client_state (CLIENT_AUTHENTIC);
29536  break;
29537 
29538  case CLIENT_VERIFY_AGENT:
29539  assert (strcasecmp ("VERIFY_AGENT", element_name) == 0);
29541  {
29543  {
29544  case 0:
29545  SEND_TO_CLIENT_OR_FAIL (XML_OK ("verify_agent"));
29546  break;
29547  case 1:
29548  if (send_find_error_to_client
29549  ("verify_agent", "agent", verify_agent_data->agent_id,
29550  omp_parser))
29551  {
29552  error_send_to_client (error);
29553  return;
29554  }
29555  break;
29556  case 99:
29557  SEND_TO_CLIENT_OR_FAIL
29558  (XML_ERROR_SYNTAX ("verify_agent",
29559  "Permission denied"));
29560  break;
29561  default:
29562  SEND_TO_CLIENT_OR_FAIL
29563  (XML_INTERNAL_ERROR ("verify_agent"));
29564  break;
29565  }
29566  }
29567  else
29568  SEND_TO_CLIENT_OR_FAIL
29569  (XML_ERROR_SYNTAX ("verify_agent",
29570  "VERIFY_AGENT requires a agent_id"
29571  " attribute"));
29572  verify_agent_data_reset (verify_agent_data);
29573  set_client_state (CLIENT_AUTHENTIC);
29574  break;
29575 
29577  assert (strcasecmp ("VERIFY_REPORT_FORMAT", element_name) == 0);
29579  {
29580  switch (verify_report_format
29582  {
29583  case 0:
29584  SEND_TO_CLIENT_OR_FAIL (XML_OK ("verify_report_format"));
29585  break;
29586  case 1:
29587  if (send_find_error_to_client
29588  ("verify_report_format", "report format",
29590  omp_parser))
29591  {
29592  error_send_to_client (error);
29593  return;
29594  }
29595  break;
29596  case 99:
29597  SEND_TO_CLIENT_OR_FAIL
29598  (XML_ERROR_SYNTAX ("verify_report_format",
29599  "Permission denied"));
29600  break;
29601  default:
29602  SEND_TO_CLIENT_OR_FAIL
29603  (XML_INTERNAL_ERROR ("verify_report_format"));
29604  break;
29605  }
29606  }
29607  else
29608  SEND_TO_CLIENT_OR_FAIL
29609  (XML_ERROR_SYNTAX ("verify_report_format",
29610  "VERIFY_REPORT_FORMAT requires a report_format_id"
29611  " attribute"));
29612  verify_report_format_data_reset (verify_report_format_data);
29613  set_client_state (CLIENT_AUTHENTIC);
29614  break;
29615 
29616  case CLIENT_VERIFY_SCANNER:
29617  assert (strcasecmp ("VERIFY_SCANNER", element_name) == 0);
29619  {
29620  char *version = NULL;
29621  switch (verify_scanner (verify_scanner_data->scanner_id, &version))
29622  {
29623  case 0:
29624  SENDF_TO_CLIENT_OR_FAIL
29625  ("<verify_scanner_response status=\"" STATUS_OK "\""
29626  " status_text=\"" STATUS_OK_TEXT "\">"
29627  "<version>%s</version>"
29628  "</verify_scanner_response>", version);
29629  break;
29630  case 1:
29631  if (send_find_error_to_client
29632  ("verify_scanner", "scanner",
29633  verify_scanner_data->scanner_id, omp_parser))
29634  {
29635  error_send_to_client (error);
29636  return;
29637  }
29638  break;
29639  case 2:
29640  SEND_TO_CLIENT_OR_FAIL
29641  (XML_ERROR_UNAVAILABLE ("verify_scanner",
29642  "Service unavailable"));
29643  break;
29644  case 3:
29645  SEND_TO_CLIENT_OR_FAIL
29646  (XML_ERROR_SYNTAX ("verify_scanner", "No CA certificate"));
29647  break;
29648  case 99:
29649  SEND_TO_CLIENT_OR_FAIL
29650  (XML_ERROR_SYNTAX ("verify_scanner", "Permission denied"));
29651  break;
29652  default:
29653  SEND_TO_CLIENT_OR_FAIL (XML_INTERNAL_ERROR
29654  ("verify_scanner"));
29655  break;
29656  }
29657  }
29658  else
29659  SEND_TO_CLIENT_OR_FAIL
29660  (XML_ERROR_SYNTAX ("verify_scanner", "VERIFY_SCANNER requires a"
29661  " scanner_id attribute"));
29662  verify_scanner_data_reset (verify_scanner_data);
29663  set_client_state (CLIENT_AUTHENTIC);
29664  break;
29665 
29666  default:
29667  assert (0);
29668  break;
29669  }
29670 }
29671 
29678 #define APPEND(state, dest) \
29679  case state: \
29680  openvas_append_text (dest, text, text_len); \
29681  break;
29682 
29697 static void
29698 omp_xml_handle_text (/* unused */ GMarkupParseContext* context,
29699  const gchar *text,
29700  gsize text_len,
29701  /* unused */ gpointer user_data,
29702  /* unused */ GError **error)
29703 {
29704  if (text_len == 0) return;
29705  g_debug (" XML text: %s\n", text);
29706  switch (client_state)
29707  {
29709  append_to_credentials_username (&current_credentials, text, text_len);
29710  break;
29711 
29713  append_to_credentials_password (&current_credentials, text, text_len);
29714  break;
29715 
29718 
29721 
29724 
29727 
29730 
29731 
29734 
29737 
29740 
29743 
29746 
29749 
29752 
29755 
29758 
29761 
29764 
29767 
29768 
29771 
29774 
29777 
29780 
29783 
29784 
29787 
29788 
29791 
29794 
29797 
29800 
29803 
29804 
29807 
29810 
29811 
29814 
29817 
29820 
29823 
29826 
29829 
29832 
29833 
29836 
29839 
29840 
29843 
29846 
29849 
29852 
29855 
29858 
29859 
29862 
29865 
29868 
29871 
29874 
29877 
29880 
29883 
29884 
29887 
29890 
29893 
29896 
29897 
29900 
29903 
29906 
29909 
29912 
29915 
29918 
29921 
29924 
29927 
29930 
29933 
29936 
29939 
29942 
29945 
29948 
29951 
29952 
29955 
29958 
29961 
29964 
29967 
29970 
29973 
29976 
29979 
29982 
29985 
29988 
29991 
29994 
29995 
29998 
30001 
30004 
30007 
30010 
30013 
30014 
30017 
30020 
30023 
30024 
30027 
30030 
30033 
30034 
30037 
30040 
30043 
30046 
30049 
30052 
30053 
30056 
30059 
30062 
30065 
30066 
30069 
30072 
30075 
30078 
30081 
30084 
30087 
30088 
30091 
30094 
30097 
30100 
30103 
30106 
30109 
30112 
30115 
30116 
30119 
30122 
30125 
30128 
30131 
30132 
30135 
30138 
30141 
30144 
30145 
30148 
30151 
30154 
30157 
30160 
30163 
30164 
30167 
30170 
30173 
30176 
30177 
30180 
30183 
30186 
30189 
30192 
30193 
30196 
30199 
30200 
30203 
30206 
30209 
30212 
30215 
30218 
30221 
30224 
30225 
30228 
30231 
30234 
30237 
30240 
30243 
30244 
30247 
30250 
30251 
30254 
30257 
30260 
30263 
30266 
30269 
30272 
30275 
30278 
30281 
30284 
30287 
30290 
30293 
30296 
30298  break;
30299 
30300 
30303 
30306 
30309 
30312 
30315 
30318 
30321 
30324 
30327 
30330 
30333 
30336 
30339 
30342 
30345 
30348 
30351 
30354 
30357 
30360 
30363 
30366 
30369 
30372 
30373 
30376 
30379 
30381  &create_tag_data->copy);
30382 
30385 
30387  &create_tag_data->name);
30388 
30391 
30392 
30395 
30398 
30401 
30404 
30407 
30410 
30413 
30416 
30419 
30422 
30425 
30428 
30429 
30432 
30434  append_to_task_comment (create_task_data->task, text, text_len);
30435  break;
30436 
30439 
30442 
30444  append_to_task_name (create_task_data->task, text, text_len);
30445  break;
30446 
30449 
30452 
30455 
30458 
30459 
30462 
30465 
30468 
30471 
30474 
30477 
30478 
30480  {
30481  GList *last = g_list_last (get_aggregates_data->data_columns);
30482  gchar *data_column = last->data;
30483  openvas_append_text (&data_column, text, text_len);
30484  last->data = data_column;
30485  break;
30486  }
30487 
30489  {
30490  GList *last = g_list_last (get_aggregates_data->text_columns);
30491  gchar *text_column = last->data;
30492  openvas_append_text (&text_column, text, text_len);
30493  last->data = text_column;
30494  break;
30495  }
30496 
30499 
30502 
30503 
30506 
30509 
30512 
30515 
30518 
30519 
30522 
30525 
30528 
30529 
30532 
30535 
30538 
30539 
30542 
30543 
30545  &modify_auth_data->key);
30546 
30549 
30550 
30553 
30556 
30559 
30562 
30563 
30566 
30569 
30572 
30573 
30576 
30579 
30582 
30585 
30588 
30591 
30592 
30595 
30598 
30601 
30604 
30607 
30610 
30613 
30616 
30617 
30620 
30623 
30626 
30629 
30630 
30633 
30636 
30637 
30640 
30643 
30646 
30649 
30652 
30655 
30658 
30661 
30664 
30665 
30668 
30671 
30674 
30677 
30680 
30683 
30686 
30689 
30692 
30695 
30698 
30701 
30702 
30705 
30708 
30711 
30713  &modify_tag_data->name);
30714 
30717 
30718 
30721 
30724 
30727 
30730 
30733 
30736 
30739 
30742 
30745 
30746 
30748  &run_wizard_data->mode);
30749 
30751  &run_wizard_data->name);
30752 
30755 
30758 
30759 
30760  default:
30761  /* Just pass over the text. */
30762  break;
30763  }
30764 }
30765 
30775 static void
30776 omp_xml_handle_error (/* unused */ GMarkupParseContext* context,
30777  GError *error,
30778  /* unused */ gpointer user_data)
30779 {
30780  g_debug (" XML ERROR %s\n", error->message);
30781 }
30782 
30783 
30784 /* OMP input processor. */
30785 
30790 extern char from_client[];
30793 
30813 int
30814 init_omp (GSList *log_config, int nvt_cache_mode, const gchar *database,
30815  int max_ips_per_target, int max_email_attachment_size,
30816  int max_email_include_size, int max_email_message_size,
30817  void (*progress) (),
30818  int (*fork_connection) (openvas_connection_t *, gchar*),
30819  int skip_db_check)
30820 {
30821  g_log_set_handler (G_LOG_DOMAIN,
30823  (GLogFunc) openvas_log_func,
30824  log_config);
30825  command_data_init (&command_data);
30826  return init_manage (log_config, nvt_cache_mode, database, max_ips_per_target,
30827  max_email_attachment_size, max_email_include_size,
30828  max_email_message_size,
30829  progress, fork_connection, skip_db_check);
30830 }
30831 
30845 void
30846 init_omp_process (int update_nvt_cache, const gchar *database,
30847  int (*write_to_client) (const char*, void*),
30848  void* write_to_client_data, gchar **disable)
30849 {
30850  forked = 0;
30851  client_state = CLIENT_TOP;
30852  command_data_init (&command_data);
30853  init_manage_process (update_nvt_cache, database);
30855  /* Create the XML parser. */
30856  xml_parser.start_element = omp_xml_handle_start_element;
30857  xml_parser.end_element = omp_xml_handle_end_element;
30858  xml_parser.text = omp_xml_handle_text;
30859  xml_parser.passthrough = NULL;
30860  xml_parser.error = omp_xml_handle_error;
30861  if (xml_context)
30862  g_markup_parse_context_free (xml_context);
30863  xml_context = g_markup_parse_context_new
30864  (&xml_parser,
30865  0,
30866  omp_parser_new (write_to_client, write_to_client_data,
30867  disable),
30868  (GDestroyNotify) omp_parser_free);
30869 }
30870 
30894 int
30896 {
30897  gboolean success;
30898  GError* error = NULL;
30899 
30900  /* Terminate any pending transaction. (force close = TRUE). */
30901  manage_transaction_stop (TRUE);
30902 
30903  /* In the XML parser handlers all writes to the to_scanner buffer must be
30904  * complete OTP commands, because the caller may also write into to_scanner
30905  * between calls to this function (via manage_check_current_task). */
30906 
30907  if (xml_context == NULL) return -1;
30908 
30909  current_error = 0;
30910  success = g_markup_parse_context_parse (xml_context,
30913  &error);
30914  if (success == FALSE)
30915  {
30916  int err;
30917  if (error)
30918  {
30919  err = -4;
30920  if (g_error_matches (error,
30921  G_MARKUP_ERROR,
30922  G_MARKUP_ERROR_UNKNOWN_ELEMENT))
30923  g_debug (" client error: G_MARKUP_ERROR_UNKNOWN_ELEMENT\n");
30924  else if (g_error_matches (error,
30925  G_MARKUP_ERROR,
30926  G_MARKUP_ERROR_INVALID_CONTENT))
30927  {
30928  if (current_error)
30929  {
30930  /* This is the return status for a forked child. */
30931  forked = 2; /* Prevent further forking. */
30932  g_error_free (error);
30933  return current_error;
30934  }
30935  g_debug (" client error: G_MARKUP_ERROR_INVALID_CONTENT\n");
30936  }
30937  else if (g_error_matches (error,
30938  G_MARKUP_ERROR,
30939  G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE))
30940  g_debug (" client error: G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE\n");
30941  else
30942  err = -1;
30943  g_info (" Failed to parse client XML: %s\n", error->message);
30944  g_error_free (error);
30945  }
30946  else
30947  err = -1;
30948  /* In all error cases the caller must cease to call this function as it
30949  * would be too hard, if possible at all, to figure out the position of
30950  * start of the next command. */
30951  return err;
30952  }
30954  if (forked)
30955  return 3;
30956  return 0;
30957 }
30958 
30967 int
30968 process_omp_write (const char* msg, void* buffer)
30969 {
30970  g_debug ("-> client internal: %s\n", msg);
30971  g_string_append ((GString*) buffer, msg);
30972  return FALSE;
30973 }
30974 
30998 static int
30999 process_omp (omp_parser_t *parser, const gchar *command, gchar **response)
31000 {
31001  gboolean success;
31002  GError* error = NULL;
31003  GString *buffer;
31004  int (*client_writer) (const char*, void*);
31005  void* client_writer_data;
31006  GMarkupParseContext *old_xml_context;
31007  client_state_t old_client_state;
31008  command_data_t old_command_data;
31009 
31010  /* Terminate any pending transaction. (force close = TRUE). */
31011  manage_transaction_stop (TRUE);
31012 
31013  if (response) *response = NULL;
31014 
31015  old_xml_context = xml_context;
31016  xml_context = g_markup_parse_context_new (&xml_parser, 0, parser, NULL);
31017  if (xml_context == NULL)
31018  {
31019  xml_context = old_xml_context;
31020  return -1;
31021  }
31022 
31023  old_command_data = command_data;
31024  command_data_init (&command_data);
31025  old_client_state = client_state;
31026  client_state = CLIENT_AUTHENTIC;
31027  buffer = g_string_new ("");
31028  client_writer = parser->client_writer;
31029  client_writer_data = parser->client_writer_data;
31030  parser->client_writer = process_omp_write;
31031  parser->client_writer_data = buffer;
31032  current_error = 0;
31033  success = g_markup_parse_context_parse (xml_context,
31034  command,
31035  strlen (command),
31036  &error);
31037  parser->client_writer = client_writer;
31038  parser->client_writer_data = client_writer_data;
31039  xml_context = old_xml_context;
31040  client_state = old_client_state;
31041  command_data = old_command_data;
31042  if (success == FALSE)
31043  {
31044  int err;
31045  if (error)
31046  {
31047  err = -4;
31048  if (g_error_matches (error,
31049  G_MARKUP_ERROR,
31050  G_MARKUP_ERROR_UNKNOWN_ELEMENT))
31051  g_debug (" client error: G_MARKUP_ERROR_UNKNOWN_ELEMENT\n");
31052  else if (g_error_matches (error,
31053  G_MARKUP_ERROR,
31054  G_MARKUP_ERROR_INVALID_CONTENT))
31055  {
31056  if (current_error)
31057  {
31058  /* This is the return status for a forked child. */
31059  forked = 2; /* Prevent further forking. */
31060  g_error_free (error);
31061  return current_error;
31062  }
31063  g_debug (" client error: G_MARKUP_ERROR_INVALID_CONTENT\n");
31064  }
31065  else if (g_error_matches (error,
31066  G_MARKUP_ERROR,
31067  G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE))
31068  g_debug (" client error: G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE\n");
31069  else
31070  err = -1;
31071  g_info (" Failed to parse client XML: %s\n", error->message);
31072  g_error_free (error);
31073  }
31074  else
31075  err = -1;
31076  return err;
31077  }
31078 
31079  if (response)
31080  *response = g_string_free (buffer, FALSE);
31081  else
31082  g_string_free (buffer, TRUE);
31083 
31084  if (forked)
31085  return 3;
31086  return 0;
31087 }
31088 
31089 /* OMP change processor. */
31090 
31097 int
31099 {
31100  return manage_check_current_task ();
31101 }
gchar * current_source
Definition: omp.c:1798
void append_to_task_comment(task_t, const char *, int)
int init_omp(GSList *log_config, int nvt_cache_mode, const gchar *database, int max_ips_per_target, int max_email_attachment_size, int max_email_include_size, int max_email_message_size, void(*progress)(), int(*fork_connection)(openvas_connection_t *, gchar *), int skip_db_check)
Initialise OMP library.
Definition: omp.c:30814
#define STATUS_OK_REQUESTED
Response code on success, when the operation will finish later.
Definition: omp.c:667
int move_task(const char *task_id, const char *slave_id)
Reassign a task to another slave.
Definition: manage.c:5576
char * reverse_lookup_unify
Boolean. Whether to unify based on reverse lookup.
Definition: omp.c:3709
char * target_port_range(target_t)
const char * report_iterator_uuid(iterator_t *)
int report_format_predefined(report_format_t)
char * smb_credential_id
SMB credential for target.
Definition: omp.c:3717
char * ssh_lsc_port
Port for SSH (deprecated).
Definition: omp.c:3716
array_t * families_static_all
New family selection: static, all NVTs.
Definition: omp.c:3069
long long int filter_t
Definition: manage.h:281
char * copy
UUID of resource to copy.
Definition: omp.c:844
void init_config_task_iterator(iterator_t *, config_t, int)
char * name
Name of role.
Definition: omp.c:3540
int buffer_get_filter_xml(GString *, const char *, const get_data_t *, const char *, const char *)
int copy_port_list(const char *, const char *, const char *, port_list_t *)
const char * override_iterator_new_threat(iterator_t *)
int key
Whether the command included a key element.
Definition: omp.c:1042
int verify_report_format(const char *)
task_t task
ID of new task.
Definition: omp.c:1743
create_scanner_data_t * create_scanner_data
Parser callback data for CREATE_SCANNER.
Definition: omp.c:4426
create_filter_data_t create_filter
create_filter
Definition: omp.c:4215
char * first_time_day_of_month
Day of month schedule must first run.
Definition: omp.c:3604
GSList * curr_group_settings
Settings of currently parsed group.
Definition: omp.c:3238
char * threat
Threat to which to limit override.
Definition: omp.c:1195
void init_omp_process(int update_nvt_cache, const gchar *database, int(*write_to_client)(const char *, void *), void *write_to_client_data, gchar **disable)
Initialise OMP library data for a process.
Definition: omp.c:30846
alert_condition_t
Types of alert conditions.
Definition: manage.h:501
#define INIT_GET(type, capital)
Call init_get for a GET end handler.
Definition: omp.c:13157
Command data for the create_task command.
Definition: omp.c:1728
char * id
ID of resource to restore.
Definition: omp.c:3976
get_scanners_data_t get_scanners
get_scanners
Definition: omp.c:4274
long long int permission_t
Definition: manage.h:296
const char * preference_iterator_name(iterator_t *)
char * result_nvt_oid
OID of NVT for current result.
Definition: omp.c:1375
int start_task(const char *task_id, char **report_id)
Start a task.
Definition: manage.c:5399
const char * result_iterator_nvt_cvss_base(iterator_t *)
const char * report_format_iterator_description(iterator_t *)
int schedule_task_iterator_readable(iterator_t *)
int details
Boolean. Whether to include full details.
Definition: manage.h:312
void buffer_aggregate_xml(GString *xml, iterator_t *aggregate, const gchar *type, const char *group_column, const char *group_column_type, const char *subgroup_column, const char *subgroup_column_type, GArray *data_columns, GArray *data_column_types, GArray *text_columns, GArray *text_column_types, GArray *c_sums)
Buffer XML for an aggregate.
Definition: omp.c:12341
Command data for the get_targets command.
Definition: omp.c:3024
int first
Skip over rows before this number.
Definition: omp.c:2948
void init_cve_dfn_cert_adv_iterator(iterator_t *, const char *, int, const char *)
long long int schedule_t
Definition: manage.h:299
char * key_private
Private key from key.
Definition: omp.c:1044
double aggregate_iterator_max(iterator_t *, int)
Get the maximum from an aggregate iterator.
Definition: manage_sql.c:5953
array_t * groups
IDs of groups.
Definition: omp.c:1790
const char * credential_iterator_auth_algorithm(iterator_t *)
void init_manage_process(int, const gchar *)
Initialize the manage library for a process.
Definition: manage_sql.c:14303
void init_port_list_target_iterator(iterator_t *, port_list_t, int)
#define TO_CLIENT_BUFFER_SIZE
The size of the to_client data buffer, in bytes.
Definition: omp.h:38
const char * tag_iterator_value(iterator_t *)
int user_role_iterator_readable(iterator_t *)
int modify_group(const char *, const char *, const char *, const char *)
int delete_user(const char *, const char *, int, int, const char *, const char *)
delete_credential_data_t delete_credential
delete_credential
Definition: omp.c:4233
const char * filter_iterator_type(iterator_t *)
const char * target_iterator_alive_tests(iterator_t *)
int init_credential_iterator(iterator_t *, const get_data_t *)
char * port
Port.
Definition: manage.h:1181
char * first_time_minute
Minute schedule must first run.
Definition: omp.c:1597
const char * resource_tag_iterator_value(iterator_t *)
get_groups_data_t * get_groups_data
Parser callback data for GET_GROUPS.
Definition: omp.c:4636
const char * report_format_iterator_trust(iterator_t *)
A port range.
Definition: omp.c:1258
char * agent_id
ID of agent to delete.
Definition: omp.c:1830
char * comment
Comment.
Definition: omp.c:3427
int trash
Boolean. Whether to return from trashcan.
Definition: manage.h:318
create_asset_data_t create_asset
create_asset
Definition: omp.c:4211
GSList * log_config
Logging parameters, as passed to setup_log_handlers.
Definition: openvasmd.c:310
array_t * groups
IDs of groups.
Definition: omp.c:3910
int modify_note(note_t, const char *, const char *, const char *, const char *, const char *, const char *, task_t, result_t)
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1987
const char * result_iterator_nvt_xref(iterator_t *)
const char * ovaldef_info_iterator_description(iterator_t *)
modify_config_data_t * modify_config_data
Parser callback data for MODIFY_CONFIG.
Definition: omp.c:4774
char * nvt_oid
OID of NVT to which to limit listing.
Definition: omp.c:2697
Command data for the create_report command.
Definition: omp.c:1357
char * ip
IP.
Definition: manage.h:1193
gchar * hosts
Definition: omp.c:3912
char * default_value
Default value of preference.
Definition: manage.h:1745
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1943
int process_omp_write(const char *msg, void *buffer)
Buffer the response for process_omp.
Definition: omp.c:30968
int config_iterator_nvt_count(iterator_t *)
alert_condition_t alert_condition_from_name(const char *name)
Get an alert condition from a name.
Definition: manage.c:1173
int config_count(const get_data_t *)
get_users_data_t get_users
get_users
Definition: omp.c:4280
Command data for the modify_agent command.
Definition: omp.c:3135
Command data for the delete_tag command.
Definition: omp.c:2204
const char * host_identifier_iterator_os_id(iterator_t *)
const char * host_identifier_iterator_value(iterator_t *)
int resume_task(const char *task_id, char **report_id)
Resume a task.
Definition: manage.c:5543
char * name
Definition: omp.c:1795
char * host
Host.
Definition: manage.h:1178
Command data for the create_role command.
Definition: omp.c:1528
char * name
Name of new group.
Definition: omp.c:1119
const char * override_iterator_nvt_name(iterator_t *)
task_t override_iterator_task(iterator_t *)
int skip
The amount of entries to skip at start.
Definition: omp.c:11964
int order
The sort order.
Definition: manage.h:4102
int modify_scanner(const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *)
void init_nvt_cert_bund_adv_iterator(iterator_t *, const char *, int, const char *)
get_roles_data_t * get_roles_data
Parser callback data for GET_ROLES.
Definition: omp.c:4708
const char * host_identifier_iterator_os_title(iterator_t *)
int set_task_preferences(task_t, array_t *)
char * preference_default
Default value in PREFERENCE.
Definition: omp.c:914
char * hosts
Hosts for new target.
Definition: omp.c:1644
char * credential_id
UUID of credential for new scanner.
Definition: omp.c:1564
Command data for the get_report_formats command.
Definition: omp.c:2835
void buffer_aggregate_wc_xml(GString *xml, iterator_t *aggregate, const gchar *type, const char *group_column, GArray *sort_data, int first_group, int max_groups)
Count words of an aggregate and buffer as XML.
Definition: omp.c:12125
char * name
Name.
Definition: omp.c:3509
char * user_uuid(user_t)
const char * report_format_param_iterator_name(iterator_t *)
char * ifaces
Definition: omp.c:3914
int create_credential(const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, credential_t *)
char * comment
Comment.
Definition: omp.c:1639
char * filter_id
UUID of filter.
Definition: omp.c:1001
long long int credential_t
Definition: manage.h:279
const char * result_iterator_nvt_tag(iterator_t *)
int process_omp_change()
Deal with any changes caused by other processes.
Definition: omp.c:31098
gchar * file_iterator_content_64(file_iterator_t *iterator)
Return the file contents from a file iterator.
Definition: manage.c:7187
scanner_t config_scanner(config_t)
char * name
Config name.
Definition: omp.c:905
char * name
Name of preference.
Definition: manage.h:1739
int cve_info_count(const get_data_t *get)
char * result_id
ID of result to which to limit override.
Definition: omp.c:3833
Command data for the get_results command.
Definition: omp.c:2857
char * param_type_max
Max qualifier of above type.
Definition: omp.c:1475
void init_scanner_task_iterator(iterator_t *, scanner_t)
get_nvts_data_t * get_nvts_data
Parser callback data for GET_NVTS.
Definition: omp.c:4654
Command data for the create_credential command.
Definition: omp.c:1036
char * method
Method of alert, e.g. "Email".
Definition: omp.c:3170
const char * note_iterator_port(iterator_t *)
get_tasks_data_t * get_tasks_data
Parser callback data for GET_TASKS.
Definition: omp.c:4750
char * event
Event that will cause alert.
Definition: omp.c:999
report_format_param_type_t report_format_param_iterator_type(iterator_t *)
char * name
Detail name.
Definition: manage.h:1194
gchar * value
The value.
Definition: omp.c:382
get_notes_data_t get_notes
get_notes
Definition: omp.c:4262
char * filter
Filter term.
Definition: omp.c:2947
char * term
Filter term.
Definition: omp.c:1090
const char * agent_iterator_installer_64(iterator_t *)
modify_target_data_t modify_target
modify_target
Definition: omp.c:4299
char * group_column
Column to group data by.
Definition: omp.c:2421
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2172
create_port_range_data_t * create_port_range_data
Parser callback data for CREATE_PORT_RANGE.
Definition: omp.c:4402
schedule_t task_schedule_uuid(const gchar *)
Return the schedule of a task.
Definition: manage_sql.c:18938
#define MIN_QOD_DEFAULT
Default min quality of detection percentage for filters.
Definition: manage.h:1110
void omp_parser_free(omp_parser_t *omp_parser)
Free an OMP parser.
Definition: omp.c:748
Helper data structure for word counts.
Definition: omp.c:11952
get_preferences_data_t * get_preferences_data
Parser callback data for GET_PREFERENCES.
Definition: omp.c:4684
void set_task_target(task_t, target_t)
Set the target of a task.
Definition: manage_sql.c:18137
const char * report_format_alert_iterator_uuid(iterator_t *)
const char * task_iterator_first_report(iterator_t *)
Get the first report UUID from a task iterator.
Definition: manage_sql.c:14118
char * first_time_year
Year schedule must first run.
Definition: omp.c:1599
int task_target_in_trash(task_t)
Return whether the target of a task is in the trashcan.
Definition: manage_sql.c:18168
int get_certificate_info(const gchar *certificate, time_t *activation_time, time_t *expiration_time, gchar **fingerprint, gchar **issuer)
Gathers info from a certificate.
Definition: manage.c:252
const char * credential_iterator_password(iterator_t *)
gchar * group_name
Name of the current group.
Definition: omp.c:3226
char * ifaces
Definition: omp.c:1793
char * report_id
ID of report to modify.
Definition: omp.c:3486
char * report_format_id
ID of report format to delete.
Definition: omp.c:2118
char * summary
Summary.
Definition: omp.c:1478
void sort_data_free(sort_data_t *)
const char * note_iterator_nvt_type(iterator_t *)
char * severity
Severity score to which to limit note.
Definition: omp.c:1151
int trash_scanner_readable(scanner_t)
char * condition
Condition for alert, e.g. "Always".
Definition: omp.c:3168
void init_family_iterator(iterator_t *, int, const char *, int)
gchar * stat
The statistic to sort by.
Definition: manage.h:4101
int modify_schedule(const char *, const char *, const char *, time_t, time_t, time_t, time_t, const char *)
int target_count(const get_data_t *)
char * result_qod
QoD value of current result.
Definition: omp.c:1377
const char * cve_iterator_cvss(iterator_t *)
#define ELSE_ERROR_CREATE_TASK()
Insert else clause for omp_xml_handle_start_element in create_task.
Definition: omp.c:6530
int alerts
Boolean. Whether to include alerts that use filter.
Definition: omp.c:2549
Command data for the delete_agent command.
Definition: omp.c:1828
gchar * group_users(group_t)
Command data for the start_task command.
Definition: omp.c:4016
time_t schedule_iterator_first_time(iterator_t *)
int tag_iterator_orphan(iterator_t *)
gboolean find_task(const char *id, task_t *)
void init_user_group_iterator(iterator_t *, user_t)
create_target_data_t create_target
create_target
Definition: omp.c:4228
char * login
Login name.
Definition: omp.c:1045
char * type
Type of asset.
Definition: omp.c:880
char * target_id
ID of task target.
Definition: omp.c:1742
char * name
Agent name.
Definition: omp.c:850
const char * config_iterator_nvt_selector(iterator_t *)
get_schedules_data_t get_schedules
get_schedules
Definition: omp.c:4273
char * ssh_port
Port for SSH.
Definition: omp.c:1649
char * scanner_id
ID of scanner to delete.
Definition: omp.c:2171
int modify_report_format(const char *, const char *, const char *, const char *, const char *, const char *, const char *)
const char * report_format_param_iterator_type_name(iterator_t *)
char * resource_type
Resource type, for Super permissions.
Definition: omp.c:3431
int trash_config_readable_uuid(const gchar *)
char * comment
Comment.
Definition: omp.c:904
const char * result_iterator_qod(iterator_t *)
int task_config_in_trash(task_t)
Return whether the config of a task is in the trashcan.
Definition: manage_sql.c:18081
char * config_id
ID of config to delete.
Definition: omp.c:1876
array_t * event_data
Array of pointers. Extra data for event.
Definition: omp.c:3166
long long int alert_t
Definition: manage.h:280
int scanners
Boolean. Whether to return scanners using credential.
Definition: omp.c:2527
long long int report_format_param_iterator_type_min(iterator_t *)
credential_t scanner_iterator_credential(iterator_t *)
#define XML_OK_CREATED_ID(tag)
Expand to XML for a STATUS_OK_CREATED response with s for ID.
Definition: omp.c:5862
Command data for the get_agents command.
Definition: omp.c:2391
resource_t get_iterator_resource(iterator_t *)
const char * result_iterator_original_severity(iterator_t *)
int sort_order
Result sort order: 0 descending, else ascending.
Definition: omp.c:2676
get_data_t get
Get args.
Definition: omp.c:2615
const char * dfn_cert_adv_info_iterator_max_cvss(iterator_t *)
Command data for the create_schedule command.
Definition: omp.c:1590
delete_config_data_t delete_config
delete_config
Definition: omp.c:4234
int task_scanner_in_trash(task_t)
Return whether the scanner of a task is in the trashcan.
Definition: manage_sql.c:18224
int report_counts(const char *, int *, int *, int *, int *, int *, int *, double *, int, int, int)
char * result_scan_nvt_version
Version of NVT used in scan.
Definition: omp.c:1379
char * comment
Comment.
Definition: omp.c:3566
int create_asset_report(const char *, const char *)
char * host_start_host
Host name for start time.
Definition: omp.c:1369
create_credential_data_t create_credential
create_credential
Definition: omp.c:4214
char * copy
UUID of resource to copy.
Definition: omp.c:1146
char * task_config_uuid(task_t)
Return the UUID of the config of a task.
Definition: manage_sql.c:18043
char * active
Whether the tag is active.
Definition: omp.c:3647
modify_role_data_t * modify_role_data
Parser callback data for MODIFY_ROLE.
Definition: omp.c:4858
char * setting_id
Setting.
Definition: omp.c:3681
void manage_reset_currents()
Cleanup as immediately as possible.
Definition: manage_sql.c:17173
const char * manage_scap_update_time()
GET SCAP update time, as a string.
Definition: manage.c:7842
#define XML_INTERNAL_ERROR(tag)
Expand to XML for a STATUS_INTERNAL_ERROR response.
Definition: omp.c:5883
modify_note_data_t * modify_note_data
Parser callback data for MODIFY_NOTE.
Definition: omp.c:4822
Command data for the get_scanners command.
Definition: omp.c:2912
char * subgroup_column
Column to further group data by.
Definition: omp.c:2422
char * type
Type.
Definition: omp.c:1264
char * alert_iterator_filter_name(iterator_t *)
Return the filter name from an alert iterator.
Definition: manage_sql.c:8677
const char * event_name(event_t event)
Get the name of an alert event.
Definition: manage.c:1043
char * observers
Space separated list of observer user names.
Definition: omp.c:3771
long long int role_t
Definition: manage.h:292
void init_credential_target_iterator(iterator_t *, credential_t, int)
modify_permission_data_t modify_permission
modify_permission
Definition: omp.c:4290
char * result_qod_type
QoD type of current result.
Definition: omp.c:1378
char * read_only
Read only flag.
Definition: omp.c:4172
create_alert_data_t create_alert
create_alert
Definition: omp.c:4213
get_reports_data_t * get_reports_data
Parser callback data for GET_REPORTS.
Definition: omp.c:4690
char * alterable
Boolean. Whether task is alterable.
Definition: omp.c:1730
const char * get_iterator_name(iterator_t *)
void host_detail_free(host_detail_t *)
const char * scanner_iterator_host(iterator_t *)
long long int target_t
Definition: manage.h:285
gchar * cve_cvss_base(const gchar *)
char * type
Type of help.
Definition: omp.c:3115
delete_group_data_t delete_group
delete_group
Definition: omp.c:4237
void init_alert_task_iterator(iterator_t *, alert_t, int)
Initialise an alert task iterator.
Definition: manage_sql.c:13591
void manage_set_radius_info(int, gchar *, gchar *)
char * param_value
Param value during ...GRFR_REPORT_FORMAT_PARAM.
Definition: omp.c:1467
int copy_permission(const char *, const char *, permission_t *)
stop_task_data_t * stop_task_data
Parser callback data for STOP_TASK.
Definition: omp.c:4928
Command data for the get_schedules command.
Definition: omp.c:2903
int manage_scap_loaded()
Check whether SCAP is available.
Definition: manage_pg.c:2659
const char * result_iterator_level(iterator_t *)
char * qod
QoD (quality of detection).
Definition: manage.h:1182
int verify_scanner(const char *, char **)
test_alert_data_t test_alert
test_alert
Definition: omp.c:4308
const char * resource_tag_iterator_uuid(iterator_t *)
modify_agent_data_t modify_agent
modify_agent
Definition: omp.c:4282
char * smb_lsc_credential_id
SMB credential (deprecated).
Definition: omp.c:1652
const char * filter_alert_iterator_uuid(iterator_t *)
Command data for the create_tag command.
Definition: omp.c:1696
gchar * new_name
Definition: omp.c:3918
char * esxi_credential_id
ESXi credential for new target.
Definition: omp.c:1653
int manage_count_hosts(const char *, const char *)
void cleanup_report_type_iterator(report_type_iterator_t *iterator)
Cleanup a report type iterator.
Definition: manage.c:6066
int column_is_timestamp(const char *)
delete_override_data_t delete_override
delete_override
Definition: omp.c:4239
char * schedule_id
ID of task schedule.
Definition: omp.c:1740
const char * get_iterator_modification_time(iterator_t *)
int set_task_schedule_periods_id(task_t, int)
Set the schedule periods of a task, given an ID.
Definition: manage_sql.c:18894
char * start_time
Time of the first data point to report on.
Definition: omp.c:2980
void init_cpe_cve_iterator(iterator_t *, const char *, int, const char *)
const char * credential_iterator_type(iterator_t *)
char * ssh_credential_id
SSH credential for new target.
Definition: omp.c:1647
const char * ovaldef_info_iterator_deprecated(iterator_t *)
delete_alert_data_t delete_alert
delete_alert
Definition: omp.c:4235
long long int config_t
Definition: manage.h:278
void init_alert_data_iterator(iterator_t *, alert_t, int, const char *)
Initialise an alert data iterator.
Definition: manage_sql.c:8756
int agent_count(const get_data_t *)
char * name
Name of scanner.
Definition: omp.c:3567
char * host
Host for asset report.
Definition: omp.c:2804
int import
Import flag.
Definition: omp.c:1280
delete_tag_data_t delete_tag
delete_tag
Definition: omp.c:4248
A report format file iterator.
Definition: manage.h:3051
GList * text_columns
Columns to get simple text from.
Definition: omp.c:2420
help_data_t help
help
Definition: omp.c:4281
char * host_uuid(resource_t)
const char * override_iterator_port(iterator_t *)
int init_system_report_type_iterator(report_type_iterator_t *iterator, const char *type, const char *slave_id)
Initialise a system report type iterator.
Definition: manage.c:6041
char * preference_value
New value for preference.
Definition: omp.c:3084
Command data for the modify_report_format command.
Definition: omp.c:3506
char * preference_name
Config preference to modify.
Definition: omp.c:3082
char * comment
New comment for config.
Definition: omp.c:3065
char * active
Whether the note is active.
Definition: omp.c:1145
get_data_t get
Get args.
Definition: omp.c:3047
char * credential_uuid(credential_t)
int manage_max_rows(int)
char * first_time_hour
Hour schedule must first run.
Definition: omp.c:1596
char * trash_credential_uuid(credential_t)
char * copy
UUID of resource to copy.
Definition: omp.c:1118
double aggregate_iterator_mean(iterator_t *, int)
Get the mean from an aggregate iterator.
Definition: manage_sql.c:5969
const char * host_identifier_iterator_source_data(iterator_t *)
char * host_search_phrase
Search phrase result filter.
Definition: omp.c:2800
char * resource_id
Resource.
Definition: omp.c:3430
int manage_run_wizard(const gchar *, int(*)(void *, gchar *, gchar **), void *, array_t *, int, const char *, gchar **, gchar **, gchar **)
delete_tag_data_t * delete_tag_data
Parser callback data for DELETE_TAG.
Definition: omp.c:4564
char * certificate
Certificate.
Definition: omp.c:3327
const char * ovaldef_info_iterator_status(iterator_t *)
int aggregate_iterator_count(iterator_t *)
Get the count from an aggregate iterator.
Definition: manage_sql.c:5923
int find_attribute(const gchar **attribute_names, const gchar **attribute_values, const char *attribute_name, const gchar **attribute_value)
Find an attribute in a parser callback list of attributes.
Definition: omp.c:332
int create_user(const gchar *, const gchar *, const gchar *, int, const gchar *, int, const array_t *, array_t *, gchar **, array_t *, gchar **, gchar **, user_t *, int)
const char * filter_iterator_term(iterator_t *)
int save_tasks()
char * value
Value of the tag.
Definition: omp.c:1703
const char * agent_iterator_trust(iterator_t *)
char * text
Text of override.
Definition: omp.c:1194
char * duration
Duration of schedule (how long it runs for).
Definition: omp.c:1602
int create_target(const char *, const char *, const char *, const char *, const char *, const char *, const char *, credential_t, const char *, credential_t, credential_t, credential_t, const char *, const char *, const char *, int, target_t *)
char * family_selection_family_all_text
Text version of above.
Definition: omp.c:3071
char * copy
UUID of resource to copy.
Definition: omp.c:1087
char * report_id
ID of report to delete.
Definition: omp.c:2096
char * part_name
First part of data during *_data: name.
Definition: omp.c:1006
char * period
Period of schedule (how often it runs).
Definition: omp.c:3609
get_feeds_data_t get_feeds
get_feeds
Definition: omp.c:4258
delete_note_data_t delete_note
delete_note
Definition: omp.c:4238
create_note_data_t create_note
create_note
Definition: omp.c:4217
char * auth_algorithm
SNMP Authentication algorithm.
Definition: omp.c:3326
create_report_format_data_t create_report_format
create_report_format
Definition: omp.c:4223
int names_only
Boolean. Whether to get only distinct names.
Definition: omp.c:3006
unsigned int task_count(const get_data_t *)
Return the number of tasks associated with the current user.
Definition: manage_sql.c:17814
char * get_ovaldi_files()
Get list of ovaldi definitions files using the values in ovaldefs table in scap.db.
Definition: omp.c:13188
char * result_host_asset_id(const char *, result_t)
char * esxi_credential_id
ESXi credential for target.
Definition: omp.c:3719
char * trash_credential_name(credential_t)
const char * note_iterator_severity(iterator_t *)
Command data for the move_task command.
Definition: omp.c:3951
char * report_id
ID of single report to get.
Definition: omp.c:2796
int config_type(config_t)
int create_permission(const char *, const char *, const char *, const char *, const char *, const char *, permission_t *)
char * trash_target_name(target_t)
int targets
Boolean. Whether to return targets using credential.
Definition: omp.c:2528
gchar * value
Value of param.
Definition: manage.h:2931
name_value_t * preference
Current preference.
Definition: omp.c:1738
char * scan_end_time_uuid(const char *)
int report_format_trust(report_format_t)
delete_report_data_t delete_report
delete_report
Definition: omp.c:4243
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2229
int sort_order
Result sort order: 0 descending, else ascending.
Definition: omp.c:2650
modify_tag_data_t modify_tag
modify_tag
Definition: omp.c:4298
delete_scanner_data_t delete_scanner
delete_scanner
Definition: omp.c:4246
gboolean find_result_with_permission(const char *, result_t *, const char *)
int manage_empty_trashcan()
const char * preference_iterator_value(iterator_t *)
int task_result_count(task_t, int)
Return number of results in a task.
Definition: manage_sql.c:18375
Command data for the get_assets command.
Definition: omp.c:2455
char * note_id
ID of note to delete.
Definition: omp.c:1986
get_port_lists_data_t get_port_lists
get_port_lists
Definition: omp.c:4267
char * name
Name of Port List.
Definition: omp.c:3461
#define STATUS_INTERNAL_ERROR
Response code for an internal error.
Definition: omp.c:677
const char * override_iterator_severity(iterator_t *)
int family_selection_family_all
All flag in FAMILY_SELECTION/FAMILY.
Definition: omp.c:3070
const char * credential_target_iterator_uuid(iterator_t *)
void modify_auth_data_reset(modify_auth_data_t *data)
Reset command data.
Definition: omp.c:3247
int set_task_alerts(task_t, array_t *, gchar **)
Set the alerts on a task, removing any previous alerts.
Definition: manage_sql.c:18674
const char * host_detail_iterator_name(iterator_t *)
Command data for the modify_user command.
Definition: omp.c:3908
gchar ** disabled_commands
Disabled commands.
Definition: omp.c:712
char * role_uuid(role_t)
Command data for the get_system_reports command.
Definition: omp.c:2973
create_credential_data_t * create_credential_data
Parser callback data for CREATE_CREDENTIAL.
Definition: omp.c:4360
char * threat
Threat to which to limit override.
Definition: omp.c:1154
char * copy
UUID of resource to copy.
Definition: omp.c:1594
const char * task_group_iterator_uuid(iterator_t *)
gchar * task_second_last_report_id(task_t)
Get report ID from second most recently completed invocation of task.
Definition: manage_sql.c:18640
array_t * method_data
Array of pointer. Extra data for method.
Definition: omp.c:1003
Command data for the delete_permission command.
Definition: omp.c:2015
int notes_details
Boolean. Whether to include details of above.
Definition: omp.c:2801
int params
Boolean. Whether to include params.
Definition: omp.c:2839
create_group_data_t create_group
create_group
Definition: omp.c:4216
const char * get_iterator_owner_name(iterator_t *)
buffer_size_t to_client_start
The start of the data in the to_client buffer.
Definition: omp.c:4984
char * task_id
ID of container task.
Definition: omp.c:1386
array_t * params
Parameters.
Definition: omp.c:4171
Command data for the modify_note command.
Definition: omp.c:3826
char * name
Name of filter.
Definition: omp.c:3372
char * comment
Comment.
Definition: omp.c:3762
char * task_owner_name(task_t)
Return the name of the owner of a task.
Definition: manage_sql.c:17915
int init_asset_host_iterator(iterator_t *, const get_data_t *)
import_config_data_t * import_config_data
Parser callback data for CREATE_CONFIG (import).
Definition: omp.c:4768
move_task_data_t move_task
move_task
Definition: omp.c:4302
get_overrides_data_t * get_overrides_data
Parser callback data for GET_OVERRIDES.
Definition: omp.c:4666
char * copy
UUID of Port List to copy.
Definition: omp.c:1279
char * comment
Comment.
Definition: omp.c:3485
create_agent_data_t create_agent
create_agent
Definition: omp.c:4210
char * result_id
ID of result to which to limit override.
Definition: omp.c:3874
char * preference_value
Value in PREFERENCE.
Definition: omp.c:920
char * setting_filter(const char *)
delete_port_range_data_t * delete_port_range_data
Parser callback data for DELETE_PORT_RANGE.
Definition: omp.c:4528
#define NVT_SELECTOR_TYPE_ANY
Special NVT selector type for selecting all types in interfaces.
Definition: manage.h:2006
char * text
Text of override.
Definition: omp.c:3836
get_filters_data_t * get_filters_data
Parser callback data for GET_FILTERS.
Definition: omp.c:4630
int set_task_parameter(task_t, const char *, char *)
int acl_user_has_super(const char *super_user_id, user_t other_user)
Test whether a user has super permission on another user.
Definition: manage_acl.c:226
A generic SQL iterator.
Definition: iterator.h:52
int init_schedule_iterator(iterator_t *, const get_data_t *)
int init_tag_name_iterator(iterator_t *, const get_data_t *)
char * part_name
First part of data during *_data: name.
Definition: omp.c:3173
char * preference_nvt_oid
NVT OID in PREFERENCE.
Definition: omp.c:918
char * port
Port to which to limit override.
Definition: omp.c:3873
int init_role_iterator(iterator_t *, const get_data_t *)
void init_task_group_iterator(iterator_t *, task_t)
Initialise a task group iterator.
Definition: manage_sql.c:6822
int scanner_iterator_port(iterator_t *)
char * ca_pub
CA Certificate of scanner.
Definition: omp.c:3572
const char * config_timeout_iterator_value(iterator_t *)
char * schedule_periods
Number of periods the schedule must run for.
Definition: omp.c:1741
const char * override_iterator_nvt_type(iterator_t *)
char * duration_unit
Unit of duration: "hour", "day", "week", ....
Definition: omp.c:1603
char * pos
Position of report from end.
Definition: omp.c:2805
char * name
New name for task.
Definition: omp.c:3770
#define ELSE_ERROR(op)
Insert else clause for omp_xml_handle_start_element.
Definition: omp.c:6500
char * task_id
ID of task to stop.
Definition: omp.c:4039
const char * cve_info_iterator_description(iterator_t *)
const char * cve_iterator_name(iterator_t *)
char * nvt_oid
OID of NVT preference affects.
Definition: manage.h:1743
const char * target_iterator_port_list_name(iterator_t *)
get_assets_data_t get_assets
get_assets
Definition: omp.c:4256
move_task_data_t * move_task_data
Parser callback data for MOVE_TASK.
Definition: omp.c:4904
int group_count(const get_data_t *)
char * hr_name
Extended, more human-readable name used by OSP.
Definition: manage.h:1746
char * inheritor_id
ID of user that will inherit owned objects.
Definition: omp.c:2275
char * name
Name of new filter.
Definition: omp.c:1089
char * password
Password associated with login name.
Definition: omp.c:1047
result_t result_iterator_result(iterator_t *)
char * file
File to attach to task.
Definition: omp.c:3767
char * name
Name.
Definition: omp.c:3335
char * host
Host of new scanner.
Definition: omp.c:1560
char * name
Name of asset.
Definition: omp.c:876
char * family
Name of family to which to limit NVT selection.
Definition: omp.c:2645
report_t task_iterator_current_report(iterator_t *)
Return the current report of a task.
Definition: manage_sql.c:18416
gboolean find_credential_with_permission(const char *, credential_t *, const char *)
int copy_override(const char *, override_t *)
int create_schedule(const char *, const char *, time_t, time_t, time_t, time_t, const char *, schedule_t *)
modify_port_list_data_t * modify_port_list_data
Parser callback data for MODIFY_PORT_LIST.
Definition: omp.c:4840
gchar * role_users(role_t)
char * howto_install
Install HOWTO.
Definition: omp.c:845
gchar * column
The column prefix, or NULL.
Definition: manage.h:3430
const char * cert_bund_adv_info_iterator_cve_refs(iterator_t *)
char * installer_signature
Installer signature.
Definition: omp.c:849
char * trash_target_uuid(target_t)
get_data_t get
Get args with result filtering.
Definition: omp.c:2791
int ultimate
Dummy field for generic macros.
Definition: omp.c:1854
const char * user_role_iterator_uuid(iterator_t *)
int report_count(const get_data_t *)
char * preference
Single preference to get.
Definition: omp.c:2768
char * note_id
ID of note to modify.
Definition: omp.c:3830
gchar * credential_value(credential_t, const char *)
Command data for the get_filters command.
Definition: omp.c:2546
const char * result_iterator_descr(iterator_t *)
int count
The number of occurences.
Definition: omp.c:11955
gchar * get_nvti_xml(iterator_t *nvts, int details, int pref_count, int preferences, const char *timeout, config_t config, int close_tag)
Create and return XML description for an NVT.
Definition: manage.c:7658
void manage_get_ldap_info(int *, gchar **, gchar **, int *, gchar **)
const char * permission_iterator_subject_type(iterator_t *)
char * schedule_periods
Number of periods the schedule must run for.
Definition: omp.c:3775
get_overrides_data_t get_overrides
get_overrides
Definition: omp.c:4265
get_data_t get
Get args.
Definition: omp.c:2483
delete_schedule_data_t * delete_schedule_data
Parser callback data for DELETE_SCHEDULE.
Definition: omp.c:4558
get_port_lists_data_t * get_port_lists_data
Parser callback data for GET_PORT_LISTS.
Definition: omp.c:4678
void init_task_role_iterator(iterator_t *, task_t)
Initialise a task role iterator.
Definition: manage_sql.c:6851
char * scanner
Scanner to create config from.
Definition: omp.c:930
resume_task_data_t * resume_task_data
Parser callback data for RESUME_TASK.
Definition: omp.c:4916
char * subject_type
Subject type permission applies to.
Definition: omp.c:1232
char * comment
Comment.
Definition: omp.c:3371
gchar * name
Name.
Definition: manage.h:65
void init_filter_alert_iterator(iterator_t *, filter_t)
Command data for the delete_config command.
Definition: omp.c:1874
int load_tasks()
get_system_reports_data_t * get_system_reports_data
Parser callback data for GET_SYSTEM_REPORTS.
Definition: omp.c:4732
gchar * host_routes_xml(host_t)
char * users
Users for group.
Definition: omp.c:3403
const char * resource_tag_iterator_comment(iterator_t *)
char * iso_time_tz(time_t *, const char *, const char **)
Create an ISO time from seconds since epoch, given a timezone.
Definition: manage_sql.c:1153
char * start
Start.
Definition: omp.c:1263
int families
Boolean. Whether to include config families.
Definition: omp.c:2481
const char * report_format_iterator_extension(iterator_t *)
Command data for the get_alerts command.
Definition: omp.c:2502
gboolean find_schedule_with_permission(const char *, schedule_t *, const char *)
char * name
Name.
Definition: omp.c:1466
int manage_max_hosts()
time_t schedule_iterator_period_months(iterator_t *)
Command data for the verify_report_format command.
Definition: omp.c:4124
Command data for the get_preferences command.
Definition: omp.c:2764
const char * target_task_iterator_uuid(iterator_t *)
int manage_cert_loaded()
Check whether CERT is available.
Definition: manage_pg.c:2643
modify_config_data_t modify_config
modify_config
Definition: omp.c:4286
int alert_iterator_event(iterator_t *)
Return the event from an alert iterator.
Definition: manage_sql.c:8590
int tasks
Boolean. Whether to include tasks that use target.
Definition: omp.c:3027
time_t schedule_iterator_next_time(iterator_t *)
int preferences
Boolean. Whether to include NVT preferences.
Definition: omp.c:2648
Command data for the create_report_format command.
Definition: omp.c:1456
Command data for the modify_config command.
Definition: omp.c:3063
int scanner_iterator_type(iterator_t *)
const char * permission_iterator_subject_uuid(iterator_t *)
char * param_type_min
Min qualifier of above type.
Definition: omp.c:1474
const char * task_alert_iterator_uuid(iterator_t *)
char * comment
Comment.
Definition: omp.c:3137
char * end
End.
Definition: omp.c:1261
char * copy
UUID of resource to copy.
Definition: omp.c:1643
gchar * type_max
Maximum value for integer type.
Definition: manage.h:2929
modify_role_data_t modify_role
modify_role
Definition: omp.c:4294
create_task_data_t create_task
create_task
Definition: omp.c:4229
char * format
Format.
Definition: omp.c:3114
const char * report_format_param_iterator_fallback(iterator_t *)
char * hosts
Hosts to which to limit override.
Definition: omp.c:1147
int tag_iterator_resource_location(iterator_t *)
get_data_t get
Get Args.
Definition: omp.c:2458
void manage_session_set_timezone(const char *)
Setup session timezone.
Definition: manage_pg.c:63
char * credential_id
ID of credential to modify.
Definition: omp.c:3330
char * new_severity
New severity score of overridden results.
Definition: omp.c:1188
const char * note_iterator_text(iterator_t *)
char * port_range_uuid(port_range_t)
modify_target_data_t * modify_target_data
Parser callback data for MODIFY_TARGET.
Definition: omp.c:4888
const char * cert_bund_adv_info_iterator_summary(iterator_t *)
get_alerts_data_t get_alerts
get_alerts
Definition: omp.c:4255
void init_report_iterator_task(iterator_t *, task_t)
task_status_t task_iterator_run_status(iterator_t *)
Get the run status from a task iterator.
Definition: manage_sql.c:14088
gchar * type_min
Minimum value for integer type.
Definition: manage.h:2930
char * copy
UUID of resource to copy.
Definition: omp.c:1735
char * config_id
ID of config to which to limit NVT selection.
Definition: omp.c:2642
#define ALERT_MESSAGE_INCLUDE
Default format string for alert email, when including report.
Definition: manage.h:389
char * port_list_id
Port list for new target.
Definition: omp.c:1645
char * reverse_lookup_unify
Boolean. Whether to unify based on reverse lookup.
Definition: omp.c:1642
int cert_bund_adv_info_count(const get_data_t *get)
const char * alert_method_name(alert_method_t method)
Get the name of an alert method.
Definition: manage.c:1146
get_data_t get
Get args.
Definition: omp.c:2722
const char * nvt_iterator_name(iterator_t *)
long long int nvt_t
Definition: manage.h:294
char * severity
Severity score of results to override.
Definition: omp.c:1192
int alert_iterator_condition(iterator_t *)
Return the condition from an alert iterator.
Definition: manage_sql.c:8606
int result_count(const get_data_t *, report_t, const char *)
#define STATUS_ERROR_MISSING
Response code for a missing resource.
Definition: omp.c:617
char * filt_id
Filter ID. Overrides "filter".
Definition: manage.h:313
char * type
Config type.
Definition: omp.c:921
void init_host_identifier_iterator(iterator_t *, host_t, int, const char *)
char * timezone
Time zone of the schedule.
Definition: omp.c:1604
void set_task_scanner(task_t, scanner_t)
Set the scanner of a task.
Definition: manage_sql.c:18208
char * task_id
ID of task to resume.
Definition: omp.c:3997
char * type
Type of preference (radio, password, ...).
Definition: manage.h:1740
const char * host_identifier_iterator_source_id(iterator_t *)
restore_data_t * restore_data
Parser callback data for RESTORE.
Definition: omp.c:4910
Command data for the delete_report_format command.
Definition: omp.c:2116
Command data for the create_agent command.
Definition: omp.c:841
int importing
Whether the current op is importing.
Definition: omp.c:709
char * nvt_oid(const char *)
get_users_data_t * get_users_data
Parser callback data for GET_USERS.
Definition: omp.c:4756
get_report_formats_data_t get_report_formats
get_report_formats
Definition: omp.c:4270
Command data for the create_target command.
Definition: omp.c:1635
gchar * certificate_iso_time(time_t time)
Converts a certificate time to an ISO time string.
Definition: manage.c:352
char * task_id
ID of task to which to limit override.
Definition: omp.c:3876
char * threat
Threat.
Definition: manage.h:1185
delete_filter_data_t delete_filter
delete_filter
Definition: omp.c:4236
array_t * params_options
Options for all params.
Definition: omp.c:1472
char * inheritor_name
Name of user that will inherit owned objects.
Definition: omp.c:2276
get_data_t get
Get args.
Definition: omp.c:2416
array_t * params
All params.
Definition: omp.c:1476
delete_port_list_data_t delete_port_list
delete_port_list
Definition: omp.c:4241
char * first_time_year
Year schedule must first run.
Definition: omp.c:3608
char * description
Description.
Definition: omp.c:1459
alert_method_t
Types of alerts.
Definition: manage.h:482
Helper data structure for buffering word counts.
Definition: omp.c:11961
char * resource_id
ID of the resource to which to attach the tag.
Definition: omp.c:1699
int parent_state
Parent state when reading over.
Definition: omp.c:711
char * observers
Space separated names of observer users.
Definition: omp.c:1737
int task_uuid(task_t, char **)
Return the UUID of a task.
Definition: manage_sql.c:17885
#define STATUS_INTERNAL_ERROR_TEXT
Response code text for an internal error.
Definition: omp.c:682
gchar * filter_term_value(const char *, const char *)
int modify_credential(const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *)
char * new_threat
New threat value of overridden results.
Definition: omp.c:3870
char * subtype
Resource subtype.
Definition: omp.c:2418
get_assets_data_t * get_assets_data
Parser callback data for GET_ASSETS.
Definition: omp.c:4612
#define ALERT_MESSAGE_ATTACH
Default format string for alert email, when attaching report.
Definition: manage.h:433
modify_task_data_t modify_task
modify_task
Definition: omp.c:4300
char * param_option
Current option of above param.
Definition: omp.c:1470
void init_setting_iterator(iterator_t *, const char *, const char *, int, int, int, const char *)
get_tasks_data_t get_tasks
get_tasks
Definition: omp.c:4279
const char * credential_iterator_private_key(iterator_t *)
char * name
Permission name.
Definition: omp.c:1229
const char * schedule_iterator_timezone(iterator_t *)
char * task_name
Name for container task.
Definition: omp.c:1387
char * smb_credential_id
SMB credential for new target.
Definition: omp.c:1651
Command data for the get_roles command.
Definition: omp.c:2883
int target_iterator_snmp_credential(iterator_t *)
gboolean report_task(report_t, task_t *)
char * detail_name
Name of current host detail.
Definition: omp.c:1359
Command data for the stop_task command.
Definition: omp.c:4037
char * name
Name of the tag.
Definition: omp.c:1702
Command data for the delete_target command.
Definition: omp.c:2226
char * name
Name of permission.
Definition: omp.c:3428
modify_alert_data_t * modify_alert_data
Parser callback data for MODIFY_ALERT.
Definition: omp.c:4786
int process_omp_client_input()
Process any XML available in from_client.
Definition: omp.c:30895
int port_list_iterator_count_all(iterator_t *)
Command data for the get_tags command.
Definition: omp.c:3003
create_report_data_t * create_report_data
Parser callback data for CREATE_REPORT.
Definition: omp.c:4414
time_t note_iterator_end_time(iterator_t *)
char * comment
Comment.
Definition: omp.c:843
char * comment
Comment.
Definition: omp.c:1277
char * method
Method of alert, e.g. "Email".
Definition: omp.c:1002
int report_format_active(report_format_t)
int copy_task(const char *, const char *, const char *, int, task_t *)
#define XML_ERROR_SYNTAX(tag, text)
Expand to XML for a STATUS_ERROR_SYNTAX response.
Definition: omp.c:5754
int init_manage(GSList *, int, const gchar *, int, int, int, int, void(*)(), int(*)(openvas_connection_t *, gchar *), int)
Initialize the manage library.
Definition: manage_sql.c:17065
char * group_uuid(group_t)
char * config_id
ID of new config for task.
Definition: omp.c:3765
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2207
get_notes_data_t * get_notes_data
Parser callback data for GET_NOTES.
Definition: omp.c:4648
char * period_unit
Unit of period: "hour", "day", "week", ....
Definition: omp.c:3610
char * asset_hosts_filter
Asset hosts.
Definition: omp.c:1638
char * task_id
ID of task to start.
Definition: omp.c:4018
char * nvt_oid
Name of single NVT to get.
Definition: omp.c:2646
char * port
Port to which to limit override.
Definition: omp.c:1190
char * key_private
Private key from key.
Definition: omp.c:3333
const char * dfn_cert_adv_info_iterator_cve_refs(iterator_t *)
int init_all_info_iterator(iterator_t *, get_data_t *, const char *)
char * scan_start_time_uuid(const char *)
int report_format_iterator_active(iterator_t *)
void buffer_config_preference_xml(GString *buffer, iterator_t *prefs, config_t config, int hide_passwords)
Buffer XML for the NVT preference of a config.
Definition: omp.c:11120
int alert_iterator_method(iterator_t *)
Return the method from an alert iterator.
Definition: manage_sql.c:8622
create_role_data_t create_role
create_role
Definition: omp.c:4224
int asset_iterator_in_use(iterator_t *)
config_t task_config(task_t)
Return the config of a task.
Definition: manage_sql.c:18016
gboolean find_report_format_with_permission(const char *, report_format_t *, const char *)
int authenticate(credentials_t *)
Authenticate credentials.
Definition: manage_sql.c:17631
long long int result_t
Definition: manage.h:287
int verify_agent(const char *)
A command.
Definition: manage.h:95
array_t * method_data
Array of pointer. Extra data for method.
Definition: omp.c:3171
char * filter_uuid(filter_t)
int asset_os_count(const get_data_t *)
int create_asset_host(const char *, const char *, resource_t *)
void init_host_detail_iterator(iterator_t *, resource_t)
char * comment
Comment.
Definition: omp.c:3203
Command data for the delete_scanner command.
Definition: omp.c:2169
int init_filter_iterator(iterator_t *, const get_data_t *)
char * asset_id
ID of asset to delete.
Definition: omp.c:1852
delete_report_format_data_t * delete_report_format_data
Parser callback data for DELETE_REPORT_FORMAT.
Definition: omp.c:4540
char * name
Name of schedule.
Definition: omp.c:3602
task_status_t task_run_status(task_t)
Return the run state of a task.
Definition: manage_sql.c:18238
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2163
int schedule_count(const get_data_t *)
const char * asset_os_iterator_latest_severity(iterator_t *)
int schedule_info(schedule_t, time_t *, time_t *, int *, int *, int *)
const char * credential_iterator_certificate(iterator_t *)
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1899
char * comment
Comment.
Definition: omp.c:1040
char * target_id
ID of target to delete.
Definition: omp.c:2228
char * summary
Summary.
Definition: omp.c:3513
char * first_time_day_of_month
Day of month schedule must first run.
Definition: omp.c:1595
Command data for the modify_port_list command.
Definition: omp.c:3458
gboolean modify_password
Definition: omp.c:3916
Command data for the delete_role command.
Definition: omp.c:2138
get_agents_data_t * get_agents_data
Parser callback data for GET_AGENTS.
Definition: omp.c:4588
char * login
Login name.
Definition: omp.c:3334
int config_iterator_type(iterator_t *)
char * family_selection_family_name
FAMILY_SELECTION/FAMILY family name.
Definition: omp.c:3074
Command data for the modify_group command.
Definition: omp.c:3398
modify_auth_data_t modify_auth
modify_auth
Definition: omp.c:4285
get_data_t get
Get args.
Definition: omp.c:2885
modify_auth_data_t * modify_auth_data
Parser callback data for MODIFY_AUTH.
Definition: omp.c:4798
modify_scanner_data_t modify_scanner
modify_scanner
Definition: omp.c:4295
#define CLOSE(parent, element)
Insert else clause for omp_xml_handle_start_element.
Definition: omp.c:13008
char * name
Name of new role.
Definition: omp.c:1532
Command data for the create_asset command.
Definition: omp.c:874
char * hosts
Hosts for target.
Definition: omp.c:3710
#define APPEND(state, dest)
Append text to a var for a case in omp_xml_hand_text.
Definition: omp.c:29678
modify_report_format_data_t modify_report_format
modify_report_format
Definition: omp.c:4293
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1965
gchar * user_name(const char *)
const char * credential_full_type(const char *abbreviation)
Get the written-out name of an LSC Credential type.
Definition: manage.c:5797
create_role_data_t * create_role_data
Parser callback data for CREATE_ROLE.
Definition: omp.c:4408
const char * report_format_param_iterator_value(iterator_t *)
const char * override_iterator_new_severity(iterator_t *)
int init_user_iterator(iterator_t *, const get_data_t *)
int modify_tag(const char *, const char *, const char *, const char *, const char *, const char *, const char *)
char * resource_id
ID of the resource to which to attach the tag.
Definition: omp.c:3648
int family_selection_growing
Whether families in selection grow.
Definition: omp.c:3075
int overrides_details
Boolean. Whether to include details of above.
Definition: omp.c:2802
create_schedule_data_t create_schedule
create_schedule
Definition: omp.c:4226
char * type
Type of new filter.
Definition: omp.c:1091
char * report_format_id
ID of report format to verify.
Definition: omp.c:4126
const char * nvt_selector_iterator_nvt(iterator_t *)
get_feeds_data_t * get_feeds_data
Parser callback data for GET_FEEDS.
Definition: omp.c:4624
int alert_task_iterator_readable(iterator_t *)
Get the read permission status from a GET iterator.
Definition: manage_sql.c:13659
char * description
Description of NVT.
Definition: manage.h:1177
char * comment
Comment.
Definition: omp.c:3328
const char * asset_os_iterator_highest_severity(iterator_t *)
gboolean find_alert_with_permission(const char *, alert_t *, const char *)
Find a alert for a specific permission, given a UUID.
Definition: manage_sql.c:6983
const char * tag_name_iterator_name(iterator_t *)
char * file_name
Name of file to attach to task.
Definition: omp.c:3768
const char * result_iterator_nvt_cve(iterator_t *)
modify_scanner_data_t * modify_scanner_data
Parser callback data for MODIFY_SCANNER.
Definition: omp.c:4864
#define STATUS_OK_CREATED
Response code on success, when a resource is created.
Definition: omp.c:657
char * resource_type
Resource type, for special permissions.
Definition: omp.c:1230
int set_task_observers(task_t, const gchar *)
Set the observers of a task.
Definition: manage_sql.c:19148
char * smb_lsc_credential_id
SMB credential for target (deprecated).
Definition: omp.c:3718
const char * target_iterator_hosts(iterator_t *)
gboolean find_target_with_permission(const char *, target_t *, const char *)
gchar * manage_clean_filter_remove(const gchar *, const gchar *)
Clean a filter, removing a keyword in the process.
Definition: manage_sql.c:2743
int target_iterator_snmp_trash(iterator_t *)
const char * nvt_preference_iterator_value(iterator_t *)
#define XML_ERROR_AUTH_FAILED(tag)
Expand to XML for a STATUS_ERROR_AUTH_FAILED response.
Definition: omp.c:5822
int modify_asset(const char *, const char *)
int alert_count(const get_data_t *)
Count the number of alerts.
Definition: manage_sql.c:8489
const char * get_iterator_uuid(iterator_t *)
void(* progress)()
Function to mark progress.
Definition: manage_sql.c:352
char * task_preference_value(task_t, const char *)
int config_iterator_families_growing(iterator_t *)
#define XML_ERROR_BUSY(tag)
Expand to XML for a STATUS_ERROR_BUSY response.
Definition: omp.c:5832
delete_note_data_t * delete_note_data
Parser callback data for DELETE_NOTE.
Definition: omp.c:4504
const char * ovaldef_info_iterator_class(iterator_t *)
gchar * subtype
Subtype, or NULL.
Definition: manage.h:320
const char * override_iterator_threat(iterator_t *)
GList * data_columns
Columns to calculate aggregate for.
Definition: omp.c:2419
const char * config_task_iterator_name(iterator_t *)
A CREATE_REPORT result.
Definition: manage.h:1175
const char * result_iterator_original_level(iterator_t *)
int modify_user(const gchar *, gchar **, const gchar *, const gchar *, const gchar *, int, const gchar *, int, const array_t *, array_t *, gchar **, array_t *, gchar **, gchar **)
char * comment
Comment to add to the tag.
Definition: omp.c:3650
Command data for the delete_user command.
Definition: omp.c:2270
gchar * field
The field to sort by.
Definition: manage.h:4100
create_tag_data_t * create_tag_data
Parser callback data for CREATE_TAG.
Definition: omp.c:4438
int create_role(const char *, const char *, const char *, role_t *)
array_t * nvt_selection
OID array. New NVT set for config.
Definition: omp.c:3079
gboolean find_override_with_permission(const char *, override_t *, const char *)
Command data for the get_nvt_families command.
Definition: omp.c:2674
Command data for the restore command.
Definition: omp.c:3974
int limit
The maximum number of entries to output or -1 for all.
Definition: omp.c:11965
char * override_id
ID of override to get.
Definition: omp.c:2696
int filter_alert_iterator_readable(iterator_t *)
char * sort_field
Field to sort results on.
Definition: omp.c:2950
char * source_type
Source type.
Definition: manage.h:1197
int scanner_task_iterator_readable(iterator_t *)
char * content_type
Content type.
Definition: omp.c:1458
long long int user_t
Definition: manage.h:302
array_t * preferences
Preferences.
Definition: omp.c:1739
result_t note_iterator_result(iterator_t *)
char * manage_nvt_name(nvt_t)
get_nvt_families_data_t get_nvt_families
get_nvt_families
Definition: omp.c:4264
char * value
Value of preference.
Definition: manage.h:1741
char * active
Whether the note is active.
Definition: omp.c:3828
char * type
Requested information type.
Definition: omp.c:2589
int key
Whether the command included a key element.
Definition: omp.c:3331
get_configs_data_t get_configs
get_configs
Definition: omp.c:4254
Command data for the delete_group command.
Definition: omp.c:1962
delete_role_data_t delete_role
delete_role
Definition: omp.c:4245
char * name
Name.
Definition: omp.c:3680
Command data for the modify_credential command.
Definition: omp.c:3323
char * type
Type of scanner.
Definition: omp.c:3570
char * resource_type
Type of the resource to which to attach the tag.
Definition: omp.c:1700
gchar * type
Type (boolean, string, integer, ...).
Definition: manage.h:2928
char * exclude_hosts
Hosts to exclude from set.
Definition: omp.c:1640
int equal
Whether the keyword is like "=example".
Definition: manage.h:3431
Command data for the create_port_list command.
Definition: omp.c:1275
char * detail_value
Value of current host detail.
Definition: omp.c:1360
create_filter_data_t * create_filter_data
Parser callback data for CREATE_FILTER.
Definition: omp.c:4366
int credential_scanner_iterator_readable(iterator_t *)
delete_report_data_t * delete_report_data
Parser callback data for DELETE_REPORT.
Definition: omp.c:4534
long long int group_t
Definition: manage.h:282
const char * result_iterator_qod_type(iterator_t *)
delete_agent_data_t delete_agent
delete_agent
Definition: omp.c:4231
char * term
Term for filter.
Definition: omp.c:3374
Command data for a get command.
Definition: manage.h:310
int init_dfn_cert_adv_info_iterator(iterator_t *, get_data_t *, const char *)
char * signature
Signature.
Definition: omp.c:1477
int filter_count(const get_data_t *)
int cpe_info_count(const get_data_t *get)
Command data for the get_tasks command.
Definition: omp.c:3090
const char * ovaldef_info_iterator_version(iterator_t *)
char * allow_insecure
Whether to allow insecure use.
Definition: omp.c:3325
#define XML_OK(tag)
Expand to XML for a STATUS_OK response.
Definition: omp.c:5842
const char * ovaldef_info_iterator_cve_refs(iterator_t *)
delete_agent_data_t * delete_agent_data
Parser callback data for DELETE_AGENT.
Definition: omp.c:4462
char * nvt_selector_include
In NVT_SELECTORS include/exclude flag.
Definition: omp.c:909
int trash_port_list_readable_uuid(const gchar *)
int credential_iterator_allow_insecure(iterator_t *)
char * copy
UUID of resource to copy.
Definition: omp.c:1185
verify_agent_data_t * verify_agent_data
Parser callback data for VERIFY_AGENT.
Definition: omp.c:4946
char * exclude_hosts
Hosts to exclude from set.
Definition: omp.c:3707
task_t result_iterator_task(iterator_t *)
restore_data_t restore
restore
Definition: omp.c:4303
char * comment
Comment.
Definition: omp.c:3460
gboolean find_nvt(const char *, nvt_t *)
char * scan_end_time(report_t)
Command data for the create_override command.
Definition: omp.c:1182
char * task_id
ID of task to which to limit listing.
Definition: omp.c:2618
int config_nvts_growing(config_t)
create_port_list_data_t * create_port_list_data
Parser callback data for CREATE_PORT_LIST.
Definition: omp.c:4396
gboolean openvas_sync_script_perform_selftest(const gchar *, gchar **)
array_t * details
Host details.
Definition: omp.c:1364
void init_cve_cert_bund_adv_iterator(iterator_t *, const char *, int, const char *)
int copy_credential(const char *, const char *, const char *, credential_t *)
int init_tag_iterator(iterator_t *, const get_data_t *)
int init_note_iterator(iterator_t *, const get_data_t *, nvt_t, result_t, task_t)
char * hosts_ordering
Order for scanning of target hosts.
Definition: omp.c:3763
const char * task_role_iterator_uuid(iterator_t *)
int copy_tag(const char *, const char *, const char *, tag_t *)
char * task_observers(task_t)
Return the observers of a task.
Definition: manage_sql.c:17987
Command data for the modify_filter command.
Definition: omp.c:3369
double aggregate_iterator_sum(iterator_t *, int)
Get the sum from a statistics iterator.
Definition: manage_sql.c:5985
Command data for the delete_schedule command.
Definition: omp.c:2160
long long int port_range_t
Definition: manage.h:298
char * permission_uuid(permission_t)
char * text
Text of override.
Definition: omp.c:3877
Command data for the create_port_range command.
Definition: omp.c:1328
An NVT selector.
Definition: manage.h:1752
get_data_t get
Get args.
Definition: omp.c:2905
get_data_t get
Get args.
Definition: omp.c:2914
char * comment
Comment to add to the tag.
Definition: omp.c:1701
gboolean find_report_with_permission(const char *, report_t *, const char *)
const char * host_identifier_iterator_source_type(iterator_t *)
const char * user_iterator_hosts(iterator_t *)
void manage_report_filter_controls(const gchar *, int *, int *, gchar **, int *, int *, gchar **, gchar **, gchar **, gchar **, int *, int *, int *, int *, int *, gchar **)
Get info from a filter for report.
Definition: manage_sql.c:2474
char * result_host
Host for current result.
Definition: omp.c:1374
#define NVT_FEED
Definition: manage.h:4141
#define NAME
Preference name.
Command data for the modify_asset command.
Definition: omp.c:3201
const char * note_iterator_hosts(iterator_t *)
schedule_t task_schedule(task_t)
Return the schedule of a task.
Definition: manage_sql.c:18911
char * alive_tests
Alive tests.
Definition: omp.c:1637
int create_note(const char *, const char *, const char *, const char *, const char *, const char *, const char *, task_t, result_t, note_t *)
char * format
Format requested: "key", "deb", ....
Definition: omp.c:2525
int modify_override(override_t, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, task_t, result_t)
char * name
Name of agent.
Definition: omp.c:3138
char * nvt_oid
NVT to which to limit override.
Definition: omp.c:1148
char * filter_id
ID of filter to delete.
Definition: omp.c:1942
int manage_resource_name(const char *, const char *, char **)
Get the name of a resource.
Definition: manage_sql.c:4942
create_task_data_t * create_task_data
Parser callback data for CREATE_TASK.
Definition: omp.c:4450
array_t * preferences
Array of preference_t&#39;s.
Definition: omp.c:911
int target_iterator_port_list_trash(iterator_t *)
int user_iterator_hosts_allow(iterator_t *)
const char * scanner_iterator_credential_name(iterator_t *)
int acl_user_can_everything(const char *user_id)
Test whether a user may perform any operation.
Definition: manage_acl.c:179
char * scanner_uuid(scanner_t)
char * comment
Comment.
Definition: omp.c:3706
int manage_set_config_preference(config_t, const char *, const char *, const char *)
int task_upload_progress(task_t)
Return the upload progress of a task.
Definition: manage_sql.c:18460
int create_config_from_scanner(const char *, const char *, const char *, char **)
long long int report_t
Definition: manage.h:288
delete_schedule_data_t delete_schedule
delete_schedule
Definition: omp.c:4247
int override_uuid(override_t, char **)
void init_nvt_dfn_cert_adv_iterator(iterator_t *, const char *, int, const char *)
char * credential_id
ID of Credential to delete.
Definition: omp.c:1920
int resource_count(const char *, const get_data_t *)
Return number of resources of a certain type for current user.
Definition: manage_sql.c:17704
char * name
Credential name.
Definition: omp.c:1046
int wrapper
Whether there was a wrapper REPORT.
Definition: omp.c:1389
void manage_get_radius_info(int *, char **, char **)
char * text
Text of override.
Definition: omp.c:1153
import_config_data_t import
Config to import.
Definition: omp.c:932
char * preferences_config_id
ID of config to get preference values from.
Definition: omp.c:2643
int nvt_preference_count(const char *)
GString * buffer
The GString buffer to write to.
Definition: omp.c:11963
gchar * key
The key.
Definition: omp.c:381
int init_cve_info_iterator(iterator_t *, get_data_t *, const char *)
char * type
Type of report.
Definition: omp.c:2803
Struct for defining a report format param.
Definition: manage.h:2924
array_t * files
All files.
Definition: omp.c:1463
char * value
Value of the tag.
Definition: omp.c:3652
sync_config_data_t * sync_config_data
Parser callback data for SYNC_CONFIG.
Definition: omp.c:4934
const char * port_range_iterator_comment(iterator_t *)
int init_nvt_info_iterator(iterator_t *, get_data_t *, const char *)
create_schedule_data_t * create_schedule_data
Parser callback data for CREATE_SCHEDULE.
Definition: omp.c:4432
get_preferences_data_t get_preferences
get_preferences
Definition: omp.c:4268
const char * agent_iterator_howto_install(iterator_t *)
Command data for the get_overrides command.
Definition: omp.c:2693
Command data for the create_alert command.
Definition: omp.c:993
const char * asset_os_iterator_average_severity(iterator_t *)
GList * sort_data
List of Sort data.
Definition: omp.c:2423
command_data_t command_data
Parser callback data.
Definition: omp.c:4330
char * port_list_id
Port list for target.
Definition: omp.c:3712
const char * task_iterator_last_report(iterator_t *)
Get the last report UUID from a task iterator.
Definition: manage_sql.c:14146
int import
Boolean. Whether to import a format.
Definition: omp.c:1465
char * name
Name of group.
Definition: omp.c:3401
user_t get_iterator_owner(iterator_t *)
int host_first_result
Skip over results before this result number.
Definition: omp.c:2797
char * result_id
ID of result to which to limit override.
Definition: omp.c:1150
const char * host_detail_iterator_source_type(iterator_t *)
char * task_config_name(task_t)
Return the name of the config of a task.
Definition: manage_sql.c:18062
char * report_format_id
ID of report format to modify.
Definition: omp.c:3512
int copy_schedule(const char *, const char *, const char *, schedule_t *)
char * copy
UUID of resource to copy.
Definition: omp.c:1704
get_info_data_t get_info
get_info
Definition: omp.c:4261
task_t make_task(char *, char *, int, int)
modify_credential_data_t * modify_credential_data
Parser callback data for MODIFY_CREDENTIAL.
Definition: omp.c:4804
keyword_relation_t relation
The relation.
Definition: manage.h:3437
char * group_id
Group UUID.
Definition: omp.c:3402
int asset_os_iterator_installs(iterator_t *)
buffer_size_t from_client_start
The start of the data in the from_client buffer.
Definition: ompd.c:84
char * alive_tests
Alive tests.
Definition: omp.c:3705
const char * report_format_alert_iterator_name(iterator_t *)
get_tags_data_t * get_tags_data
Parser callback data for GET_TAGS.
Definition: omp.c:4738
char * name
Name of user to delete.
Definition: omp.c:2272
get_filters_data_t get_filters
get_filters
Definition: omp.c:4259
unsigned int task_id(task_t)
Return the identifier of a task.
Definition: manage_sql.c:17869
Command data for the create_scanner command.
Definition: omp.c:1555
get_data_t get
Get args.
Definition: omp.c:3026
delete_asset_data_t delete_asset
delete_asset
Definition: omp.c:4232
array_t * condition_data
Array of pointers. Extra data for condition.
Definition: omp.c:3169
Command data for the get_credentials command.
Definition: omp.c:2523
target_t task_target(task_t)
Return the target of a task.
Definition: manage_sql.c:18111
int port_list_target_iterator_readable(iterator_t *)
time_t agent_iterator_trust_time(iterator_t *)
char * type
Type of new scanner.
Definition: omp.c:1562
char * new_severity
New severity score of overridden results.
Definition: omp.c:3869
gchar * string
The keyword string, outer quotes removed.
Definition: manage.h:3435
array_t * split_filter(const gchar *)
Split the filter term into parts.
Definition: manage_sql.c:2043
get_data_t get
Get args.
Definition: omp.c:2859
long long int tag_t
Definition: manage.h:284
int request_delete_task_uuid(const char *, int)
char * resource_type
Type of the resource to which to attach the tag.
Definition: omp.c:3649
char * param_name
Name of above param.
Definition: omp.c:1469
char * report_format_name(report_format_t)
char * detail_source_name
Name of source of current host detail.
Definition: omp.c:1361
char * config_id
ID of config to modify.
Definition: omp.c:3066
report_format_param_t report_format_param_iterator_param(iterator_t *)
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2009
char * filter_id
Filter UUID.
Definition: omp.c:3373
gchar * filter_term(const char *)
char * nvt_oid
Single NVT whose preferences to get.
Definition: omp.c:2767
test_alert_data_t * test_alert_data
Parser callback data for TEST_ALERT.
Definition: omp.c:4940
modify_report_format_data_t * modify_report_format_data
Parser callback data for MODIFY_REPORT_FORMAT.
Definition: omp.c:4852
char * severity
Severity score.
Definition: manage.h:1184
char * result_port
Port for current result.
Definition: omp.c:1376
const char * scanner_task_iterator_name(iterator_t *)
char * extension
File extension.
Definition: omp.c:1460
char * resource_id
Resource whose permissions to get.
Definition: omp.c:2723
void * client_writer_data
Argument to client_writer.
Definition: omp.c:708
int task_alterable(task_t)
Return whether a task is an Alterable Task.
Definition: manage_sql.c:14238
char * type
Type of credential.
Definition: omp.c:1052
void manage_filter_controls(const gchar *, int *, int *, gchar **, int *)
Get info from a filter.
Definition: manage_sql.c:2289
#define XML_OK_CREATED(tag)
Expand to XML for a STATUS_OK_CREATED response.
Definition: omp.c:5852
Command data, as passed between OMP parser callbacks.
Definition: omp.c:4208
int target_iterator_esxi_credential(iterator_t *)
create_port_range_data_t create_port_range
create_port_range
Definition: omp.c:4221
char * password
Definition: omp.c:1796
gboolean next_report(iterator_t *, report_t *)
create_alert_data_t * create_alert_data
Parser callback data for CREATE_ALERT.
Definition: omp.c:4354
char * target_id
Target UUID.
Definition: omp.c:3722
int notes_details
Boolean. Whether to include details of above.
Definition: omp.c:2861
const char * cve_info_iterator_authentication(iterator_t *)
modify_group_data_t modify_group
modify_group
Definition: omp.c:4289
char * report_id
ID of report from which to delete assets.
Definition: omp.c:1853
int user_iterator_ifaces_allow(iterator_t *)
int init_report_format_file_iterator(file_iterator_t *iterator, report_format_t report_format)
Initialise a report format file iterator.
Definition: manage.c:7096
char * nvt_selection_family
Family of NVT selection.
Definition: omp.c:3080
const char * param_option_iterator_value(iterator_t *)
const char * override_iterator_hosts(iterator_t *)
modify_asset_data_t modify_asset
modify_asset
Definition: omp.c:4284
int tasks
Boolean. Whether to include tasks that use scan config.
Definition: omp.c:2484
char * scanner_id
ID of new scanner for task.
Definition: omp.c:3764
char * task_id
ID of task to which to limit override.
Definition: omp.c:1152
char * value
Detail value.
Definition: manage.h:1198
char * task_id
Task associated with results.
Definition: omp.c:2860
#define G_LOG_DOMAIN
GLib log domain.
Definition: omp.c:130
Command data for the get_aggregates command.
Definition: omp.c:2414
int sync_config(const char *)
modify_alert_data_t modify_alert
modify_alert
Definition: omp.c:4283
#define XML_OK_REQUESTED(tag)
Expand to XML for a STATUS_OK_REQUESTED response.
Definition: omp.c:5873
char * hosts
Hosts to which to limit override.
Definition: omp.c:3829
char * howto_use
Usage HOWTO.
Definition: omp.c:846
create_asset_data_t * create_asset_data
Parser callback data for CREATE_ASSET.
Definition: omp.c:4342
#define XML_ERROR_UNAVAILABLE(tag, text)
Expand to XML for a STATUS_SERVICE_UNAVAILABLE response.
Definition: omp.c:5802
char * mode
Mode to run the wizard in.
Definition: omp.c:4168
char * port_range
Port range for new target.
Definition: omp.c:1646
modify_task_data_t * modify_task_data
Parser callback data for MODIFY_TASK.
Definition: omp.c:4894
char * hosts
Definition: omp.c:1791
array_t * groups
IDs of new groups for task.
Definition: omp.c:3769
void init_target_task_iterator(iterator_t *, target_t)
gchar * type
Type of resource.
Definition: manage.h:319
char * start
First port.
Definition: omp.c:1333
#define NVT_SELECTOR_TYPE_ALL
NVT selector type for "all" rule.
Definition: manage.h:1991
delete_credential_data_t * delete_credential_data
Parser callback data for DELETE_CREDENTIAL.
Definition: omp.c:4486
get_aggregates_data_t get_aggregates
get_aggregates
Definition: omp.c:4253
char * param_default
Default value for above param.
Definition: omp.c:1468
int setting_is_default_ca_cert(const gchar *)
int targets
Boolean. Include targets that use Port List or not.
Definition: omp.c:2745
int create_filter(const char *, const char *, const char *, const char *, int, filter_t *)
delete_alert_data_t * delete_alert_data
Parser callback data for DELETE_ALERT.
Definition: omp.c:4480
create_target_data_t * create_target_data
Parser callback data for CREATE_TARGET.
Definition: omp.c:4444
char * nvt_oid
NVT to which to limit override.
Definition: omp.c:3831
modify_report_data_t * modify_report_data
Parser callback data for MODIFY_REPORT.
Definition: omp.c:4846
char * alert_id
alert UUID.
Definition: omp.c:3162
Command data for the delete_alert command.
Definition: omp.c:1896
char * report_id
Report UUID.
Definition: omp.c:879
char * schedule_id
ID of new schedule for task.
Definition: omp.c:3774
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2018
int permission_iterator_resource_in_trash(iterator_t *)
char * type
Name of NVT selector.
Definition: manage.h:1755
array_t * nvt_selectors
Array of nvt_selector_t&#39;s.
Definition: omp.c:906
void buffer_results_xml(GString *, iterator_t *, task_t, int, int, int, int, int, int, int, const char *, iterator_t *, int)
Buffer XML for some results.
Definition: omp.c:11579
Command data for the create_group command.
Definition: omp.c:1115
int(* client_writer)(const char *, void *)
Writes to the client.
Definition: omp.c:707
get_targets_data_t get_targets
get_targets
Definition: omp.c:4278
char * setting_id
UUID of single setting to get.
Definition: omp.c:2952
int scanner_count(const get_data_t *)
int manage_schema(gchar *, gchar **, gsize *, gchar **, gchar **)
int nvt_selector_nvt_count(const char *, const char *, int)
char * tag_id
UUID of the tag.
Definition: omp.c:3646
char * comment
Comment.
Definition: omp.c:1227
int user_count(const get_data_t *)
int init_result_get_iterator(iterator_t *, const get_data_t *, report_t, const char *, const gchar *)
int init_asset_os_iterator(iterator_t *, const get_data_t *)
char * config_id
Config UUID.
Definition: omp.c:4063
char * copy
UUID of resource to copy.
Definition: omp.c:1228
int copy_group(const char *, const char *, const char *, group_t *)
long long int agent_t
Definition: manage.h:277
char * snmp_credential_id
SNMP credential for new target.
Definition: omp.c:1655
char * subject_type
Subject type.
Definition: omp.c:3432
const char * cve_info_iterator_vector(iterator_t *)
void init_config_timeout_iterator(iterator_t *, config_t)
scanner_t task_iterator_scanner(iterator_t *)
Get the UUID of task scanner from a task iterator.
Definition: manage_sql.c:14188
void manage_task_update_file(task_t, const char *, const void *)
int copy_filter(const char *, const char *, const char *, filter_t *)
const char * note_iterator_threat(iterator_t *)
Command data for the delete_asset command.
Definition: omp.c:1850
Command data for the import part of the create_config command.
Definition: omp.c:901
char * preference_name
Name in PREFERENCE.
Definition: omp.c:916
const char * credential_target_iterator_name(iterator_t *)
void init_preference_iterator(iterator_t *, config_t)
gchar * slave_id
ID of the slave to move to.
Definition: omp.c:3954
char * report_format_content_type(report_format_t)
modify_override_data_t * modify_override_data
Parser callback data for MODIFY_OVERRIDE.
Definition: omp.c:4828
array_t * families_growing_empty
New family selection: growing, empty.
Definition: omp.c:3067
char * key_phrase
Passphrase for key.
Definition: omp.c:1043
const char * port_range_iterator_uuid(iterator_t *)
get_settings_data_t get_settings
get_settings
Definition: omp.c:4275
const char * schedule_task_iterator_uuid(iterator_t *)
char * target_id
ID of new target for task.
Definition: omp.c:3776
gchar * current_source
Definition: omp.c:3922
array_t * results
All results.
Definition: omp.c:1382
omp_parser_t * omp_parser_new(int(*write_to_client)(const char *, void *), void *write_to_client_data, gchar **disable)
Create an OMP parser.
Definition: omp.c:729
gboolean find_port_list_with_permission(const char *, port_list_t *, const char *)
char * name
Name of single report to get.
Definition: omp.c:2976
create_port_list_data_t create_port_list
create_port_list
Definition: omp.c:4220
const char * task_alert_iterator_name(iterator_t *)
int ignore_pagination
Boolean. Whether to ignore pagination filters.
Definition: omp.c:2806
char * host_end_host
Host name for end time.
Definition: omp.c:1366
const gchar * certificate_time_status(time_t activates, time_t expires)
Tests the activation and expiration time of a certificate.
Definition: manage.c:371
delete_user_data_t * delete_user_data
Parser callback data for DELETE_USER.
Definition: omp.c:4582
char * resource_id
Resource permission applies to.
Definition: omp.c:1231
char * name
Name of new port list.
Definition: omp.c:1281
create_scanner_data_t create_scanner
create_scanner
Definition: omp.c:4225
int setting_count(const char *)
char * period_unit
Unit of period: "hour", "day", "week", ....
Definition: omp.c:1601
const char * port_range_iterator_start(iterator_t *)
char * esxi_lsc_credential_id
ESXi credential for target (deprecated).
Definition: omp.c:3720
char * community
SNMP Community string.
Definition: omp.c:3329
Command data for the get_permissions command.
Definition: omp.c:2720
int report_format_count(const get_data_t *)
int delete_asset(const char *, const char *, int)
get_scanners_data_t * get_scanners_data
Parser callback data for GET_scannerS.
Definition: omp.c:4714
long long int port_list_t
Definition: manage.h:297
const char * keyword_relation_symbol(keyword_relation_t)
Get the symbol of a keyword relation.
Definition: manage_sql.c:1627
char * ssh_lsc_credential_id
SSH credential for target (deprecated).
Definition: omp.c:3714
const char * agent_iterator_installer_filename(iterator_t *)
report_t result_iterator_report(iterator_t *)
const char * user_iterator_ifaces(iterator_t *)
char * hosts
Hosts to which to limit override.
Definition: omp.c:3868
char * installer_filename
Installer filename.
Definition: omp.c:848
const char * user_iterator_method(iterator_t *)
char * type
Type of report.
Definition: omp.c:1388
int manage_send_report(report_t, report_t, report_format_t, const get_data_t *, int, int, int, int, gboolean(*)(const char *, int(*)(const char *, void *), void *), int(*)(const char *, void *), void *, const char *, const char *, const char *, int, const char *, const char *, int, int, const gchar *)
int user_group_iterator_readable(iterator_t *)
const char * scanner_iterator_key_pub(iterator_t *)
int task_schedule_in_trash(task_t)
Get whether the task schedule is in the trash.
Definition: manage_sql.c:18971
const char * permission_iterator_subject_name(iterator_t *)
modify_agent_data_t * modify_agent_data
Parser callback data for MODIFY_AGENT.
Definition: omp.c:4780
int port_list_iterator_count_udp(iterator_t *)
Authentication method settings.
Definition: omp.c:3224
create_note_data_t * create_note_data
Parser callback data for CREATE_NOTE.
Definition: omp.c:4378
char * comment
Comment.
Definition: omp.c:3601
const char * result_iterator_port(iterator_t *)
int note_count(const get_data_t *, nvt_t, result_t, task_t)
char * subject_id
Subject UUID.
Definition: omp.c:3433
int permission_iterator_subject_in_trash(iterator_t *)
const char * result_iterator_scan_nvt_version(iterator_t *)
gchar * name
Definition: omp.c:3917
const char * get_iterator_creation_time(iterator_t *)
int permission_count(const get_data_t *)
char * nvt_oid
OID of NVT to which to limit listing.
Definition: omp.c:2617
array_t * alerts
IDs of alerts.
Definition: omp.c:1734
int details
Boolean. Weather to include full details.
Definition: omp.c:2592
int target_iterator_smb_credential(iterator_t *)
#define STATUS_OK_TEXT
Response code text on success.
Definition: omp.c:652
const char * config_timeout_iterator_nvt_name(iterator_t *)
char * iso_time(time_t *)
Create an ISO time from seconds since epoch.
Definition: manage_sql.c:1138
long long int setting_t
Definition: manage.h:301
int info_name_count(const gchar *, const gchar *)
char * alert_iterator_filter_uuid(iterator_t *)
Return the filter UUID from an alert iterator.
Definition: manage_sql.c:8652
char * result_id
ID of result to which to limit override.
Definition: omp.c:1191
char * nvt_selector_name
In NVT_SELECTORS name of selector.
Definition: omp.c:907
char * nvt_name
Name of NVT preference affects.
Definition: manage.h:1742
const char * run_status_name(task_status_t status)
Get the name of a run status.
Definition: manage.c:1253
char * port_list_id
UUID of Port List.
Definition: omp.c:3462
int init_group_iterator(iterator_t *, const get_data_t *)
char * comment
Comment.
Definition: omp.c:1086
const char * cve_info_iterator_integrity_impact(iterator_t *)
#define SEND_XML_SERVICE_DOWN(tag)
Sends XML for a STATUS_SERVICE_DOWN response.
Definition: omp.c:5893
void init_ovaldi_file_iterator(iterator_t *)
int manage_count_hosts_max(const char *given_hosts, const char *exclude_hosts, int max_hosts)
Return number of hosts described by a hosts string.
Definition: manage_utils.c:374
char * name
Name of the wizard.
Definition: omp.c:4169
modify_permission_data_t * modify_permission_data
Parser callback data for MODIFY_PERMISSION.
Definition: omp.c:4834
const char * task_iterator_trend_counts(iterator_t *, int, int, int, double, int, int, int, double)
get_report_formats_data_t * get_report_formats_data
Parser callback data for GET_REPORT_FORMATS.
Definition: omp.c:4696
int get_counts
Boolean. Whether to include result counts.
Definition: omp.c:2863
char * reverse_lookup_only
Boolean. Whether to consider only hosts that reverse lookup.
Definition: omp.c:3708
char * agent_id
ID of agent to verify.
Definition: omp.c:4105
#define AUTO_DELETE_KEEP_MAX
Definition: manage.h:243
int task_iterator_finished_reports(iterator_t *)
Get the number of reports of a task iterator.
Definition: manage_sql.c:14160
create_group_data_t * create_group_data
Parser callback data for CREATE_GROUP.
Definition: omp.c:4372
char * name
Name of the info.
Definition: omp.c:2590
char * param_name
Param name.
Definition: omp.c:3510
char * scanner_id
New scanner UUID for config.
Definition: omp.c:3078
double aggregate_iterator_min(iterator_t *, int)
Get the minimum from an aggregate iterator.
Definition: manage_sql.c:5937
const char * task_iterator_hosts_ordering(iterator_t *)
Get the hosts ordering value from a task iterator.
Definition: manage_sql.c:14174
get_data_t get
Get args.
Definition: omp.c:3092
char * port
Port of scanner.
Definition: omp.c:3569
const char * os_host_iterator_severity(iterator_t *)
gboolean find_task_with_permission(const char *, task_t *, const char *)
const char * type_name(const char *type)
Return the name of a resource type.
Definition: manage.c:445
int credential_target_iterator_readable(iterator_t *)
const char * asset_os_iterator_title(iterator_t *)
gchar * user_id
Definition: omp.c:3923
gboolean find_filter_with_permission(const char *, filter_t *, const char *)
const char * aggregate_iterator_subgroup_value(iterator_t *)
Get the value of the subgroup column from an aggregate iterator.
Definition: manage_sql.c:6042
array_t * param_options
Options for above param.
Definition: omp.c:1471
delete_permission_data_t * delete_permission_data
Parser callback data for DELETE_PERMISSION.
Definition: omp.c:4516
char * file_name
Name of current file.
Definition: omp.c:1462
get_system_reports_data_t get_system_reports
get_system_reports
Definition: omp.c:4276
const char * cve_info_iterator_cvss(iterator_t *)
const char * task_role_iterator_name(iterator_t *)
const char * get_iterator_comment(iterator_t *)
int append_attribute(const gchar **attribute_names, const gchar **attribute_values, const char *attribute_name, gchar **string)
Find an attribute in a parser callback list of attributes and append.
Definition: omp.c:361
const char * port_range_iterator_end(iterator_t *)
char * detail_source_type
Type of source of current host detail.
Definition: omp.c:1362
Keyword.
Definition: manage.h:3428
int result
Boolean. Whether to include associated results.
Definition: omp.c:2619
char * esxi_lsc_credential_id
ESXi credential (deprecated).
Definition: omp.c:1654
char * subject_id
Subject permission applies to.
Definition: omp.c:1233
verify_scanner_data_t verify_scanner
verify_scanner
Definition: omp.c:4311
int note_iterator_active(iterator_t *)
void init_nvt_preference_iterator(iterator_t *, const char *)
char * active
Whether the override is active.
Definition: omp.c:1184
int init_permission_iterator(iterator_t *, const get_data_t *)
char * severity
Severity score of results to override.
Definition: omp.c:3875
char * type
Type of feed.
Definition: omp.c:2300
Command data for the get_groups command.
Definition: omp.c:2567
int permission_iterator_resource_readable(iterator_t *)
const char * all_info_iterator_type(iterator_t *)
array_t * preferences
Preferences.
Definition: omp.c:3773
int create_group(const char *, const char *, const char *, int, group_t *)
char * reverse_lookup_only
Boolean. Whether to consider only hosts that reverse lookup.
Definition: omp.c:1641
Command data for the modify_scanner command.
Definition: omp.c:3564
Command data for the delete_port_range command.
Definition: omp.c:2059
const char * task_iterator_run_status_name(iterator_t *)
Get the run status name from a task iterator.
Definition: manage_sql.c:14132
gboolean next_file(file_iterator_t *iterator)
Increment a report type iterator.
Definition: manage.c:7159
int create_port_list(const char *, const char *, const char *, const char *, array_t *, port_list_t *)
char * agent_uuid(agent_t)
char * id
ID of single item to get.
Definition: manage.h:317
const char * cert_bund_adv_info_iterator_title(iterator_t *)
int init_resource_tag_iterator(iterator_t *, const char *, resource_t, int, const char *, int)
int create_override(const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, task_t, result_t, override_t *)
int init_get(gchar *command, get_data_t *get, const gchar *setting_name, int *first)
Init for a GET handler.
Definition: omp.c:396
report_t current_report
The report of the current task.
Definition: manage.c:1003
int max_groups
Maximum number of aggregate groups to return.
Definition: omp.c:2425
array_t * groups
IDs of groups.
Definition: omp.c:1736
delete_asset_data_t * delete_asset_data
Parser callback data for DELETE_ASSET.
Definition: omp.c:4468
char * preference_hr_name
Human readable name in PREFERENCE.
Definition: omp.c:915
Command data for the modify_schedule command.
Definition: omp.c:3599
int init_report_iterator(iterator_t *, const get_data_t *)
char * source_name
Source name.
Definition: manage.h:1196
const char * file_iterator_name(file_iterator_t *iterator)
Return the name from a file iterator.
Definition: manage.c:7174
int modify_permission(const char *, const char *, const char *, const char *, const char *, const char *, const char *)
char * type
Type of filter.
Definition: omp.c:3375
char * active
Boolean. Whether report format is active.
Definition: omp.c:3508
const char * target_task_iterator_name(iterator_t *)
int target_task_iterator_readable(iterator_t *)
const char * override_iterator_text(iterator_t *)
int port_list_count(const get_data_t *)
const char * credential_scanner_iterator_name(iterator_t *)
int nvt_info_count(const get_data_t *)
get_info_data_t * get_info_data
Parser callback data for GET_INFO.
Definition: omp.c:4642
const char * cpe_info_iterator_title(iterator_t *)
void set_task_hosts_ordering(task_t, const char *)
Set the hosts ordering of a task.
Definition: manage_sql.c:18152
void init_user_role_iterator(iterator_t *, user_t)
get_data_t get
Get Args.
Definition: omp.c:2591
int copy_target(const char *, const char *, const char *, target_t *)
int create_port_range(const char *, const char *, const char *, const char *, const char *, port_range_t *)
char * filter_name(filter_t)
char * name
Name of the tag.
Definition: omp.c:3651
char * filter_replacement
Filter term to replace the one in filt_id.
Definition: manage.h:316
int nvt_selector_iterator_type(iterator_t *)
modify_user_data_t * modify_user_data
Parser callback data for MODIFY_USER.
Definition: omp.c:4899
const char * ovaldef_info_iterator_max_cvss(iterator_t *)
int read_over
Read over any child elements.
Definition: omp.c:710
array_t * event_data
Array of pointers. Extra data for event.
Definition: omp.c:1000
const char * target_iterator_port_list_uuid(iterator_t *)
char * privacy_password
SNMP Privacy password.
Definition: omp.c:3338
char * result_threat
Message type for current result.
Definition: omp.c:1381
int port_list_iterator_count_tcp(iterator_t *)
char * id
UUID.
Definition: omp.c:1262
int init_ovaldef_info_iterator(iterator_t *, get_data_t *, const char *)
char * task_id
ID of task to modify.
Definition: omp.c:3777
array_t * sources
Definition: omp.c:1799
const char * setting_severity()
name_value_t * param
Current param.
Definition: omp.c:4170
Command data for the modify_report command.
Definition: omp.c:3483
Command data for the modify_auth command.
Definition: omp.c:3233
void init_cve_nvt_iterator(iterator_t *, const char *, int, const char *)
int task_iterator_total_reports(iterator_t *)
Get the number of reports of a task iterator.
Definition: manage_sql.c:14104
GSList * settings
List of auth_conf_setting_t.
Definition: omp.c:3227
gboolean find_trash_task_with_permission(const char *, task_t *, const char *)
char * preference_alt
Single radio alternative in PREFERENCE.
Definition: omp.c:913
Command data for the delete_task command.
Definition: omp.c:2248
gchar * manage_clean_filter(const gchar *)
Clean a filter.
Definition: manage_sql.c:2818
create_port_list_range_t * range
Current port range for import.
Definition: omp.c:1283
scanner_t task_scanner(task_t)
Return the scanner of a task.
Definition: manage_sql.c:18183
long long int report_format_param_iterator_type_max(iterator_t *)
gboolean find_config(const char *, config_t *)
int init_aggregate_iterator(iterator_t *, const char *, const get_data_t *, int, GArray *, const char *, const char *, GArray *, GArray *, int, int, const char *, const char *)
Initialise a GET_AGGREGATES iterator, including observed resources.
Definition: manage_sql.c:5402
char * ovaldef_cves(const char *)
int ifaces_allow
Definition: omp.c:1794
create_permission_data_t * create_permission_data
Parser callback data for CREATE_PERMISSION.
Definition: omp.c:4390
int permission_iterator_subject_readable(iterator_t *)
int init_agent_iterator(iterator_t *, const get_data_t *)
sync_config_data_t sync_config
sync_config
Definition: omp.c:4307
int trash_id_exists(const char *, const char *)
Test Whether a resource of the given type and ID exists in the trash.
Definition: manage_sql.c:17780
char * users
Users for role.
Definition: omp.c:3542
char * scanner_id
ID of scanner to verify.
Definition: omp.c:4147
int config_task_iterator_readable(iterator_t *)
char * override_id
ID of override to delete.
Definition: omp.c:2008
void init_nvt_selector_iterator(iterator_t *, const char *, config_t, int)
modify_port_list_data_t modify_port_list
modify_port_list
Definition: omp.c:4291
char * task_id
ID of task to delete.
Definition: omp.c:2250
int copy_agent(const char *, const char *, const char *, agent_t *)
Command data for the delete_filter command.
Definition: omp.c:1940
char * name
Name of alert.
Definition: omp.c:1004
get_results_data_t * get_results_data
Parser callback data for GET_RESULTS.
Definition: omp.c:4702
char * report_format_extension(report_format_t)
char * comment
Comment.
Definition: omp.c:3400
get_aggregates_data_t * get_aggregates_data
Parser callback data for GET_AGGREGATES.
Definition: omp.c:4594
const char * cve_info_iterator_complexity(iterator_t *)
gchar * fallback
Fallback value.
Definition: manage.h:2926
modify_user_data_t modify_user
modify_user
Definition: omp.c:4301
char * comment
Comment.
Definition: omp.c:929
char * in_assets
Whether to create assets from report.
Definition: omp.c:1371
char * qod_type
QoD type.
Definition: manage.h:1183
delete_config_data_t * delete_config_data
Parser callback data for DELETE_CONFIG.
Definition: omp.c:4474
int alert_iterator_filter_readable(iterator_t *)
Return the filter readable state from an alert iterator.
Definition: manage_sql.c:8720
char * tag_uuid(target_t)
const char * ovaldef_info_iterator_title(iterator_t *)
int role_count(const get_data_t *)
int resource_id_exists(const char *, const char *)
Test whether a resource of the given type and unique ID exists.
Definition: manage_sql.c:17760
const char * result_iterator_nvt_bid(iterator_t *)
int init_cert_bund_adv_info_iterator(iterator_t *, get_data_t *, const char *)
Command data for the delete_report command.
Definition: omp.c:2094
void init_aggregate_lists(const gchar *group_column, const gchar *subgroup_column, GList *data_column_list, GList *text_column_list, GList *sort_data_list, gchar **group_column_type, gchar **subgroup_column_type, GArray **data_column_types, GArray **data_columns, GArray **text_column_types, GArray **text_columns, GArray **sort_data, GArray **c_sums)
Initialize lists for aggregates.
Definition: omp.c:11849
char * alert_id
ID of alert to test.
Definition: omp.c:4084
const char * ovaldef_info_iterator_file(iterator_t *)
const char * cve_info_iterator_products(iterator_t *)
char * task_id
ID of task to which to limit override.
Definition: omp.c:3835
int init_cpe_info_iterator(iterator_t *, get_data_t *, const char *)
char * filter_term
Filter term, for report.
Definition: omp.c:878
char * sort_field
Field to sort results on.
Definition: omp.c:2649
create_override_data_t * create_override_data
Parser callback data for CREATE_OVERRIDE.
Definition: omp.c:4384
Command data for the modify_tag command.
Definition: omp.c:3644
int manage_check_current_task()
Handle state changes to current task made by other processes.
Definition: manage.c:5733
int osp_get_details_from_iterator(iterator_t *, char **, GSList **)
#define SCAP_FEED
Definition: manage.h:4142
char * event
Event that will cause alert.
Definition: omp.c:3165
char to_client[TO_CLIENT_BUFFER_SIZE]
Buffer of output to the client.
Definition: omp.c:4979
#define ALL_LOG_LEVELS
Flag with all Glib log levels.
Definition: manage.h:47
int ifaces_allow
Definition: omp.c:3915
Command data for the create_config command.
Definition: omp.c:927
char * host_start
Start time for a host.
Definition: omp.c:1368
const char * note_iterator_nvt_name(iterator_t *)
result_t override_iterator_result(iterator_t *)
delete_filter_data_t * delete_filter_data
Parser callback data for DELETE_FILTER.
Definition: omp.c:4492
char * password
Password associated with login name.
Definition: omp.c:3336
void cleanup_iterator(iterator_t *)
Cleanup an iterator.
Definition: sql.c:664
#define CERT_FEED
Definition: manage.h:4143
int config_iterator_family_count(iterator_t *)
const char * credential_iterator_login(iterator_t *)
char * ssh_lsc_credential_id
SSH credential (deprecated).
Definition: omp.c:1648
char * config_uuid(config_t)
int timeout
Boolean. Whether to include timeout preference.
Definition: omp.c:2651
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2251
int ultimate
Dummy field for generic macros.
Definition: omp.c:2141
run_wizard_data_t * run_wizard_data
Parser callback data for WIZARD.
Definition: omp.c:4964
time_t schedule_iterator_period(iterator_t *)
char * port_list_id
Port list for new port range.
Definition: omp.c:1332
const char * all_info_iterator_extra(iterator_t *)
const char * config_task_iterator_uuid(iterator_t *)
create_override_data_t create_override
create_override
Definition: omp.c:4218
int permission_is_admin(const char *)
int schedules_only
Whether to to get only schedules and basic info.
Definition: omp.c:3093
char * scan_nvt_version
Version of NVT used at scan time.
Definition: manage.h:1180
Command data for the get_nvts command.
Definition: omp.c:2640
const char * report_format_iterator_summary(iterator_t *)
char * format_id
ID of report format.
Definition: omp.c:2794
const char * report_type_iterator_title(report_type_iterator_t *iterator)
Return the title from a report type iterator.
Definition: manage.c:6109
int nvt_selector_family_growing(const char *, const char *, int)
char * copy
UUID of resource to copy.
Definition: omp.c:1788
Command data for the resume_task command.
Definition: omp.c:3995
int report_progress(report_t, task_t, gchar **)
int create_report(array_t *, const char *, const char *, const char *, const char *, const char *, const char *, array_t *, array_t *, array_t *, char **)
void filter_free(array_t *)
Free a split filter.
Definition: manage_sql.c:2018
char * scan_end
End time for a scan.
Definition: omp.c:1383
int init_alert_iterator(iterator_t *, const get_data_t *)
Initialise an alert iterator, including observed alerts.
Definition: manage_sql.c:8564
void init_schedule_task_iterator(iterator_t *, schedule_t)
int resource_tag_count(const char *, resource_t, int)
help_data_t * help_data
Parser callback data for HELP.
Definition: omp.c:4762
const char * setting_iterator_uuid(iterator_t *)
const char * cpe_info_iterator_max_cvss(iterator_t *)
int import
The import element was present.
Definition: omp.c:903
gboolean openvas_get_sync_script_description(const gchar *, gchar **)
void init_credential_scanner_iterator(iterator_t *, credential_t, int)
Command data for the modify_task command.
Definition: omp.c:3758
array_t * condition_data
Array of pointers. Extra data for condition.
Definition: omp.c:998
An NVT preference.
Definition: manage.h:1737
Command data for the help command.
Definition: omp.c:3112
char * target_name(target_t)
char * comment
Comment.
Definition: omp.c:995
int acl_user_may(const char *operation)
Test whether a user may perform an operation.
Definition: manage_acl.c:56
char * scan_start
Start time for a scan.
Definition: omp.c:1384
char * type
Resource type.
Definition: omp.c:2417
delete_task_data_t delete_task
delete_task
Definition: omp.c:4250
int create_tag(const char *, const char *, const char *, const char *, const char *, const char *, tag_t *)
delete_task_data_t * delete_task_data
Parser callback data for DELETE_TASK.
Definition: omp.c:4576
void init_port_range_iterator(iterator_t *, port_range_t, int, int, const char *)
int copy_note(const char *, note_t *)
get_groups_data_t get_groups
get_groups
Definition: omp.c:4260
const char * port_list_target_iterator_name(iterator_t *)
get_reports_data_t get_reports
get_reports
Definition: omp.c:4269
delete_target_data_t * delete_target_data
Parser callback data for DELETE_TARGET.
Definition: omp.c:4570
int note_uuid(note_t, char **)
const char * result_iterator_host(iterator_t *)
int preference_count
Boolean. Whether to include NVT preference count.
Definition: omp.c:2647
int copy_role(const char *, const char *, const char *, role_t *)
const char * alert_condition_name(alert_condition_t condition)
Get the name of an alert condition.
Definition: manage.c:1016
const char * target_iterator_ssh_port(iterator_t *)
Command data for the verify_agent command.
Definition: omp.c:4103
int openvas_current_sync(const gchar *, gchar **, gchar **)
int ultimate
Dummy field for generic macros.
Definition: omp.c:2097
const char * user_group_iterator_name(iterator_t *)
credentials_t current_credentials
Current credentials during any OMP command.
Definition: manage.c:717
char * task_id
ID of task to which to limit listing.
Definition: omp.c:2698
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2119
int target_iterator_ssh_credential(iterator_t *)
#define g_info(...)
Defines g_info for glib versions older than 2.40.
Definition: manage.h:55
resume_task_data_t resume_task
resume_task
Definition: omp.c:4304
char * result_severity
Severity score for current result.
Definition: omp.c:1380
get_permissions_data_t * get_permissions_data
Parser callback data for GET_PERMISSIONS.
Definition: omp.c:4672
void cleanup_file_iterator(file_iterator_t *iterator)
Cleanup a report type iterator.
Definition: manage.c:7143
#define STATUS_ERROR_SYNTAX
Response code for a syntax error.
Definition: omp.c:592
char * report_uuid(report_t)
char * make_name_unique
Boolean. Whether to make name unique.
Definition: omp.c:1088
int set_task_schedule(task_t, schedule_t, int)
Set the schedule of a task.
Definition: manage_sql.c:18808
int current_error
Hack for returning forked process status from the callbacks.
Definition: omp.c:4969
command_t omp_commands[]
The OMP command list.
Definition: manage_sql.c:422
buffer_size_t from_client_end
The end of the data in the from_client buffer.
Definition: ompd.c:89
delete_report_format_data_t delete_report_format
delete_report_format
Definition: omp.c:4244
int override_count(const get_data_t *, nvt_t, result_t, task_t)
char * duration
Duration into the past to report on.
Definition: omp.c:2977
const char * family_iterator_name(iterator_t *)
const char * cpe_info_iterator_cve_refs(iterator_t *)
A handle on an OMP parser.
Definition: omp.c:705
int copy_config(const char *, const char *, const char *, config_t *)
int scanner_iterator_credential_trash(iterator_t *)
delete_override_data_t * delete_override_data
Parser callback data for DELETE_OVERRIDE.
Definition: omp.c:4510
void manage_set_ldap_info(int, gchar *, gchar *, int, gchar *)
int alerts
Boolean. Whether to include alerts that use Report Format.
Definition: omp.c:2838
char * part_data
Second part of data during *_data: value.
Definition: omp.c:3172
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1877
void set_task_config(task_t, config_t)
Set the config of a task.
Definition: manage_sql.c:18095
char * alert_uuid(alert_t)
Return the UUID of an alert.
Definition: manage_sql.c:8348
create_tag_data_t create_tag
create_tag
Definition: omp.c:4227
modify_group_data_t * modify_group_data
Parser callback data for MODIFY_GROUP.
Definition: omp.c:4816
char * condition
Condition for alert, e.g. "Always".
Definition: omp.c:997
void make_task_complete(const char *)
const char * preference_iterator_hr_name(iterator_t *)
get_data_t report_get
Get args with report filtering.
Definition: omp.c:2792
char * name
Name for new schedule.
Definition: omp.c:1592
int copy_user(const char *, const char *, const char *, user_t *)
modify_setting_data_t modify_setting
modify_setting
Definition: omp.c:4297
array_t * host_starts
All host starts.
Definition: omp.c:1370
char * auth_algorithm
SNMP Authentication algorithm.
Definition: omp.c:1049
char * config_id
Config whose preference values to get.
Definition: omp.c:2766
const char * note_iterator_nvt_oid(iterator_t *)
array_t * roles
IDs of roles.
Definition: omp.c:3920
char * permission_id
Permission UUID.
Definition: omp.c:3429
gchar * value
Value for current auth_conf_setting.
Definition: omp.c:3236
get_data_t get
Get args.
Definition: omp.c:2569
int target_iterator_esxi_trash(iterator_t *)
int copy_scanner(const char *, const char *, const char *, scanner_t *)
int request_delete_task(task_t *)
char * detail_source_desc
Description of source of current detail.
Definition: omp.c:1363
void manage_transaction_stop(gboolean)
int alert_iterator_filter_trash(iterator_t *)
Return the location of an alert iterator filter.
Definition: manage_sql.c:8702
Command data for the wizard command.
Definition: omp.c:4166
int report_timestamp(const char *, gchar **)
char * ssh_port
Port for SSH.
Definition: omp.c:3715
int manage_set_config(config_t, const char *, const char *, const char *)
const char * result_iterator_nvt_name(iterator_t *)
char * ssh_credential_id
SSH credential for target.
Definition: omp.c:3713
Command data for the modify_alert command.
Definition: omp.c:3160
start_task_data_t start_task
start_task
Definition: omp.c:4305
char * privacy_password
SNMP Privacy password.
Definition: omp.c:1050
run_wizard_data_t wizard
run_wizard
Definition: omp.c:4312
const char * port_range_iterator_type(iterator_t *)
int modify_filter(const char *, const char *, const char *, const char *, const char *)
char * end_time
Time of the last data point to report on.
Definition: omp.c:2978
char * host_end
End time for a host.
Definition: omp.c:1365
gboolean find_filter(const char *, filter_t *)
char * mode
Special aggregate mode.
Definition: omp.c:2426
char * scanner_id
ID of task scanner.
Definition: omp.c:1733
int details
Boolean. Whether to include full NVT details.
Definition: omp.c:2644
int family_nvt_count(const char *)
char * privacy_algorithm
SNMP Privacy algorithm.
Definition: omp.c:3337
const char * override_iterator_nvt_oid(iterator_t *)
int tasks
Boolean. Whether to include tasks that use this schedule.
Definition: omp.c:2906
modify_setting_data_t * modify_setting_data
Parser callback data for MODIFY_SETTING.
Definition: omp.c:4876
int modify_alert(const char *, const char *, const char *, const char *, event_t, GPtrArray *, alert_condition_t, GPtrArray *, alert_method_t, GPtrArray *)
Modify an alert.
Definition: manage_sql.c:7894
Command data.
Definition: omp.c:2945
char * severity
Severity score to which to limit note.
Definition: omp.c:3834
char * schedule_id
Schedule UUID.
Definition: omp.c:3603
modify_asset_data_t * modify_asset_data
Parser callback data for MODIFY_ASSET.
Definition: omp.c:4792
char * override_id
ID of override to modify.
Definition: omp.c:3872
int host_max_results
Maximum number of results return.
Definition: omp.c:2798
char * family_selection_family_growing_text
Text version of above.
Definition: omp.c:3073
int create_report_format(const char *, const char *, const char *, const char *, const char *, const char *, int, array_t *, array_t *, array_t *, const char *, report_format_t *)
int task_schedule_periods(task_t)
Get the number of times the period schedule should run on the task.
Definition: manage_sql.c:18987
char * file
Current file during ...GRFR_REPORT_FORMAT_FILE.
Definition: omp.c:1461
long long int note_t
Definition: manage.h:293
const char * setting_iterator_comment(iterator_t *)
client_state_t
Possible states of the client.
Definition: omp.c:5022
const char * nvt_iterator_oid(iterator_t *)
char * make_name_unique
Boolean. Whether to make name unique.
Definition: omp.c:1656
create_permission_data_t create_permission
create_permission
Definition: omp.c:4219
const char * aggregate_iterator_text(iterator_t *, int, int)
Get the value of a text column from an aggregate iterator.
Definition: manage_sql.c:6003
GSList * groups
List of auth_group_t.
Definition: omp.c:3237
char * hosts
Hosts to which to limit override.
Definition: omp.c:1186
int task_schedule_next_time(task_t)
Get next time a scheduled task will run, following schedule timezone.
Definition: manage_sql.c:19021
delete_scanner_data_t * delete_scanner_data
Parser callback data for DELETE_SCANNER.
Definition: omp.c:4552
char * alert_id
ID of alert to delete.
Definition: omp.c:1898
char * allow_insecure
Whether to allow insecure use.
Definition: omp.c:1038
const char * dfn_cert_adv_info_iterator_summary(iterator_t *)
char * new_threat
New threat value of overridden results.
Definition: omp.c:1187
char * end
Last port.
Definition: omp.c:1331
gchar * task_id
ID of the task to move.
Definition: omp.c:3953
char * delta_report_id
ID of report to compare single report to.
Definition: omp.c:2793
Command data for the modify_setting command.
Definition: omp.c:3678
Command data for the create_permission command.
Definition: omp.c:1225
create_config_data_t * create_config_data
Parser callback data for CREATE_CONFIG.
Definition: omp.c:4348
gboolean openvas_get_sync_script_feed_version(const gchar *, gchar **)
const char * report_format_iterator_signature(iterator_t *)
char * user_id
ID of user to delete.
Definition: omp.c:2273
modify_filter_data_t * modify_filter_data
Parser callback data for MODIFY_FILTER.
Definition: omp.c:4810
int acl_user_can_super_everyone(const char *uuid)
Check whether a user is a Super Admin.
Definition: manage_acl.c:127
int manage_set_config_families(config_t, GPtrArray *, GPtrArray *, GPtrArray *, int)
const char * scanner_iterator_ca_pub(iterator_t *)
void free_tasks()
int overrides_details
Boolean. Whether to include details of above.
Definition: omp.c:2862
int dfn_cert_adv_info_count(const get_data_t *get)
char * port_list_uuid(port_list_t)
const char * ovaldi_file_iterator_name(iterator_t *)
char * name
Name of new target.
Definition: omp.c:1657
modify_report_data_t modify_report
modify_report
Definition: omp.c:4292
char * port
Port to which to limit override.
Definition: omp.c:3832
int create_config(const char *, const char *, const array_t *, const array_t *, const char *, config_t *, char **)
char * certificate
Certificate for client certificate auth.
Definition: omp.c:1039
get_targets_data_t * get_targets_data
Parser callback data for GET_TARGETS.
Definition: omp.c:4744
char * name
Name for new scanner.
Definition: omp.c:1557
#define CLOSE_READ_OVER(parent, element)
Insert else clause for omp_xml_handle_start_element.
Definition: omp.c:13022
const char * permission_iterator_resource_uuid(iterator_t *)
char * scanner_name(scanner_t)
char * result_description
Description of NVT for current result.
Definition: omp.c:1373
get_data_t get
Get args.
Definition: omp.c:2504
int quoted
Whether the keyword was quoted.
Definition: manage.h:3434
const char * result_iterator_nvt_oid(iterator_t *)
char * tag_id
ID of tag to delete.
Definition: omp.c:2206
Command data for the get_port_lists command.
Definition: omp.c:2743
char * report_format_uuid(report_format_t)
scanner_type
Scanner types.
Definition: manage.h:267
char * slave_id
Slave that reports apply to, 0 for local Manager.
Definition: omp.c:2979
char * nvt_oid
OID of NVT.
Definition: manage.h:1179
get_data_t get
Get args.
Definition: omp.c:2695
const char * host_detail_iterator_source_id(iterator_t *)
int manage_test_alert(const char *, gchar **)
Test an alert.
Definition: manage_sql.c:13084
#define AUTO_DELETE_KEEP_MIN
Definition: manage.h:238
char * source_desc
Source description.
Definition: manage.h:1195
A system report type iterator.
Definition: manage.h:2613
const char * tag_iterator_resource_type(iterator_t *)
int openvas_sync_feed(const gchar *, const gchar *, int)
int task_in_trash(task_t)
Return whether a task is in the trashcan.
Definition: manage_sql.c:17900
int report_scan_run_status(report_t, int *)
get_settings_data_t * get_settings_data
Parser callback data for GET_SETTINGS.
Definition: omp.c:4726
gboolean find_note_with_permission(const char *, note_t *, const char *)
int target_iterator_ssh_trash(iterator_t *)
int ovaldef_info_count(const get_data_t *get)
get_permissions_data_t get_permissions
get_permissions
Definition: omp.c:4266
time_t report_format_iterator_trust_time(iterator_t *)
char * port
Port of new scanner.
Definition: omp.c:1561
const char * cve_info_iterator_availability_impact(iterator_t *)
int brief
Boolean. Whether respond in brief.
Definition: omp.c:2975
array_t * families_growing_all
New family selection: growing, all NVTs.
Definition: omp.c:3068
int copy_report_format(const char *, const char *, report_format_t *)
get_data_t get
Get args.
Definition: omp.c:2548
int resource_count
Number of attach tags.
Definition: omp.c:3653
get_nvts_data_t get_nvts
get_nvts
Definition: omp.c:4263
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2040
modify_tag_data_t * modify_tag_data
Parser callback data for MODIFY_TAG.
Definition: omp.c:4882
stop_task_data_t stop_task
stop_task
Definition: omp.c:4306
char * name
Name of target.
Definition: omp.c:3711
const char * setting_iterator_name(iterator_t *)
delete_permission_data_t delete_permission
delete_permission
Definition: omp.c:4240
Command data for the delete_credential command.
Definition: omp.c:1918
char * task_comment(task_t)
Return the comment of a task.
Definition: manage_sql.c:17959
int all_info_count(const get_data_t *)
Command data for the get_configs command.
Definition: omp.c:2479
alert_method_t alert_method_from_name(const char *name)
Get an alert method from a name.
Definition: manage.c:1215
const char * target_iterator_reverse_lookup_only(iterator_t *)
const char * credential_iterator_privacy_algorithm(iterator_t *)
int forked
Hack for returning fork status to caller.
Definition: omp.c:4974
int trash_credential_readable(credential_t)
Command data for the modify_target command.
Definition: omp.c:3703
get_data_t get
Get args.
Definition: omp.c:3005
#define STATUS_OK
Response code on success.
Definition: omp.c:647
get_configs_data_t * get_configs_data
Parser callback data for GET_CONFIGS.
Definition: omp.c:4600
char * type
Type of new port range.
Definition: omp.c:1334
#define CASE_DELETE(upper, type, capital)
Insert DELETE case for omp_xml_handle_end_element.
Definition: omp.c:13087
int result_uuid(result_t, char **)
Command data for the modify_target command.
Definition: omp.c:4061
int ultimate
Dummy field for generic macros.
Definition: omp.c:2062
verify_agent_data_t verify_agent
verify_agent
Definition: omp.c:4309
char * comment
Comment.
Definition: omp.c:1559
char * credential_id
UUID of credential of scanner.
Definition: omp.c:3573
const char * report_format_iterator_content_type(iterator_t *)
int modify_setting(const gchar *, const gchar *, const gchar *, gchar **)
time_t override_iterator_end_time(iterator_t *)
int tag_iterator_resource_readable(iterator_t *)
char * name
Name of NVT selector.
Definition: manage.h:1754
int init_task_iterator(iterator_t *, const get_data_t *)
Initialise a task iterator.
Definition: manage_sql.c:14024
char * format
Format requested: "installer", "howto_use", ....
Definition: omp.c:2394
int config_iterator_nvts_growing(iterator_t *)
void init_report_format_alert_iterator(iterator_t *, report_format_t)
char * active
Whether the override is active.
Definition: omp.c:3867
int modify_port_list(const char *, const char *, const char *)
start_task_data_t * start_task_data
Parser callback data for START_TASK.
Definition: omp.c:4922
long long int override_t
Definition: manage.h:295
int modify_report(const char *, const char *)
time_t next_time(time_t first, int period, int period_months, const char *timezone, int periods_offset)
Calculate the next time from now given a start time and a period.
Definition: manage_utils.c:287
char * first_time_minute
Minute schedule must first run.
Definition: omp.c:3606
char * role_id
Role UUID.
Definition: omp.c:3541
get_data_t get
Get args.
Definition: omp.c:2837
char * copy
UUID of resource to copy.
Definition: omp.c:1041
char * alert_id
ID of alert.
Definition: omp.c:2795
const char * permission_iterator_resource_type(iterator_t *)
char * nvt_oid
NVT to which to limit override.
Definition: omp.c:1189
char * comment
Comment on asset.
Definition: omp.c:877
int init_target_iterator(iterator_t *, const get_data_t *)
const char * cpe_info_iterator_status(iterator_t *)
int osp_get_version_from_iterator(iterator_t *, char **, char **, char **, char **, char **, char **)
char * duration_unit
Unit of duration: "hour", "day", "week", ....
Definition: omp.c:3612
int manage_set_config_nvts(config_t, const char *, GPtrArray *)
gboolean next(iterator_t *)
Increment an iterator.
Definition: sql.c:689
int set_task_groups(task_t, array_t *, gchar **)
Set observer groups on a task, removing any previous groups.
Definition: manage_sql.c:18739
char * threat
Threat to which to limit override.
Definition: omp.c:3878
char * period
Period of schedule (how often it runs).
Definition: omp.c:1600
int manage_system_report(const char *name, const char *duration, const char *start_time, const char *end_time, const char *slave_id, char **report)
Get a system report.
Definition: manage.c:6240
Command data for the delete_port_list command.
Definition: omp.c:2037
char * alterable
Boolean. Whether the task is alterable.
Definition: omp.c:3761
Command data for the get_reports command.
Definition: omp.c:2789
char * name
Name of alert.
Definition: omp.c:3163
int first_group
Skip over groups before this group number.
Definition: omp.c:2424
void init_task_alert_iterator(iterator_t *, task_t, event_t event)
Initialise a task alert iterator.
Definition: manage_sql.c:8837
char from_client[]
Buffer of input from the client.
Definition: ompd.c:74
char * target_uuid(target_t)
delete_group_data_t * delete_group_data
Parser callback data for DELETE_GROUP.
Definition: omp.c:4498
char * copy
Config to copy.
Definition: omp.c:931
const char * result_iterator_nvt_family(iterator_t *)
Command data for the verify_scanner command.
Definition: omp.c:4145
char * copy
UUID of alert to copy.
Definition: omp.c:996
char * config_id
ID of task config.
Definition: omp.c:1731
gboolean next_report_type(report_type_iterator_t *iterator)
Increment a report type iterator.
Definition: manage.c:6081
int init_override_iterator(iterator_t *, const get_data_t *, nvt_t, result_t, task_t)
char * port_list_id
ID of port list to delete.
Definition: omp.c:2039
Command data for the modify_role command.
Definition: omp.c:3537
int asset_host_count(const get_data_t *)
array_t * alts
Array of gchar&#39;s. Alternate values for radio type.
Definition: manage.h:1744
gchar * string
The string counted.
Definition: omp.c:11954
char * copy
UUID of scanner to copy.
Definition: omp.c:1558
create_report_data_t create_report
create_report
Definition: omp.c:4222
char * copy
UUID of Report Format to copy.
Definition: omp.c:1479
void add_task_alert(task_t, alert_t)
Add an alert to a task.
Definition: manage_sql.c:18656
delete_port_range_data_t delete_port_range
delete_port_range
Definition: omp.c:4242
char * copy
UUID of resource to copy.
Definition: omp.c:1531
char * ca_pub
CA Certificate of new scanner.
Definition: omp.c:1563
char * installer
Installer content.
Definition: omp.c:847
buffer_size_t to_client_end
The end of the data in the to_client buffer.
Definition: omp.c:4988
const char * alert_task_iterator_uuid(iterator_t *)
Return the uuid from an alert task iterator.
Definition: manage_sql.c:13643
const char * target_iterator_exclude_hosts(iterator_t *)
int copy_alert(const char *, const char *, const char *, alert_t *)
Create an alert from an existing alert.
Definition: manage_sql.c:7814
get_data_t get
Get Args.
Definition: omp.c:2526
char * preference_nvt_name
NVT name in PREFERENCE.
Definition: omp.c:917
get_alerts_data_t * get_alerts_data
Parser callback data for GET_ALERTS.
Definition: omp.c:4606
A simple key/value-pair.
Definition: omp.c:379
char * first_time_month
Month schedule must first run.
Definition: omp.c:3607
char * comment
Comment.
Definition: omp.c:1330
const char * tag_iterator_resource_uuid(iterator_t *)
char * part_data
Second part of data during *_data: value.
Definition: omp.c:1005
int manage_restore(const char *)
char * family_or_nvt
Family or NVT that this selector selects.
Definition: manage.h:1757
const char * setting_iterator_value(iterator_t *)
char * task_id
ID of task to which to limit override.
Definition: omp.c:1193
const char * tag_iterator_resource_name(iterator_t *)
modify_schedule_data_t * modify_schedule_data
Parser callback data for MODIFY_SCHEDULE.
Definition: omp.c:4870
get_nvt_families_data_t * get_nvt_families_data
Parser callback data for GET_NVT_FAMILIES.
Definition: omp.c:4660
int modify_task_check_config_scanner(task_t, const char *, const char *)
void init_nvt_iterator(iterator_t *, nvt_t, config_t, const char *, const char *, int, const char *)
const char * agent_iterator_howto_use(iterator_t *)
modify_credential_data_t modify_credential
modify_credential
Definition: omp.c:4287
modify_schedule_data_t modify_schedule
modify_schedule
Definition: omp.c:4296
char * schedule_uuid(schedule_t)
int tag_iterator_active(iterator_t *)
int nvt_selector_iterator_include(iterator_t *)
int create_scanner(const char *, const char *, const char *, const char *, const char *, scanner_t *, const char *, const char *)
char * hosts_ordering
Order for scanning target hosts.
Definition: omp.c:1732
double result_iterator_severity_double(iterator_t *)
char * nvt_preference_iterator_type(iterator_t *)
char * ssh_lsc_port
Port for SSH (deprecated).
Definition: omp.c:1650
char * threat
Threat to which to limit override.
Definition: omp.c:3837
get_data_t * report_results_get_data(int first, int rows, int apply_overrides, int autofp, int min_qod)
Create a new basic get_data_t struct to get report results.
Definition: manage.c:766
void init_os_host_iterator(iterator_t *, resource_t)
int credential_count(const get_data_t *)
char * first_time_hour
Hour schedule must first run.
Definition: omp.c:3605
int valid_db_resource_type(const char *)
Check whether a resource type table name is valid.
Definition: manage_utils.c:504
unsigned int buffer_size_t
Definition: types.h:31
const char * report_type_iterator_name(report_type_iterator_t *iterator)
Return the name from a report type iterator.
Definition: manage.c:6096
create_user_data_t * create_user_data
Parser callback data for CREATE_USER.
Definition: omp.c:4456
char * type
Requested asset type.
Definition: omp.c:2457
const char * nvt_preference_iterator_name(iterator_t *)
const char * user_group_iterator_uuid(iterator_t *)
int stop_task(const char *task_id)
Initiate stopping a task.
Definition: manage.c:5514
int init_report_format_iterator(iterator_t *, const get_data_t *)
Command data for the modify_permission command.
Definition: omp.c:3425
event_t event_from_name(const char *name)
Get an event from a name.
Definition: manage.c:1196
#define STATUS_OK_CREATED_TEXT
Response code on success, when a resource is created.
Definition: omp.c:662
time_t schedule_iterator_duration(iterator_t *)
array_t * host_ends
All host ends.
Definition: omp.c:1367
int preferences
Boolean. Whether to include config preferences.
Definition: omp.c:2482
char * family_selection_growing_text
Text version of above.
Definition: omp.c:3076
const char * target_iterator_reverse_lookup_unify(iterator_t *)
delete_role_data_t * delete_role_data
Parser callback data for DELETE_ROLE.
Definition: omp.c:4546
gchar * password
Definition: omp.c:3919
char * action
What to do to file: "update" or "remove".
Definition: omp.c:3760
const char * schedule_task_iterator_name(iterator_t *)
gboolean find_scanner_with_permission(const char *, scanner_t *, const char *)
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:2274
name_value_t * preference
Current preference.
Definition: omp.c:3772
int trash_target_readable(target_t)
char * nvt_preference_iterator_real_name(iterator_t *)
const char * task_group_iterator_name(iterator_t *)
get_data_t get
Get args.
Definition: omp.c:2393
int modify_target(const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *)
char * schedule_name(schedule_t)
int tasks
Boolean. Whether to include tasks that use alert.
Definition: omp.c:2505
const char * host_detail_iterator_value(iterator_t *)
int include
Whether family/NVT is included or excluded.
Definition: manage.h:1756
int init_port_list_iterator(iterator_t *, const get_data_t *)
int host_identifier_iterator_source_orphan(iterator_t *)
char * credential_name(credential_t)
gchar * key
Key for current auth_conf_setting.
Definition: omp.c:3235
int target_iterator_smb_trash(iterator_t *)
int create_agent(const char *, const char *, const char *, const char *, const char *, const char *, const char *, agent_t *)
int result_detection_reference(result_t, char **, char **, char **, char **, char **)
int manage_task_remove_file(task_t, const char *)
char * role_id
ID of role to delete.
Definition: omp.c:2140
char * host
Host of scanner.
Definition: omp.c:3568
modify_filter_data_t modify_filter
modify_filter
Definition: omp.c:4288
int config_families_growing(config_t)
const char * cpe_info_iterator_nvd_id(iterator_t *)
const char * scanner_uuid_default()
int create_task_check_config_scanner(config_t, scanner_t)
char * community
SNMP Community string.
Definition: omp.c:1048
char * nvt_preference_iterator_nvt(iterator_t *)
int total_info_count(const get_data_t *, int)
char * port_range
Port range for new port list.
Definition: omp.c:1282
const char * resource_tag_iterator_name(iterator_t *)
array_t * alerts
IDs of new alerts for task.
Definition: omp.c:3766
array_t * sources
Definition: omp.c:3921
get_agents_data_t get_agents
get_agents
Definition: omp.c:4252
const char * permission_iterator_resource_name(iterator_t *)
void append_to_task_name(task_t, const char *, int)
const char * asset_host_iterator_severity(iterator_t *)
char * timezone
Timezone.
Definition: omp.c:3613
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1921
int override_iterator_active(iterator_t *)
char * privacy_algorithm
SNMP Privacy algorithm.
Definition: omp.c:1051
int max
Maximum number of rows returned.
Definition: omp.c:2949
char client_address[]
The OMP client&#39;s address.
Definition: openvasmd.c:285
char * comment
Comment.
Definition: omp.c:1260
int trash_schedule_readable(schedule_t)
const char * port_list_target_iterator_uuid(iterator_t *)
int asset_iterator_writable(iterator_t *)
char * scanner_id
scanner UUID.
Definition: omp.c:3571
const char * cert_bund_adv_info_iterator_max_cvss(iterator_t *)
char * filter_id
UUID of filter.
Definition: omp.c:3167
char * filter_replace
Column to replace in filter.
Definition: manage.h:315
long long int task_t
Definition: manage.h:286
event_t
Types of task events.
Definition: manage.h:471
char * name
New name for config.
Definition: omp.c:3077
get_results_data_t get_results
get_results
Definition: omp.c:4271
char * param_type
Type of above param.
Definition: omp.c:1473
char * comment
Comment.
Definition: omp.c:1117
Command data for the create_filter command.
Definition: omp.c:1084
const char * scanner_task_iterator_uuid(iterator_t *)
const char * alert_data_iterator_name(iterator_t *)
Return the name from an alert data iterator.
Definition: manage_sql.c:8775
char * task_name(task_t)
Return the name of a task.
Definition: manage_sql.c:17945
delete_target_data_t delete_target
delete_target
Definition: omp.c:4249
Name value pair.
Definition: manage.h:63
Command data for the delete_note command.
Definition: omp.c:1984
create_agent_data_t * create_agent_data
Parser callback data for CREATE_AGENT.
Definition: omp.c:4336
char * preference_nvt_oid
OID of NVT of preference.
Definition: omp.c:3083
char * snmp_credential_id
SNMP credential for target.
Definition: omp.c:3721
char * key_phrase
Passphrase for key.
Definition: omp.c:3332
long long int scanner_t
Definition: manage.h:300
A host detail for create_report.
Definition: manage.h:1191
void get_data_reset(get_data_t *data)
Reset command data.
Definition: omp.c:2322
char * nvt_selector_type
In NVT_SELECTORS type of selector.
Definition: omp.c:908
char * port_range_id
ID of port range to delete.
Definition: omp.c:2061
Command data for the delete_override command.
Definition: omp.c:2006
char * task_comment
Comment for container task.
Definition: omp.c:1385
get_credentials_data_t get_credentials
get_credentials
Definition: omp.c:4257
char * nvts_feed_version()
int tag_count(const get_data_t *get)
int ignore_pagination
Whether to ignore the pagination (first and max).
Definition: manage.h:322
array_t * ranges
Port ranges for import.
Definition: omp.c:1284
int result
Boolean. Whether to include associated results.
Definition: omp.c:2699
char * schedule_id
ID of schedule to delete.
Definition: omp.c:2162
int ultimate
Boolean. Whether to remove entirely or to trashcan.
Definition: omp.c:1831
task_t note_iterator_task(iterator_t *)
char * agent_id
agent UUID.
Definition: omp.c:3139
char * nvt_selector_family_or_nvt
In NVT_SELECTORS family/NVT flag.
Definition: omp.c:910
#define STATUS_OK_REQUESTED_TEXT
Response code text on success, when the operation will finish later.
Definition: omp.c:672
const char * all_info_iterator_severity(iterator_t *)
char * host_levels
Letter encoded threat level filter, for hosts.
Definition: omp.c:2799
delete_port_list_data_t * delete_port_list_data
Parser callback data for DELETE_PORT_LIST.
Definition: omp.c:4522
char * param_value
Param value.
Definition: omp.c:3511
int modify_agent(const char *, const char *, const char *)
char * preference_type
Type in PREFERENCE.
Definition: omp.c:919
int report_format_alert_iterator_readable(iterator_t *)
verify_report_format_data_t * verify_report_format_data
Parser callback data for VERIFY_REPORT_FORMAT.
Definition: omp.c:4952
int init_scanner_iterator(iterator_t *, const get_data_t *)
char * nvt_oid
NVT to which to limit override.
Definition: omp.c:3871
verify_report_format_data_t verify_report_format
verify_report_format
Definition: omp.c:4310
int sort_order
Result sort order: 0 descending, else ascending.
Definition: omp.c:2951
const char * alert_task_iterator_name(iterator_t *)
Return the name from an alert task iterator.
Definition: manage_sql.c:13627
Command data for the get_info command.
Definition: omp.c:2587
get_credentials_data_t * get_credentials_data
Parser callback data for GET_CREDENTIALS.
Definition: omp.c:4618
array_t * roles
Definition: omp.c:1797
void set_task_alterable(task_t, int)
Set the alterable state of a task.
Definition: manage_sql.c:18722
char * name
Name.
Definition: omp.c:933
char * asset_id
asset UUID.
Definition: omp.c:3204
char * duration
Duration of schedule (how long it runs for).
Definition: omp.c:3611
const char * preference_iterator_type(iterator_t *)
int minimal
Whether to respond with minimal information.
Definition: manage.h:323
verify_scanner_data_t * verify_scanner_data
Parser callback data for VERIFY_SCANNER.
Definition: omp.c:4958
create_user_data_t create_user
create_user
Definition: omp.c:4230
char * comment
Comment.
Definition: omp.c:3539
get_roles_data_t get_roles
get_roles
Definition: omp.c:4272
int set_task_schedule_periods(const gchar *, int)
Set the schedule periods of a task, given a UUID.
Definition: manage_sql.c:18869
void init_report_format_param_iterator(iterator_t *, report_format_t, int, int, const char *)
#define APPLY_OVERRIDES_DEFAULT
Default apply_overrides setting.
Definition: manage.h:1100
int family_selection_family_growing
FAMILY_SELECTION/FAMILY growing flag.
Definition: omp.c:3072
char * note_id
ID of single note to get.
Definition: omp.c:2616
create_config_data_t create_config
create_config
Definition: omp.c:4212
char * users
Users belonging to new group.
Definition: omp.c:1120
const char * nvt_selector_iterator_name(iterator_t *)
char * comment
Comment.
Definition: omp.c:1530
int details
Boolean. Whether to include full details.
Definition: omp.c:2459
create_report_format_data_t * create_report_format_data
Parser callback data for CREATE_REPORT_FORMAT.
Definition: omp.c:4420
const char * credential_scanner_iterator_uuid(iterator_t *)
char * active
Whether the tag is active.
Definition: omp.c:1698
const char * cve_info_iterator_confidentiality_impact(iterator_t *)
delete_user_data_t delete_user
delete_user
Definition: omp.c:4251
int special_full
Boolean. Give group Super on itself.
Definition: omp.c:1121
int manage_trash_resource_name(const char *, const char *, char **)
Get the name of a trashcan resource.
Definition: manage_sql.c:4957
char * scan_start_time(report_t)
get_data_t get
Get args.
Definition: omp.c:2746
int create_alert(const char *, const char *, const char *, event_t, GPtrArray *, alert_condition_t, GPtrArray *, alert_method_t, GPtrArray *, alert_t *)
Create an alert.
Definition: manage_sql.c:7545
gchar * value
Param value.
Definition: manage.h:66
int task_average_scan_duration(task_t)
Get the average duration of all finished reports of a task.
Definition: manage_sql.c:14283
char * id
UUID.
Definition: omp.c:1278
Command data for the create_note command.
Definition: omp.c:1143
char * ip
Current host for host details.
Definition: omp.c:1372
const char * preference_iterator_default(iterator_t *)
const char * filter_alert_iterator_name(iterator_t *)
char * filter
Filter term.
Definition: manage.h:314
const char * config_timeout_iterator_oid(iterator_t *)
char * group_id
ID of group to delete.
Definition: omp.c:1964
char * comment
Comment.
Definition: omp.c:3164
char * nvt_selection_nvt_oid
OID during NVT_selection/NVT.
Definition: omp.c:3081
void init_param_option_iterator(iterator_t *, report_format_param_t, int, const char *)
long long int resource_t
A resource, like a task or target.
Definition: iterator.h:42
int manage_read_info(gchar *type, gchar *uid, gchar *name, gchar **result)
Read raw information.
Definition: manage.c:7889
const char * alert_data_iterator_data(iterator_t *)
Return the data from an alert data iterator.
Definition: manage_sql.c:8792
gboolean find_config_with_permission(const char *, config_t *, const char *)
char * port
Port to which to limit override.
Definition: omp.c:1149
const char * aggregate_iterator_value(iterator_t *)
Get the value of the group column from a statistics iterator.
Definition: manage_sql.c:6025
array_t * preference_alts
Array of gchar&#39;s in PREFERENCES.
Definition: omp.c:912
long long int report_format_t
Definition: manage.h:290
const char * dfn_cert_adv_info_iterator_title(iterator_t *)
get_schedules_data_t * get_schedules_data
Parser callback data for GET_SCHEDULES.
Definition: omp.c:4720
char * first_time_month
Month schedule must first run.
Definition: omp.c:1598
int init_config_iterator(iterator_t *, const get_data_t *)
Command data for the get_users command.
Definition: omp.c:3045
Command data for the get_feeds command.
Definition: omp.c:2298
char * comment
Comment.
Definition: omp.c:1593
Command data for the get_notes command.
Definition: omp.c:2613
const char * user_role_iterator_name(iterator_t *)
get_tags_data_t get_tags
get_tags
Definition: omp.c:4277
Command data for the modify_override command.
Definition: omp.c:3865
char * nvt_preference_iterator_config_value(iterator_t *, config_t)
int modify_role(const char *, const char *, const char *, const char *)
char * config_nvt_timeout(config_t, const char *)
char * permission_id
ID of permission to delete.
Definition: omp.c:2017
gchar * strdiff(const gchar *one, const gchar *two)
Compare two string with the "diff" command.
Definition: omp.c:11208
char * value
Value.
Definition: omp.c:3682
int permission_iterator_resource_orphan(iterator_t *)
char * users
Users belonging to new role.
Definition: omp.c:1533
gboolean openvas_get_sync_script_identification(const gchar *, gchar **, int)
Command data for the test_alert command.
Definition: omp.c:4082