nasl_http2.c File Reference

#include "nasl_http2.h"
#include "../misc/plugutils.h"
#include "../misc/user_agent.h"
#include "exec.h"
#include "nasl_debug.h"
#include "nasl_func.h"
#include "nasl_global_ctxt.h"
#include "nasl_lex_ctxt.h"
#include "nasl_socket.h"
#include "nasl_tree.h"
#include "nasl_var.h"
#include <ctype.h>
#include <curl/curl.h>
#include <gnutls/gnutls.h>
#include <gvm/base/prefs.h>
#include <gvm/util/kb.h>
#include <string.h>

Include dependency graph for nasl_http2.c:

Go to the source code of this file.

Data Structures
struct	handle_table_s
	Struct to store handles. More...
struct	string
	Define a string struct for storing the response. More...

Macros
#define	G_LOG_DOMAIN   "lib nasl"
	GLib log domain.
#define	MAX_HANDLES   10

Typedefs
typedef enum KEYWORD_E	KEYWORD
	Allowed methods.

Enumerations
enum	KEYWORD_E {   POST , GET , PUT , DELETE ,   HEAD }
	Allowed methods. More...

Functions
static int	next_handle_id (void)
	Get the new available handle identifier.
tree_cell *	nasl_http2_handle (lex_ctxt *lexic)
	Creates a handle for http requests.
tree_cell *	nasl_http2_close_handle (lex_ctxt *lexic)
	Close a handle for http requests previously initialized.
static void	init_string (struct string *s)
	Initialize the string struct to hold the response or header.
static size_t	response_callback_fn (void *ptr, size_t size, size_t nmemb, void *struct_string)
	Call back function to stored the response.
static size_t	header_callback_fn (char *buffer, size_t size, size_t nmemb, void *struct_string)
	Call back function to stored the header.
static tree_cell *	_http2_req (lex_ctxt *lexic, KEYWORD keyword)
	Perform an HTTP request. Forcing HTTP2 if possible.
tree_cell *	nasl_http2_get_response_code (lex_ctxt *lexic)
	Get the http response code after performing a HTTP request.
tree_cell *	nasl_http2_set_custom_header (lex_ctxt *lexic)
	Set a custom header element in the header.
tree_cell *	nasl_http2_get (lex_ctxt *lexic)
	Wrapper function for GET request. See _http2_req.
tree_cell *	nasl_http2_head (lex_ctxt *lexic)
	Wrapper function for HEAD request. See _http2_req.
tree_cell *	nasl_http2_post (lex_ctxt *lexic)
	Wrapper function for POST request. See _http2_req.
tree_cell *	nasl_http2_delete (lex_ctxt *lexic)
	Wrapper function for DELETE request. See _http2_req.
tree_cell *	nasl_http2_put (lex_ctxt *lexic)
	Wrapper function for PUT request. See _http2_req.

Variables
static struct handle_table_s *	handle_table [MAX_HANDLES]
	Handle Table.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "lib nasl"

GLib log domain.

Definition at line 31 of file nasl_http2.c.

MAX_HANDLES

#define MAX_HANDLES   10

Definition at line 55 of file nasl_http2.c.

Referenced by _http2_req(), nasl_http2_close_handle(), nasl_http2_get_response_code(), nasl_http2_handle(), and nasl_http2_set_custom_header().

Typedef Documentation

KEYWORD

typedef enum KEYWORD_E KEYWORD

Allowed methods.

Enumeration Type Documentation

KEYWORD_E

enum KEYWORD_E

Allowed methods.

Enumerator
POST
GET
PUT
DELETE
HEAD

Definition at line 37 of file nasl_http2.c.

{
  POST,
  GET,
  PUT,
  DELETE,
  HEAD,
} KEYWORD;

Function Documentation

_http2_req()

tree_cell * _http2_req ( lex_ctxt * lexic, KEYWORD keyword )

static

Perform an HTTP request. Forcing HTTP2 if possible.

NASL Named Parameters:\n

• handle The handle identifier
• port The port to use for the connection
• item The path
• schema Optional URL schema to be used. http or https. Default to https.
• data Optional data to be sent with POST or PUT

NASL Returns:\n http header followed by the response from the server. Null on error.

Parameters

[in]

lexic

Lexical context of NASL interpreter.

Returns

On success the function returns a tree-cell with the http header followed by the response from the server. Null on error.

Definition at line 252 of file nasl_http2.c.

{
  tree_cell *retc;
  char *item = get_str_var_by_name (lexic, "item");
  char *data = get_str_var_by_name (lexic, "data");
  int port = get_int_var_by_name (lexic, "port", -1);
  char *schema = get_str_var_by_name (lexic, "schema");
  struct script_infos *script_infos = lexic->script_infos;
  char *hostname;
  GString *url = NULL;
  CURL *handle = NULL;
  int handle_id = get_int_var_by_name (lexic, "handle", -1);
  struct string response, header_data;
 
  if (item == NULL || port < 0 || handle_id < 0)
    {
      nasl_perror (lexic,
                   "Error : http2_* functions have the following syntax :\n");
      nasl_perror (lexic, "http_*(handle: <handle>, port:<port>, item:<item> "
                          "[,schema:<schema>][, data:<data>]\n");
      return NULL;
    }
 
  unsigned int table_slot;
  for (table_slot = 0; table_slot < MAX_HANDLES; table_slot++)
    {
      if (handle_table[table_slot]->handle_id == handle_id)
        break;
      else
        {
          g_message ("%s: Unknown handle identifier %d", __func__, handle_id);
          return NULL;
        }
    }
 
  handle = handle_table[table_slot]->handle;
 
  if (port <= 0 || port > 65535)
    {
      nasl_perror (lexic, "http2_req: invalid value %d for port parameter\n",
                   port);
      return NULL;
    }
 
  // Fork here for every vhost
  hostname = plug_get_host_fqdn (script_infos);
  if (hostname == NULL)
    return NULL;
 
  curl_easy_reset (handle);
 
  // force http2
  curl_easy_setopt (handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
 
  // Build URL
  url = schema ? g_string_new (schema) : g_string_new ("https");
  g_string_append (url, "://");
  g_string_append (url, hostname);
 
  /* Servers should not have a problem with port 80 or 443 appended.
   * RFC2616 allows to omit the port in which case the default port for
   * that service is assumed.
   * However, some servers like IIS/OWA wrongly respond with a "404"
   * instead of a "200" in case the port is appended. Because of this,
   * ports 80 and 443 are not appended.
   */
  if (port != 80 && port != 443)
    {
      char buf[12];
      snprintf (buf, sizeof (buf), ":%d", port);
      g_string_append (url, buf);
    }
  g_string_append (url, item);
 
  g_message ("%s: URL: %s", __func__, url->str);
  // Set URL
  if (curl_easy_setopt (handle, CURLOPT_URL, url->str) != CURLE_OK)
    {
      g_warning ("Not possible to set the URL");
      curl_easy_cleanup (handle);
      return NULL;
    }
  g_string_free (url, TRUE);
 
  // Accept an insecure connection. Don't verify the server certificate
  curl_easy_setopt (handle, CURLOPT_SSL_VERIFYPEER, 0L);
  curl_easy_setopt (handle, CURLOPT_SSL_VERIFYHOST, 0L);
 
  // Set User Agent
  char *ua = NULL;
  if ((user_agent_get (lexic->script_infos->ipc_context, &ua) == -2)
      && !script_infos->standalone)
    {
      g_message ("Not possible to send the User Agent to the host process. "
                 "Invalid IPC context");
    }
  if (ua)
    {
      curl_easy_setopt (handle, CURLOPT_USERAGENT, g_strdup (url->str));
      g_free (ua);
    }
 
  // Init the struct where the response is stored and set the callback function
  init_string (&response);
  curl_easy_setopt (handle, CURLOPT_WRITEFUNCTION, response_callback_fn);
  curl_easy_setopt (handle, CURLOPT_WRITEDATA, &response);
 
  init_string (&header_data);
  curl_easy_setopt (handle, CURLOPT_HEADERFUNCTION, header_callback_fn);
  curl_easy_setopt (handle, CURLOPT_HEADERDATA, &header_data);
 
  switch (keyword)
    {
    case DELETE:
      curl_easy_setopt (handle, CURLOPT_CUSTOMREQUEST, "DELETE");
      break;
    case HEAD:
      curl_easy_setopt (handle, CURLOPT_NOBODY, 1L);
      break;
    case PUT:
      curl_easy_setopt (handle, CURLOPT_CUSTOMREQUEST, "PUT");
      if (data)
        {
          curl_easy_setopt (handle, CURLOPT_POSTFIELDS, data);
          curl_easy_setopt (handle, CURLOPT_POSTFIELDSIZE, strlen (data));
        }
      break;
    case GET:
      curl_easy_setopt (handle, CURLOPT_HTTPGET, 1L);
      break;
    case POST:
      // Set body. POST is set automatically with this options
      if (data)
        {
          curl_easy_setopt (handle, CURLOPT_POSTFIELDS, data);
          curl_easy_setopt (handle, CURLOPT_POSTFIELDSIZE, strlen (data));
        }
      break;
    default:
      g_message ("%s: Invalid http method.", __func__);
      break;
    }
 
  int ret = CURLE_OK;
  if ((ret = curl_easy_perform (handle)) != CURLE_OK)
    {
      g_warning ("%s: Error sending request: %d", __func__, ret);
      curl_easy_cleanup (handle);
      g_free (response.ptr);
      return NULL;
    }
 
  GString *complete_resp = g_string_new (header_data.ptr);
  g_string_append (complete_resp, "\n");
  g_string_append (complete_resp, response.ptr);
  g_free (response.ptr);
  g_free (header_data.ptr);
 
  long http_code = -1;
  curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &http_code);
  handle_table[table_slot]->http_code = http_code;
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = complete_resp->len;
  retc->x.str_val = g_strdup (complete_resp->str);
 
  g_string_free (complete_resp, TRUE);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, DELETE, GET, get_int_var_by_name(), get_str_var_by_name(), handle_table, HEAD, header_callback_fn(), hostname, init_string(), script_infos::ipc_context, MAX_HANDLES, nasl_perror(), plug_get_host_fqdn(), POST, string::ptr, PUT, response_callback_fn(), struct_lex_ctxt::script_infos, TC::size, script_infos::standalone, TC::str_val, user_agent_get(), and TC::x.

Referenced by nasl_http2_delete(), nasl_http2_get(), nasl_http2_head(), nasl_http2_post(), and nasl_http2_put().

Here is the call graph for this function:

Here is the caller graph for this function:

header_callback_fn()

size_t header_callback_fn ( char * buffer, size_t size, size_t nmemb, void * struct_string )

static

Call back function to stored the header.

@description The function signature is the necessary to work with libcurl. It stores the header in s. It reallocate memory if necessary.

Definition at line 211 of file nasl_http2.c.

{
  struct string *s = struct_string;
  size_t new_len = s->len + size * nmemb;
  char *ptr_aux = g_realloc (s->ptr, new_len + 1);
  s->ptr = ptr_aux;
  if (s->ptr == NULL)
    {
      g_warning ("%s: Error allocating memory for response", __func__);
      return 0; // no memory left
    }
  memcpy (s->ptr + s->len, buffer, size * nmemb);
  s->ptr[new_len] = '\0';
  s->len = new_len;
 
  return size * nmemb;
}

References string::len, and string::ptr.

Referenced by _http2_req().

Here is the caller graph for this function:

init_string()

void init_string ( struct string * s )

static

Initialize the string struct to hold the response or header.

Parameters

s[in/out]

The string struct to be initialized

Definition at line 169 of file nasl_http2.c.

{
  s->len = 0;
  s->ptr = g_malloc0 (s->len + 1);
  if (s->ptr == NULL)
    {
      g_warning ("%s: Error allocating memory for response", __func__);
      return;
    }
  s->ptr[0] = '\0';
}

References string::len, and string::ptr.

Referenced by _http2_req().

Here is the caller graph for this function:

nasl_http2_close_handle()

tree_cell * nasl_http2_close_handle

(

lex_ctxt *

lexic

)

Close a handle for http requests previously initialized.

NASL Function: http2_handle\n

NASL Named Parameters:\n

• handle The handle identifier for the handle to be closed

NASL Returns:\n O on success, -1 on error

Parameters

[in]

lexic

Lexical context of NASL interpreter.

Returns

The function returns a tree-cell with a integer. O on success, -1 on error.

Definition at line 129 of file nasl_http2.c.

{
  tree_cell *retc = NULL;
  int handle_id = get_int_var_by_num (lexic, 0, -1);
  unsigned int table_slot;
  int ret = 0;
 
  for (table_slot = 0; table_slot < MAX_HANDLES; table_slot++)
    {
      if (handle_table[table_slot]->handle_id == handle_id)
        {
          curl_easy_cleanup (handle_table[table_slot]->handle);
          handle_table[table_slot]->handle = NULL;
          handle_table[table_slot]->handle_id = 0;
          handle_table[table_slot] = NULL;
        }
      else
        {
          g_message ("%s: Unknown handle identifier %d", __func__, handle_id);
          ret = -1;
        }
    }
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ret;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_num(), handle_table_s::handle, handle_table_s::handle_id, handle_table, TC::i_val, MAX_HANDLES, and TC::x.

Here is the call graph for this function:

nasl_http2_delete()

tree_cell * nasl_http2_delete

(

lex_ctxt *

lexic

)

Wrapper function for DELETE request. See _http2_req.

Definition at line 549 of file nasl_http2.c.

{
  return _http2_req (lexic, DELETE);
}

References _http2_req(), and DELETE.

Here is the call graph for this function:

nasl_http2_get()

tree_cell * nasl_http2_get

(

lex_ctxt *

lexic

)

Wrapper function for GET request. See _http2_req.

Definition at line 525 of file nasl_http2.c.

{
  return _http2_req (lexic, GET);
}

References _http2_req(), and GET.

Here is the call graph for this function:

nasl_http2_get_response_code()

tree_cell * nasl_http2_get_response_code

(

lex_ctxt *

lexic

)

Get the http response code after performing a HTTP request.

NASL Named Parameters:\n

• handle The handle identifier

NASL Returns:\n http code or 0 if not set. NULL on error

Parameters

[in]

lexic

Lexical context of NASL interpreter.

Returns

On success the function returns a tree-cell with and integer representing the http code response. Null on error.

Definition at line 436 of file nasl_http2.c.

{
  tree_cell *retc = NULL;
  unsigned int table_slot;
  int handle_id = get_int_var_by_name (lexic, "handle", -1);
 
  if (handle_id < 0)
    {
      nasl_perror (lexic,
                   "Error : http2_* functions have the following syntax :\n");
      nasl_perror (lexic, "http_*(handle: <handle>\n");
      return NULL;
    }
 
  for (table_slot = 0; table_slot < MAX_HANDLES; table_slot++)
    {
      if (handle_table[table_slot]->handle_id == handle_id)
        break;
      else
        {
          g_message ("%s: Unknown handle identifier %d", __func__, handle_id);
          return NULL;
        }
    }
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = handle_table[table_slot]->http_code;
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), handle_table, TC::i_val, MAX_HANDLES, nasl_perror(), and TC::x.

Here is the call graph for this function:

nasl_http2_handle()

tree_cell * nasl_http2_handle

(

lex_ctxt *

lexic

)

Creates a handle for http requests.

NASL Function: http2_handle\n

NASL Returns:\n Handle identifier. Null on error.

Parameters

[in]

lexic

Lexical context of NASL interpreter.

Returns

On success the function returns a tree-cell with the handle identifier. Null on error.

Definition at line 84 of file nasl_http2.c.

{
  (void) lexic;
  tree_cell *retc = NULL;
  CURL *handle = curl_easy_init ();
  unsigned int table_slot;
 
  if (!handle)
    return NULL;
 
  for (table_slot = 0; table_slot < MAX_HANDLES; table_slot++)
    if (!handle_table[table_slot] || !handle_table[table_slot]->handle_id)
      break;
 
  if (!(table_slot < MAX_HANDLES))
    {
      g_message ("%s: No space left in HTTP2 handle table", __func__);
      curl_easy_cleanup (handle);
      return NULL;
    }
 
  handle_table[table_slot] = g_malloc0 (sizeof (struct handle_table_s));
  handle_table[table_slot]->handle = handle;
  handle_table[table_slot]->handle_id = next_handle_id ();
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = handle_table[table_slot]->handle_id;
  return retc;
}

References alloc_typed_cell(), CONST_INT, handle_table_s::handle, handle_table_s::handle_id, handle_table, TC::i_val, MAX_HANDLES, next_handle_id(), and TC::x.

Here is the call graph for this function:

nasl_http2_head()

tree_cell * nasl_http2_head

(

lex_ctxt *

lexic

)

Wrapper function for HEAD request. See _http2_req.

Definition at line 533 of file nasl_http2.c.

{
  return _http2_req (lexic, HEAD);
}

References _http2_req(), and HEAD.

Here is the call graph for this function:

nasl_http2_post()

tree_cell * nasl_http2_post

(

lex_ctxt *

lexic

)

Wrapper function for POST request. See _http2_req.

Definition at line 541 of file nasl_http2.c.

{
  return _http2_req (lexic, POST);
}

References _http2_req(), and POST.

Here is the call graph for this function:

nasl_http2_put()

tree_cell * nasl_http2_put

(

lex_ctxt *

lexic

)

Wrapper function for PUT request. See _http2_req.

Definition at line 557 of file nasl_http2.c.

{
  return _http2_req (lexic, PUT);
}

References _http2_req(), and PUT.

Here is the call graph for this function:

nasl_http2_set_custom_header()

tree_cell * nasl_http2_set_custom_header

(

lex_ctxt *

lexic

)

Set a custom header element in the header.

NASL Named Parameters:\n

• handle The handle identifier
• header_item A string to add to the header

NASL Returns:\n 0 on success. NULL on error

Parameters

[in]

lexic

Lexical context of NASL interpreter.

Returns

On success the function returns a tree-cell integer 0 on success. Null on error.

Definition at line 482 of file nasl_http2.c.

{
  tree_cell *retc = NULL;
  struct curl_slist *customheader = NULL;
  unsigned int table_slot;
  CURL *handle;
  int handle_id = get_int_var_by_name (lexic, "handle", -1);
  char *headeritem = get_str_var_by_name (lexic, "header_item");
 
  if (handle_id < 0 || headeritem == NULL)
    {
      nasl_perror (lexic,
                   "Error : http2_* functions have the following syntax :\n");
      nasl_perror (lexic,
                   "http_*(handle: <handle>, header_item:<header_item>\n");
      return NULL;
    }
 
  for (table_slot = 0; table_slot < MAX_HANDLES; table_slot++)
    {
      if (handle_table[table_slot]->handle_id == handle_id)
        break;
      else
        {
          g_message ("%s: Unknown handle identifier %d", __func__, handle_id);
          return NULL;
        }
    }
  handle = handle_table[table_slot]->handle;
 
  // SET Content type
  customheader = curl_slist_append (customheader, headeritem);
  curl_easy_setopt (handle, CURLOPT_HTTPHEADER, customheader);
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = 0;
 
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_name(), get_str_var_by_name(), handle_table, TC::i_val, MAX_HANDLES, nasl_perror(), and TC::x.

Here is the call graph for this function:

next_handle_id()

int next_handle_id ( void )

static

Get the new available handle identifier.

Definition at line 64 of file nasl_http2.c.

{
  static int last = 9000;
  last++;
 
  return last;
}

Referenced by nasl_http2_handle().

Here is the caller graph for this function:

response_callback_fn()

size_t response_callback_fn ( void * ptr, size_t size, size_t nmemb, void * struct_string )

static

Call back function to stored the response.

@description The function signature is the necessary to work with libcurl. It stores the response in s. It reallocate memory if necessary.

Definition at line 187 of file nasl_http2.c.

{
  struct string *s = struct_string;
  size_t new_len = s->len + size * nmemb;
  char *ptr_aux = g_realloc (s->ptr, new_len + 1);
  s->ptr = ptr_aux;
  if (s->ptr == NULL)
    {
      g_warning ("%s: Error allocating memory for response", __func__);
      return 0; // no memory left
    }
  memcpy (s->ptr + s->len, ptr, size * nmemb);
  s->ptr[new_len] = '\0';
  s->len = new_len;
 
  return size * nmemb;
}

References string::len, and string::ptr.

Variable Documentation

handle_table

struct handle_table_s* handle_table[MAX_HANDLES]

static

Handle Table.

Definition at line 59 of file nasl_http2.c.

Referenced by _http2_req(), nasl_http2_close_handle(), nasl_http2_get_response_code(), nasl_http2_handle(), and nasl_http2_set_custom_header().