nasl_builtin_plugins.h File Reference

Header file for built-in plugins. More...

#include "nasl_lex_ctxt.h"
#include "nasl_tree.h"

Include dependency graph for nasl_builtin_plugins.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
tree_cell *	plugin_run_find_service (lex_ctxt *)
tree_cell *	plugin_run_openvas_tcp_scanner (lex_ctxt *)
tree_cell *	plugin_run_synscan (lex_ctxt *)

Detailed Description

Header file for built-in plugins.

Definition in file nasl_builtin_plugins.h.

Function Documentation

plugin_run_find_service()

tree_cell* plugin_run_find_service

(

lex_ctxt *

)

Definition at line 2435 of file nasl_builtin_find_service.c.

{
  struct script_infos *desc = lexic->script_infos;
 
  oid = lexic->oid;
 
  kb_t kb = plug_get_kb (desc);
  struct kb_item *kbitem, *kbitem_tmp;
 
  GSList *sons_args[MAX_SONS];
  int num_ports = 0;
  char *num_sons_s;
  int num_sons = 6;
  int port_per_son;
  int i;
  int test_ssl = 1;
  char *key = get_plugin_preference (oid, KEY_FILE, -1);
  char *cert = get_plugin_preference (oid, CERT_FILE, -1);
  char *pempass = get_plugin_preference (oid, PEM_PASS, -1);
  char *cafile = get_plugin_preference (oid, CA_FILE, -1);
  char *test_ssl_s = get_plugin_preference (oid, TEST_SSL_PREF, -1);
 
  if (key && key[0] != '\0')
    key = (char *) get_plugin_preference_fname (desc, key);
  else
    key = NULL;
 
  if (cert && cert[0] != '\0')
    cert = (char *) get_plugin_preference_fname (desc, cert);
  else
    cert = NULL;
 
  if (cafile && cafile[0] != '\0')
    cafile = (char *) get_plugin_preference_fname (desc, cafile);
  else
    cafile = NULL;
 
  if (test_ssl_s != NULL)
    {
      if (strcmp (test_ssl_s, "None") == 0)
        test_ssl = 0;
    }
  g_free (test_ssl_s);
  if (key || cert)
    {
      if (!key)
        key = cert;
      if (!cert)
        cert = key;
      plug_set_ssl_cert (desc, cert);
      plug_set_ssl_key (desc, key);
    }
  if (pempass != NULL)
    plug_set_ssl_pem_password (desc, pempass);
  if (cafile != NULL)
    plug_set_ssl_CA_file (desc, cafile);
 
  signal (SIGTERM, sigterm);
  signal (SIGCHLD, sigchld);
  num_sons_s = get_plugin_preference (oid, NUM_CHILDREN, -1);
  if (num_sons_s != NULL)
    num_sons = atoi (num_sons_s);
  g_free (num_sons_s);
 
  if (num_sons <= 0)
    num_sons = 6;
 
  if (num_sons > MAX_SONS)
    num_sons = MAX_SONS;
 
  for (i = 0; i < num_sons; i++)
    {
      sons[i] = 0;
      sons_args[i] = NULL;
    }
 
  if (kb == NULL)
    return NULL; // TODO: in old days returned "1". Still relevant?
 
  kbitem = kb_item_get_pattern (kb, "Ports/tcp/*");
 
  /* count the number of open TCP ports */
  kbitem_tmp = kbitem;
  while (kbitem_tmp != NULL)
    {
      num_ports++;
      kbitem_tmp = kbitem_tmp->next;
    }
 
  port_per_son = num_ports / num_sons;
 
  /* The next two loops distribute the ports across a number of 'sons'.
   */
 
  kbitem_tmp = kbitem;
 
  for (i = 0; i < num_sons; i = i + 1)
    {
      int j;
 
      if (kbitem_tmp != NULL)
        {
          for (j = 0; j < port_per_son && kbitem_tmp != NULL;)
            {
              sons_args[i] =
                g_slist_prepend (sons_args[i], g_strdup (kbitem_tmp->name));
              j++;
              kbitem_tmp = kbitem_tmp->next;
            }
        }
      else
        break;
    }
 
  for (i = 0; (i < num_ports % num_sons) && kbitem_tmp != NULL;)
    {
      sons_args[i] =
        g_slist_prepend (sons_args[i], g_strdup (kbitem_tmp->name));
      i++;
      kbitem_tmp = kbitem_tmp->next;
    }
 
  kb_item_free (kbitem);
 
  for (i = 0; i < num_sons; i++)
    if (sons_args[i] == NULL)
      break;
 
  num_sons = i;
 
  for (i = 0; i < num_sons; i++)
    {
      usleep (5000);
      if (sons_args[i] != NULL)
        {
          sons[i] = fork ();
          if (sons[i] == 0)
            {
              kb_lnk_reset (kb);
              kb_lnk_reset (get_main_kb ());
              mqtt_reset ();
              nvticache_reset ();
 
              signal (SIGTERM, _exit);
              plugin_do_run (desc, sons_args[i], test_ssl);
              _exit (0);
            }
          else
            {
              if (sons[i] < 0)
                sons[i] = 0; /* Fork failed */
            }
          g_slist_free_full (sons_args[i], g_free);
        }
    }
 
  for (;;)
    {
      int flag = 0;
 
      for (i = 0; i < num_sons; i++)
        {
          if (sons[i] != 0)
            {
              while (waitpid (sons[i], NULL, WNOHANG) && errno == EINTR)
                ;
 
              if (kill (sons[i], 0) >= 0)
                flag++;
            }
        }
 
      if (flag == 0)
        break;
      usleep (100000);
    }
 
  return NULL;
}

