OpenVAS Manager  7.0.3~git
Macros | Enumerations | Functions | Variables
otp.c File Reference

The OpenVAS Manager OTP library. More...

#include "otp.h"
#include "manage.h"
#include "scanner.h"
#include "types.h"
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <openvas/base/openvas_string.h>
#include <openvas/misc/nvt_categories.h>
Include dependency graph for otp.c:

Go to the source code of this file.

Macros

#define G_LOG_DOMAIN   "md otp"
 GLib log domain. More...
 

Enumerations

enum  scanner_state_t {
  SCANNER_BYE, SCANNER_DONE, SCANNER_ERRMSG_DESCRIPTION, SCANNER_ERRMSG_HOST,
  SCANNER_ERRMSG_NUMBER, SCANNER_ERRMSG_OID, SCANNER_ALARM_DESCRIPTION, SCANNER_ALARM_HOST,
  SCANNER_ALARM_NUMBER, SCANNER_ALARM_OID, SCANNER_LOG_DESCRIPTION, SCANNER_LOG_HOST,
  SCANNER_LOG_NUMBER, SCANNER_LOG_OID, SCANNER_NVT_INFO, SCANNER_PLUGIN_LIST_BUGTRAQ_ID,
  SCANNER_PLUGIN_LIST_CATEGORY, SCANNER_PLUGIN_LIST_COPYRIGHT, SCANNER_PLUGIN_LIST_CVE_ID, SCANNER_PLUGIN_LIST_FAMILY,
  SCANNER_PLUGIN_LIST_NAME, SCANNER_PLUGIN_LIST_OID, SCANNER_PLUGIN_LIST_PLUGIN_VERSION, SCANNER_PLUGIN_LIST_TAGS,
  SCANNER_PLUGIN_LIST_XREFS, SCANNER_PREFERENCE_NAME, SCANNER_PREFERENCE_VALUE, SCANNER_SERVER,
  SCANNER_STATUS, SCANNER_STATUS_HOST, SCANNER_STATUS_PROGRESS, SCANNER_TIME,
  SCANNER_TIME_HOST_START_HOST, SCANNER_TIME_HOST_START_TIME, SCANNER_TIME_HOST_END_HOST, SCANNER_TIME_HOST_END_TIME,
  SCANNER_TIME_SCAN_START, SCANNER_TIME_SCAN_END, SCANNER_TOP
}
 Possible states of the scanner. More...
 

Functions

void init_otp_data ()
 Initialise OTP library data. More...
 
void set_scanner_init_state (scanner_init_state_t state)
 Set the scanner initialisation state, scanner_init_state. More...
 
void reset_scanner_states ()
 Set the scanner initialisation state, scanner_init_state. More...
 
int process_otp_scanner_input (void(*progress)())
 Process any lines available in from_scanner. More...
 

Variables

buffer_size_t from_buffer_size
 Size of from_client data buffer, in bytes. More...
 
GList * scanner_plugins_list = NULL
 The full plugins list, during reading of scanner plugin list. More...
 
GList * scanner_preferences_list = NULL
 The full preferences list, during reading of scanner plugin list. More...
 
scanner_init_state_t scanner_init_state = SCANNER_INIT_TOP
 The initialisation state of the scanner. More...
 
int scanner_init_offset = 0
 Offset into initialisation string being sent to scanner. More...
 
int scanner_current_loading = 0
 Scanner current number of loaded plugins, when still loading. More...
 
int scanner_total_loading = 0
 Scanner total number of plugins to be loaded, when still loading. More...
 
char * from_scanner
 Buffer of input from the scanner. More...
 
buffer_size_t from_scanner_start
 The start of the data in the from_scanner buffer. More...
 
buffer_size_t from_scanner_end
 The end of the data in the from_scanner buffer. More...
 

Detailed Description

The OpenVAS Manager OTP library.

This file defines an OpenVAS Transfer Protocol (OTP) library, for implementing OpenVAS managers such as the OpenVAS Manager daemon.

The library provides a single function, process_otp_scanner_input. This function parses a given string of OTP text and adjusts local task records according to the OTP messages in the string.

Definition in file otp.c.

Macro Definition Documentation

#define G_LOG_DOMAIN   "md otp"

GLib log domain.

Todo:
Ensure that the globals used to store information across the XML parser callbacks (for example, current_scanner_preferences) are freed in the failure cases.

Definition at line 65 of file otp.c.

Referenced by process_otp_scanner_input().

Enumeration Type Documentation

enum scanner_state_t

Possible states of the scanner.

Enumerator
SCANNER_BYE 
SCANNER_DONE 
SCANNER_ERRMSG_DESCRIPTION 
SCANNER_ERRMSG_HOST 
SCANNER_ERRMSG_NUMBER 
SCANNER_ERRMSG_OID 
SCANNER_ALARM_DESCRIPTION 
SCANNER_ALARM_HOST 
SCANNER_ALARM_NUMBER 
SCANNER_ALARM_OID 
SCANNER_LOG_DESCRIPTION 
SCANNER_LOG_HOST 
SCANNER_LOG_NUMBER 
SCANNER_LOG_OID 
SCANNER_NVT_INFO 
SCANNER_PLUGIN_LIST_BUGTRAQ_ID 
SCANNER_PLUGIN_LIST_CATEGORY 
SCANNER_PLUGIN_LIST_COPYRIGHT 
SCANNER_PLUGIN_LIST_CVE_ID 
SCANNER_PLUGIN_LIST_FAMILY 
SCANNER_PLUGIN_LIST_NAME 
SCANNER_PLUGIN_LIST_OID 
SCANNER_PLUGIN_LIST_PLUGIN_VERSION 
SCANNER_PLUGIN_LIST_TAGS 
SCANNER_PLUGIN_LIST_XREFS 
SCANNER_PREFERENCE_NAME 
SCANNER_PREFERENCE_VALUE 
SCANNER_SERVER 
SCANNER_STATUS 
SCANNER_STATUS_HOST 
SCANNER_STATUS_PROGRESS 
SCANNER_TIME 
SCANNER_TIME_HOST_START_HOST 
SCANNER_TIME_HOST_START_TIME 
SCANNER_TIME_HOST_END_HOST 
SCANNER_TIME_HOST_END_TIME 
SCANNER_TIME_SCAN_START 
SCANNER_TIME_SCAN_END 
SCANNER_TOP 

Definition at line 350 of file otp.c.

