nasl_lex_ctxt.h File Reference

#include <glib.h>
#include "nasl_tree.h"
#include "nasl_var.h"
#include "nasl_func.h"

Include dependency graph for nasl_lex_ctxt.h:

Go to the source code of this file.

Data Structures
struct	struct_lex_ctxt

Macros
#define	NASL_COMPAT_LEX_CTXT   "NASL compat lex context"

Typedefs
typedef struct struct_lex_ctxt	lex_ctxt

Functions
lex_ctxt *	init_empty_lex_ctxt (void)
void	free_lex_ctxt (lex_ctxt *)
void	dump_ctxt (lex_ctxt *)
nasl_func *	get_func_ref_by_name (lex_ctxt *, const char *)
tree_cell *	decl_nasl_func (lex_ctxt *, tree_cell *, int)
nasl_func *	insert_nasl_func (lex_ctxt *, const char *, tree_cell *, int)
tree_cell *	nasl_func_call (lex_ctxt *, const nasl_func *, tree_cell *)
tree_cell *	get_variable_by_name (lex_ctxt *, const char *)
tree_cell *	get_array_elem (lex_ctxt *, const char *, tree_cell *)
anon_nasl_var *	add_numbered_var_to_ctxt (lex_ctxt *, int, tree_cell *)
named_nasl_var *	add_named_var_to_ctxt (lex_ctxt *, const char *, tree_cell *)
tree_cell *	nasl_read_var_ref (lex_ctxt *, tree_cell *)
tree_cell *	nasl_incr_variable (lex_ctxt *, tree_cell *, int, int)
tree_cell *	nasl_return (lex_ctxt *, tree_cell *)
tree_cell *	decl_local_variables (lex_ctxt *, tree_cell *)
tree_cell *	decl_global_variables (lex_ctxt *, tree_cell *)
tree_cell *	cell2atom (lex_ctxt *, tree_cell *)
long int	get_int_var_by_num (lex_ctxt *, int, int)
char *	get_str_var_by_num (lex_ctxt *, int)
long int	get_int_var_by_name (lex_ctxt *, const char *, int)
char *	get_str_var_by_name (lex_ctxt *, const char *)
int	get_var_size_by_name (lex_ctxt *, const char *)
int	get_var_type_by_name (lex_ctxt *, const char *)
int	get_var_size_by_num (lex_ctxt *, int)
int	get_var_type_by_num (lex_ctxt *, int)
	Returns NASL variable/cell type, VAR2_UNDEF if value is NULL. More...

Macro Definition Documentation

NASL_COMPAT_LEX_CTXT

#define NASL_COMPAT_LEX_CTXT   "NASL compat lex context"

Definition at line 40 of file nasl_lex_ctxt.h.

Typedef Documentation

lex_ctxt

typedef struct struct_lex_ctxt lex_ctxt

Function Documentation

add_named_var_to_ctxt()

named_nasl_var* add_named_var_to_ctxt	(	lex_ctxt *	,
		const char *	,
		tree_cell *
	)