References CA_FILE, CERT_FILE, get_main_kb(), get_plugin_preference(), get_plugin_preference_fname(), KEY_FILE, MAX_SONS, NUM_CHILDREN, oid, struct_lex_ctxt::oid, PEM_PASS, plug_get_kb(), plug_set_ssl_CA_file(), plug_set_ssl_cert(), plug_set_ssl_key(), plug_set_ssl_pem_password(), plugin_do_run(), struct_lex_ctxt::script_infos, sigchld(), sigterm(), sons, and TEST_SSL_PREF.

Here is the call graph for this function:

plugin_run_openvas_tcp_scanner()

tree_cell* plugin_run_openvas_tcp_scanner

(

lex_ctxt *

)

Definition at line 1049 of file nasl_builtin_openvas_tcp_scanner.c.

{
  struct script_infos *desc = lexic->script_infos;
  const char *port_range = prefs_get ("port_range");
  const char *p;
  struct in6_addr *p_addr;
  unsigned int timeout = 0, max_cnx, min_cnx, x;
  int safe_checks = prefs_get_bool ("safe_checks");
 
  p = prefs_get ("checks_read_timeout");
  if (p != NULL)
    timeout = atoi (p);
  if (timeout <= 0)
    timeout = 5;
  {
    int max_host = 0, max_checks = 0, cur_sys_fd = 0, max_sys_fd = 0;
    struct rlimit rlim;
    FILE *fp;
    int i;
    double loadavg[3], maxloadavg = -1.0;
    int stderr_fd = dup (2);
    int devnull_fd = open ("/dev/null", O_WRONLY);
    /* Avoid error messages from sysctl */
    if (devnull_fd <= 0)
      {
        if (stderr_fd != -1)
          close (stderr_fd);
        return NULL;
      }
    dup2 (devnull_fd, 2);
 
    p = prefs_get ("max_hosts");
    if (p != NULL)
      max_host = atoi (p);
    if (max_host <= 0)
      max_host = 15;
 
    p = prefs_get ("max_checks");
    if (p != NULL)
      max_checks = atoi (p);
    if (max_checks <= 0 || max_checks > 5)
      {
        max_checks = 5; /* bigger values do not make sense */
        g_debug ("openvas_tcp_scanner: max_checks forced to %d", max_checks);
      }
 
    min_cnx = 8 * max_checks;
    if (safe_checks)
      max_cnx = 24 * max_checks;
    else
      max_cnx = 80 * max_checks;
 
    getloadavg (loadavg, 3);
    for (i = 0; i < 3; i++)
      if (loadavg[i] > maxloadavg)
        maxloadavg = loadavg[i];
 
    if (max_sys_fd <= 0)
      {
        fp = popen ("sysctl fs.file-nr", "r");
        if (fp != NULL)
          {
            if (fscanf (fp, "%*s = %*d %d %d", &cur_sys_fd, &max_sys_fd) == 1)
              max_sys_fd -= cur_sys_fd;
            else
              max_sys_fd = 0;
            pclose (fp);
          }
      }
    if (max_sys_fd <= 0)
      {
        fp = popen ("sysctl fs.file-max", "r");
        if (fp != NULL)
          {
            if (fscanf (fp, "%*s = %d", &max_sys_fd) < 1)
              max_sys_fd = 0;
            pclose (fp);
          }
      }
 
    if (max_sys_fd <= 0)
      {
        fp = popen ("sysctl kern.maxfiles", "r");
        if (fp != NULL)
          {
            if (fscanf (fp, "%*s = %d", &max_sys_fd) < 1)
              max_sys_fd = 0;
            pclose (fp);
          }
      }
 
    /* Restore stderr */
    close (devnull_fd);
    dup2 (stderr_fd, 2);
    close (stderr_fd);
 
    if (maxloadavg >= 0.0)
      max_cnx /= (1.0 + maxloadavg);
 
    if (max_sys_fd <= 0)
      max_sys_fd = 16384; /* reasonable default */
    /* Let's leave at least 1024 FD for other processes */
    if (max_sys_fd < 1024)
      x = GRAB_MIN_SOCK;
    else
      {
        max_sys_fd -= 1024;
        x = max_sys_fd / max_host;
      }
    if (max_cnx > x)
      max_cnx = x;
    if (max_cnx > GRAB_MAX_SOCK)
      max_cnx = GRAB_MAX_SOCK;
    if (max_cnx < GRAB_MIN_SOCK)
      max_cnx = GRAB_MIN_SOCK;
 
    if (safe_checks && max_cnx > GRAB_MAX_SOCK_SAFE)
      max_cnx = GRAB_MAX_SOCK_SAFE;
 
    if (getrlimit (RLIMIT_NOFILE, &rlim) < 0)
      perror ("getrlimit(RLIMIT_NOFILE)");
    else
      {
        /* value = one greater than the maximum  file  descriptor number */
        if (rlim.rlim_cur != RLIM_INFINITY && max_cnx >= rlim.rlim_cur)
          max_cnx = rlim.rlim_cur - 1;
      }
    x = max_cnx / 2;
    if (min_cnx > x)
      min_cnx = x > 0 ? x : 1;
  }
 
  p_addr = desc->ip;
  if (p_addr == NULL)
    return NULL; // TODO: before it returned "1";
  if (banner_grab (p_addr, port_range, timeout, min_cnx, max_cnx, desc) < 0)
    return NULL; // TODO: before it returned "1";
  plug_set_key (desc, "Host/scanned", ARG_INT, (void *) 1);
  plug_set_key (desc, "Host/scanners/openvas_tcp_scanner", ARG_INT, (void *) 1);
  return NULL;
}

References ARG_INT, banner_grab(), GRAB_MAX_SOCK, GRAB_MAX_SOCK_SAFE, GRAB_MIN_SOCK, script_infos::ip, plug_set_key(), safe_checks(), and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

plugin_run_synscan()

tree_cell* plugin_run_synscan

(

lex_ctxt *

)

Definition at line 778 of file nasl_builtin_synscan.c.

{
  struct script_infos *env = lexic->script_infos;
  unsigned long rtt;
  struct in6_addr *dst6 = plug_get_host_ip (env);
  struct in_addr *dst;
  struct in_addr inaddr;
 
  inaddr.s_addr = dst6->s6_addr32[3];
  dst = &inaddr;
 
  if (islocalhost (dst))
    return NULL;
 
  rtt = htonl (1 << 28);
 
  const char *range = prefs_get ("port_range");
  scan (env, (char *) range, dst6, rtt);
  plug_set_key (env, "Host/scanned", ARG_INT, (void *) 1);
  plug_set_key (env, "Host/scanners/synscan", ARG_INT, (void *) 1);
  return NULL;
}

References ARG_INT, islocalhost(), plug_get_host_ip(), plug_set_key(), scan(), and struct_lex_ctxt::script_infos.

Here is the call graph for this function: