lint.c File Reference

#include "lint.h"
#include "exec.h"
#include "nasl.h"
#include "nasl_debug.h"
#include "nasl_func.h"
#include "nasl_global_ctxt.h"
#include "nasl_init.h"
#include "nasl_lex_ctxt.h"
#include "nasl_tree.h"
#include "nasl_var.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>

Include dependency graph for lint.c:

Go to the source code of this file.

Data Structures
struct	st_func_info
	Define struct to store information about a called function. More...

Macros
#define	G_LOG_DOMAIN   "lib nasl"
	GLib logging domain.

Typedefs
typedef struct st_func_info	func_info
	Define struct to store information about a called function.

Functions
static void	init_errors_cnt ()
static void	inc_errors_cnt ()
static int	get_errors_cnt ()
static void	free_list_func (func_info *data)
	Free a func_info structure.
static void	add_predef_varname (GSList **defined_var)
	Add keywords to the varnames list.
static gint	list_cmp1 (gconstpointer lelem, gconstpointer data)
	This function is called by g_slist_find_custom.
static gint	reverse_search (GSList **def_func_tree, GSList *finfo)
	Check if an undefined called function is needed or not. This is the case in which the function is called from a nested and defined function but never called.
static gint	list_cmp (gconstpointer lelem, gconstpointer data)
	This function is called by g_slist_find_custom.
static void	check_called_files (gpointer key, gpointer value, GSList **unusedfiles)
	This function is called by g_hash_table_foreach to check if an include file was used or not. If the file is not used, it is added to a list.
static void	print_uncall_files (gpointer filename, gpointer lexic)
	It shows a msg for unused included files.
static tree_cell *	nasl_lint_def (lex_ctxt *lexic, tree_cell *st, int lint_mode, GHashTable **include_files, GHashTable **func_fnames_tab, gchar *err_fname, GSList **called_funcs, GSList **def_func_tree)
	Loads all defined functions. Also, It constructs a tree of called functions to help recognize a not defined function which is never called (nested functions).
static char *	get_argument_by_name (tree_cell *st, char *name)
	Checks if a given Arguments is within a given Argument List.
static tree_cell *	validate_script_xref (lex_ctxt *lexic, tree_cell *st)
	Validates parameters of a script_xref function call.
static tree_cell *	validate_function (lex_ctxt *lexic, tree_cell *st)
	Validate functions.
static int	is_deffunc_used (const char *funcname, const char *filename, GSList *def_func_tree)
	Returns 1 if the function is at least used once by another caller than filename otherwise 0.
void	nasl_lint_feature_flags (int flag)
static tree_cell *	nasl_lint_call (lex_ctxt *lexic, tree_cell *st, GHashTable **include_files, GHashTable **func_fnames_tab, gchar *err_fname, GSList **called_funcs, GSList **def_func_tree)
	Check if a called function was defined.
static tree_cell *	nasl_lint_defvar (lex_ctxt *lexic, tree_cell *st, GHashTable **include_files, GHashTable **func_fnames_tab, gchar *err_fname, GSList **defined_var, GSList **called_funcs)
	Consider all cases in which a variable is set, and add it to a list. If a variable is read, it checks if it was previously added to the list.
static tree_cell *	make_call_func_list (lex_ctxt *lexic, tree_cell *st, GSList **called_funcs)
	Make a list of all called functions.
static tree_cell *	check_description_block_xref (lex_ctxt *lexic, tree_cell *st)
	Sanity check of the script_xref parameters in the description block.
static tree_cell *	check_description_block (lex_ctxt *lexic, tree_cell *st)
	Sanity check of the description block.
static tree_cell *	find_description_block (lex_ctxt *lexic, tree_cell *st)
	Sanity check of the description block.
tree_cell *	nasl_lint (lex_ctxt *lexic, tree_cell *st)
	Search for errors in a nasl script.

Variables
char *	nasl_name
int	errors_cnt
int	features = 0

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "lib nasl"

GLib logging domain.

Definition at line 27 of file lint.c.

Typedef Documentation

func_info

typedef struct st_func_info func_info

Define struct to store information about a called function.

Function Documentation

add_predef_varname()

void add_predef_varname ( GSList ** defined_var )

static

Add keywords to the varnames list.

Parameters

[in,out]

defined_var

List with all defined variables

Definition at line 81 of file lint.c.

{
  int i;
  gchar *keywords[] = {"ACT_UNKNOWN",  "description",    "NULL", "SCRIPT_NAME",
                       "COMMAND_LINE", "_FCT_ANON_ARGS", NULL};
 
  for (i = 0; keywords[i] != NULL; i++)
    *defined_var = g_slist_prepend (*defined_var, keywords[i]);
  add_nasl_library (defined_var);
}

References add_nasl_library().

Referenced by nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

check_called_files()

void check_called_files ( gpointer key, gpointer value, GSList ** unusedfiles )

static

This function is called by g_hash_table_foreach to check if an include file was used or not. If the file is not used, it is added to a list.

Parameters

[in]	key	Element key of GHashTable.
[in]	value	Element value for a key of GHashTable.
[in]	unusedfiles	List with unused .inc files.

Definition at line 169 of file lint.c.

{
  if (key != NULL)
    // only check for includes not for main file
    if (nasl_get_include_order ((const char *) key) > 0
        && g_strcmp0 (value, "YES") != 0)
      *unusedfiles = g_slist_prepend (*unusedfiles, key);
}

References nasl_get_include_order().

Referenced by nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

check_description_block()

tree_cell * check_description_block ( lex_ctxt * lexic, tree_cell * st )

static

Sanity check of the description block.

Returns

FAKE_CELL if success, NULL otherwise.

Definition at line 749 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
 
  if (st->type == NODE_FUN_CALL)
    if (!g_strcmp0 (st->x.str_val, "script_xref"))
      if ((ret = check_description_block_xref (lexic, st)) == NULL)
        return NULL;
 
  for (i = 0; i < 4; i++)
    if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
      if ((ret = check_description_block (lexic, st->link[i])) == NULL)
        return NULL;
 
  return ret;
}

References check_description_block(), check_description_block_xref(), FAKE_CELL, TC::link, NODE_FUN_CALL, TC::str_val, TC::type, and TC::x.

Referenced by check_description_block(), and nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

check_description_block_xref()

tree_cell * check_description_block_xref ( lex_ctxt * lexic, tree_cell * st )

static

Sanity check of the script_xref parameters in the description block.

Definition at line 718 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
 
  switch (st->type)
    {
    case CONST_STR:
      if (g_strrstr (st->x.str_val, ", ") != NULL)
        {
          g_message ("%s: An error in script_xrefs function was found. "
                     "Spaces after a comma are not allow in xrefs names "
                     "or values: '%s'",
                     nasl_get_filename (st->x.str_val), st->x.str_val);
          return NULL;
        }
      /* fallthrough */
    default:
      for (i = 0; i < 4; i++)
        if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
          if ((ret = check_description_block_xref (lexic, st->link[i])) == NULL)
            return NULL;
    }
  return ret;
}

References check_description_block_xref(), CONST_STR, FAKE_CELL, TC::link, nasl_get_filename(), TC::str_val, TC::type, and TC::x.

Referenced by check_description_block(), and check_description_block_xref().

Here is the call graph for this function:

Here is the caller graph for this function:

find_description_block()

tree_cell * find_description_block ( lex_ctxt * lexic, tree_cell * st )

static

Sanity check of the description block.

Returns

pointer to the description block tree cell.

Definition at line 773 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
  tree_cell *st_aux = NULL;
 
  if (st && st->type == NODE_IF_ELSE)
    {
      for (i = 0; i < 4; i++)
        if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
          {
            st_aux = st->link[i];
            if (st_aux->type == NODE_VAR
                && !g_strcmp0 (st_aux->x.str_val, "description"))
              return st;
          }
    }
  else
    for (i = 0; i < 4; i++)
      {
        if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
          if ((ret = find_description_block (lexic, st->link[i])) == NULL)
            return NULL;
        return ret;
      }
  return NULL;
}

References FAKE_CELL, find_description_block(), TC::link, NODE_IF_ELSE, NODE_VAR, TC::str_val, TC::type, and TC::x.

Referenced by find_description_block(), and nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

free_list_func()

void free_list_func ( func_info * data )

static

Free a func_info structure.

Parameters

[in]

defined_var

List with all defined variables

Definition at line 66 of file lint.c.

{
  g_free (data->func_name);
  g_free (data->caller_func);
  g_free (data->caller_file);
  memset (data, '\0', sizeof (func_info));
}

References st_func_info::caller_file, st_func_info::caller_func, and st_func_info::func_name.

Referenced by nasl_lint().

Here is the caller graph for this function:

get_argument_by_name()

char * get_argument_by_name ( tree_cell * st, char * name )

static

Checks if a given Arguments is within a given Argument List.

Parameters

st	Argument List, should be of Type NODE_ARG
name	Name of the Argument to search for