Definition at line 813 of file nasl_var.c.

 {
   int h = hash_str (name);
   named_nasl_var *v;
 
   /* Duplicated code ? */
   for (v = lexic->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
     if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
       {
         if (val != NULL)
           nasl_perror (lexic, "Cannot add existing variable %s\n", name);
         return NULL;
       }
   v = create_named_var (name, val);
   if (v == NULL)
     return NULL;
   v->next_var = lexic->ctx_vars.hash_elt[h];
   lexic->ctx_vars.hash_elt[h] = v;
   return v;
 }

References create_named_var(), struct_lex_ctxt::ctx_vars, st_nasl_array::hash_elt, hash_str(), name, nasl_perror(), st_n_nasl_var::next_var, val, and st_n_nasl_var::var_name.

Referenced by decl_local_variables(), exec_nasl_script(), init_nasl_library(), and nasl_func_call().

Here is the call graph for this function:

Here is the caller graph for this function:

add_numbered_var_to_ctxt()

anon_nasl_var* add_numbered_var_to_ctxt	(	lex_ctxt *	,
		int	,
		tree_cell *
	)

Definition at line 784 of file nasl_var.c.

 {
   anon_nasl_var *v;
   nasl_array *a = &lexic->ctx_vars;
 
   if (a->max_idx > num)
     {
       v = a->num_elt[num];
       if (v != NULL && v->var_type != VAR2_UNDEF)
         {
           if (val != NULL)
             nasl_perror (lexic, "Cannot add existing variable %d\n", num);
           return NULL;
         }
       free_anon_var (a->num_elt[num]);
     }
   else
     {
       a->num_elt =
         g_realloc (a->num_elt, (num + 1) * sizeof (anon_nasl_var *));
       bzero (a->num_elt + a->max_idx,
              sizeof (anon_nasl_var *) * (num + 1 - a->max_idx));
       a->max_idx = num + 1;
     }
   a->num_elt[num] = v = create_anon_var (val);
   return v;
 }

References create_anon_var(), struct_lex_ctxt::ctx_vars, free_anon_var(), st_nasl_array::max_idx, nasl_perror(), st_nasl_array::num_elt, val, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_func_call().

Here is the call graph for this function:

Here is the caller graph for this function:

cell2atom()

tree_cell* cell2atom	(	lex_ctxt *	lexic,
		tree_cell *	c1
	)

Returns

A 'referenced' cell.

Definition at line 194 of file exec.c.

{
  tree_cell *c2 = NULL, *ret = NULL;
  if (c1 == NULL || c1 == FAKE_CELL)
    return c1;
 
  switch (c1->type)
    {
    case CONST_INT:
    case CONST_STR:
    case CONST_DATA:
    case REF_ARRAY:
    case DYN_ARRAY:
      ref_cell (c1);
      return c1;
    default:
      c2 = nasl_exec (lexic, c1);
      ret = cell2atom (lexic, c2);
      deref_cell (c2);
      return ret;
    }
}

References cell2atom(), CONST_DATA, CONST_INT, CONST_STR, deref_cell(), DYN_ARRAY, FAKE_CELL, nasl_exec(), REF_ARRAY, ref_cell(), and TC::type.

Referenced by cell2atom(), cell_cmp(), nasl_exec(), nasl_func_call(), and nasl_return().

Here is the call graph for this function:

Here is the caller graph for this function:

decl_global_variables()

tree_cell* decl_global_variables	(	lex_ctxt *	,
		tree_cell *
	)

Definition at line 774 of file nasl_var.c.

 {
   lex_ctxt *c = lexic;
 
   while (c->up_ctxt != NULL)
     c = c->up_ctxt;
   return decl_local_variables (c, vars);
 }

References decl_local_variables(), and struct_lex_ctxt::up_ctxt.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

decl_local_variables()

tree_cell* decl_local_variables	(	lex_ctxt *	,
		tree_cell *
	)

Definition at line 761 of file nasl_var.c.

 {
   tree_cell *t;
 
   for (t = vars; t != NULL; t = t->link[0])
     if (t->x.str_val == NULL)
       nasl_perror (lexic, "decl_local_variables: null name!\n");
     else
       add_named_var_to_ctxt (lexic, t->x.str_val, NULL);
   return FAKE_CELL;
 }

References add_named_var_to_ctxt(), FAKE_CELL, TC::link, nasl_perror(), TC::str_val, and TC::x.

Referenced by decl_global_variables(), and nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

decl_nasl_func()

tree_cell* decl_nasl_func	(	lex_ctxt *	,
		tree_cell *	,
		int
	)

Definition at line 66 of file nasl_func.c.

{
  if (decl_node == NULL || decl_node == FAKE_CELL)
    {
      nasl_perror (lexic, "Cannot insert NULL or FAKE cell as function\n");
      return NULL;
    }
 
  if (insert_nasl_func (lexic, decl_node->x.str_val, decl_node, lint_mode)
      == NULL)
    return NULL;
  else
    return FAKE_CELL;
}

References FAKE_CELL, insert_nasl_func(), nasl_perror(), TC::str_val, and TC::x.

Referenced by nasl_exec(), nasl_lint_call(), and nasl_lint_def().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_ctxt()

void dump_ctxt

(

lex_ctxt *

)

Definition at line 52 of file nasl_lex_ctxt.c.

{
  int i;
  named_nasl_var *v;
 
  printf ("--------<CTXT>--------\n");
  if (c->fct_ctxt)
    printf ("Is a function context\n");
  if (c->up_ctxt == NULL)
    printf ("Is the top level context\n");
  if (c->ret_val)
    {
      printf ("Return value\n");
      nasl_dump_tree (c->ret_val);
    }
 
  printf ("Variables:\n");
  for (i = 0; i < VAR_NAME_HASH; i++)
    for (v = c->ctx_vars.hash_elt[i]; v != NULL; v = v->next_var)
      printf ("%s\t", v->var_name);
  putchar ('\n');
 
  printf ("----------------------\n");
}

References struct_lex_ctxt::ctx_vars, struct_lex_ctxt::fct_ctxt, st_nasl_array::hash_elt, nasl_dump_tree(), st_n_nasl_var::next_var, struct_lex_ctxt::ret_val, struct_lex_ctxt::up_ctxt, st_n_nasl_var::var_name, and VAR_NAME_HASH.

Referenced by nasl_dump_ctxt().

Here is the call graph for this function:

Here is the caller graph for this function:

free_lex_ctxt()

void free_lex_ctxt

(

lex_ctxt *

)

Definition at line 43 of file nasl_lex_ctxt.c.

{
  deref_cell (c->ret_val);
  free_array (&c->ctx_vars);
  g_hash_table_destroy (c->functions);
  g_free (c);
}

References struct_lex_ctxt::ctx_vars, deref_cell(), free_array(), struct_lex_ctxt::functions, and struct_lex_ctxt::ret_val.

Referenced by exec_nasl_script(), nasl_func_call(), and nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

get_array_elem()

tree_cell* get_array_elem	(	lex_ctxt *	,
		const char *	,
		tree_cell *
	)

Definition at line 211 of file nasl_var.c.

 {
   named_nasl_var *nv;
   anon_nasl_var *u, *av, fake_var;
   tree_cell *tc, idx0;
 
   /* Fake variable */
   if (strcmp (name, "_FCT_ANON_ARGS") == 0)
     {
       lex_ctxt *c;
       for (c = ctxt; c != NULL && !c->fct_ctxt; c = c->up_ctxt)
         ;
       if (c == NULL)
         return NULL;
       fake_var.var_type = VAR2_ARRAY;
       fake_var.v.v_arr = c->ctx_vars;
       fake_var.v.v_arr.hash_elt = NULL; /* mask named elements */
       u = &fake_var;
     }
   else
     {
       named_nasl_var *v = get_var_ref_by_name (ctxt, name, 1);
       u = &v->u;
     }
 
   if (idx == NULL)
     {
       /* Treat it as zero */
       memset (&idx0, '\0', sizeof (idx0));
       idx = &idx0;
       idx->type = CONST_INT;
     }
 
   switch (u->var_type)
     {
     case VAR2_UNDEF:
       /* We define the array here */
       u->var_type = VAR2_ARRAY;
       /* fallthrough */
     case VAR2_ARRAY:
       switch (idx->type)
         {
         case CONST_INT:
           av = nasl_get_var_by_num (ctxt, &u->v.v_arr, idx->x.i_val,
                                     /* avoid dangling pointers */
                                     strcmp (name, "_FCT_ANON_ARGS"));
           return var2cell (av);
 
         case CONST_STR:
         case CONST_DATA:
           nv = get_var_by_name (&u->v.v_arr, idx->x.str_val);
           return var2cell (nv != NULL ? &nv->u : NULL);
 
         default:
           nasl_perror (ctxt,
                        "get_array_elem: unhandled index type 0x%x for "
                        "variable %s\n",
                        idx->type, name);
           return NULL;
         }
       /*NOTREACHED*/ break;
 
     case VAR2_INT:
       nasl_perror (ctxt, "get_array_elem: variable %s is an integer\n", name);
       return NULL;
 
     case VAR2_STRING:
     case VAR2_DATA:
       if (idx->type == CONST_INT)
         {
           int l = u->v.v_str.s_siz;
 
           if (idx->x.i_val >= l)
             {
               nasl_perror (ctxt,
                            "get_array_elem: requesting character after end "
                            "of string %s (%d >= %d)\n",
                            name, idx->x.i_val, l);
               tc = alloc_expr_cell (idx->line_nb, CONST_DATA /*CONST_STR */,
                                     NULL, NULL);
               tc->x.str_val = g_strdup ("");
               tc->size = 0;
               return tc;
             }
           else
             {
               if (idx->x.i_val < 0)
                 {
                   nasl_perror (ctxt,
                                "get_array_elem: Negative index (%d) passed to "
                                "\"%s\"!\n",
                                idx->x.i_val, name);
                   return NULL;
                 }
               tc = alloc_expr_cell (idx->line_nb, CONST_DATA /*CONST_STR */,
                                     NULL, NULL);
               tc->x.str_val = g_malloc0 (2);
               tc->x.str_val[0] = u->v.v_str.s_val[idx->x.i_val];
               tc->x.str_val[1] = '\0';
               tc->size = 1;
               return tc;
             }
         }
       else
         {
           nasl_perror (ctxt,
                        "get_array_elem: Cannot use a non integer index"
                        " (type 0x%x) in string. Variable: %s\n",
                        idx->type, name);
           return NULL;
         }
       /*NOTREACHED*/ break;
 
     default:
       nasl_perror (ctxt, "Severe bug: unknown variable type 0x%x %s\n",
                    u->var_type, get_line_nb (idx));
       return NULL;
     }
   /*NOTREACHED*/ return NULL;
 }

References alloc_expr_cell(), CONST_DATA, CONST_INT, CONST_STR, struct_lex_ctxt::ctx_vars, struct_lex_ctxt::fct_ctxt, get_line_nb(), get_var_by_name(), get_var_ref_by_name(), st_nasl_array::hash_elt, TC::i_val, TC::line_nb, name, nasl_get_var_by_num(), nasl_perror(), st_nasl_string::s_siz, st_nasl_string::s_val, TC::size, TC::str_val, TC::type, st_n_nasl_var::u, struct_lex_ctxt::up_ctxt, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, var2cell(), st_a_nasl_var::var_type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

get_func_ref_by_name()

nasl_func* get_func_ref_by_name	(	lex_ctxt *	,
		const char *
	)

Definition at line 82 of file nasl_func.c.

{
  nasl_func *f;
 
  if ((f = get_func (ctxt, name)))
    return f;
  else
    return NULL;
}

References get_func(), and name.

Referenced by exec_nasl_script(), make_call_func_list(), nasl_defined_func(), nasl_exec(), nasl_lint_call(), and nasl_lint_def().

Here is the call graph for this function:

Here is the caller graph for this function:

get_int_var_by_name()

long int get_int_var_by_name	(	lex_ctxt *	,
		const char *	,
		int
	)

Definition at line 1104 of file nasl_var.c.

 {
   named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
   return var2int (&v->u, defval);
 }

References get_var_ref_by_name(), name, st_n_nasl_var::u, and var2int().

Referenced by _http_req(), crypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ip_v6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_port_transport(), get_tcp_option(), get_tcp_v6_option(), insert_ip_options(), insert_ip_v6_options(), nasl_bn_random(), nasl_close_stream_cipher(), nasl_crap(), nasl_dec2str(), nasl_egrep(), nasl_ereg(), nasl_ereg_replace(), nasl_eregmatch(), nasl_file_read(), nasl_file_seek(), nasl_file_write(), nasl_forge_frame(), nasl_ftp_get_pasv_address(), nasl_ftp_log_in(), nasl_get_sign(), nasl_get_sock_info(), nasl_isotime_add(), nasl_localtime(), nasl_match(), nasl_mktime(), nasl_ntlm_response(), nasl_ntlmv2_hash(), nasl_ntlmv2_response(), nasl_open_privileged_socket(), nasl_open_sock_tcp_bufsz(), nasl_pcap_next(), nasl_pread(), nasl_prf(), nasl_rc4_encrypt(), nasl_recv(), nasl_recv_line(), nasl_rsa_private_decrypt(), nasl_rsa_public_encrypt(), nasl_same_host(), nasl_scanner_add_port(), nasl_send(), nasl_send_arp_request(), nasl_send_capture(), nasl_send_frame(), nasl_send_packet(), nasl_send_v6packet(), nasl_smb3kdf(), nasl_smb_close(), nasl_smb_file_group_sid(), nasl_smb_file_owner_sid(), nasl_smb_file_SDDL(), nasl_smb_file_trustee_rights(), nasl_snmpv1v2c_get(), nasl_snmpv3_get_action(), nasl_socket_cert_verify(), nasl_socket_check_ssl_safe_renegotiation(), nasl_socket_get_cert(), nasl_socket_get_ssl_ciphersuite(), nasl_socket_get_ssl_session_id(), nasl_socket_get_ssl_version(), nasl_socket_negotiate_ssl(), nasl_socket_ssl_do_handshake(), nasl_split(), nasl_ssh_connect(), nasl_ssh_request_exec(), nasl_ssh_shell_open(), nasl_ssh_shell_read(), nasl_str_replace(), nasl_tcp_ping(), nasl_tcp_v6_ping(), nasl_wmi_close(), nasl_wmi_query(), nasl_wmi_query_rsop(), nasl_wmi_reg_create_key(), nasl_wmi_reg_delete_key(), nasl_wmi_reg_enum_key(), nasl_wmi_reg_enum_value(), nasl_wmi_reg_get_bin_val(), nasl_wmi_reg_get_dword_val(), nasl_wmi_reg_get_ex_string_val(), nasl_wmi_reg_get_mul_string_val(), nasl_wmi_reg_get_qword_val(), nasl_wmi_reg_get_sz(), nasl_wmi_reg_set_dword_val(), nasl_wmi_reg_set_ex_string_val(), nasl_wmi_reg_set_qword_val(), nasl_wmi_reg_set_string_val(), replace_kb_item(), script_add_preference(), script_get_preference(), security_something(), set_ip_elements(), set_ip_v6_elements(), set_kb_item(), set_kb_item_volatile(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

Here is the call graph for this function:

get_int_var_by_num()

long int get_int_var_by_num	(	lex_ctxt *	,
		int	,
		int
	)

Definition at line 1097 of file nasl_var.c.

 {
   anon_nasl_var *v = get_var_ref_by_num (lexic, num);
   return var2int (v, defval);
 }

References get_var_ref_by_num(), and var2int().

Referenced by get_kb_item(), get_port_state(), get_port_transport(), get_udp_port_state(), insert_tcp_options(), insert_tcp_v6_options(), nasl_close_socket(), nasl_crap(), nasl_do_exit(), nasl_file_close(), nasl_get_sock_info(), nasl_get_source_port(), nasl_hex(), nasl_insstr(), nasl_int(), nasl_localtime(), nasl_open_sock_tcp_bufsz(), nasl_open_sock_udp(), nasl_rawstring(), nasl_scanner_get_port(), nasl_sftp_enabled_check(), nasl_sleep(), nasl_socket_get_error(), nasl_ssh_disconnect(), nasl_ssh_get_auth_methods(), nasl_ssh_get_host_key(), nasl_ssh_get_issue_banner(), nasl_ssh_get_server_banner(), nasl_ssh_get_sock(), nasl_ssh_login_interactive(), nasl_ssh_login_interactive_pass(), nasl_ssh_request_exec(), nasl_ssh_session_id_from_sock(), nasl_ssh_set_login(), nasl_ssh_shell_close(), nasl_ssh_shell_open(), nasl_ssh_shell_read(), nasl_ssh_shell_write(), nasl_ssh_userauth(), nasl_stridx(), nasl_substr(), nasl_telnet_init(), nasl_usleep(), script_category(), script_timeout(), and security_something().

Here is the call graph for this function:

Here is the caller graph for this function:

get_str_var_by_name()

char* get_str_var_by_name	(	lex_ctxt *	,
		const char *
	)

Definition at line 1118 of file nasl_var.c.

 {
   named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
   return (char *) var2str (&v->u);
 }

References get_var_ref_by_name(), name, st_n_nasl_var::u, and var2str().

Referenced by _http_req(), add_hostname(), crypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ip_v6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_hostname_source(), get_icmp_element(), get_icmp_v6_element(), get_ip_element(), get_ip_v6_element(), get_tcp_element(), get_tcp_option(), get_tcp_v6_element(), get_tcp_v6_option(), get_udp_element(), get_udp_v6_element(), insert_ip_options(), insert_ip_v6_options(), insert_tcp_options(), insert_tcp_v6_options(), mpi_from_named_parameter(), nasl_bf_cbc(), nasl_crap(), nasl_dump_frame(), nasl_egrep(), nasl_ereg(), nasl_ereg_replace(), nasl_eregmatch(), nasl_file_open(), nasl_file_write(), nasl_forge_frame(), nasl_ftp_log_in(), nasl_fwrite(), nasl_get_sign(), nasl_gunzip(), nasl_gzip(), nasl_hmac(), nasl_hmac_sha256(), nasl_insert_hexzeros(), nasl_keyexchg(), nasl_load_privkey_param(), nasl_mac(), nasl_match(), nasl_ntlm2_response(), nasl_ntlm_response(), nasl_ntlmv1_hash(), nasl_ntlmv2_hash(), nasl_ntlmv2_response(), nasl_ntv2_owf_gen(), nasl_open_sock_tcp_bufsz(), nasl_open_stream_cipher(), nasl_pcap_next(), nasl_pread(), nasl_prf(), nasl_rsa_private_decrypt(), nasl_rsa_public_encrypt(), nasl_rsa_sign(), nasl_scanner_add_port(), nasl_send(), nasl_send_capture(), nasl_send_frame(), nasl_send_packet(), nasl_send_v6packet(), nasl_smb3kdf(), nasl_smb_connect(), nasl_smb_file_group_sid(), nasl_smb_file_owner_sid(), nasl_smb_file_SDDL(), nasl_smb_file_trustee_rights(), nasl_smb_sign(), nasl_snmpv1v2c_get(), nasl_snmpv3_get_action(), nasl_split(), nasl_ssh_connect(), nasl_ssh_login_interactive_pass(), nasl_ssh_request_exec(), nasl_ssh_set_login(), nasl_ssh_shell_write(), nasl_ssh_userauth(), nasl_str_replace(), nasl_wmi_query(), nasl_wmi_query_rsop(), nasl_wmi_reg_create_key(), nasl_wmi_reg_delete_key(), nasl_wmi_reg_enum_key(), nasl_wmi_reg_enum_value(), nasl_wmi_reg_get_bin_val(), nasl_wmi_reg_get_dword_val(), nasl_wmi_reg_get_ex_string_val(), nasl_wmi_reg_get_mul_string_val(), nasl_wmi_reg_get_qword_val(), nasl_wmi_reg_get_sz(), nasl_wmi_reg_set_dword_val(), nasl_wmi_reg_set_ex_string_val(), nasl_wmi_reg_set_qword_val(), nasl_wmi_reg_set_string_val(), replace_kb_item(), resolve_hostname(), resolve_hostname_to_multiple_ips(), script_add_preference(), script_mandatory_keys(), script_tag(), script_xref(), security_something(), set_ip_elements(), set_ip_v6_elements(), set_kb_item(), set_kb_item_volatile(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

Here is the call graph for this function:

get_str_var_by_num()

char* get_str_var_by_num	(	lex_ctxt *	,
		int
	)

Definition at line 1111 of file nasl_var.c.

 {
   anon_nasl_var *v = get_var_ref_by_num (lexic, num);
   return (char *) var2str (v);
 }

References get_var_ref_by_num(), and var2str().

Referenced by dump_icmp_packet(), dump_icmp_v6_packet(), dump_ip_packet(), dump_ip_v6_packet(), dump_tcp_packet(), dump_tcp_v6_packet(), dump_udp_packet(), dump_udp_v6_packet(), get_kb_item(), get_kb_list(), nasl_chomp(), nasl_cipher_des(), nasl_defined_func(), nasl_file_stat(), nasl_find_in_path(), nasl_fread(), nasl_get_local_mac_address_from_ip(), nasl_get_preference(), nasl_get_sock_info(), nasl_hash(), nasl_hexstr(), nasl_insstr(), nasl_isotime_add(), nasl_isotime_is_valid(), nasl_isotime_print(), nasl_isotime_scan(), nasl_join_multicast_group(), nasl_leave_multicast_group(), nasl_lm_owf_gen(), nasl_nt_owf_gen(), nasl_ord(), nasl_rawstring(), nasl_same_host(), nasl_send_packet(), nasl_send_v6packet(), nasl_split(), nasl_strcat(), nasl_stridx(), nasl_string(), nasl_strstr(), nasl_substr(), nasl_tolower(), nasl_toupper(), nasl_unlink(), script_cve_id(), script_dependencies(), script_exclude_keys(), script_family(), script_get_preference(), script_get_preference_file_content(), script_get_preference_file_location(), script_mandatory_keys(), script_name(), script_oid(), script_require_keys(), script_require_ports(), and script_require_udp_ports().

Here is the call graph for this function:

get_var_size_by_name()

int get_var_size_by_name	(	lex_ctxt *	,
		const char *
	)

Definition at line 1138 of file nasl_var.c.

 {
   named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
   return get_var_size (&v->u);
 }

References get_var_ref_by_name(), get_var_size(), name, and st_n_nasl_var::u.

Referenced by crypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ip_v6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_icmp_element(), get_icmp_v6_element(), get_tcp_element(), get_tcp_option(), get_tcp_v6_element(), get_tcp_v6_option(), get_udp_element(), get_udp_v6_element(), insert_ip_options(), insert_ip_v6_options(), insert_tcp_options(), insert_tcp_v6_options(), mpi_from_named_parameter(), nasl_bf_cbc(), nasl_crap(), nasl_dump_frame(), nasl_egrep(), nasl_ereg(), nasl_ereg_replace(), nasl_eregmatch(), nasl_file_write(), nasl_forge_frame(), nasl_fwrite(), nasl_gunzip(), nasl_gzip(), nasl_hmac(), nasl_hmac_sha256(), nasl_insert_hexzeros(), nasl_load_privkey_param(), nasl_mac(), nasl_ntlm2_response(), nasl_ntlm_response(), nasl_ntlmv1_hash(), nasl_ntlmv2_hash(), nasl_ntv2_owf_gen(), nasl_open_stream_cipher(), nasl_prf(), nasl_rsa_sign(), nasl_send(), nasl_send_frame(), nasl_smb3kdf(), nasl_smb_sign(), nasl_split(), nasl_str_replace(), replace_kb_item(), security_something(), set_ip_elements(), set_ip_v6_elements(), set_kb_item(), set_kb_item_volatile(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

Here is the call graph for this function:

get_var_size_by_num()

int get_var_size_by_num	(	lex_ctxt *	,
		int
	)

Definition at line 1145 of file nasl_var.c.

 {
   anon_nasl_var *v = get_var_ref_by_num (lexic, num);
   return get_var_size (v);
 }

References get_var_ref_by_num(), and get_var_size().

Referenced by dump_icmp_v6_packet(), dump_tcp_packet(), dump_tcp_v6_packet(), dump_udp_packet(), dump_udp_v6_packet(), nasl_cipher_des(), nasl_hash(), nasl_hexstr(), nasl_insstr(), nasl_isotime_add(), nasl_isotime_is_valid(), nasl_isotime_print(), nasl_isotime_scan(), nasl_lm_owf_gen(), nasl_rawstring(), nasl_send_packet(), nasl_send_v6packet(), nasl_split(), nasl_strcat(), nasl_stridx(), nasl_string(), nasl_strlen(), nasl_strstr(), nasl_substr(), nasl_tolower(), and nasl_toupper().

Here is the call graph for this function:

Here is the caller graph for this function:

get_var_type_by_name()

int get_var_type_by_name	(	lex_ctxt *	,
		const char *
	)

Definition at line 1162 of file nasl_var.c.

 {
   named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
   return v == NULL ? VAR2_UNDEF : v->u.var_type;
 }

References get_var_ref_by_name(), name, st_n_nasl_var::u, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_open_sock_tcp_bufsz(), nasl_rsa_private_decrypt(), nasl_rsa_public_encrypt(), replace_kb_item(), set_kb_item(), and set_kb_item_volatile().

Here is the call graph for this function:

Here is the caller graph for this function:

get_var_type_by_num()

int get_var_type_by_num	(	lex_ctxt *	,
		int
	)

Returns NASL variable/cell type, VAR2_UNDEF if value is NULL.

Definition at line 1155 of file nasl_var.c.

 {
   anon_nasl_var *v = get_var_ref_by_num (lexic, num);
   return v == NULL ? VAR2_UNDEF : v->var_type;
 }

References get_var_ref_by_num(), VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_get_sock_info(), nasl_isnull(), nasl_isotime_is_valid(), nasl_isotime_scan(), nasl_rawstring(), nasl_string(), and nasl_substr().

Here is the call graph for this function:

Here is the caller graph for this function:

get_variable_by_name()

tree_cell* get_variable_by_name	(	lex_ctxt *	,
		const char *
	)

Definition at line 179 of file nasl_var.c.

{
  if (name == NULL)
    return NULL;
  /* Broken: Need also code in get_array_elem */
  if (strcmp (name, "_FCT_ANON_ARGS") == 0)
    {
      tree_cell *retc = alloc_typed_cell (DYN_ARRAY);
      nasl_array *a = retc->x.ref_val = g_malloc0 (sizeof (nasl_array));
      copy_array (a, &ctxt->ctx_vars, 0);
      return retc;
    }
  else
    {
      named_nasl_var *v = get_var_ref_by_name (ctxt, name, 1);
      return var2cell (&v->u);
    }
 /*NOTREACHED*/}

References alloc_typed_cell(), copy_array(), struct_lex_ctxt::ctx_vars, DYN_ARRAY, get_var_ref_by_name(), name, TC::ref_val, st_n_nasl_var::u, var2cell(), and TC::x.

Referenced by nasl_exec(), and nasl_pread().

Here is the call graph for this function:

Here is the caller graph for this function:

init_empty_lex_ctxt()

lex_ctxt* init_empty_lex_ctxt

(

void

)

Todo:

Initialization of the library seems intuitively be necessary only once (involves "linking" the nasl functions to c code). Consider a "prototype" context that has to be created only once and of which copies are made when needed.

Definition at line 20 of file nasl_lex_ctxt.c.

{
  lex_ctxt *c = g_malloc0 (sizeof (lex_ctxt));
 
  c->ctx_vars.hash_elt = g_malloc0 (sizeof (named_nasl_var *) * VAR_NAME_HASH);
  c->ctx_vars.num_elt = NULL;
  c->ctx_vars.max_idx = 0;
  c->functions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
                                        (GDestroyNotify) free_func);
  c->oid = NULL;
  c->ret_val = NULL;
  c->fct_ctxt = 0;
 
  init_nasl_library (c);
 
  return c;
}

References struct_lex_ctxt::ctx_vars, struct_lex_ctxt::fct_ctxt, free_func(), struct_lex_ctxt::functions, st_nasl_array::hash_elt, init_nasl_library(), st_nasl_array::max_idx, st_nasl_array::num_elt, struct_lex_ctxt::oid, struct_lex_ctxt::ret_val, and VAR_NAME_HASH.

Referenced by exec_nasl_script(), nasl_func_call(), and nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_nasl_func()

nasl_func* insert_nasl_func	(	lex_ctxt *	,
		const char *	,
		tree_cell *	,
		int
	)

Definition at line 41 of file nasl_func.c.

{
  nasl_func *pf;
 
  if (get_func (lexic, fname))
    {
      if (lint_mode == 0)
        nasl_perror (
          lexic, "insert_nasl_func: function '%s' is already defined\n", fname);
      return NULL;
    }
  pf = g_malloc0 (sizeof (nasl_func));
  pf->func_name = g_strdup (fname);
 
  if (decl_node != NULL && decl_node != FAKE_CELL)
    {
      pf->block = decl_node->link[1];
      ref_cell (pf->block);
    }
  g_hash_table_insert (lexic->functions, pf->func_name, pf);
  return pf;
}

References st_nasl_func::block, FAKE_CELL, st_nasl_func::func_name, struct_lex_ctxt::functions, get_func(), TC::link, nasl_perror(), and ref_cell().

Referenced by decl_nasl_func().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_func_call()

tree_cell* nasl_func_call	(	lex_ctxt *	,
		const nasl_func *	,
		tree_cell *
	)

Definition at line 95 of file nasl_func.c.

{
  int nb_u = 0, nb_a = 0;
  tree_cell *pc = NULL, *pc2 = NULL, *retc = NULL;
  lex_ctxt *lexic2 = NULL;
  char *trace_buf = NULL;
  char *temp_funname = NULL, *tmp_filename = NULL;
  int trace_buf_len = 0, tn;
#define TRACE_BUF_SZ 255
 
  /* 1. Create a new context */
  lexic2 = init_empty_lex_ctxt ();
  lexic2->script_infos = lexic->script_infos;
  lexic2->oid = lexic->oid;
  lexic2->recv_timeout = lexic->recv_timeout;
  lexic2->fct_ctxt = 1;
 
  if (nasl_trace_fp != NULL)
    {
      trace_buf = g_malloc0 (TRACE_BUF_SZ);
      tn = snprintf (trace_buf, TRACE_BUF_SZ, "Call %s(", f->func_name);
      if (tn > 0)
        trace_buf_len += tn;
    }
 
  for (pc = arg_list; pc != NULL; pc = pc->link[1])
    if (pc->x.str_val == NULL)
      nb_u++;
 
  /*
   * I should look exactly how unnamed arguments works...
   * Or maybe I should remove this feature?
   */
 
  for (nb_u = 0, pc = arg_list; pc != NULL; pc = pc->link[1])
    {
      pc2 = cell2atom (lexic, pc->link[0]);
      if (pc->x.str_val == NULL)
        {
          /* 2. Add unnamed (numbered) variables for unnamed args */
          if (add_numbered_var_to_ctxt (lexic2, nb_u, pc2) == NULL)
            goto error;
          nb_u++;
          if (nasl_trace_fp != NULL && trace_buf_len < TRACE_BUF_SZ)
            {
              tn = snprintf (trace_buf + trace_buf_len,
                             TRACE_BUF_SZ - trace_buf_len, "%s%d: %s",
                             nb_a > 0 ? ", " : "", nb_u, dump_cell_val (pc2));
              if (tn > 0)
                trace_buf_len += tn;
            }
          nb_a++;
        }
      else
        {
          /* 3. and add named variables for named args */
          if (add_named_var_to_ctxt (lexic2, pc->x.str_val, pc2) == NULL)
            goto error;
          if (nasl_trace_fp != NULL && trace_buf_len < TRACE_BUF_SZ)
            {
              tn = snprintf (trace_buf + trace_buf_len,
                             TRACE_BUF_SZ - trace_buf_len, "%s%s: %s",
                             nb_a > 0 ? ", " : "", pc->x.str_val,
                             dump_cell_val (pc2));
              if (tn > 0)
                trace_buf_len += tn;
            }
          nb_a++;
        }
      deref_cell (pc2);
    }
 
  if (nasl_trace_fp != NULL)
    {
      if (trace_buf_len < TRACE_BUF_SZ)
        nasl_trace (lexic, "NASL> %s)\n", trace_buf);
      else
        nasl_trace (lexic, "NASL> %s ...)\n", trace_buf);
    }
  /* trace_buf freed here because nasl_trace_fp might get set to NULL during the
   * execution of nasl_func_call and therefore not get freed if we only free in
   * the previous if block. This is done to make static analyzer happy. */
  g_free (trace_buf);
 
  /* 4. Chain new context to old (lexic) */
  lexic2->up_ctxt = lexic;
  /* 5. Execute */
  tmp_filename = g_strdup (nasl_get_filename (NULL));
  nasl_set_filename (nasl_get_filename (f->func_name));
  if (func_is_internal (f->func_name))
    {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
      // unless it is arcane system this void casting should work
      // therefore ignoring pedantic here.
      tree_cell *(*pf2) (lex_ctxt *) = f->block;
#pragma GCC diagnostic pop
      retc = pf2 (lexic2);
    }
  else
    {
      temp_funname = g_strdup (nasl_get_function_name ());
      nasl_set_function_name (f->func_name);
      retc = nasl_exec (lexic2, f->block);
      deref_cell (retc);
      retc = FAKE_CELL;
      nasl_set_function_name (temp_funname);
      g_free (temp_funname);
    }
  nasl_set_filename (tmp_filename);
  g_free (tmp_filename);
 
  if ((retc == NULL || retc == FAKE_CELL)
      && (lexic2->ret_val != NULL && lexic2->ret_val != FAKE_CELL))
    {
      retc = lexic2->ret_val;
      ref_cell (retc);
    }
 
  if (nasl_trace_enabled ())
    nasl_trace (lexic, "NASL> Return %s: %s\n", f->func_name,
                dump_cell_val (retc));
  if (!nasl_is_leaf (retc))
    {
      nasl_perror (lexic,
                   "nasl_func_call: return value from %s is not atomic!\n",
                   f->func_name);
      nasl_dump_tree (retc);
    }
 
  free_lex_ctxt (lexic2);
  lexic2 = NULL;
  return retc;
 
error:
  g_free (trace_buf);
  free_lex_ctxt (lexic2);
  return NULL;
}

References add_named_var_to_ctxt(), add_numbered_var_to_ctxt(), st_nasl_func::block, cell2atom(), deref_cell(), dump_cell_val(), FAKE_CELL, struct_lex_ctxt::fct_ctxt, free_lex_ctxt(), func_is_internal(), st_nasl_func::func_name, init_empty_lex_ctxt(), TC::link, nasl_dump_tree(), nasl_exec(), nasl_get_filename(), nasl_get_function_name(), nasl_is_leaf(), nasl_perror(), nasl_set_filename(), nasl_set_function_name(), nasl_trace(), nasl_trace_enabled(), nasl_trace_fp, struct_lex_ctxt::oid, struct_lex_ctxt::recv_timeout, ref_cell(), struct_lex_ctxt::ret_val, struct_lex_ctxt::script_infos, TC::str_val, TRACE_BUF_SZ, struct_lex_ctxt::up_ctxt, and TC::x.

Referenced by exec_nasl_script(), and nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_incr_variable()

tree_cell* nasl_incr_variable	(	lex_ctxt *	,
		tree_cell *	,
		int	,
		int
	)

Definition at line 922 of file nasl_var.c.

 {
   anon_nasl_var *v;
   int old_val = 0, new_val;
   tree_cell *retc;
 
   if (tc->type != REF_VAR)
     {
       nasl_perror (
         lexic, "nasl_incr_variable: argument (type=%d) is not REF_VAR %s\n",
         tc->type, get_line_nb (tc));
       return NULL;
     }
 
   v = tc->x.ref_val;
 
   switch (v->var_type)
     {
     case VAR2_INT:
       old_val = v->v.v_int;
       break;
     case VAR2_STRING:
     case VAR2_DATA:
       old_val =
         v->v.v_str.s_val == NULL ? 0 : atoi ((char *) v->v.v_str.s_val);
       break;
     case VAR2_UNDEF:
       old_val = 0;
       break;
 
     default:
       nasl_perror (lexic,
                    "nasl_incr_variable: variable %s has bad type %d %s\n",
                    /*get_var_name(v) */ "", get_line_nb (tc));
       return NULL;
     }
   new_val = old_val + val;
 
   clear_anon_var (v);
   v->var_type = VAR2_INT;
   v->v.v_int = new_val;
 
   retc = alloc_typed_cell (CONST_INT);
   retc->x.i_val = pre ? new_val : old_val;
 
   return retc;
 }

References alloc_typed_cell(), clear_anon_var(), CONST_INT, get_line_nb(), TC::i_val, nasl_perror(), TC::ref_val, REF_VAR, st_nasl_string::s_val, TC::type, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, val, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, st_a_nasl_var::var_type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_read_var_ref()

tree_cell* nasl_read_var_ref	(	lex_ctxt *	,
		tree_cell *
	)

Definition at line 835 of file nasl_var.c.

 {
   tree_cell *ret;
   anon_nasl_var *v;
 
   if (tc == NULL || tc == FAKE_CELL)
     {
       nasl_perror (lexic,
                    "nasl_read_var_ref: cannot read NULL or FAKE cell\n");
       return NULL;
     }
   if (tc->type != REF_VAR)
     {
       nasl_perror (lexic,
                    "nasl_read_var_ref: argument (type=%d) is not REF_VAR %s\n",
                    tc->type, get_line_nb (tc));
       return NULL;
     }
 
   v = tc->x.ref_val;
   if (v == NULL)
     return NULL;
 
   ret = alloc_typed_cell (NODE_EMPTY);
   ret->line_nb = tc->line_nb;
 
   switch (v->var_type)
     {
     case VAR2_INT:
       ret->type = CONST_INT;
       ret->x.i_val = v->v.v_int;
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> %lu\n", get_var_name (v),
                     ret->x.i_val);
       return ret;
 
     case VAR2_STRING:
       ret->type = CONST_STR;
       /* Fix bad string length */
       if (v->v.v_str.s_siz <= 0 && v->v.v_str.s_val[0] != '\0')
         {
           v->v.v_str.s_siz = strlen ((char *) v->v.v_str.s_val);
           nasl_perror (lexic, "nasl_read_var_ref: Bad string length fixed\n");
         }
       /* fallthrough */
     case VAR2_DATA:
       ret->type = v->var_type == VAR2_STRING ? CONST_STR : CONST_DATA;
       if (v->v.v_str.s_val == NULL)
         {
           ret->x.str_val = NULL;
           ret->size = 0;
         }
       else
         {
           ret->x.str_val = g_malloc0 (v->v.v_str.s_siz + 1);
           memcpy (ret->x.str_val, v->v.v_str.s_val, v->v.v_str.s_siz);
           ret->size = v->v.v_str.s_siz;
         }
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> \"%s\"\n", get_var_name (v),
                     ret->x.str_val);
       return ret;
 
     case VAR2_ARRAY:
       ret->type = REF_ARRAY;
       ret->x.ref_val = &v->v.v_arr;
       return ret;
 
     case VAR2_UNDEF:
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> undef\n", get_var_name (v),
                     v->var_type);
       break;
 
     default:
       nasl_perror (lexic, "nasl_read_var_ref: unhandled variable type %d\n",
                    v->var_type);
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> ???? (Var type %d)\n",
                     get_var_name (v), v->var_type);
       break;
     }
   deref_cell (ret);
   return NULL;
 }