351 {
352  SCANNER_BYE,
353  SCANNER_DONE,
354  SCANNER_ERRMSG_DESCRIPTION,
355  SCANNER_ERRMSG_HOST,
356  SCANNER_ERRMSG_NUMBER,
357  SCANNER_ERRMSG_OID,
358  SCANNER_ALARM_DESCRIPTION,
359  SCANNER_ALARM_HOST,
360  SCANNER_ALARM_NUMBER,
361  SCANNER_ALARM_OID,
362  SCANNER_LOG_DESCRIPTION,
363  SCANNER_LOG_HOST,
364  SCANNER_LOG_NUMBER,
365  SCANNER_LOG_OID,
366  SCANNER_NVT_INFO,
367  SCANNER_PLUGIN_LIST_BUGTRAQ_ID,
368  SCANNER_PLUGIN_LIST_CATEGORY,
369  SCANNER_PLUGIN_LIST_COPYRIGHT,
370  SCANNER_PLUGIN_LIST_CVE_ID,
371  SCANNER_PLUGIN_LIST_FAMILY,
372  SCANNER_PLUGIN_LIST_NAME,
373  SCANNER_PLUGIN_LIST_OID,
374  SCANNER_PLUGIN_LIST_PLUGIN_VERSION,
375  SCANNER_PLUGIN_LIST_TAGS,
376  SCANNER_PLUGIN_LIST_XREFS,
377  SCANNER_PREFERENCE_NAME,
378  SCANNER_PREFERENCE_VALUE,
379  SCANNER_SERVER,
380  SCANNER_STATUS,
381  SCANNER_STATUS_HOST,
382  SCANNER_STATUS_PROGRESS,
383  SCANNER_TIME,
384  SCANNER_TIME_HOST_START_HOST,
385  SCANNER_TIME_HOST_START_TIME,
386  SCANNER_TIME_HOST_END_HOST,
387  SCANNER_TIME_HOST_END_TIME,
388  SCANNER_TIME_SCAN_START,
389  SCANNER_TIME_SCAN_END,
390  SCANNER_TOP
391 } scanner_state_t;
scanner_state_t
scanner_state_t
Possible states of the scanner.
Definition: otp.c:350

Function Documentation

void init_otp_data ( )

Initialise OTP library data.

This must run once, before the first call to process_otp_scanner_input.

Definition at line 342 of file otp.c.

Referenced by openvas_scanner_connect(), and openvas_scanner_connect_unix().

343 {
344  plugins_feed_version = NULL;
345 }

Here is the caller graph for this function:

int process_otp_scanner_input ( void(*)()  progress)

Process any lines available in from_scanner.

Update scanner information according to the input from the scanner.

This function simply records input from the scanner. Output to the scanner or client is almost always done via process_omp_client_input in reaction to client requests, the only exception being stop requests initiated in other processes.

Parameters
[in]progressFunction to mark progress, or NULL.
Returns
0 success, 1 received scanner BYE, 2 bad login, 3 scanner loading, -1 error.
Todo:
Replace "\n" with newline in description.
Todo:
Field could be "general".
Todo:
Replace "\n" with newline in description.
Todo:
Field could be "general".
Todo:
Replace "\n" with newline in description.
Todo:
Field could be "general".
Todo:
Exit more formally with Scanner?
Todo:
Consider reading all fields up to <|> SERVER?

Definition at line 781 of file otp.c.

References acknowledge_bye(), acknowledge_feed_version_info(), clear_duration_schedules(), current_report, current_scanner_task, delete_task_lock(), from_scanner_end, from_scanner_start, G_LOG_DOMAIN, host_notice(), hosts_set_details(), hosts_set_identifiers(), hosts_set_max_severity(), manage_check_current_task(), manage_complete_nvt_cache_update(), manage_nvt_preferences_enable(), manage_transaction_stop(), port_name_formatted(), progress, report_host_noticeable(), report_uuid(), scan_start_time_epoch(), SCANNER_ALARM_DESCRIPTION, SCANNER_ALARM_HOST, SCANNER_ALARM_NUMBER, SCANNER_ALARM_OID, SCANNER_BYE, SCANNER_DONE, SCANNER_ERRMSG_DESCRIPTION, SCANNER_ERRMSG_HOST, SCANNER_ERRMSG_NUMBER, SCANNER_ERRMSG_OID, SCANNER_INIT_CONNECTED, SCANNER_INIT_DONE, SCANNER_INIT_DONE_CACHE_MODE, SCANNER_INIT_DONE_CACHE_MODE_UPDATE, SCANNER_INIT_GOT_FEED_VERSION, SCANNER_INIT_GOT_PLUGINS, SCANNER_INIT_SENT_COMPLETE_LIST, SCANNER_INIT_SENT_COMPLETE_LIST_UPDATE, SCANNER_INIT_SENT_VERSION, SCANNER_INIT_TOP, SCANNER_LOG_DESCRIPTION, SCANNER_LOG_HOST, SCANNER_LOG_NUMBER, SCANNER_LOG_OID, SCANNER_NVT_INFO, SCANNER_PLUGIN_LIST_BUGTRAQ_ID, SCANNER_PLUGIN_LIST_CATEGORY, SCANNER_PLUGIN_LIST_COPYRIGHT, SCANNER_PLUGIN_LIST_CVE_ID, SCANNER_PLUGIN_LIST_FAMILY, SCANNER_PLUGIN_LIST_NAME, SCANNER_PLUGIN_LIST_OID, SCANNER_PLUGIN_LIST_PLUGIN_VERSION, SCANNER_PLUGIN_LIST_TAGS, SCANNER_PLUGIN_LIST_XREFS, SCANNER_PREFERENCE_NAME, SCANNER_PREFERENCE_VALUE, SCANNER_SERVER, SCANNER_STATUS_HOST, SCANNER_STATUS_PROGRESS, SCANNER_TIME, SCANNER_TIME_HOST_END_HOST, SCANNER_TIME_HOST_END_TIME, SCANNER_TIME_HOST_START_HOST, SCANNER_TIME_HOST_START_TIME, SCANNER_TIME_SCAN_END, SCANNER_TIME_SCAN_START, SCANNER_TOP, set_nvts_feed_version(), set_scan_end_time_otp(), set_scan_host_end_time_otp(), set_scan_host_start_time_otp(), set_scan_ports(), set_scan_start_time_otp(), set_scanner_init_state(), set_task_end_time(), set_task_run_status(), set_task_start_time_otp(), task_run_status(), TASK_STATUS_DELETE_REQUESTED, TASK_STATUS_DELETE_ULTIMATE_REQUESTED, TASK_STATUS_DELETE_ULTIMATE_WAITING, TASK_STATUS_DELETE_WAITING, TASK_STATUS_DONE, TASK_STATUS_INTERNAL_ERROR, TASK_STATUS_REQUESTED, TASK_STATUS_RUNNING, TASK_STATUS_STOP_REQUESTED, TASK_STATUS_STOP_WAITING, TASK_STATUS_STOPPED, and update_duration_schedule_periods().