Returns

char* Value of the given Argument name

Definition at line 317 of file lint.c.

{
  if (st == NULL)
    return NULL;
 
  if (st->type != NODE_ARG)
    return NULL;
 
  tree_cell *cp;
  for (cp = st; cp != NULL; cp = cp->link[1])
    {
      if (!g_strcmp0 (cp->x.str_val, name))
        return cp->link[0]->x.str_val;
    }
 
  return NULL;
}

References TC::link, name, NODE_ARG, TC::str_val, TC::type, and TC::x.

Referenced by validate_script_xref().

Here is the caller graph for this function:

get_errors_cnt()

int get_errors_cnt ( )

static

Definition at line 54 of file lint.c.

{
  return errors_cnt;
}

References errors_cnt.

Referenced by nasl_lint().

Here is the caller graph for this function:

inc_errors_cnt()

void inc_errors_cnt ( )

static

Definition at line 48 of file lint.c.

{
  errors_cnt++;
  return;
}

References errors_cnt.

Referenced by nasl_lint(), nasl_lint_defvar(), and print_uncall_files().

Here is the caller graph for this function:

init_errors_cnt()

void init_errors_cnt ( )

static

Definition at line 43 of file lint.c.

{
  errors_cnt = 0;
}

References errors_cnt.

Referenced by nasl_lint().

Here is the caller graph for this function:

is_deffunc_used()

int is_deffunc_used ( const char * funcname, const char * filename, GSList * def_func_tree )

static

Returns 1 if the function is at least used once by another caller than filename otherwise 0.

Definition at line 405 of file lint.c.

{
  func_info *element;
  GSList *current = def_func_tree;
 
  if (current == NULL)
    return 0;
 
  do
    {
      element = current->data;
      if (g_strcmp0 (element->func_name, funcname) == 0
          && g_strcmp0 (element->caller_file, filename) != 0)
        return 1;
      current = current->next;
    }
  while (current != NULL && current->next != NULL);
  return 0;
}

References st_func_info::caller_file, and st_func_info::func_name.

Referenced by nasl_lint_call().

Here is the caller graph for this function:

list_cmp()

gint list_cmp ( gconstpointer lelem, gconstpointer data )

static

This function is called by g_slist_find_custom.

Parameters

[in]	lelem	Element of GSList.
[in]	data	str to be found in the list.

Returns

0 on success, non 0 otherwise.

Definition at line 151 of file lint.c.

{
  if (data)
    return (g_strcmp0 (lelem, data));
  return -1;
}

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

Here is the caller graph for this function:

list_cmp1()

gint list_cmp1 ( gconstpointer lelem, gconstpointer data )

static

This function is called by g_slist_find_custom.

Parameters

[in]	lelem	Element of GSList.
[in]	data	func_info structure to be found.

Returns

0 on success, non 0 otherwise.

Definition at line 101 of file lint.c.

{
  if (data)
    {
      gchar *lala = g_strdup (((func_info *) lelem)->func_name);
      return (g_strcmp0 (lala, data));
    }
  return -1;
}

Referenced by nasl_lint_call(), and reverse_search().

Here is the caller graph for this function:

make_call_func_list()

tree_cell * make_call_func_list ( lex_ctxt * lexic, tree_cell * st, GSList ** called_funcs )

static

Make a list of all called functions.

Definition at line 687 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
  nasl_func *pf = NULL;
 
  switch (st->type)
    {
    case NODE_FUN_CALL:
      pf = get_func_ref_by_name (lexic, st->x.str_val);
      if (st->x.str_val && !pf)
        {
          *called_funcs =
            g_slist_prepend (*called_funcs, g_strdup (st->x.str_val));
        }
      /* fallthrough */
 
    default:
      for (i = 0; i < 4; i++)
        if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
          if ((ret = make_call_func_list (lexic, st->link[i], called_funcs))
              == NULL)
            return NULL;
      return ret;
    }
}

References FAKE_CELL, get_func_ref_by_name(), TC::link, make_call_func_list(), NODE_FUN_CALL, TC::str_val, TC::type, and TC::x.

Referenced by make_call_func_list(), and nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_lint()

tree_cell * nasl_lint	(	lex_ctxt *	lexic,
		tree_cell *	st )

Search for errors in a nasl script.

Parameters

[in]	lexic	nasl context.
[in]	st	structure tree of a nasl script.

Returns

FAKE_CELL if no error was found, otherwise NULL or tree_cell which has number of errors as x.i_val.

Definition at line 811 of file lint.c.

{
  lex_ctxt *lexic_aux;
  tree_cell *ret = FAKE_CELL;
  int lint_mode = 1;
  GHashTable *include_files = NULL;
  GHashTable *func_fnames_tab = NULL;
  GSList *unusedfiles = NULL;
  GSList *called_funcs = NULL;
  GSList *def_func_tree = NULL;
  gchar *err_fname = NULL;
  tree_cell *desc_block = FAKE_CELL;
  init_errors_cnt ();
 
  nasl_name = g_strdup (nasl_get_filename (st->x.str_val));
  include_files =
    g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
  func_fnames_tab =
    g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
 
  lexic_aux = init_empty_lex_ctxt ();
  lexic_aux->script_infos = lexic->script_infos;
  lexic_aux->oid = lexic->oid;
 
  /* Check description block sanity. */
  desc_block = find_description_block (lexic_aux, st);
  if (desc_block != NULL && desc_block != FAKE_CELL)
    {
      /* FAKE_CELL if success, NULL otherwise which counts as error */
      if (check_description_block (lexic_aux, desc_block) == NULL)
        {
          inc_errors_cnt ();
        }
    }
  /* Make a list of all called functions */
  make_call_func_list (lexic_aux, st, &called_funcs);
 
  /* Loads all defined functions. */
  if (nasl_lint_def (lexic_aux, st, lint_mode, &include_files, &func_fnames_tab,
                     err_fname, &called_funcs, &def_func_tree)
      == NULL)
    {
      inc_errors_cnt ();
    }
  /* Check if a called function was defined. */
 
  if (nasl_lint_call (lexic_aux, st, &include_files, &func_fnames_tab,
                      err_fname, &called_funcs, &def_func_tree)
      == NULL)
    {
      inc_errors_cnt ();
    }
 
  /* Check if the included files are used or not. */
  g_hash_table_foreach (include_files, (GHFunc) check_called_files,
                        &unusedfiles);
  if (unusedfiles != NULL)
    g_slist_foreach (unusedfiles, (GFunc) print_uncall_files, lexic_aux);
  if ((g_slist_length (unusedfiles)) > 0)
    {
      inc_errors_cnt ();
    }
 
  /* Now check that each function was loaded just once. */
  lint_mode = 0;
  if (nasl_lint_def (lexic, st, lint_mode, &include_files, &func_fnames_tab,
                     err_fname, &called_funcs, &def_func_tree)
      == NULL)
    {
      inc_errors_cnt ();
    }
 
  /* Check if a variable was declared. */
  GSList *defined_var = NULL;
  add_predef_varname (&defined_var);
  ret = nasl_lint_defvar (lexic_aux, st, &include_files, &func_fnames_tab,
                          err_fname, &defined_var, &called_funcs);
  g_slist_free (defined_var);
  defined_var = NULL;
 
  g_slist_free (called_funcs);
  called_funcs = NULL;
  g_slist_free_full (def_func_tree, (GDestroyNotify) free_list_func);
  def_func_tree = NULL;
  g_hash_table_destroy (include_files);
  include_files = NULL;
  g_hash_table_destroy (func_fnames_tab);
  func_fnames_tab = NULL;
  g_free (err_fname);
  g_slist_free (unusedfiles);
  unusedfiles = NULL;
  free_lex_ctxt (lexic_aux);
 
  if (get_errors_cnt () > 0)
    {
      ret = alloc_typed_cell (NODE_VAR);
      ret->x.i_val = get_errors_cnt ();
    }
 
  return ret;
}

References add_predef_varname(), alloc_typed_cell(), check_called_files(), check_description_block(), FAKE_CELL, find_description_block(), free_lex_ctxt(), free_list_func(), get_errors_cnt(), TC::i_val, inc_errors_cnt(), init_empty_lex_ctxt(), init_errors_cnt(), make_call_func_list(), nasl_get_filename(), nasl_lint_call(), nasl_lint_def(), nasl_lint_defvar(), nasl_name, NODE_VAR, struct_lex_ctxt::oid, print_uncall_files(), struct_lex_ctxt::script_infos, TC::str_val, and TC::x.

Referenced by exec_nasl_script().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_lint_call()

tree_cell * nasl_lint_call ( lex_ctxt * lexic, tree_cell * st, GHashTable ** include_files, GHashTable ** func_fnames_tab, gchar * err_fname, GSList ** called_funcs, GSList ** def_func_tree )

static

Check if a called function was defined.

This checks if a defined function is called. If it is never called it does not go deeper.

Definition at line 438 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
  nasl_func *pf;
  char *incname = NULL;
  int f_inc_ord, c_inc_order, rc = 0;
  static int defined_flag = 0;

  if (st->type == NODE_FUN_DEF)
    {
      if (!g_slist_find_custom (*called_funcs, st->x.str_val,
                                (GCompareFunc) list_cmp))
        {
          return FAKE_CELL;
        }
    }
 
  switch (st->type)
    {
    case CONST_DATA:
    case CONST_STR:
      if (st->x.str_val != NULL && defined_flag == 1)
        {
          decl_nasl_func (lexic, st, 1);
          defined_flag = 0;
        }
      return FAKE_CELL;
 
    case NODE_FUN_CALL:
      pf = get_func_ref_by_name (lexic, st->x.str_val);
 
      if (pf == NULL)
        {
          incname = g_hash_table_lookup (*func_fnames_tab, st->x.str_val);
 
          nasl_set_filename (incname ? incname : "unknown");
          lexic->line_nb = st->line_nb;
 
          GSList *called_f_aux;
          called_f_aux = g_slist_find_custom (*def_func_tree, st->x.str_val,
                                              (GCompareFunc) list_cmp1);
          if (called_f_aux != NULL)
            {
              if (reverse_search (def_func_tree, called_f_aux))
                {
                  nasl_perror (lexic, "Undefined function '%s'\n",
                               st->x.str_val);
                  return NULL;
                }
            }
        }
      else
        {
          // only check functions that are not internal
          if ((features & NLFF_STRICT_INCLUDES)
              && func_is_internal (st->x.str_val) == NULL)
            {
              // get incname verify include order when not 0
              incname = (char *) nasl_get_filename (st->x.str_val);
              if (incname != NULL)
                {
                  f_inc_ord = nasl_get_include_order (incname);
                  c_inc_order = nasl_get_include_order (st->name);
                  // if caller definition is not the main file but included
                  // before the function definition warn about an include error
                  if (c_inc_order > 0 && c_inc_order < f_inc_ord)
                    {
                      nasl_perror (
                        lexic, "%s must be included after %s (usage of %s).",
                        st->name, incname, st->x.str_val);
                      rc = -1;
                    }
                }
            }
          // Check if function parameters are right
          if (validate_function (lexic, st) == NULL)
            return NULL;
        }
      if (*include_files && st->x.str_val)
        {
          if (g_hash_table_lookup (*include_files,
                                   nasl_get_filename (st->x.str_val)))
            {
              incname = g_strdup (nasl_get_filename (st->x.str_val));
              if (is_deffunc_used (st->x.str_val, incname, *def_func_tree))
                {
                  g_hash_table_replace (*include_files, incname,
                                        g_strdup ("YES"));
                }
            }
        }
      if (g_strcmp0 (st->x.str_val, "defined_func") == 0)
        defined_flag = 1;
      /* fallthrough */
 
    default:
      for (i = 0; i < 4; i++)
        if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
          if ((ret = nasl_lint_call (lexic, st->link[i], include_files,
                                     func_fnames_tab, err_fname, called_funcs,
                                     def_func_tree))
              == NULL)
            return NULL;
      return rc == 0 ? ret : NULL;
    }
}

References CONST_DATA, CONST_STR, decl_nasl_func(), FAKE_CELL, features, func_is_internal(), get_func_ref_by_name(), is_deffunc_used(), struct_lex_ctxt::line_nb, TC::line_nb, TC::link, list_cmp(), list_cmp1(), TC::name, nasl_get_filename(), nasl_get_include_order(), nasl_lint_call(), nasl_perror(), nasl_set_filename(), NLFF_STRICT_INCLUDES, NODE_FUN_CALL, NODE_FUN_DEF, reverse_search(), TC::str_val, TC::type, validate_function(), and TC::x.

Referenced by nasl_lint(), and nasl_lint_call().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_lint_def()

tree_cell * nasl_lint_def ( lex_ctxt * lexic, tree_cell * st, int lint_mode, GHashTable ** include_files, GHashTable ** func_fnames_tab, gchar * err_fname, GSList ** called_funcs, GSList ** def_func_tree )

static

Loads all defined functions. Also, It constructs a tree of called functions to help recognize a not defined function which is never called (nested functions).

Definition at line 203 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
  char *incname = NULL;
  gchar *tmp_filename = NULL;
  nasl_func *pf;
  static gchar *current_fun_def = NULL;
 
  if (st->type == NODE_FUN_CALL)
    {
      pf = get_func_ref_by_name (lexic, st->x.str_val);
      if (pf == NULL)
        {
          g_hash_table_insert (*func_fnames_tab, g_strdup (st->x.str_val),
                               g_strdup (err_fname));
        }
 
      /* Save in a list the name of the called function, the file where it
         is called from, and the function where it is called from. This will
         help to know if a called function is really needed, or it was just
         called by another defined function which is never called. */
      func_info *finfo = g_malloc0 (sizeof (func_info));
      finfo->func_name = g_strdup (st->x.str_val);
      finfo->caller_file = g_strdup (err_fname ? err_fname : nasl_name);
      finfo->caller_func = g_strdup (current_fun_def);
      *def_func_tree = g_slist_prepend (*def_func_tree, finfo);
      /* Check if function parameters are used multiple times. Only check
       * this if we are in lint mode 1 to not check it multiple times. */
      if (lint_mode == 1)
        {
          GSList *func_params = NULL;
          int linenum = st->line_nb;
          tree_cell *args = st->link[0];
          for (; args != NULL; args = args->link[1])
            {
              if (args->x.str_val)
                {
                  /* Check if param was already used */
                  if (!g_slist_find_custom (func_params, args->x.str_val,
                                            (GCompareFunc) list_cmp))
                    func_params =
                      g_slist_prepend (func_params, args->x.str_val);
                  else
                    {
                      g_message ("%s: Error at or near line %d. "
                                 "Parameter \"%s\" passed to function \"%s\" "
                                 "was provided multiple times.",
                                 finfo->caller_file, linenum, args->x.str_val,
                                 finfo->func_name);
                      g_slist_free (func_params);
                      return NULL;
                    }
                }
            }
          g_slist_free (func_params);
        }
    }
 
  switch (st->type)
    {
    case NODE_FUN_DEF:
      /* with lint_mode = 0 check if this function was declared twice*/
      if (lint_mode == 0)
        {
          if (decl_nasl_func (lexic, st, lint_mode) == NULL)
            ret = NULL;
          return ret;
        }
      /* Check if it was already added */
      if (!g_slist_find_custom (*called_funcs, st->x.str_val,
                                (GCompareFunc) list_cmp))
        {
          return FAKE_CELL;
        }
 
      /* x.str_val = function name, [0] = argdecl, [1] = block */
      decl_nasl_func (lexic, st, lint_mode);
      current_fun_def = g_strdup (st->x.str_val);
      incname = g_strdup (nasl_get_filename (st->x.str_val));
      g_hash_table_replace (*include_files, incname, g_strdup ("NO"));
      tmp_filename = g_strdup (nasl_get_filename (NULL));
      err_fname = g_strdup (incname);
      /* fallthrough */
 
    default:
      for (i = 0; i < 4; i++)
        if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
          if ((ret = nasl_lint_def (lexic, st->link[i], lint_mode,
                                    include_files, func_fnames_tab, err_fname,
                                    called_funcs, def_func_tree))
              == NULL)
            return NULL;
 
      if (st->type == NODE_FUN_DEF)
        {
          if (tmp_filename)
            nasl_set_filename (tmp_filename);
          g_free (tmp_filename);
        }
      return ret;
    }
}

References st_func_info::caller_file, st_func_info::caller_func, decl_nasl_func(), FAKE_CELL, st_func_info::func_name, get_func_ref_by_name(), TC::line_nb, TC::link, list_cmp(), nasl_get_filename(), nasl_lint_def(), nasl_name, nasl_set_filename(), NODE_FUN_CALL, NODE_FUN_DEF, TC::str_val, TC::type, and TC::x.

Referenced by nasl_lint(), and nasl_lint_def().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_lint_defvar()

tree_cell * nasl_lint_defvar ( lex_ctxt * lexic, tree_cell * st, GHashTable ** include_files, GHashTable ** func_fnames_tab, gchar * err_fname, GSList ** defined_var, GSList ** called_funcs )

static

Consider all cases in which a variable is set, and add it to a list. If a variable is read, it checks if it was previously added to the list.

This checks if a defined function is called. If it is never called it does not go deeper.

It is a local variable and it is added in special list, which will be cleaned at the end of the function.

Leaving the function definition, the local variables list is cleaned.

Definition at line 557 of file lint.c.