References alloc_typed_cell(), CONST_DATA, CONST_INT, CONST_STR, deref_cell(), FAKE_CELL, get_line_nb(), get_var_name(), TC::i_val, TC::line_nb, nasl_perror(), nasl_trace(), nasl_trace_enabled(), NODE_EMPTY, REF_ARRAY, TC::ref_val, REF_VAR, st_nasl_string::s_siz, st_nasl_string::s_val, TC::size, TC::str_val, TC::type, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, st_a_nasl_var::var_type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_return()

tree_cell* nasl_return	(	lex_ctxt *	,
		tree_cell *
	)

Definition at line 236 of file nasl_func.c.

{
  tree_cell *c;
 
  retv = cell2atom (ctxt, retv);
  if (retv == NULL)
    retv = FAKE_CELL;
 
  if (retv != FAKE_CELL && retv->type == REF_ARRAY)
    /* We have to "copy" it as the referenced array will be freed */
    {
      c = copy_ref_array (retv);
      deref_cell (retv);
      retv = c;
    }
 
  while (ctxt != NULL)
    {
      ctxt->ret_val = retv;
      ref_cell (retv);
      if (ctxt->fct_ctxt)
        break;
      ctxt = ctxt->up_ctxt;
    }
  /* Bug? Do not return NULL, as we may test it to break the control flow */
  deref_cell (retv);
  return FAKE_CELL;
}

References cell2atom(), copy_ref_array(), deref_cell(), FAKE_CELL, struct_lex_ctxt::fct_ctxt, REF_ARRAY, ref_cell(), struct_lex_ctxt::ret_val, TC::type, and struct_lex_ctxt::up_ctxt.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function: