gmp.h File Reference

API for Greenbone Management Protocol communication. More...

#include "../base/array.h"
#include "../util/serverutils.h"
#include "../util/xmlutils.h"
#include <glib.h>
#include <glib/gtypes.h>
#include <gnutls/gnutls.h>
#include <stddef.h>

Include dependency graph for gmp.h:

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

Go to the source code of this file.

Data Structures
struct	gmp_authenticate_info_opts_t
	Struct holding options for authentication. More...
struct	gmp_get_report_opts_t
	Struct holding options for gmp get_report command. More...
struct	gmp_get_tasks_opts_t
	Struct holding options for gmp get_tasks command. More...
struct	gmp_get_task_opts_t
	Struct holding options for gmp get_tasks command. More...
struct	gmp_create_task_opts_t
	Struct holding options for gmp create_task command. More...
struct	gmp_create_target_opts_t
	Struct holding options for gmp create_target command. More...
struct	gmp_get_system_reports_opts_t
	Struct holding options for gmp get_system_reports command. More...
struct	gmp_create_lsc_credential_opts_t
	Struct holding options for gmp create_lsc_credential command. More...
struct	gmp_delete_opts_t
	Struct holding options for various gmp delete_[...] commands. More...
struct	gmp_start_task_opts_t
	Struct holding options for gmp start_task command. More...

Functions
int	gmp_read_create_response (gnutls_session_t *, gchar **)
	Read response status and resource UUID.
const char *	gmp_task_status (entity_t status_response)
	Get the task status from a GMP GET_TASKS response.
int	gmp_ping (gnutls_session_t *, int)
	"Ping" the manager.
int	gmp_ping_c (gvm_connection_t *, int, gchar **)
	"Ping" the manager.
int	gmp_authenticate (gnutls_session_t *session, const char *username, const char *password)
	Authenticate with the manager.
int	gmp_authenticate_info_ext (gnutls_session_t *, gmp_authenticate_info_opts_t)
	Authenticate with the manager.
int	gmp_authenticate_info_ext_c (gvm_connection_t *, gmp_authenticate_info_opts_t)
	Authenticate with the manager.
int	gmp_create_task (gnutls_session_t *, const char *, const char *, const char *, const char *, gchar **)
	Create a task given a config and target.
int	gmp_create_task_ext (gnutls_session_t *, gmp_create_task_opts_t, gchar **)
	Create a task.
int	gmp_start_task_report (gnutls_session_t *, const char *, char **)
	Start a task and read the manager response.
int	gmp_start_task_report_c (gvm_connection_t *, const char *, char **)
	Start a task and read the manager response.
int	gmp_start_task_ext_c (gvm_connection_t *, gmp_start_task_opts_t)
	Start a task and read the manager response.
int	gmp_stop_task (gnutls_session_t *, const char *)
	Stop a task and read the manager response.
int	gmp_stop_task_c (gvm_connection_t *, const char *)
	Stop a task and read the manager response.
int	gmp_resume_task_report (gnutls_session_t *, const char *, char **)
	Resume a task and read the manager response.
int	gmp_resume_task_report_c (gvm_connection_t *, const char *, char **)
	Resume a task and read the manager response.
int	gmp_get_tasks (gnutls_session_t *, const char *, int, int, entity_t *)
	Get the status of a task.
int	gmp_get_tasks_ext (gnutls_session_t *, gmp_get_tasks_opts_t, entity_t *)
	Get all tasks (generic version).
int	gmp_get_task_ext (gnutls_session_t *, gmp_get_task_opts_t, entity_t *)
	Get a task (generic version).
int	gmp_get_targets (gnutls_session_t *, const char *, int, int, entity_t *)
	Get a target.
int	gmp_get_report_ext (gnutls_session_t *, gmp_get_report_opts_t, entity_t *)
	Get a report (generic version).
int	gmp_delete_port_list_ext (gnutls_session_t *, const char *, gmp_delete_opts_t)
	Delete a port list.
int	gmp_delete_task (gnutls_session_t *, const char *)
	Delete a task and read the manager response.
int	gmp_delete_task_ext (gnutls_session_t *, const char *, gmp_delete_opts_t)
	Delete a task and read the manager response.
int	gmp_modify_task_file (gnutls_session_t *, const char *, const char *, const void *, gsize)
	Modify a file on a task.
int	gmp_delete_report (gnutls_session_t *, const char *)
	Remove a report.
int	gmp_create_target_ext (gnutls_session_t *, gmp_create_target_opts_t, gchar **)
	Create a target.
int	gmp_delete_target_ext (gnutls_session_t *, const char *, gmp_delete_opts_t)
	Delete a target.
int	gmp_delete_config_ext (gnutls_session_t *, const char *, gmp_delete_opts_t)
	Delete a config.
int	gmp_create_lsc_credential_ext (gnutls_session_t *, gmp_create_lsc_credential_opts_t, gchar **)
	Create an LSC credential.
int	gmp_create_lsc_credential (gnutls_session_t *, const char *, const char *, const char *, const char *, gchar **)
	Create an LSC Credential.
int	gmp_create_lsc_credential_key (gnutls_session_t *, const char *, const char *, const char *, const char *, const char *, gchar **)
	Create an LSC Credential with a key.
int	gmp_delete_lsc_credential_ext (gnutls_session_t *, const char *, gmp_delete_opts_t)
	Delete a LSC credential.
int	gmp_get_system_reports (gnutls_session_t *, const char *, int, entity_t *)
	Get system reports.
int	gmp_get_system_reports_ext (gnutls_session_t *, gmp_get_system_reports_opts_t, entity_t *)
	Get system reports.

Variables
static const gmp_authenticate_info_opts_t	gmp_authenticate_info_opts_defaults
	Sensible default values for gmp_authenticate_info_opts_t.
static const gmp_get_report_opts_t	gmp_get_report_opts_defaults
	Sensible default values for gmp_get_report_opts_t.
static const gmp_get_tasks_opts_t	gmp_get_tasks_opts_defaults
	Sensible default values for gmp_get_tasks_opts_t.
static const gmp_get_task_opts_t	gmp_get_task_opts_defaults
	Sensible default values for gmp_get_tasks_opts_t.
static const gmp_create_task_opts_t	gmp_create_task_opts_defaults
	Sensible default values for gmp_get_report_opts_t.
static const gmp_create_target_opts_t	gmp_create_target_opts_defaults
	Sensible default values for gmp_get_report_opts_t.
static const gmp_get_system_reports_opts_t	gmp_get_system_reports_opts_defaults = {NULL, NULL, NULL, NULL, NULL, 0}
	Sensible default values for gmp_get_report_opts_t.
static const gmp_create_lsc_credential_opts_t	gmp_create_lsc_credential_opts_defaults
	Sensible default values for gmp_create_lsc_credential_opts_t.
static const gmp_delete_opts_t	gmp_delete_opts_defaults = {0}
	Sensible default values for gmp_get_report_opts_t.
static const gmp_delete_opts_t	gmp_delete_opts_ultimate_defaults = {1}
	Default values for gmp_get_report_opts_t for ultimate deletion.
static const gmp_start_task_opts_t	gmp_start_task_opts_defaults = {NULL}

Detailed Description

API for Greenbone Management Protocol communication.

Definition in file gmp.h.

Function Documentation

gmp_authenticate()

int gmp_authenticate	(	gnutls_session_t *	session,
		const char *	username,
		const char *	password )

Authenticate with the manager.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	username	Username.
[in]	password	Password.

Returns

0 on success, 1 if manager closed connection, 2 if auth failed, -1 on error.

Definition at line 321 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  /* Send the auth request. */
  ret = gvm_server_sendf_xml_quiet (session,
                                    "<authenticate><credentials>"
                                    "<username>%s</username>"
                                    "<password>%s</password>"
                                    "</credentials></authenticate>",
                                    username ? username : "",
                                    password ? password : "");
  if (ret)
    return ret;
 
  /* Read the response. */
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    {
      free_entity (entity);
      return ret;
    }
  else if (ret == -1)
    return ret;
  return 2;
}

References free_entity(), gmp_check_response(), and gvm_server_sendf_xml_quiet().

Here is the call graph for this function:

gmp_authenticate_info_ext()

int gmp_authenticate_info_ext	(	gnutls_session_t *	session,
		gmp_authenticate_info_opts_t	opts )

Authenticate with the manager.

Parameters

[in]	session	Pointer to GNUTLS session.
[in,out]	opts	In: Struct containing the options to apply. Out: Additional account information if authentication was successful.

Returns

0 on success, 1 if manager closed connection, 2 if auth failed, 3 on timeout, -1 on error.

Definition at line 364 of file gmp.c.

{
  entity_t entity;
  const char *status;
  char first;
  int ret;
 
  *(opts.timezone) = NULL;
 
  /* Send the auth request. */
 
  ret = gvm_server_sendf_xml_quiet (session,
                                    "<authenticate><credentials>"
                                    "<username>%s</username>"
                                    "<password>%s</password>"
                                    "</credentials></authenticate>",
                                    opts.username, opts.password);
  if (ret)
    return ret;
 
  /* Read the response. */
 
  entity = NULL;
  switch (try_read_entity (session, opts.timeout, &entity))
    {
    case 0:
      break;
    case -4:
      return 3;
    default:
      return -1;
    }
 
  /* Check the response. */
 
  status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
  first = status[0];
  if (first == '2')
    {
      entity_t timezone_entity, role_entity, pw_warn_entity;
      /* Get the extra info. */
      timezone_entity = entity_child (entity, "timezone");
      if (timezone_entity)
        *opts.timezone = g_strdup (entity_text (timezone_entity));
      role_entity = entity_child (entity, "role");
      if (role_entity)
        *opts.role = g_strdup (entity_text (role_entity));
      pw_warn_entity = entity_child (entity, "password_warning");
      if (pw_warn_entity)
        *(opts.pw_warning) = g_strdup (entity_text (pw_warn_entity));
      else
        *(opts.pw_warning) = NULL;
 
      free_entity (entity);
      return 0;
    }
  free_entity (entity);
  return 2;
}

References entity_attribute(), entity_child(), entity_text(), free_entity(), gvm_server_sendf_xml_quiet(), gmp_authenticate_info_opts_t::password, gmp_authenticate_info_opts_t::pw_warning, gmp_authenticate_info_opts_t::role, gmp_authenticate_info_opts_t::timeout, gmp_authenticate_info_opts_t::timezone, try_read_entity(), and gmp_authenticate_info_opts_t::username.

Here is the call graph for this function:

gmp_authenticate_info_ext_c()

int gmp_authenticate_info_ext_c	(	gvm_connection_t *	connection,
		gmp_authenticate_info_opts_t	opts )

Authenticate with the manager.

Parameters

[in]	connection	Connection
[in]	opts	Struct containing the options to apply.

Returns

0 on success, 1 if manager closed connection, 2 if auth failed, 3 on timeout, -1 on error.

Definition at line 445 of file gmp.c.

{
  entity_t entity;
  const char *status;
  char first;
  int ret;
 
  if (opts.timezone)
    *(opts.timezone) = NULL;
 
  /* Send the auth request. */
 
  ret = gvm_connection_sendf_xml_quiet (connection,
                                        "<authenticate>"
                                        "<credentials>"
                                        "<username>%s</username>"
                                        "<password>%s</password>"
                                        "</credentials>"
                                        "</authenticate>",
                                        opts.username, opts.password);
  if (ret)
    return ret;
 
  /* Read the response. */
 
  entity = NULL;
  switch (try_read_entity_c (connection, opts.timeout, &entity))
    {
    case 0:
      break;
    case -4:
      return 3;
    default:
      return -1;
    }
 
  /* Check the response. */
 
  status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
  first = status[0];
  if (first == '2')
    {
      entity_t timezone_entity, role_entity;
      /* Get the extra info. */
      timezone_entity = entity_child (entity, "timezone");
      if (timezone_entity && opts.timezone)
        *opts.timezone = g_strdup (entity_text (timezone_entity));
      role_entity = entity_child (entity, "role");
      if (role_entity && opts.role)
        *opts.role = g_strdup (entity_text (role_entity));
      if (opts.pw_warning)
        {
          entity_t pw_warn_entity;
          pw_warn_entity = entity_child (entity, "password_warning");
          if (pw_warn_entity)
            *(opts.pw_warning) = g_strdup (entity_text (pw_warn_entity));
          else
            *(opts.pw_warning) = NULL;
        }
 
      free_entity (entity);
      return 0;
    }
  free_entity (entity);
  return 2;
}

References entity_attribute(), entity_child(), entity_text(), free_entity(), gvm_connection_sendf_xml_quiet(), gmp_authenticate_info_opts_t::password, gmp_authenticate_info_opts_t::pw_warning, gmp_authenticate_info_opts_t::role, gmp_authenticate_info_opts_t::timeout, gmp_authenticate_info_opts_t::timezone, try_read_entity_c(), and gmp_authenticate_info_opts_t::username.

Here is the call graph for this function:

gmp_create_lsc_credential()

int gmp_create_lsc_credential	(	gnutls_session_t *	session,
		const char *	name,
		const char *	login,
		const char *	password,
		const char *	comment,
		gchar **	uuid )

Create an LSC Credential.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	name	Name of LSC Credential.
[in]	login	Login associated with name.
[in]	password	Password, or NULL for autogenerated credentials.
[in]	comment	LSC Credential comment.
[out]	uuid	Either NULL or address for UUID of created credential.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1724 of file gmp.c.

{
  int ret;
 
  if (password)
    {
      if (comment)
        ret = gvm_server_sendf_xml_quiet (session,
                                          "<create_credential>"
                                          "<name>%s</name>"
                                          "<login>%s</login>"
                                          "<password>%s</password>"
                                          "<comment>%s</comment>"
                                          "</create_credential>",
                                          name, login, password, comment);
      else
        ret = gvm_server_sendf_xml_quiet (session,
                                          "<create_credential>"
                                          "<name>%s</name>"
                                          "<login>%s</login>"
                                          "<password>%s</password>"
                                          "</create_credential>",
                                          name, login, password);
    }
  else
    {
      if (comment)
        ret = gvm_server_sendf_xml (session,
                                    "<create_credential>"
                                    "<name>%s</name>"
                                    "<login>%s</login>"
                                    "<comment>%s</comment>"
                                    "</create_credential>",
                                    name, login, comment);
      else
        ret = gvm_server_sendf_xml (session,
                                    "<create_credential>"
                                    "<name>%s</name>"
                                    "<login>%s</login>"
                                    "</create_credential>",
                                    name, login);
    }
  if (ret)
    return -1;
 
  ret = gmp_read_create_response (session, uuid);
  if (ret == 201)
    return 0;
  return ret;
}

References gmp_read_create_response(), gvm_server_sendf_xml(), and gvm_server_sendf_xml_quiet().

Here is the call graph for this function:

gmp_create_lsc_credential_ext()

int gmp_create_lsc_credential_ext	(	gnutls_session_t *	session,
		gmp_create_lsc_credential_opts_t	opts,
		gchar **	id )

Create an LSC credential.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	id	Pointer for newly allocated ID of new LSC credential, or NULL. Only set on successful return.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1845 of file gmp.c.

{
  gchar *comment, *pass, *start, *snmp_elems;
  int ret;
 
  /* Create the GMP request. */
 
  if (opts.login == NULL)
    return -1;
 
  start =
    g_markup_printf_escaped ("<create_credential>"
                             "<name>%s</name>"
                             "<login>%s</login>",
                             opts.name ? opts.name : "unnamed", opts.login);
 
  if (opts.comment)
    comment = g_markup_printf_escaped ("<comment>"
                                       "%s"
                                       "</comment>",
                                       opts.comment);
  else
    comment = NULL;
 
  if (opts.private_key)
    pass = g_markup_printf_escaped ("<key>"
                                    "<phrase>%s</phrase>"
                                    "<private>%s</private>"
                                    "</key>",
                                    opts.passphrase ? opts.passphrase : "",
                                    opts.private_key);
  else
    {
      if (opts.passphrase)
        pass = g_markup_printf_escaped ("<password>"
                                        "%s"
                                        "</password>",
                                        opts.passphrase);
      else
        pass = NULL;
    }
 
  if (opts.community && opts.auth_algorithm && opts.privacy_password
      && opts.privacy_algorithm)
    snmp_elems =
      g_markup_printf_escaped ("<community>"
                               "%s"
                               "</community>"
                               "<auth_algorithm>"
                               "%s"
                               "</auth_algorithm>"
                               "<privacy>"
                               "<password>%s</password>"
                               "<algorithm>%s</algorithm>"
                               "</privacy>",
                               opts.community, opts.auth_algorithm,
                               opts.privacy_password, opts.privacy_algorithm);
  else
    snmp_elems = NULL;
 
  /* Send the request. */
 
  ret = gvm_server_sendf (session, "%s%s%s%s</create_credential>", start,
                          comment ? comment : "", pass ? pass : "",
                          snmp_elems ? snmp_elems : "");
 
  g_free (start);
  g_free (comment);
  g_free (pass);
  if (ret)
    return -1;
 
  /* Read the response. */
 
  ret = gmp_read_create_response (session, id);
  if (ret == 201)
    return 0;
  return ret;
}

References gmp_create_lsc_credential_opts_t::auth_algorithm, gmp_create_lsc_credential_opts_t::comment, gmp_create_lsc_credential_opts_t::community, gmp_read_create_response(), gvm_server_sendf(), gmp_create_lsc_credential_opts_t::login, gmp_create_lsc_credential_opts_t::name, gmp_create_lsc_credential_opts_t::passphrase, gmp_create_lsc_credential_opts_t::privacy_algorithm, gmp_create_lsc_credential_opts_t::privacy_password, and gmp_create_lsc_credential_opts_t::private_key.

Here is the call graph for this function:

gmp_create_lsc_credential_key()

int gmp_create_lsc_credential_key	(	gnutls_session_t *	session,
		const char *	name,
		const char *	login,
		const char *	passphrase,
		const char *	private_key,
		const char *	comment,
		gchar **	uuid )

Create an LSC Credential with a key.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	name	Name of LSC Credential.
[in]	login	Login associated with name.
[in]	passphrase	Passphrase for private key.
[in]	private_key	Private key.
[in]	comment	LSC Credential comment.
[out]	uuid	Either NULL or address for UUID of created credential.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1792 of file gmp.c.

{
  int ret;
 
  if (comment)
    ret = gvm_server_sendf_xml (session,
                                "<create_credential>"
                                "<name>%s</name>"
                                "<login>%s</login>"
                                "<key>"
                                "<phrase>%s</phrase>"
                                "<private>%s</private>"
                                "</key>"
                                "<comment>%s</comment>"
                                "</create_credential>",
                                name, login, passphrase ? passphrase : "",
                                private_key, comment);
  else
    ret = gvm_server_sendf_xml (session,
                                "<create_credential>"
                                "<name>%s</name>"
                                "<login>%s</login>"
                                "<key>"
                                "<phrase>%s</phrase>"
                                "<private>%s</private>"
                                "</key>"
                                "</create_credential>",
                                name, login, passphrase ? passphrase : "",
                                private_key);
 
  if (ret)
    return -1;
 
  ret = gmp_read_create_response (session, uuid);
  if (ret == 201)
    return 0;
  return ret;
}

References gmp_read_create_response(), and gvm_server_sendf_xml().

Here is the call graph for this function:

gmp_create_target_ext()

int gmp_create_target_ext	(	gnutls_session_t *	session,
		gmp_create_target_opts_t	opts,
		gchar **	id )

Create a target.

FIXME: Using the according opts it should be possible to generate any type of create_target request defined by the spec.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	id	Pointer for newly allocated ID of new target, or NULL. Only set on successful return.

Returns

0 on success (GMP 201), -2 on connection error, GMP response code on GMP error, -1 other error.

Definition at line 1542 of file gmp.c.

{
  gchar *comment, *ssh, *smb, *esxi, *snmp, *port_range, *start;
  gchar *exclude_hosts, *alive_tests;
  int ret;
 
  /* Create the GMP request. */
 
  if (opts.hosts == NULL)
    return -1;
 
  start =
    g_markup_printf_escaped ("<create_target>"
                             "<name>%s</name>"
                             "<hosts>%s</hosts>",
                             opts.name ? opts.name : "unnamed", opts.hosts);
 
  if (opts.exclude_hosts)
    exclude_hosts = g_markup_printf_escaped ("<exclude_hosts>"
                                             "%s"
                                             "</exclude_hosts>",
                                             opts.exclude_hosts);
  else
    exclude_hosts = NULL;
 
  if (opts.alive_tests)
    alive_tests = g_markup_printf_escaped ("<alive_tests>"
                                           "%s"
                                           "</alive_tests>",
                                           opts.alive_tests);
  else
    alive_tests = NULL;
 
  if (opts.comment)
    comment = g_markup_printf_escaped ("<comment>"
                                       "%s"
                                       "</comment>",
                                       opts.comment);
  else
    comment = NULL;
 
  if (opts.ssh_credential_id)
    {
      if (opts.ssh_credential_port)
        ssh = g_markup_printf_escaped ("<ssh_lsc_credential id=\"%s\">"
                                       "<port>%i</port>"
                                       "</ssh_lsc_credential>",
                                       opts.ssh_credential_id,
                                       opts.ssh_credential_port);
      else
        ssh = g_markup_printf_escaped ("<ssh_lsc_credential id=\"%s\"/>",
                                       opts.ssh_credential_id);
    }
  else
    ssh = NULL;
 
  if (opts.smb_credential_id)
    smb = g_markup_printf_escaped ("<smb_lsc_credential id=\"%s\"/>",
                                   opts.smb_credential_id);
  else
    smb = NULL;
 
  if (opts.esxi_credential_id)
    esxi = g_markup_printf_escaped ("<esxi_lsc_credential id=\"%s\"/>",
                                    opts.esxi_credential_id);
  else
    esxi = NULL;
 
  if (opts.snmp_credential_id)
    snmp = g_markup_printf_escaped ("<snmp_credential id=\"%s\"/>",
                                    opts.snmp_credential_id);
  else
    snmp = NULL;
 
  if (opts.port_range)
    port_range =
      g_markup_printf_escaped ("<port_range>%s</port_range>", opts.port_range);
  else
    port_range = NULL;
 
  /* Send the request. */
  ret = gvm_server_sendf (session,
                          "%s%s%s%s%s%s%s%s%s"
                          "<reverse_lookup_only>%d</reverse_lookup_only>"
                          "<reverse_lookup_unify>%d</reverse_lookup_unify>"
                          "</create_target>",
                          start, exclude_hosts ? exclude_hosts : "",
                          alive_tests ? alive_tests : "", ssh ? ssh : "",
                          smb ? smb : "", esxi ? esxi : "", snmp ? snmp : "",
                          port_range ? port_range : "", comment ? comment : "",
                          opts.reverse_lookup_only, opts.reverse_lookup_unify);
  g_free (start);
  g_free (exclude_hosts);
  g_free (alive_tests);
  g_free (ssh);
  g_free (smb);
  g_free (esxi);
  g_free (port_range);
  g_free (comment);
  if (ret)
    return -2;
 
  /* Read the response. */
 
  ret = gmp_read_create_response (session, id);
  if (ret == 201)
    return 0;
  return ret;
}

References gmp_create_target_opts_t::alive_tests, gmp_create_target_opts_t::comment, gmp_create_target_opts_t::esxi_credential_id, gmp_create_target_opts_t::exclude_hosts, gmp_read_create_response(), gvm_server_sendf(), gmp_create_target_opts_t::hosts, gmp_create_target_opts_t::name, gmp_create_target_opts_t::port_range, gmp_create_target_opts_t::reverse_lookup_only, gmp_create_target_opts_t::reverse_lookup_unify, gmp_create_target_opts_t::smb_credential_id, gmp_create_target_opts_t::snmp_credential_id, gmp_create_target_opts_t::ssh_credential_id, and gmp_create_target_opts_t::ssh_credential_port.

Here is the call graph for this function:

gmp_create_task()

int gmp_create_task	(	gnutls_session_t *	session,
		const char *	name,
		const char *	config,
		const char *	target,
		const char *	comment,
		gchar **	id )

Create a task given a config and target.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	name	Task name.
[in]	config	Task config name.
[in]	target	Task target name.
[in]	comment	Task comment.
[out]	id	Pointer for newly allocated ID of new task. Only set on successful return.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 717 of file gmp.c.

{
  int ret;
 
  ret = gvm_server_sendf_xml (session,
                              "<create_task>"
                              "<config id=\"%s\"/>"
                              "<target id=\"%s\"/>"
                              "<name>%s</name>"
                              "<comment>%s</comment>"
                              "</create_task>",
                              config, target, name, comment);
  if (ret)
    return -1;
 
  /* Read the response. */
 
  ret = gmp_read_create_response (session, id);
  if (ret == 201)
    return 0;
  return ret;
}

References gmp_read_create_response(), and gvm_server_sendf_xml().

Here is the call graph for this function:

gmp_create_task_ext()

int gmp_create_task_ext	(	gnutls_session_t *	session,
		gmp_create_task_opts_t	opts,
		gchar **	id )

Create a task.

FIXME: Using the according opts it should be possible to generate any type of create_task request defined by the spec.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	id	Pointer for newly allocated ID of new task, or NULL. Only set on successful return.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 537 of file gmp.c.

{
  /* Create the GMP request. */
 
  gchar *prefs, *start, *hosts_ordering, *scanner, *schedule, *slave;
  GString *alerts, *observers;
  int ret;
  if ((opts.config_id == NULL) || (opts.target_id == NULL))
    return -1;
 
  prefs = NULL;
  start = g_markup_printf_escaped (
    "<create_task>"
    "<config id=\"%s\"/>"
    "<target id=\"%s\"/>"
    "<name>%s</name>"
    "<comment>%s</comment>"
    "<alterable>%d</alterable>",
    opts.config_id, opts.target_id, opts.name ? opts.name : "unnamed",
    opts.comment ? opts.comment : "", opts.alterable ? 1 : 0);
 
  if (opts.hosts_ordering)
    hosts_ordering = g_strdup_printf ("<hosts_ordering>%s</hosts_ordering>",
                                      opts.hosts_ordering);
  else
    hosts_ordering = NULL;
 
  if (opts.scanner_id)
    scanner = g_strdup_printf ("<scanner id=\"%s\"/>", opts.scanner_id);
  else
    scanner = NULL;
 
  if (opts.schedule_id)
    schedule = g_strdup_printf ("<schedule id=\"%s\"/>"
                                "<schedule_periods>%d</schedule_periods>",
                                opts.schedule_id, opts.schedule_periods);
  else
    schedule = NULL;
 
  if (opts.slave_id)
    slave = g_strdup_printf ("<slave id=\"%s\"/>", opts.slave_id);
  else
    slave = NULL;
 
  if (opts.max_checks || opts.max_hosts || opts.in_assets || opts.source_iface)
    {
      gchar *in_assets, *checks, *hosts, *source_iface;
 
      in_assets = checks = hosts = source_iface = NULL;
 
      if (opts.in_assets)
        in_assets = g_markup_printf_escaped ("<preference>"
                                             "<scanner_name>"
                                             "in_assets"
                                             "</scanner_name>"
                                             "<value>"
                                             "%s"
                                             "</value>"
                                             "</preference>",
                                             opts.in_assets);
 
      if (opts.max_hosts)
        hosts = g_markup_printf_escaped ("<preference>"
                                         "<scanner_name>"
                                         "max_hosts"
                                         "</scanner_name>"
                                         "<value>"
                                         "%s"
                                         "</value>"
                                         "</preference>",
                                         opts.max_hosts);
 
      if (opts.max_checks)
        checks = g_markup_printf_escaped ("<preference>"
                                          "<scanner_name>"
                                          "max_checks"
                                          "</scanner_name>"
                                          "<value>"
                                          "%s"
                                          "</value>"
                                          "</preference>",
                                          opts.max_checks);
 
      if (opts.source_iface)
        source_iface = g_markup_printf_escaped ("<preference>"
                                                "<scanner_name>"
                                                "source_iface"
                                                "</scanner_name>"
                                                "<value>"
                                                "%s"
                                                "</value>"
                                                "</preference>",
                                                opts.source_iface);
 
      prefs =
        g_strdup_printf ("<preferences>%s%s%s%s</preferences>",
                         in_assets ? in_assets : "", checks ? checks : "",
                         hosts ? hosts : "", source_iface ? source_iface : "");
      g_free (in_assets);
      g_free (checks);
      g_free (hosts);
      g_free (source_iface);
    }
 
  if (opts.alert_ids)
    {
      unsigned int i;
      alerts = g_string_new ("");
      for (i = 0; i < opts.alert_ids->len; i++)
        {
          char *alert = (char *) g_ptr_array_index (opts.alert_ids, i);
          g_string_append_printf (alerts, "<alert id=\"%s\"/>", alert);
        }
    }
  else
    alerts = g_string_new ("");
 
  if (opts.observers || opts.observer_groups)
    {
      observers = g_string_new ("<observers>");
 
      if (opts.observers)
        g_string_append (observers, opts.observers);
 
      if (opts.observer_groups)
        {
          unsigned int i;
          for (i = 0; i < opts.observer_groups->len; i++)
            {
              char *group =
                (char *) g_ptr_array_index (opts.observer_groups, i);
              g_string_append_printf (observers, "<group id=\"%s\"/>", group);
            }
        }
      g_string_append (observers, "</observers>");
    }
  else
    observers = g_string_new ("");
 
  /* Send the request. */
  ret = gvm_server_sendf (
    session, "%s%s%s%s%s%s%s%s</create_task>", start, prefs ? prefs : "",
    hosts_ordering ? hosts_ordering : "", scanner ? scanner : "",
    schedule ? schedule : "", slave ? slave : "", alerts ? alerts->str : "",
    observers ? observers->str : "");
  g_free (start);
  g_free (prefs);
  g_free (hosts_ordering);
  g_free (scanner);
  g_free (schedule);
  g_free (slave);
  g_string_free (alerts, TRUE);
  g_string_free (observers, TRUE);
 
  if (ret)
    return -1;
 
  /* Read the response. */
 
  ret = gmp_read_create_response (session, id);
  if (ret == 201)
    return 0;
  return ret;
}

References gmp_create_task_opts_t::alert_ids, gmp_create_task_opts_t::alterable, gmp_create_task_opts_t::comment, gmp_create_task_opts_t::config_id, gmp_read_create_response(), gvm_server_sendf(), gmp_create_task_opts_t::hosts_ordering, gmp_create_task_opts_t::in_assets, gmp_create_task_opts_t::max_checks, gmp_create_task_opts_t::max_hosts, gmp_create_task_opts_t::name, gmp_create_task_opts_t::observer_groups, gmp_create_task_opts_t::observers, gmp_create_task_opts_t::scanner_id, gmp_create_task_opts_t::schedule_id, gmp_create_task_opts_t::schedule_periods, gmp_create_task_opts_t::slave_id, gmp_create_task_opts_t::source_iface, and gmp_create_task_opts_t::target_id.

Here is the call graph for this function:

gmp_delete_config_ext()

int gmp_delete_config_ext	(	gnutls_session_t *	session,
		const char *	id,
		gmp_delete_opts_t	opts )

Delete a config.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	UUID of config.
[in]	opts	Struct containing the options to apply.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1692 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session,
                        "<delete_config config_id=\"%s\" ultimate=\"%d\"/>", id,
                        opts.ultimate)
      == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), gvm_server_sendf(), and gmp_delete_opts_t::ultimate.

Here is the call graph for this function:

gmp_delete_lsc_credential_ext()

int gmp_delete_lsc_credential_ext	(	gnutls_session_t *	session,
		const char *	id,
		gmp_delete_opts_t	opts )

Delete a LSC credential.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	UUID of LSC credential.
[in]	opts	Struct containing the options to apply.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1937 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session,
                        "<delete_credential credential_id=\"%s\""
                        " ultimate=\"%d\"/>",
                        id, opts.ultimate)
      == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), gvm_server_sendf(), and gmp_delete_opts_t::ultimate.

Here is the call graph for this function:

gmp_delete_port_list_ext()

int gmp_delete_port_list_ext	(	gnutls_session_t *	session,
		const char *	id,
		gmp_delete_opts_t	opts )

Delete a port list.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	UUID of port list.
[in]	opts	Struct containing the options to apply.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1484 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (
        session, "<delete_port_list port_list_id=\"%s\" ultimate=\"%d\"/>", id,
        opts.ultimate)
      == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), gvm_server_sendf(), and gmp_delete_opts_t::ultimate.

Here is the call graph for this function:

gmp_delete_report()

int gmp_delete_report	(	gnutls_session_t *	session,
		const char *	id )

Remove a report.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of report.

Returns

0 on success, GMP response code on failure, -1 on error.

Definition at line 1512 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session, "<delete_report report_id=\"%s\"/>", id))
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_delete_target_ext()

int gmp_delete_target_ext	(	gnutls_session_t *	session,
		const char *	id,
		gmp_delete_opts_t	opts )

Delete a target.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	UUID of target.
[in]	opts	Struct containing the options to apply.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1663 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session,
                        "<delete_target target_id=\"%s\" ultimate=\"%d\"/>", id,
                        opts.ultimate)
      == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), gvm_server_sendf(), and gmp_delete_opts_t::ultimate.

Here is the call graph for this function:

gmp_delete_task()

int gmp_delete_task	(	gnutls_session_t *	session,
		const char *	id )

Delete a task and read the manager response.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of task.

Returns

0 on success, GMP response code on failure, -1 on error.

Definition at line 1320 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session, "<delete_task task_id=\"%s\"/>", id) == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_delete_task_ext()

int gmp_delete_task_ext	(	gnutls_session_t *	session,
		const char *	id,
		gmp_delete_opts_t	opts )

Delete a task and read the manager response.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of task.
[in]	opts	Struct containing the options to apply.

Returns

0 on success, GMP response code on failure, -1 on error.

Definition at line 1092 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session,
                        "<delete_task task_id=\"%s\" ultimate=\"%d\"/>", id,
                        opts.ultimate)
      == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), gvm_server_sendf(), and gmp_delete_opts_t::ultimate.

Here is the call graph for this function:

gmp_get_report_ext()

int gmp_get_report_ext	(	gnutls_session_t *	session,
		gmp_get_report_opts_t	opts,
		entity_t *	response )

Get a report (generic version).

FIXME: Using the according opts it should be possible to generate any type of get_reports request defined by the spec.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	response	Report. On success contains GET_REPORT response.

Returns

0 on success, 2 on timeout, -1 or GMP response code on error.

Definition at line 1386 of file gmp.c.

{
  int ret;
  const char *status_code;
 
  if (response == NULL)
    return -1;
 
  if (gvm_server_sendf (
        session,
        "<get_reports"
        " details=\"1\""
        " report_id=\"%s\""
        " format_id=\"%s\""
        " host_first_result=\"%i\""
        " host_max_results=\"%i\""
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s"
        "%s%s%s%s%s%s%s/>",
        opts.report_id, opts.format_id, opts.host_first_result,
        opts.host_max_results, GMP_FMT_STRING_ATTRIB (opts, type),
        GMP_FMT_STRING_ATTRIB (opts, filter),
        GMP_FMT_STRING_ATTRIB (opts, filt_id),
        GMP_FMT_STRING_ATTRIB (opts, host), GMP_FMT_STRING_ATTRIB (opts, pos),
        GMP_FMT_STRING_ATTRIB (opts, timezone),
        GMP_FMT_STRING_ATTRIB (opts, alert_id),
        GMP_FMT_STRING_ATTRIB (opts, delta_report_id),
        GMP_FMT_STRING_ATTRIB (opts, delta_states),
        GMP_FMT_STRING_ATTRIB (opts, host_levels),
        GMP_FMT_STRING_ATTRIB (opts, search_phrase),
        GMP_FMT_STRING_ATTRIB (opts, host_search_phrase),
        GMP_FMT_STRING_ATTRIB (opts, min_cvss_base),
        GMP_FMT_STRING_ATTRIB (opts, min_qod),
        GMP_FMT_BOOL_ATTRIB (opts, notes),
        GMP_FMT_BOOL_ATTRIB (opts, notes_details),
        GMP_FMT_BOOL_ATTRIB (opts, overrides),
        GMP_FMT_BOOL_ATTRIB (opts, override_details),
        GMP_FMT_BOOL_ATTRIB (opts, apply_overrides),
        GMP_FMT_BOOL_ATTRIB (opts, result_hosts_only),
        GMP_FMT_BOOL_ATTRIB (opts, ignore_pagination)))
    return -1;
 
  *response = NULL;
  switch (try_read_entity (session, opts.timeout, response))
    {
    case 0:
      break;
    case -4:
      return 2;
    default:
      return -1;
    }
 
  /* Check the response. */
 
  status_code = entity_attribute (*response, "status");
  if (status_code == NULL)
    {
      free_entity (*response);
      return -1;
    }
  if (strlen (status_code) == 0)
    {
      free_entity (*response);
      return -1;
    }
  if (status_code[0] == '2')
    return 0;
  ret = (int) strtol (status_code, NULL, 10);
  free_entity (*response);
  if (errno == ERANGE)
    return -1;
  return ret;
}

References entity_attribute(), gmp_get_report_opts_t::format_id, free_entity(), GMP_FMT_BOOL_ATTRIB, GMP_FMT_STRING_ATTRIB, gvm_server_sendf(), gmp_get_report_opts_t::host_first_result, gmp_get_report_opts_t::host_max_results, gmp_get_report_opts_t::report_id, gmp_get_report_opts_t::timeout, and try_read_entity().

Here is the call graph for this function:

gmp_get_system_reports()

int gmp_get_system_reports	(	gnutls_session_t *	session,
		const char *	name,
		int	brief,
		entity_t *	reports )

Get system reports.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	name	Name of system report. NULL for all.
[in]	brief	Whether to request brief response.
[out]	reports	Reports return. On success contains GET_SYSTEM_REPORTS response.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1969 of file gmp.c.