{
  int i;
  tree_cell *ret = FAKE_CELL;
  static int defined_fn_mode = 0;
  static int defined_var_mode = 0;
  static int def_glob_var = 0;
  static GSList *local_var_list = NULL;

  if (st->type == NODE_FUN_DEF)
    {
      if (!g_slist_find_custom (*called_funcs, st->x.str_val,
                                (GCompareFunc) list_cmp))
        {
          return FAKE_CELL;
        }
    }
 
  if ((defined_fn_mode == 1 || def_glob_var) && st->type != NODE_DECL)
    {
      defined_fn_mode = 0;
      def_glob_var = 0;
    }
 
  /* A variable will be defined, then set the mode variable. */
  if ((st->type == NODE_AFF || st->type == EXPR_NOT || st->type == EXPR_INCR
       || st->type == NODE_PLUS_EQ)
      && defined_var_mode == 0)
    defined_var_mode = 1;
  else if ((st->type == NODE_FUN_DEF || st->type == NODE_LOCAL
            || st->type == NODE_FUN_CALL)
           && defined_fn_mode == 0)
    {
      defined_fn_mode = 1;
      defined_var_mode = 0;
    }
 
  else if (st->type == NODE_GLOBAL)
    def_glob_var = 1;
 
  /* The variable is being defined. Therefore is save into the
   * global list only if was not previously added in local list.
   */
  else if ((st->type == NODE_VAR || st->type == NODE_ARRAY_EL)
           && (defined_var_mode == 1 || defined_fn_mode == 1))
    {
      if (st->x.str_val != NULL)
        {
          if (!g_slist_find_custom (local_var_list, st->x.str_val,
                                    (GCompareFunc) list_cmp))
            *defined_var = g_slist_prepend (*defined_var, st->x.str_val);
          defined_var_mode = 0;
        }
    }
  else if (st->type == NODE_DECL && st->x.str_val != NULL)
    {
      if (defined_fn_mode == 1)
        {
          local_var_list = g_slist_prepend (local_var_list, st->x.str_val);
        }
      if (def_glob_var == 1)
        {
          *defined_var = g_slist_prepend (*defined_var, st->x.str_val);
        }
    }
  /* Special case foreach. */
  else if (st->type == NODE_FOREACH)
    {
      // Hacky way of checking if we are in a function definition by checking
      // if local_var_list is non empty. Otherwise all variables declared in a
      // foreach call are considered file scope which leads to false negatives.
      if (st->x.str_val != NULL && local_var_list != NULL)
        {
          local_var_list = g_slist_prepend (local_var_list, st->x.str_val);
        }
      else if (st->x.str_val != NULL)
        {
          *defined_var = g_slist_prepend (*defined_var, st->x.str_val);
        }
    }
 
  // The variable is used. It checks if the variable was defined
  // Also check for NODE_ARRAY_EL to catch use of undeclared array.
  // E.g "if(foo[0]) {}" and foo was not declared previously.
  else if ((st->type == NODE_VAR || st->type == NODE_ARRAY_EL)
           && defined_var_mode == 0)
    {
      if (!g_slist_find_custom (*defined_var, st->x.str_val,
                                (GCompareFunc) list_cmp)
          && !g_slist_find_custom (local_var_list, st->x.str_val,
                                   (GCompareFunc) list_cmp))
        {
          lexic->line_nb = st->line_nb;
          nasl_perror (lexic, "The variable %s was not declared",
                       st->x.str_val);
          inc_errors_cnt ();
        }
    }
 
  for (i = 0; i < 4; i++)
    if (st->link[i] != NULL && st->link[i] != FAKE_CELL)
      if ((ret = nasl_lint_defvar (lexic, st->link[i], include_files,
                                   func_fnames_tab, err_fname, defined_var,
                                   called_funcs))
          == NULL)
        return NULL;

  if (st->type == NODE_FUN_DEF)
    {
      g_slist_free (local_var_list);
      local_var_list = NULL;
    }
 
  return ret;
}

References EXPR_INCR, EXPR_NOT, FAKE_CELL, inc_errors_cnt(), struct_lex_ctxt::line_nb, TC::line_nb, TC::link, list_cmp(), nasl_lint_defvar(), nasl_perror(), NODE_AFF, NODE_ARRAY_EL, NODE_DECL, NODE_FOREACH, NODE_FUN_CALL, NODE_FUN_DEF, NODE_GLOBAL, NODE_LOCAL, NODE_PLUS_EQ, NODE_VAR, TC::str_val, TC::type, and TC::x.

Referenced by nasl_lint(), and nasl_lint_defvar().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_lint_feature_flags()

void nasl_lint_feature_flags

(

int

flag

)

Definition at line 429 of file lint.c.

{
  features = flag;
}

References features.

print_uncall_files()

void print_uncall_files ( gpointer filename, gpointer lexic )

static

It shows a msg for unused included files.

Parameters

[in]	filename	Filename of the not used inc file.
[in]	lexic	nasl context.

Definition at line 186 of file lint.c.

{
  if (filename != NULL)
    {
      nasl_perror (lexic, "The included file '%s' is never used.",
                   (char *) filename);
      inc_errors_cnt ();
      lexic = NULL;
    }
}

References inc_errors_cnt(), and nasl_perror().

Referenced by nasl_lint().

Here is the call graph for this function:

Here is the caller graph for this function:

reverse_search()

gint reverse_search ( GSList ** def_func_tree, GSList * finfo )

static

Check if an undefined called function is needed or not. This is the case in which the function is called from a nested and defined function but never called.

Returns

1 if the function is needed, 0 otherwise.

Definition at line 118 of file lint.c.

{
  func_info *fdata = finfo->data;
  GSList *finfo_aux;
 
  // The file name is the original file to be tested. It is not an include.
  if (!g_strcmp0 (fdata->caller_file, nasl_name)
      && !g_str_has_suffix (nasl_name, ".inc"))
    return 1;
 
  // The function is it self.
  if (!g_strcmp0 (fdata->func_name, fdata->caller_func))
    return 0;
 
  // I go up in the tree of called and defined functions.
  if ((finfo_aux = g_slist_find_custom (*def_func_tree, fdata->caller_func,
                                        (GCompareFunc) list_cmp1))
      != NULL)
    if (reverse_search (def_func_tree, finfo_aux))
      return 1;
 
  return 0;
}

References st_func_info::caller_file, st_func_info::caller_func, st_func_info::func_name, list_cmp1(), nasl_name, and reverse_search().

Referenced by nasl_lint_call(), and reverse_search().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_function()

tree_cell * validate_function ( lex_ctxt * lexic, tree_cell * st )

static

Validate functions.

Parameters

lexic
st

Returns

tree_cell * NULL if it is invalid, FAKE_CELL if it is valid

Definition at line 386 of file lint.c.

{
  lexic->line_nb = st->line_nb;
  if (st != NULL)
    {
      if (!g_strcmp0 (st->x.str_val, "script_xref"))
        return validate_script_xref (lexic, st->link[0]);
    }
  else
    return NULL;
 
  return FAKE_CELL;
}

References FAKE_CELL, struct_lex_ctxt::line_nb, TC::line_nb, TC::link, TC::str_val, validate_script_xref(), and TC::x.

Referenced by nasl_lint_call().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_script_xref()

tree_cell * validate_script_xref ( lex_ctxt * lexic, tree_cell * st )

static

Validates parameters of a script_xref function call.

Parameters

lexic
st	Function Parameters should be of type NODE_ARG

Returns

tree_cell*

Definition at line 343 of file lint.c.

{
  char *name = get_argument_by_name (st, "name");
  char *value = get_argument_by_name (st, "value");
  char *csv = get_argument_by_name (st, "csv");
 
  if (((value == NULL) && (csv == NULL)) || name == NULL)
    {
      nasl_perror (lexic,
                   "script_xref() syntax error - should be"
                   " script_xref(name:<name>, value:<value>) or"
                   " script_xref(name:<name>, value:<value>, csv:<CSVs>) or"
                   " script_xref(name:<name>, csv:<CSVs>)\n");
      if (name == NULL)
        {
          nasl_perror (lexic, "  <name> is empty\n");
        }
      else
        {
          nasl_perror (lexic, "  <name> is %s\n", name);
        }
      if ((value == NULL) && (csv == NULL))
        {
          nasl_perror (lexic, "  <value> and <csv> is empty)\n");
        }
      else
        {
          nasl_perror (lexic, "  <value> is %s\n)", value);
          nasl_perror (lexic, "  <csv> is %s\n)", csv);
        }
      return NULL;
    }
  return FAKE_CELL;
}

References FAKE_CELL, get_argument_by_name(), name, and nasl_perror().

Referenced by validate_function().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

errors_cnt

int errors_cnt

Definition at line 41 of file lint.c.

Referenced by get_errors_cnt(), inc_errors_cnt(), and init_errors_cnt().

features

int features = 0

Definition at line 426 of file lint.c.

Referenced by nasl_lint_call(), and nasl_lint_feature_flags().

nasl_name

char* nasl_name

Definition at line 39 of file lint.c.

Referenced by nasl_lint(), nasl_lint_def(), and reverse_search().