Referenced by openvas_scanner_is_loading(), and serve_omp().

782 {
783  char* match = NULL;
784  char* messages = from_scanner + from_scanner_start;
785  char* input;
786  const char *ver_str = "< OTP/2.0 >\n";
787  size_t ver_len = strlen (ver_str);
788  buffer_size_t from_start, from_end;
789  //g_debug (" consider %.*s\n", from_scanner_end - from_scanner_start, messages);
790 
791  /* Before processing the input, check if another manager process has stopped
792  * the current task. If so, send the stop request to the scanner. This is
793  * the only place in this file that writes to the to_scanner buffer, and hence
794  * the only place that requires that the writes to to_scanner in the OMP XML
795  * handlers must be whole OTP commands. */
796 
797  if (manage_check_current_task () == -1)
798  {
799  /* Out of space in to_scanner. Just treat it as an error for now. */
800  return -1;
801  }
802 
803  /* First, handle special scanner states where the input from the scanner
804  * ends in something other than <|> (usually a newline). */
805 
806  switch (scanner_init_state)
807  {
808  case SCANNER_INIT_SENT_VERSION:
809  /* Read over any whitespace left by the previous session. */
810  while (from_scanner_start < from_scanner_end
811  && (messages[0] == ' ' || messages[0] == '\n'))
812  from_scanner_start++, messages++;
813 
814  if (scanner_is_loading (messages))
815  {
816  parse_scanner_loading (messages);
817  if (scanner_current_loading && scanner_total_loading)
818  g_log (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE,
819  "Waiting for scanner to load NVTs: %d / %d.\n",
820  scanner_current_loading, scanner_total_loading);
821  else
822  g_log (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE,
823  "Waiting for scanner to load: No information provided. (Message: %s)\n", messages);
824  return 3;
825  }
826  /* If message is empty we assume the scanner is still loading. */
827  if (!*messages)
828  {
829  return 5;
830  }
831  if (from_scanner_end - from_scanner_start < ver_len)
832  {
833  /* Need more input. */
834  if (sync_buffer ()) return -1;
835  return 0;
836  }
837  if (strncasecmp (ver_str, messages, ver_len))
838  {
839  g_debug (" scanner fail: expected \"%s\""
840  " got \"%.12s\"\n\n", ver_str, messages);
841  return -1;
842  }
843  from_scanner_start += ver_len;
844  messages += ver_len;
845  set_scanner_init_state (SCANNER_INIT_DONE);
846  return 0;
847  case SCANNER_INIT_GOT_FEED_VERSION:
848  /* Nothing to parse. */
849  return 0;
850  case SCANNER_INIT_GOT_PLUGINS:
851  /* Nothing to parse. */
852  return 0;
853  case SCANNER_INIT_CONNECTED:
854  /* Input from scanner before version string sent. */
855  return -1;
856  case SCANNER_INIT_SENT_COMPLETE_LIST:
857  case SCANNER_INIT_SENT_COMPLETE_LIST_UPDATE:
858  case SCANNER_INIT_DONE:
859  case SCANNER_INIT_DONE_CACHE_MODE:
860  case SCANNER_INIT_DONE_CACHE_MODE_UPDATE:
861  case SCANNER_INIT_TOP:
862  if (scanner_state == SCANNER_TOP)
863  switch (parse_scanner_bad_login (&messages))
864  {
865  case 0: return 2; /* Found bad login response. */
866  case 1: break;
867  }
868  else if (scanner_state == SCANNER_DONE)
869  switch (parse_scanner_done (&messages))
870  {
871  case -1: return -1;
872  case -2:
873  /* Need more input. */
874  if (sync_buffer ()) return -1;
875  return 0;
876  }
877  else if (scanner_state == SCANNER_PLUGIN_LIST_TAGS)
878  switch (parse_scanner_plugin_list_tags (&messages))
879  {
880  case -2:
881  /* Need more input. */
882  if (sync_buffer ()) return -1;
883  return 0;
884  }
885  else if (scanner_state == SCANNER_PREFERENCE_VALUE)
886  {
887  switch (parse_scanner_preference_value (&messages, progress))
888  {
889  case -2:
890  /* Need more input. */
891  if (sync_buffer ()) return -1;
892  return 0;
893  }
894  g_free (current_scanner_preference);
895  current_scanner_preference = NULL;
896  }
897  else if (scanner_state == SCANNER_SERVER)
898  /* Look for any newline delimited scanner commands. */
899  switch (parse_scanner_server (&messages))
900  {
901  case 0: break; /* Found newline delimited command. */
902  case -1: return -1; /* Error. */
903  case -2:
904  /* Need more input. */
905  if (sync_buffer ()) return -1;
906  return 0;
907  case -3: break; /* Next <|> is before next \n. */
908  case -4: break; /* Failed to find \n, try for <|>. */
909  }
910  break;
911  } /* switch (scanner_init_state) */
912 
913  /* Parse and handle any fields ending in <|>. */
914 
915  input = messages;
916  from_start = from_scanner_start;
917  from_end = from_scanner_end;
918  while (from_start < from_end
919  && ((match = memchr (input,
920  (int) '<',
921  from_end - from_start))
922  != NULL))
923  {
924  assert (match >= input);
925 
926  /* Check whether we've had a transaction open too long, because
927  * it may take some time until we get out of this loop and do a
928  * process_omp_change, and we don't want to hold up other writer
929  * processes. Note that in GSA even tabular pages like Tasks now
930  * write (settings) to the db. */
931  manage_transaction_stop (FALSE);
932 
933  if ((((match - input) + from_start + 1) < from_end)
934  && (match[1] == '|')
935  && (match[2] == '>'))
936  {
937  char* message;
938  char* field;
939  /* Found a full field, process the field. */
940  message = messages;
941  *match = '\0';
942  from_scanner_start += match + 3 - messages;
943  from_start = from_scanner_start;
944  messages = match + 3;
945  input = messages;
946 
947  /* Strip leading and trailing whitespace. */
948  field = openvas_strip_space (message, match);
949  blank_control_chars (field);
950 
951  g_debug (" scanner old state %i\n", scanner_state);
952  g_debug (" scanner field: %s\n", field);
953  switch (scanner_state)
954  {
955  case SCANNER_BYE:
956  if (strcasecmp ("BYE", field))
957  goto return_error;
958  /* It's up to the caller to set the init state, as the
959  * caller must flush the ACK. */
960  set_scanner_state (SCANNER_DONE);
961  switch (parse_scanner_done (&messages))
962  {
963  case 0:
964  if (sync_buffer ()) goto return_error;
965  if (acknowledge_bye ()) goto return_error;
966  goto return_bye;
967  case -1: goto return_error;
968  case -2:
969  /* Need more input. */
970  if (sync_buffer ()) goto return_error;
971  goto return_need_more;
972  }
973  break;
974  case SCANNER_ERRMSG_DESCRIPTION:
975  {
976  if (current_message)
977  {
979  char* description = g_strdup (field);
980  set_message_description (current_message, description);
981  }
982  set_scanner_state (SCANNER_ERRMSG_OID);
983  break;
984  }
985  case SCANNER_ERRMSG_HOST:
986  {
987  assert (current_message == NULL);
988  current_message = make_message (field);
989  set_scanner_state (SCANNER_ERRMSG_NUMBER);
990  break;
991  }
992  case SCANNER_ERRMSG_NUMBER:
993  {
995  int number;
996  char *protocol, *formatted;
997 
998  assert (current_message);
999 
1000  protocol = g_newa (char, strlen (field));
1001 
1002  if (sscanf (field, "%i/%s",
1003  &number, protocol)
1004  != 2)
1005  {
1006  number = atoi (field);
1007  protocol[0] = '\0';
1008  }
1009  g_debug (" scanner got debug port, number: %i, protocol: %s\n",
1010  number, protocol);
1011 
1012  set_message_port_number (current_message, number);
1013  set_message_port_protocol (current_message, protocol);
1014 
1015  formatted = port_name_formatted (field);
1016  if (formatted == NULL)
1017  formatted = g_strdup (field);
1018  set_message_port_string (current_message, formatted);
1019 
1020  set_scanner_state (SCANNER_ERRMSG_DESCRIPTION);
1021  break;
1022  }
1023  case SCANNER_ERRMSG_OID:
1024  {
1025  if (current_message != NULL
1026  && current_scanner_task != (task_t) 0)
1027  {
1028  char* oid = g_strdup (field);
1029  set_message_oid (current_message, oid);
1030 
1031  append_error_message (current_scanner_task, current_message);
1032  free_message (current_message);
1033  current_message = NULL;
1034  }
1035  set_scanner_state (SCANNER_DONE);
1036  switch (parse_scanner_done (&messages))
1037  {
1038  case -1: goto return_error;
1039  case -2:
1040  /* Need more input. */
1041  if (sync_buffer ()) goto return_error;
1042  goto return_need_more;
1043  }
1044  break;
1045  }
1046  case SCANNER_ALARM_DESCRIPTION:
1047  {
1048  if (current_message)
1049  {
1051  char* description = g_strdup (field);
1052  set_message_description (current_message, description);
1053  }
1054  set_scanner_state (SCANNER_ALARM_OID);
1055  break;
1056  }
1057  case SCANNER_ALARM_HOST:
1058  {
1059  assert (current_message == NULL);
1060  current_message = make_message (field);
1061  set_scanner_state (SCANNER_ALARM_NUMBER);
1062  break;
1063  }
1064  case SCANNER_ALARM_NUMBER:
1065  {
1067  int number;
1068  char *protocol, *formatted;
1069 
1070  assert (current_message);
1071 
1072  protocol = g_newa (char, strlen (field));
1073 
1074  if (sscanf (field, "%i/%s",
1075  &number, protocol)
1076  != 2)
1077  {
1078  number = atoi (field);
1079  protocol[0] = '\0';
1080  }
1081  g_debug (" scanner got alarm port, number: %i, protocol: %s\n",
1082  number, protocol);
1083 
1084  set_message_port_number (current_message, number);
1085  set_message_port_protocol (current_message, protocol);
1086 
1087  formatted = port_name_formatted (field);
1088  if (formatted == NULL)
1089  formatted = g_strdup (field);
1090  set_message_port_string (current_message, formatted);
1091 
1092  set_scanner_state (SCANNER_ALARM_DESCRIPTION);
1093  break;
1094  }
1095  case SCANNER_ALARM_OID:
1096  {
1097  if (current_message != NULL
1098  && current_scanner_task != (task_t) 0)
1099  {
1100  char* oid = g_strdup (field);
1101  set_message_oid (current_message, oid);
1102 
1103  append_alarm_message (current_scanner_task, current_message);
1104  free_message (current_message);
1105  current_message = NULL;
1106  }
1107  set_scanner_state (SCANNER_DONE);
1108  switch (parse_scanner_done (&messages))
1109  {
1110  case -1: goto return_error;
1111  case -2:
1112  /* Need more input. */
1113  if (sync_buffer ()) goto return_error;
1114  goto return_need_more;
1115  }
1116  break;
1117  }
1118  case SCANNER_LOG_DESCRIPTION:
1119  {
1120  if (current_message)
1121  {
1123  char* description = g_strdup (field);
1124  set_message_description (current_message, description);
1125  }
1126  set_scanner_state (SCANNER_LOG_OID);
1127  break;
1128  }
1129  case SCANNER_LOG_HOST:
1130  {
1131  assert (current_message == NULL);
1132  current_message = make_message (field);
1133  set_scanner_state (SCANNER_LOG_NUMBER);
1134  break;
1135  }
1136  case SCANNER_LOG_NUMBER:
1137  {
1139  int number;
1140  char *protocol, *formatted;
1141 
1142  assert (current_message);
1143 
1144  protocol = g_newa (char, strlen (field));
1145 
1146  if (sscanf (field, "%i/%s",
1147  &number, protocol)
1148  != 2)
1149  {
1150  number = atoi (field);
1151  protocol[0] = '\0';
1152  }
1153  g_debug (" scanner got log port, number: %i, protocol: %s\n",
1154  number, protocol);
1155 
1156  set_message_port_number (current_message, number);
1157  set_message_port_protocol (current_message, protocol);
1158 
1159  formatted = port_name_formatted (field);
1160  if (formatted == NULL)
1161  formatted = g_strdup (field);
1162  set_message_port_string (current_message, formatted);
1163 
1164  set_scanner_state (SCANNER_LOG_DESCRIPTION);
1165  break;
1166  }
1167  case SCANNER_LOG_OID:
1168  {
1169  if (current_message != NULL
1170  && current_scanner_task != (task_t) 0)
1171  {
1172  char* oid = g_strdup (field);
1173  set_message_oid (current_message, oid);
1174 
1175  append_log_message (current_scanner_task, current_message);
1176  free_message (current_message);
1177  current_message = NULL;
1178  }
1179  set_scanner_state (SCANNER_DONE);
1180  switch (parse_scanner_done (&messages))
1181  {
1182  case -1: goto return_error;
1183  case -2:
1184  /* Need more input. */
1185  if (sync_buffer ()) goto return_error;
1186  goto return_need_more;
1187  }
1188  break;
1189  }
1190  case SCANNER_PLUGIN_LIST_OID:
1191  {
1192  /* Use match[1] instead of field[1] for UTF-8 hack. */
1193  if (strlen (field) == 0 && match[1] == '|')
1194  {
1195  set_scanner_state (SCANNER_DONE);
1196  switch (parse_scanner_done (&messages))
1197  {
1198  case 0:
1199  if (scanner_init_state
1200  == SCANNER_INIT_SENT_COMPLETE_LIST
1201  || scanner_init_state
1202  == SCANNER_INIT_SENT_COMPLETE_LIST_UPDATE)
1203  {
1204  set_scanner_init_state (SCANNER_INIT_GOT_PLUGINS);
1205  set_nvts_feed_version (plugins_feed_version);
1206  }
1207  break;
1208  case -1: goto return_error;
1209  case -2:
1210  /* Need more input. */
1211  if (sync_buffer ()) goto return_error;
1212  goto return_need_more;
1213  }
1214  break;
1215  }
1216  assert (current_plugin == NULL);
1217  current_plugin = nvti_new ();
1218  if (progress)
1219  progress ();
1220  if (current_plugin == NULL) abort ();
1221  nvti_set_oid (current_plugin, field);
1222  set_scanner_state (SCANNER_PLUGIN_LIST_NAME);
1223  break;
1224  }
1225  case SCANNER_PLUGIN_LIST_NAME:
1226  {
1227  nvti_set_name (current_plugin, field);
1228  set_scanner_state (SCANNER_PLUGIN_LIST_CATEGORY);
1229  break;
1230  }
1231  case SCANNER_PLUGIN_LIST_CATEGORY:
1232  {
1233  nvti_set_category (current_plugin, category_number (field));
1234  set_scanner_state (SCANNER_PLUGIN_LIST_COPYRIGHT);
1235  break;
1236  }
1237  case SCANNER_PLUGIN_LIST_COPYRIGHT:
1238  {
1239  nvti_set_copyright (current_plugin, field);
1240  set_scanner_state (SCANNER_PLUGIN_LIST_FAMILY);
1241  break;
1242  }
1243  case SCANNER_PLUGIN_LIST_FAMILY:
1244  {
1245  nvti_set_family (current_plugin, field);
1246  set_scanner_state (SCANNER_PLUGIN_LIST_PLUGIN_VERSION);
1247  break;
1248  }
1249  case SCANNER_PLUGIN_LIST_PLUGIN_VERSION:
1250  {
1251  nvti_set_version (current_plugin, field);
1252  set_scanner_state (SCANNER_PLUGIN_LIST_CVE_ID);
1253  break;
1254  }
1255  case SCANNER_PLUGIN_LIST_CVE_ID:
1256  {
1257  nvti_set_cve (current_plugin, field);
1258  set_scanner_state (SCANNER_PLUGIN_LIST_BUGTRAQ_ID);
1259  break;
1260  }
1261  case SCANNER_PLUGIN_LIST_BUGTRAQ_ID:
1262  {
1263  nvti_set_bid (current_plugin, field);
1264  set_scanner_state (SCANNER_PLUGIN_LIST_XREFS);
1265  break;
1266  }
1267  case SCANNER_PLUGIN_LIST_XREFS:
1268  {
1269  nvti_set_xref (current_plugin, field);
1270  set_scanner_state (SCANNER_PLUGIN_LIST_TAGS);
1271  switch (parse_scanner_plugin_list_tags (&messages))
1272  {
1273  case -2:
1274  /* Need more input. */
1275  if (sync_buffer ()) goto return_error;
1276  goto return_need_more;
1277  }
1278  break;
1279  }
1280  case SCANNER_NVT_INFO:
1281  {
1282  char* feed_version = g_strdup (field);
1283  g_debug (" scanner got nvti_info: %s\n", feed_version);
1284  if (plugins_feed_version)
1285  g_free (plugins_feed_version);
1286  plugins_feed_version = feed_version;
1287  set_scanner_state (SCANNER_DONE);
1288  switch (parse_scanner_done (&messages))
1289  {
1290  case 0:
1291  if (scanner_init_state == SCANNER_INIT_DONE)
1292  set_scanner_init_state (SCANNER_INIT_GOT_FEED_VERSION);
1293  else if (acknowledge_feed_version_info ())
1294  goto return_error;
1295  break;
1296  case -1: goto return_error;
1297  case -2:
1298  /* Need more input. */
1299  if (sync_buffer ()) goto return_error;
1300  goto return_need_more;
1301  }
1302  break;
1303  }
1304  case SCANNER_PREFERENCE_NAME:
1305  {
1306  /* Use match[1] instead of field[1] for UTF-8 hack. */
1307  if (strlen (field) == 0 && match[1] == '|')
1308  {
1309  set_scanner_state (SCANNER_DONE);
1310  switch (parse_scanner_done (&messages))
1311  {
1312  case -1: goto return_error;
1313  case -2:
1314  /* Need more input. */
1315  if (sync_buffer ()) goto return_error;
1316  goto return_need_more;
1317  }
1318  if (scanner_init_state == SCANNER_INIT_DONE_CACHE_MODE
1319  || scanner_init_state
1320  == SCANNER_INIT_DONE_CACHE_MODE_UPDATE)
1321  {
1322  manage_complete_nvt_cache_update
1323  (scanner_plugins_list,
1324  scanner_preferences_list,
1325  scanner_init_state == SCANNER_INIT_DONE_CACHE_MODE
1326  ? -2 : -1);
1327  set_scanner_init_state (SCANNER_INIT_DONE);
1328  manage_nvt_preferences_enable ();
1329  /* Return 1, as though the scanner sent BYE. */
1331  goto return_bye;
1332  }
1333  break;
1334  }
1335 
1336  {
1337  int value_start = -1, value_end = -1, count;
1338  char name[21];
1339  /* LDAPsearch[entry]:Timeout value */
1340  count = sscanf (field, "%20[^[][%*[^]]]:%n%*[ -~]%n",
1341  name, &value_start, &value_end);
1342  if (count == 1 && value_start > 0 && value_end > 0
1343  && ((strcmp (name, "SSH Authorization") == 0)
1344  || (strcmp (name, "SMB Authorization") == 0)))
1345  current_scanner_preference = NULL;
1346  else
1347  current_scanner_preference = g_strdup (field);
1348  set_scanner_state (SCANNER_PREFERENCE_VALUE);
1349  switch (parse_scanner_preference_value (&messages,
1350  progress))
1351  {
1352  case -2:
1353  /* Need more input. */
1354  if (sync_buffer ()) goto return_error;
1355  goto return_need_more;
1356  }
1357  g_free (current_scanner_preference);
1358  current_scanner_preference = NULL;
1359  }
1360  break;
1361  }
1362  case SCANNER_SERVER:
1363  if (strcasecmp ("BYE", field) == 0)
1364  set_scanner_state (SCANNER_BYE);
1365  else if (strcasecmp ("ERRMSG", field) == 0)
1366  set_scanner_state (SCANNER_ERRMSG_HOST);
1367  else if (strcasecmp ("FILE_ACCEPTED", field) == 0)
1368  {
1369  set_scanner_state (SCANNER_DONE);
1370  switch (parse_scanner_done (&messages))
1371  {
1372  case -1: goto return_error;
1373  case -2:
1374  /* Need more input. */
1375  if (sync_buffer ()) goto return_error;
1376  goto return_need_more;
1377  }
1378  }
1379  else if (strcasecmp ("ALARM", field) == 0)
1380  set_scanner_state (SCANNER_ALARM_HOST);
1381  else if (strcasecmp ("LOG", field) == 0)
1382  set_scanner_state (SCANNER_LOG_HOST);
1383  else if (strcasecmp ("NVT_INFO", field) == 0)
1384  set_scanner_state (SCANNER_NVT_INFO);
1385  else if (strcasecmp ("PLUGIN_LIST", field) == 0)
1386  {
1387  set_scanner_state (SCANNER_PLUGIN_LIST_OID);
1388  }
1389  else if (strcasecmp ("PREFERENCES", field) == 0)
1390  {
1391  assert (current_scanner_preference == NULL);
1392  set_scanner_state (SCANNER_PREFERENCE_NAME);
1393  }
1394  else if (strcasecmp ("TIME", field) == 0)
1395  {
1396  set_scanner_state (SCANNER_TIME);
1397  }
1398  else if (strcasecmp ("STATUS", field) == 0)
1399  {
1400  set_scanner_state (SCANNER_STATUS_HOST);
1401  }
1402  else
1403  {
1404  g_debug ("New scanner command to implement: %s\n",
1405  field);
1406  goto return_error;
1407  }
1408  break;
1409  case SCANNER_STATUS_HOST:
1410  {
1411  assert (current_host == NULL);
1412  current_host = g_strdup (field);
1413  set_scanner_state (SCANNER_STATUS_PROGRESS);
1414  break;
1415  }
1416  case SCANNER_STATUS_PROGRESS:
1417  {
1418  /* Store the progress in the ports slots in the db. */
1419  assert (current_report);
1420  if (current_report && current_host)
1421  {
1422  unsigned int current, max;
1423  g_debug (" scanner got ports: %s\n", field);
1424  if (sscanf (field, "%u/%u", &current, &max) == 2)
1425  set_scan_ports (current_report,
1426  current_host,
1427  current,
1428  max);
1429  }
1430  if (current_host)
1431  {
1432  g_free (current_host);
1433  current_host = NULL;
1434  }
1435  set_scanner_state (SCANNER_DONE);
1436  switch (parse_scanner_done (&messages))
1437  {
1438  case -1: goto return_error;
1439  case -2:
1440  /* Need more input. */
1441  if (sync_buffer ()) goto return_error;
1442  goto return_need_more;
1443  }
1444  break;
1445  }
1446  case SCANNER_TIME:
1447  {
1448  if (strcasecmp ("HOST_START", field) == 0)
1449  set_scanner_state (SCANNER_TIME_HOST_START_HOST);
1450  else if (strcasecmp ("HOST_END", field) == 0)
1451  set_scanner_state (SCANNER_TIME_HOST_END_HOST);
1452  else if (strcasecmp ("SCAN_START", field) == 0)
1453  set_scanner_state (SCANNER_TIME_SCAN_START);
1454  else if (strcasecmp ("SCAN_END", field) == 0)
1455  set_scanner_state (SCANNER_TIME_SCAN_END);
1456  else
1458  abort ();
1459  break;
1460  }
1461  case SCANNER_TIME_HOST_START_HOST:
1462  {
1463  assert (current_host == NULL);
1464  current_host = g_strdup (field);
1465  set_scanner_state (SCANNER_TIME_HOST_START_TIME);
1466  break;
1467  }
1468  case SCANNER_TIME_HOST_START_TIME:
1469  {
1470  if (current_scanner_task)
1471  {
1472  assert (current_host);
1473  assert (current_report);
1474 
1475  set_scan_host_start_time_otp (current_report,
1476  current_host,
1477  field);
1478  g_free (current_host);
1479  current_host = NULL;
1480  }
1481  set_scanner_state (SCANNER_DONE);
1482  switch (parse_scanner_done (&messages))
1483  {
1484  case -1: goto return_error;
1485  case -2:
1486  /* Need more input. */
1487  if (sync_buffer ()) goto return_error;
1488  goto return_need_more;
1489  }
1490  break;
1491  }
1492  case SCANNER_TIME_HOST_END_HOST:
1493  {
1494  assert (current_host == NULL);
1495  current_host = g_strdup (field);
1496  set_scanner_state (SCANNER_TIME_HOST_END_TIME);
1497  break;
1498  }
1499  case SCANNER_TIME_HOST_END_TIME:
1500  {
1501  assert (current_host);
1502  assert (current_report);
1503 
1504  if (report_host_noticeable (current_report, current_host))
1505  {
1506  char *uuid;
1507  uuid = report_uuid (current_report);
1508  host_notice (current_host, "ip", current_host,
1509  "Report Host", uuid, 1, 0);
1510  free (uuid);
1511  }
1512 
1513  if (current_scanner_task)
1514  {
1515  assert (current_host);
1516  set_scan_host_end_time_otp (current_report,
1517  current_host,
1518  field);
1519  g_free (current_host);
1520  current_host = NULL;
1521  }
1522  set_scanner_state (SCANNER_DONE);
1523  switch (parse_scanner_done (&messages))
1524  {
1525  case -1: goto return_error;
1526  case -2:
1527  /* Need more input. */
1528  if (sync_buffer ()) goto return_error;
1529  goto return_need_more;
1530  }
1531  break;
1532  }
1533  case SCANNER_TIME_SCAN_START:
1534  {
1535  if (current_scanner_task)
1536  {
1537  if (task_run_status (current_scanner_task)
1538  == TASK_STATUS_REQUESTED)
1539  {
1540  set_task_run_status (current_scanner_task,
1541  TASK_STATUS_RUNNING);
1542  /* If the scan has been started before, then leave
1543  * the start time alone. */
1544  if (scan_start_time_epoch (current_report) == 0)
1545  {
1546  set_task_start_time_otp (current_scanner_task,
1547  g_strdup (field));
1548  set_scan_start_time_otp (current_report, field);
1549  }
1550  }
1551  }
1552  set_scanner_state (SCANNER_DONE);
1553  switch (parse_scanner_done (&messages))
1554  {
1555  case -1: goto return_error;
1556  case -2:
1557  /* Need more input. */
1558  if (sync_buffer ()) goto return_error;
1559  goto return_need_more;
1560  }
1561  break;
1562  }
1563  case SCANNER_TIME_SCAN_END:
1564  {
1565  if (current_scanner_task)
1566  {
1567  /* Stop transaction now, because delete_task_lock and
1568  * set_scan_end_time_otp run transactions themselves. */
1569  manage_transaction_stop (TRUE);
1570  hosts_set_identifiers ();
1571  if (current_report)
1572  {
1573  hosts_set_max_severity (current_report, NULL, NULL);
1574  hosts_set_details (current_report);
1575  set_scan_end_time_otp (current_report, field);
1576  }
1577  switch (task_run_status (current_scanner_task))
1578  {
1579  case TASK_STATUS_INTERNAL_ERROR:
1580  break;
1581  case TASK_STATUS_STOP_REQUESTED:
1582  case TASK_STATUS_STOP_WAITING:
1583  set_task_run_status (current_scanner_task,
1584  TASK_STATUS_STOPPED);
1585  break;
1586  case TASK_STATUS_DELETE_REQUESTED:
1587  case TASK_STATUS_DELETE_WAITING:
1588  set_task_run_status (current_scanner_task,
1589  TASK_STATUS_STOPPED);
1590  delete_task_lock (current_scanner_task, 0);
1591  current_report = (report_t) 0;
1592  break;
1593  case TASK_STATUS_DELETE_ULTIMATE_REQUESTED:
1594  case TASK_STATUS_DELETE_ULTIMATE_WAITING:
1595  set_task_run_status (current_scanner_task,
1596  TASK_STATUS_STOPPED);
1597  delete_task_lock (current_scanner_task, 1);
1598  current_report = (report_t) 0;
1599  break;
1600  default:
1601  set_task_end_time (current_scanner_task,
1602  g_strdup (field));
1603  set_task_run_status (current_scanner_task,
1604  TASK_STATUS_DONE);
1605  }
1606  clear_duration_schedules (current_scanner_task);
1607  update_duration_schedule_periods (current_scanner_task);
1608  current_report = (report_t) 0;
1609  current_scanner_task = (task_t) 0;
1610  }
1611  set_scanner_state (SCANNER_DONE);
1612  switch (parse_scanner_done (&messages))
1613  {
1614  case -1: goto return_error;
1615  case -2:
1616  /* Need more input. */
1617  if (sync_buffer ()) goto return_error;
1618  goto return_need_more;
1619  }
1620  break;
1621  }
1622  case SCANNER_TOP:
1623  default:
1624  g_debug (" switch t\n");
1625  g_debug (" cmp %i\n", strcasecmp ("SERVER", field));
1626  if (strcasecmp ("SERVER", field))
1627  goto return_error;
1628  set_scanner_state (SCANNER_SERVER);
1629  /* Look for any newline delimited scanner commands. */
1630  switch (parse_scanner_server (&messages))
1631  {
1632  case 0: break; /* Found newline delimited command. */
1633  case -1: goto return_error; /* Error. */
1634  case -2:
1635  /* Need more input. */
1636  if (sync_buffer ()) goto return_error;
1637  goto return_need_more;
1638  case -3: break; /* Next <|> is before next \n. */
1639  case -4: break; /* Failed to find \n, try for <|>. */
1640  }
1641  break;
1642  }
1643 
1644  g_debug (" scanner new state: %i\n", scanner_state);
1645 
1646  continue;
1647 
1648  return_error:
1649  return -1;
1650 
1651  return_need_more:
1652  return 0;
1653 
1654  return_bye:
1655  return 1;
1656  }
1657  else
1658  {
1659  from_start += match + 1 - input;
1660  input = match + 1;
1661  }
1662  }
1663 
1664  if (sync_buffer ()) return -1;
1665  return 0;
1666 }
report_host_noticeable
int report_host_noticeable(report_t, const gchar *)
Check if a report host is alive and has at least one result.
Definition: manage_sql.c:31510
from_scanner_end
buffer_size_t from_scanner_end
The end of the data in the from_scanner buffer.
Definition: scanner.c:72
set_scan_host_start_time_otp
void set_scan_host_start_time_otp(report_t, const char *, const char *)
Set the start time of a scanned host.
Definition: manage_sql.c:24446
scanner_total_loading
int scanner_total_loading
Scanner total number of plugins to be loaded, when still loading.
Definition: otp.c:426
manage_complete_nvt_cache_update
void manage_complete_nvt_cache_update(GList *, GList *, int)
Complete an update of the NVT cache.
Definition: manage_sql.c:39190
progress
void(* progress)()
Function to mark progress.
Definition: manage_sql.c:352
scanner_init_state
scanner_init_state_t scanner_init_state
The initialisation state of the scanner.
Definition: otp.c:411
scanner_plugins_list
GList * scanner_plugins_list
The full plugins list, during reading of scanner plugin list.
Definition: otp.c:326
set_task_run_status
void set_task_run_status(task_t, task_status_t)
Set the run state of a task.
Definition: manage_sql.c:18307
scan_start_time_epoch
int scan_start_time_epoch(report_t)
Get the start time of a scan, in seconds since the epoch.
Definition: manage_sql.c:24198
host_notice
host_t host_notice(const char *, const char *, const char *, const char *, const char *, int, int)
Notice a host.
Definition: manage_sql.c:19765
current_scanner_task
task_t current_scanner_task
The task currently running on the scanner.
Definition: manage.c:998
hosts_set_max_severity
void hosts_set_max_severity(report_t, int *, int *)
Set the maximum severity of each host in a scan.
Definition: manage_sql.c:60390
task_run_status
task_status_t task_run_status(task_t)
Return the run state of a task.
Definition: manage_sql.c:18238
set_scan_start_time_otp
void set_scan_start_time_otp(report_t, const char *)
Set the start time of a scan.
Definition: manage_sql.c:24256
set_scan_host_end_time_otp
void set_scan_host_end_time_otp(report_t, const char *, const char *)
Set the end time of a scanned host.
Definition: manage_sql.c:24398
clear_duration_schedules
void clear_duration_schedules(task_t)
Clear once-off schedules from tasks where the duration has passed.
Definition: manage_sql.c:19289
hosts_set_identifiers
void hosts_set_identifiers()
Setup hosts and their identifiers after a scan, from host details.
Definition: manage_sql.c:60125
report_t
long long int report_t
Definition: manage.h:288
set_scan_ports
void set_scan_ports(report_t, const char *, unsigned int, unsigned int)
Set the ports for a particular host in a scan.
Definition: manage_sql.c:32533
hosts_set_details
void hosts_set_details(report_t report)
Store certain host details in the assets after a scan.
Definition: manage_sql.c:60474
G_LOG_DOMAIN
#define G_LOG_DOMAIN
GLib log domain.
Definition: otp.c:65
set_task_start_time_otp
void set_task_start_time_otp(task_t, char *)
Set the start time of a task.
Definition: manage_sql.c:18524
set_scanner_init_state
void set_scanner_init_state(scanner_init_state_t state)
Set the scanner initialisation state, scanner_init_state.
Definition: otp.c:432
update_duration_schedule_periods
void update_duration_schedule_periods(task_t)
Update tasks with limited run schedules which have durations.
Definition: manage_sql.c:19334
current_report
report_t current_report
The report of the current task.
Definition: manage.c:1003
manage_check_current_task
int manage_check_current_task()
Handle state changes to current task made by other processes.
Definition: manage.c:5733
set_scan_end_time_otp
void set_scan_end_time_otp(report_t, const char *)
Set the end time of a scan.
Definition: manage_sql.c:24336
from_scanner
char * from_scanner
Buffer of input from the scanner.
Definition: scanner.c:62
set_task_end_time
void set_task_end_time(task_t task, char *time)
Set the end time of a task.
Definition: manage_sql.c:24145
report_uuid
char * report_uuid(report_t)
Return the UUID of a report.
Definition: manage_sql.c:21382
manage_transaction_stop
void manage_transaction_stop(gboolean)
Commit the current transaction, if any.
Definition: manage_sql.c:32976
acknowledge_bye
int acknowledge_bye()
Acknowledge a scanner BYE.
Definition: manage.c:5705
set_nvts_feed_version
void set_nvts_feed_version(const char *)
Set the feed version of the plugins in the plugin cache.
Definition: manage_sql.c:37416
port_name_formatted
char * port_name_formatted(const char *)
Returns formatted port number, protocol and iana name from.
Definition: manage_sql.c:6378
from_scanner_start
buffer_size_t from_scanner_start
The start of the data in the from_scanner buffer.
Definition: scanner.c:67
manage_nvt_preferences_enable
void manage_nvt_preferences_enable()
Enable the NVT preferences.
Definition: manage_sql.c:40973
scanner_preferences_list
GList * scanner_preferences_list
The full preferences list, during reading of scanner plugin list.
Definition: otp.c:331
acknowledge_feed_version_info
int acknowledge_feed_version_info()
Acknowledge scanner PLUGINS_FEED_VERSION message,.
Definition: manage.c:5719
buffer_size_t
unsigned int buffer_size_t
Definition: types.h:31
task_t
long long int task_t
Definition: manage.h:286
scanner_current_loading
int scanner_current_loading
Scanner current number of loaded plugins, when still loading.
Definition: otp.c:421
delete_task_lock
int delete_task_lock(task_t, int)
Complete deletion of a task.
Definition: manage_sql.c:32399

Here is the call graph for this function:

Here is the caller graph for this function:

void reset_scanner_states ( )

Set the scanner initialisation state, scanner_init_state.

Todo:
Exported for scanner.c.

Definition at line 442 of file otp.c.

References SCANNER_INIT_TOP, SCANNER_TOP, and set_scanner_init_state().

Referenced by openvas_scanner_fork().

443 {
444  set_scanner_state (SCANNER_TOP);
445  set_scanner_init_state (SCANNER_INIT_TOP);
446  scanner_init_offset = 0;
447  scanner_current_loading = 0;
448  scanner_total_loading = 0;
449 }
scanner_total_loading
int scanner_total_loading
Scanner total number of plugins to be loaded, when still loading.
Definition: otp.c:426
set_scanner_init_state
void set_scanner_init_state(scanner_init_state_t state)
Set the scanner initialisation state, scanner_init_state.
Definition: otp.c:432
scanner_init_offset
int scanner_init_offset
Offset into initialisation string being sent to scanner.
Definition: otp.c:416
scanner_current_loading
int scanner_current_loading
Scanner current number of loaded plugins, when still loading.
Definition: otp.c:421

Here is the call graph for this function:

Here is the caller graph for this function:

void set_scanner_init_state ( scanner_init_state_t  state)

Set the scanner initialisation state, scanner_init_state.

Todo:
Exported for ompd.c and scanner.c.

Definition at line 432 of file otp.c.

Referenced by openvas_scanner_write(), process_otp_scanner_input(), reset_scanner_states(), and serve_omp().

433 {
434  scanner_init_state = state;
435  g_debug (" scanner init state set: %i\n", scanner_init_state);
436 }
scanner_init_state
scanner_init_state_t scanner_init_state
The initialisation state of the scanner.
Definition: otp.c:411

Here is the caller graph for this function:

Variable Documentation

buffer_size_t from_buffer_size

Size of from_client data buffer, in bytes.

Todo:
As with the OMP version, this should most likely be passed to and from the client in a data structure like an otp_parser_t.

Definition at line 79 of file ompd.c.

Referenced by serve_omp().

char* from_scanner

Buffer of input from the scanner.

Todo:
As with the OMP version, these should most likely be passed to and from the client in a data structure like an otp_parser_t.

Definition at line 62 of file scanner.c.

buffer_size_t from_scanner_end

The end of the data in the from_scanner buffer.

Definition at line 72 of file scanner.c.

buffer_size_t from_scanner_start

The start of the data in the from_scanner buffer.

Definition at line 67 of file scanner.c.

int scanner_current_loading = 0

Scanner current number of loaded plugins, when still loading.

Definition at line 421 of file otp.c.

int scanner_init_offset = 0

Offset into initialisation string being sent to scanner.

Todo:
Exported for ompd.c.

Definition at line 416 of file otp.c.

Referenced by openvas_scanner_write().

scanner_init_state_t scanner_init_state = SCANNER_INIT_TOP

The initialisation state of the scanner.

Todo:
Exported for ompd.c.

Definition at line 411 of file otp.c.

Referenced by openvas_scanner_write(), and serve_omp().

GList* scanner_plugins_list = NULL

The full plugins list, during reading of scanner plugin list.

Definition at line 326 of file otp.c.

GList* scanner_preferences_list = NULL

The full preferences list, during reading of scanner plugin list.

Definition at line 331 of file otp.c.

int scanner_total_loading = 0

Scanner total number of plugins to be loaded, when still loading.

Definition at line 426 of file otp.c.