{
  if (name)
    {
      if (gvm_server_sendf (session,
                            "<get_system_reports name=\"%s\" brief=\"%i\"/>",
                            name, brief)
          == -1)
        return -1;
    }
  else if (gvm_server_sendf (session, "<get_system_reports brief=\"%i\"/>",
                             brief)
           == -1)
    return -1;
 
  /* Read and check the response. */
  return gmp_check_response (session, reports);
}

References gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_get_system_reports_ext()

int gmp_get_system_reports_ext	(	gnutls_session_t *	session,
		gmp_get_system_reports_opts_t	opts,
		entity_t *	reports )

Get system reports.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	reports	Reports return. On success contains GET_SYSTEM_REPORTS response.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 2000 of file gmp.c.

{
  GString *request;
 
  request = g_string_new ("<get_system_reports");
 
  if (opts.slave_id)
    xml_string_append (request, " slave_id=\"%s\"", opts.slave_id);
 
  if (opts.name)
    xml_string_append (request, " name=\"%s\"", opts.name);
 
  if (opts.duration)
    xml_string_append (request, " duration=\"%s\"", opts.duration);
 
  if (opts.start_time)
    xml_string_append (request, " start_time=\"%s\"", opts.start_time);
 
  if (opts.end_time)
    xml_string_append (request, " end_time=\"%s\"", opts.end_time);
 
  g_string_append (request, "/>");
 
  /* Create the GMP request. */
 
  if (gvm_server_sendf (session, "%s", request->str) == -1)
    {
      g_string_free (request, 1);
      return -1;
    }
  g_string_free (request, 1);
 
  /* Read and check the response. */
  return gmp_check_response (session, reports);
}

References gmp_get_system_reports_opts_t::duration, gmp_get_system_reports_opts_t::end_time, gmp_check_response(), gvm_server_sendf(), gmp_get_system_reports_opts_t::name, gmp_get_system_reports_opts_t::slave_id, gmp_get_system_reports_opts_t::start_time, and xml_string_append().

Here is the call graph for this function:

gmp_get_targets()

int gmp_get_targets	(	gnutls_session_t *	session,
		const char *	id,
		int	tasks,
		int	include_rcfile,
		entity_t *	target )

Get a target.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of target or NULL for all targets.
[in]	tasks	Whether to include tasks that use the target.
[in]	include_rcfile	Not used.
[out]	target	Target return. On success contains GET_TARGETS response.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1348 of file gmp.c.

{
  (void) include_rcfile;
  if (id == NULL)
    {
      if (gvm_server_sendf (session, "<get_targets tasks=\"%i\"/>", tasks)
          == -1)
        return -1;
    }
  else
    {
      if (gvm_server_sendf (session,
                            "<get_targets"
                            " target_id=\"%s\""
                            " tasks=\"%i\"/>",
                            id, tasks)
          == -1)
        return -1;
    }
 
  /* Read the response. */
  return gmp_check_response (session, target);
}

References gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_get_task_ext()

int gmp_get_task_ext	(	gnutls_session_t *	session,
		gmp_get_task_opts_t	opts,
		entity_t *	response )

Get a task (generic version).

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	response	Task. On success contains GET_TASKS response.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1159 of file gmp.c.

{
  if ((response == NULL) || (opts.task_id == NULL))
    return -1;
 
  if (opts.actions)
    {
      if (gvm_server_sendf (session,
                            "<get_tasks"
                            " task_id=\"%s\""
                            " actions=\"%s\""
                            "%s/>",
                            opts.task_id, opts.actions,
                            GMP_FMT_BOOL_ATTRIB (opts, details)))
        return -1;
    }
  else if (gvm_server_sendf (session,
                             "<get_tasks"
                             " task_id=\"%s\""
                             "%s/>",
                             opts.task_id, GMP_FMT_BOOL_ATTRIB (opts, details)))
    return -1;
 
  return gmp_check_response (session, response);
}

References gmp_get_task_opts_t::actions, gmp_check_response(), GMP_FMT_BOOL_ATTRIB, gvm_server_sendf(), and gmp_get_task_opts_t::task_id.

Here is the call graph for this function:

gmp_get_tasks()

int gmp_get_tasks	(	gnutls_session_t *	session,
		const char *	id,
		int	details,
		int	include_rcfile,
		entity_t *	status )

Get the status of a task.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of task or NULL for all tasks.
[in]	details	Whether to request task details.
[in]	include_rcfile	Ignored. Removed since GMP 6.0.
[out]	status	Status return. On success contains GET_TASKS response.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1124 of file gmp.c.

{
  (void) include_rcfile;
  if (id == NULL)
    {
      if (gvm_server_sendf (session, "<get_tasks details=\"%i\"/>", details)
          == -1)
        return -1;
    }
  else
    {
      if (gvm_server_sendf (session,
                            "<get_tasks"
                            " task_id=\"%s\""
                            " details=\"%i\"/>",
                            id, details)
          == -1)
        return -1;
    }
 
  /* Read the response. */
  return gmp_check_response (session, status);
}

References gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_get_tasks_ext()

int gmp_get_tasks_ext	(	gnutls_session_t *	session,
		gmp_get_tasks_opts_t	opts,
		entity_t *	response )

Get all tasks (generic version).

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	opts	Struct containing the options to apply.
[out]	response	Tasks. On success contains GET_TASKS response.

Returns

0 on success, 2 on timeout, -1 or GMP response code on error.

Definition at line 1196 of file gmp.c.

{
  int ret;
  const char *status_code;
  gchar *cmd;
 
  if (response == NULL)
    return -1;
 
  cmd = g_markup_printf_escaped ("<get_tasks"
                                 " filter=\"%s\"",
                                 opts.filter);
 
  if (gvm_server_sendf (session, "%s%s/>", cmd,
                        GMP_FMT_BOOL_ATTRIB (opts, details)))
    {
      g_free (cmd);
      return -1;
    }
  g_free (cmd);
 
  *response = NULL;
  switch (try_read_entity (session, opts.timeout, response))
    {
    case 0:
      break;
    case -4:
      return 2;
    default:
      return -1;
    }
 
  /* Check the response. */
 
  status_code = entity_attribute (*response, "status");
  if (status_code == NULL)
    {
      free_entity (*response);
      return -1;
    }
  if (strlen (status_code) == 0)
    {
      free_entity (*response);
      return -1;
    }
  if (status_code[0] == '2')
    return 0;
  ret = (int) strtol (status_code, NULL, 10);
  free_entity (*response);
  if (errno == ERANGE)
    return -1;
  return ret;
}

References entity_attribute(), gmp_get_tasks_opts_t::filter, free_entity(), GMP_FMT_BOOL_ATTRIB, gvm_server_sendf(), gmp_get_tasks_opts_t::timeout, and try_read_entity().

Here is the call graph for this function:

gmp_modify_task_file()

int gmp_modify_task_file	(	gnutls_session_t *	session,
		const char *	id,
		const char *	name,
		const void *	content,
		gsize	content_len )

Modify a file on a task.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of task.
[in]	name	Name of file.
[in]	content	New content. NULL to remove file.
[in]	content_len	Length of content.

Returns

0 on success, -1 or GMP response code on error.

Definition at line 1263 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (name == NULL)
    return -1;
 
  if (gvm_server_sendf (session, "<modify_task task_id=\"%s\">", id))
    return -1;
 
  if (content)
    {
      if (gvm_server_sendf (session, "<file name=\"%s\" action=\"update\">",
                            name))
        return -1;
 
      if (content_len)
        {
          gchar *base64_content =
            g_base64_encode ((guchar *) content, content_len);
          ret = gvm_server_sendf (session, "%s", base64_content);
          g_free (base64_content);
          if (ret)
            return -1;
        }
 
      if (gvm_server_sendf (session, "</file>"))
        return -1;
    }
  else
    {
      if (gvm_server_sendf (session, "<file name=\"%s\" action=\"remove\" />",
                            name))
        return -1;
    }
 
  if (gvm_server_sendf (session, "</modify_task>"))
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_ping()

int gmp_ping	(	gnutls_session_t *	session,
		int	timeout )

"Ping" the manager.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	timeout	Server idle time before giving up, in milliseconds. 0 to wait forever.

Returns

0 on success, 1 if manager closed connection, 2 on timeout, -1 on error.

Definition at line 190 of file gmp.c.

{
  entity_t entity;
  const char *status;
  char first;
  int ret;
 
  /* Send a GET_VERSION request. */
 
  ret = gvm_server_sendf (session, "<get_version/>");
  if (ret)
    return ret;
 
  /* Read the response, with a timeout. */
 
  entity = NULL;
  switch (try_read_entity (session, timeout, &entity))
    {
    case 0:
      break;
    case -4:
      return 2;
    default:
      return -1;
    }
 
  /* Check the response. */
 
  status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
  first = status[0];
  free_entity (entity);
  if (first == '2')
    return 0;
  return -1;
}

References entity_attribute(), free_entity(), gvm_server_sendf(), and try_read_entity().

Referenced by Ensure(), Ensure(), Ensure(), and Ensure().

Here is the call graph for this function:

Here is the caller graph for this function:

gmp_ping_c()

int gmp_ping_c	(	gvm_connection_t *	connection,
		int	timeout,
		gchar **	version )

"Ping" the manager.

Parameters

[in]	connection	Pointer to GNUTLS session.
[in]	timeout	Server idle time before giving up, in milliseconds. 0 to wait forever.
[out]	version	Return location for freshly allocated version if required, else NULL.

Returns

0 on success, 1 if manager closed connection, 2 on timeout, -1 on error.

Definition at line 249 of file gmp.c.

{
  entity_t entity;
  const char *status;
  int ret;
 
  if (version && *version)
    *version = NULL;
 
  /* Send a GET_VERSION request. */
 
  ret = gvm_connection_sendf (connection, "<get_version/>");
  if (ret)
    return ret;
 
  /* Read the response, with a timeout. */
 
  entity = NULL;
  switch (try_read_entity_c (connection, timeout, &entity))
    {
    case 0:
      break;
    case -4:
      return 2;
    default:
      return -1;
    }
 
  /* Check the response. */
 
  status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
  if (status[0] == '2')
    {
      if (version)
        {
          entity_t omp_version;
          omp_version = entity_child (entity, "version");
          if (omp_version == NULL)
            {
              free_entity (entity);
              return -1;
            }
          *version = strdup (entity_text (omp_version));
        }
      free_entity (entity);
      return 0;
    }
  free_entity (entity);
  return -1;
}

References entity_attribute(), entity_child(), entity_text(), free_entity(), gvm_connection_sendf(), and try_read_entity_c().

Here is the call graph for this function:

gmp_read_create_response()

int gmp_read_create_response	(	gnutls_session_t *	session,
		gchar **	uuid )

Read response status and resource UUID.

Parameters

[in]	session	Pointer to GNUTLS session.
[out]	uuid	Either NULL or address for freshly allocated UUID of created response.

Returns

GMP response code on success, -1 on error.

Definition at line 888 of file gmp.c.

{
  int ret;
  const char *status;
  entity_t entity;
 
  /* Read the response. */
 
  entity = NULL;
  if (read_entity (session, &entity))
    return -1;
 
  /* Parse the response. */
 
  status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
 
  if (uuid)
    {
      const char *id;
 
      id = entity_attribute (entity, "id");
      if (id == NULL)
        {
          free_entity (entity);
          return -1;
        }
      if (strlen (id) == 0)
        {
          free_entity (entity);
          return -1;
        }
      *uuid = g_strdup (id);
    }
 
  ret = atoi (status);
  free_entity (entity);
  return ret;
}

References entity_attribute(), free_entity(), and read_entity().

Referenced by Ensure(), Ensure(), Ensure(), Ensure(), gmp_create_lsc_credential(), gmp_create_lsc_credential_ext(), gmp_create_lsc_credential_key(), gmp_create_target_ext(), gmp_create_task(), and gmp_create_task_ext().

Here is the call graph for this function:

Here is the caller graph for this function:

gmp_resume_task_report()

int gmp_resume_task_report	(	gnutls_session_t *	session,
		const char *	task_id,
		char **	report_id )

Resume a task and read the manager response.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	task_id	ID of task.
[out]	report_id	ID of report.

Returns

0 on success, 1 on GMP failure, -1 on error.

Definition at line 989 of file gmp.c.

{
  int ret;
  entity_t entity;
  if (gvm_server_sendf (session, "<resume_task task_id=\"%s\"/>", task_id)
      == -1)
    return -1;
 
  /* Read the response. */
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
 
  if (ret == 0)
    {
      if (report_id)
        {
          entity_t report_id_xml = entity_child (entity, "report_id");
          if (report_id_xml)
            *report_id = g_strdup (entity_text (report_id_xml));
          else
            {
              free_entity (entity);
              return -1;
            }
        }
      free_entity (entity);
      return 0;
    }
  else if (ret == -1)
    return ret;
  return 1;
}

References entity_child(), entity_text(), free_entity(), gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_resume_task_report_c()

int gmp_resume_task_report_c	(	gvm_connection_t *	connection,
		const char *	task_id,
		char **	report_id )

Resume a task and read the manager response.

Parameters

[in]	connection	Connection.
[in]	task_id	ID of task.
[out]	report_id	ID of report.

Returns

0 on success, 1 on GMP failure, -1 on error.

Definition at line 1034 of file gmp.c.

{
  if (gvm_connection_sendf (connection, "<resume_task task_id=\"%s\"/>",
                            task_id)
      == -1)
    return -1;
 
  /* Read the response. */
 
  entity_t entity = NULL;
  if (read_entity_c (connection, &entity))
    return -1;
 
  /* Check the response. */
 
  const char *status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
  char first = status[0];
  if (first == '2')
    {
      if (report_id)
        {
          entity_t report_id_xml = entity_child (entity, "report_id");
          if (report_id_xml)
            *report_id = g_strdup (entity_text (report_id_xml));
          else
            {
              free_entity (entity);
              return -1;
            }
        }
      free_entity (entity);
      return 0;
    }
  free_entity (entity);
  return 1;
}

References entity_attribute(), entity_child(), entity_text(), free_entity(), gvm_connection_sendf(), and read_entity_c().

Here is the call graph for this function:

gmp_start_task_ext_c()

int gmp_start_task_ext_c	(	gvm_connection_t *	connection,
		gmp_start_task_opts_t	opts )

Start a task and read the manager response.

Parameters

[in]	connection	Connection.
[in]	opts	Options to apply.

Returns

0 on success, 99 permission denied, -1 or GMP response code on error.

Definition at line 857 of file gmp.c.

{
  int ret;
 
  /* Check args. */
 
  if (opts.task_id == NULL)
    return -1;
 
  /* Send request. */
 
  ret = gvm_connection_sendf (connection, "<start_task task_id=\"%s\"/>",
                              opts.task_id);
  if (ret)
    return -1;
 
  /* Read response. */
 
  return check_response_c (connection, 1);
}

References check_response_c(), gvm_connection_sendf(), and gmp_start_task_opts_t::task_id.

Here is the call graph for this function:

gmp_start_task_report()

int gmp_start_task_report	(	gnutls_session_t *	session,
		const char *	task_id,
		char **	report_id )

Start a task and read the manager response.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	task_id	ID of task.
[out]	report_id	ID of report.

Returns

0 on success, 1 on failure, -1 on error.

Definition at line 752 of file gmp.c.

{
  int ret;
  entity_t entity;
  if (gvm_server_sendf (session, "<start_task task_id=\"%s\"/>", task_id) == -1)
    return -1;
 
  /* Read the response. */
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
 
  if (ret == 0)
    {
      if (report_id)
        {
          entity_t report_id_xml = entity_child (entity, "report_id");
          if (report_id_xml)
            *report_id = g_strdup (entity_text (report_id_xml));
          else
            {
              free_entity (entity);
              return -1;
            }
        }
      free_entity (entity);
      return ret;
    }
  else if (ret == -1)
    return ret;
 
  return 1;
}

References entity_child(), entity_text(), free_entity(), gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_start_task_report_c()

int gmp_start_task_report_c	(	gvm_connection_t *	connection,
		const char *	task_id,
		char **	report_id )

Start a task and read the manager response.

Parameters

[in]	connection	Connection.
[in]	task_id	ID of task.
[out]	report_id	ID of report.

Returns

0 on success, 1 on failure, -1 on error.

Definition at line 797 of file gmp.c.

{
  entity_t entity;
  const char *status;
  char first;
 
  if (gvm_connection_sendf (connection, "<start_task task_id=\"%s\"/>", task_id)
      == -1)
    return -1;
 
  /* Read the response. */
 
  entity = NULL;
  if (read_entity_c (connection, &entity))
    return -1;
 
  /* Check the response. */
 
  status = entity_attribute (entity, "status");
  if (status == NULL)
    {
      free_entity (entity);
      return -1;
    }
  if (strlen (status) == 0)
    {
      free_entity (entity);
      return -1;
    }
  first = status[0];
  if (first == '2')
    {
      if (report_id)
        {
          entity_t report_id_xml = entity_child (entity, "report_id");
          if (report_id_xml)
            *report_id = g_strdup (entity_text (report_id_xml));
          else
            {
              free_entity (entity);
              return -1;
            }
        }
      free_entity (entity);
      return 0;
    }
  free_entity (entity);
  return 1;
}

References entity_attribute(), entity_child(), entity_text(), free_entity(), gvm_connection_sendf(), and read_entity_c().

Here is the call graph for this function:

gmp_stop_task()

int gmp_stop_task	(	gnutls_session_t *	session,
		const char *	id )

Stop a task and read the manager response.

Parameters

[in]	session	Pointer to GNUTLS session.
[in]	id	ID of task.

Returns

0 on success, GMP response code on failure, -1 on error.

Definition at line 946 of file gmp.c.

{
  entity_t entity;
  int ret;
 
  if (gvm_server_sendf (session, "<stop_task task_id=\"%s\"/>", id) == -1)
    return -1;
 
  entity = NULL;
  ret = gmp_check_response (session, &entity);
  if (ret == 0)
    free_entity (entity);
  return ret;
}

References free_entity(), gmp_check_response(), and gvm_server_sendf().

Here is the call graph for this function:

gmp_stop_task_c()

int gmp_stop_task_c	(	gvm_connection_t *	connection,
		const char *	id )

Stop a task and read the manager response.

Parameters

[in]	connection	Connection.
[in]	id	ID of task.

Returns

0 on success, GMP response code on failure, -1 on error.

Definition at line 970 of file gmp.c.

{
  if (gvm_connection_sendf (connection, "<stop_task task_id=\"%s\"/>", id)
      == -1)
    return -1;
 
  return gmp_check_response_c (connection);
}

References gmp_check_response_c(), and gvm_connection_sendf().

Here is the call graph for this function:

gmp_task_status()

const char * gmp_task_status

(

entity_t

response

)

Get the task status from a GMP GET_TASKS response.

Parameters

[in]

response

GET_TASKS response.

Returns

The entity_text of the status entity if the entity is found, else NULL.

Definition at line 48 of file gmp.c.

{
  entity_t task = entity_child (response, "task");
  if (task)
    {
      entity_t status = entity_child (task, "status");
      if (status)
        return entity_text (status);
    }
  return NULL;
}

References entity_child(), and entity_text().

Referenced by Ensure(), Ensure(), and Ensure().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

gmp_authenticate_info_opts_defaults

const gmp_authenticate_info_opts_t gmp_authenticate_info_opts_defaults

static

Initial value:

=
  {0, NULL, NULL, NULL, NULL, NULL}

Sensible default values for gmp_authenticate_info_opts_t.

Definition at line 39 of file gmp.h.

  {0, NULL, NULL, NULL, NULL, NULL};

gmp_create_lsc_credential_opts_defaults

const gmp_create_lsc_credential_opts_t gmp_create_lsc_credential_opts_defaults

static

Initial value:

= {NULL, NULL, NULL, NULL, NULL,
                                             NULL, NULL, NULL, NULL}

Sensible default values for gmp_create_lsc_credential_opts_t.

Definition at line 256 of file gmp.h.

                                            {NULL, NULL, NULL, NULL, NULL,
                                             NULL, NULL, NULL, NULL};

gmp_create_target_opts_defaults

const gmp_create_target_opts_t gmp_create_target_opts_defaults

static

Initial value:

= {
  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0}

Sensible default values for gmp_get_report_opts_t.

Definition at line 214 of file gmp.h.

                                                                        {
  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0};

gmp_create_task_opts_defaults

const gmp_create_task_opts_t gmp_create_task_opts_defaults

static

Initial value:

= {
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  NULL, NULL, 0,    NULL, NULL, NULL, NULL, 0}

Sensible default values for gmp_get_report_opts_t.

Definition at line 186 of file gmp.h.

                                                                    {
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  NULL, NULL, 0,    NULL, NULL, NULL, NULL, 0};

gmp_delete_opts_defaults

const gmp_delete_opts_t gmp_delete_opts_defaults = {0}

static

Sensible default values for gmp_get_report_opts_t.

Definition at line 270 of file gmp.h.

{0};

gmp_delete_opts_ultimate_defaults

const gmp_delete_opts_t gmp_delete_opts_ultimate_defaults = {1}

static

Default values for gmp_get_report_opts_t for ultimate deletion.

Definition at line 275 of file gmp.h.

{1};

gmp_get_report_opts_defaults

const gmp_get_report_opts_t gmp_get_report_opts_defaults

static

Sensible default values for gmp_get_report_opts_t.

Definition at line 86 of file gmp.h.

                                                                  {
  "ROWID",
  "ascending",
  "a994b278-1f62-11e1-96ac-406186ea4fc5",
  "hmlgd",
  NULL,
  1,
  -1,
  0,
  0,
  0,
  0,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  0,
  0,
  0,
  0,
  0,
  0,
  0};

gmp_get_system_reports_opts_defaults

const gmp_get_system_reports_opts_t gmp_get_system_reports_opts_defaults = {NULL, NULL, NULL, NULL, NULL, 0}

static

Sensible default values for gmp_get_report_opts_t.

Definition at line 234 of file gmp.h.

{NULL, NULL, NULL, NULL, NULL, 0};

gmp_get_task_opts_defaults

const gmp_get_task_opts_t gmp_get_task_opts_defaults

static

Initial value:

= {NULL, NULL, 0,
                                                               0}

Sensible default values for gmp_get_tasks_opts_t.

Definition at line 154 of file gmp.h.

                                                              {NULL, NULL, 0,
                                                               0};

gmp_get_tasks_opts_defaults

const gmp_get_tasks_opts_t gmp_get_tasks_opts_defaults

static

Initial value:

= {"", 0, NULL, 0,
                                                                 0}

Sensible default values for gmp_get_tasks_opts_t.

Definition at line 136 of file gmp.h.

                                                                {"", 0, NULL, 0,
                                                                 0};

gmp_start_task_opts_defaults

const gmp_start_task_opts_t gmp_start_task_opts_defaults = {NULL}

static

Definition at line 320 of file gmp.h.

{NULL};