nasl_text_utils.c

来自「大国补丁后的nessus2.2.8的源代码」· C语言 代码 · 共 1,313 行 · 第 1/2 页

 *
 *	egrep(pattern, string)
 */
tree_cell * nasl_egrep(lex_ctxt * lexic)
{
 char * pattern = get_str_local_var_by_name(lexic, "pattern");
 char * string = get_str_local_var_by_name(lexic, "string");
 int icase = get_int_local_var_by_name(lexic, "icase", 0);
 tree_cell * retc;
 regex_t re;
 regmatch_t subs[NS];
 char * s, * t;
 int copt;
 char * rets;
 int max_size = get_var_size_by_name(lexic, "string");
 
 if(pattern == NULL || string == NULL)
  return NULL;
  
 bzero(subs, sizeof(subs));
 bzero(&re, sizeof(re));
  
  if(icase != 0)
  	copt = REG_ICASE;
  else 
  	copt = 0;
	
  rets = emalloc(max_size + 1);
  string = estrdup(string);
  
  
  s = string;
  while( s[0] == '\n' )s++;
  
  t = strchr(s, '\n');
  if(t != NULL ) 
  	t[0] = '\0';
  
  if(s[0] != '\0')
   for(;;)
   {
   bzero(&re, sizeof(re));
   nasl_re_set_syntax(RE_SYNTAX_POSIX_EGREP);
   if(nasl_regcomp(&re, pattern, REG_EXTENDED|copt))
   {
   nasl_perror(lexic, "egrep() : regcomp() failed\n");
   return NULL;
   }
  
   
   if(nasl_regexec(&re, s, (size_t)NS, subs, 0) == 0)
     {
      char * t = strchr(s, '\n');
      
      if(t != NULL)
      	t[0]='\0';
	
      strcat(rets, s);
      strcat(rets, "\n");
      if(t != NULL)
      	t[0]='\n';
    }
  
  nasl_regfree(&re);
  
  if(t == NULL)
  	s = NULL;
  else  
   	s = &(t[1]);
 
  if(s != NULL )
  	{
	while(s[0] == '\n') s++; /* Skip empty lines */
  	t = strchr(s, '\n');
	}
  else 
  	t = NULL;
	
  if(t != NULL)
  	t[0] = '\0';
	
  if(s == NULL || s[0] == '\0')break;
  }
#ifdef I_WANT_MANY_DIRTY_ERROR_MESSAGES  
  if(rets[0] == '\0')
  {
   efree(&rets);
   efree(&string);
   return FAKE_CELL;
  }
#endif
  efree(&string);
  
  retc = alloc_tree_cell(0, NULL);
  retc->type = CONST_DATA;
  retc->size = strlen(rets);
  retc->x.str_val = rets;
 
  return retc;
}

/*---------------------------------------------------------------------*/

/*
 * This function returns an array
 */
tree_cell*
nasl_eregmatch(lex_ctxt* lexic)
{
  char		*pattern = get_str_local_var_by_name(lexic, "pattern");
  char		*string  = get_str_local_var_by_name(lexic, "string");
  int		icase    = get_int_local_var_by_name(lexic, "icase", 0);
  int		copt = 0, i;
  tree_cell	*retc;
  regex_t	re;
  regmatch_t	subs[NS];
  anon_nasl_var	v;
  nasl_array	*a;


  if(icase != 0)
    copt = REG_ICASE;
 
  if(pattern == NULL || string == NULL)
    return NULL;

  nasl_re_set_syntax(RE_SYNTAX_POSIX_EGREP);
  if(nasl_regcomp(&re, pattern, REG_EXTENDED|copt))
    {
      nasl_perror(lexic, "regmatch() : regcomp() failed\n");
      return NULL;
    }
  
  if(nasl_regexec(&re, string, (size_t)NS, subs, 0) != 0)
   {
    nasl_regfree(&re);
    return NULL;
   }
      
  retc = alloc_tree_cell(0, NULL);
  retc->type = DYN_ARRAY;
  retc->x.ref_val = a = emalloc(sizeof(nasl_array));

  for (i = 0; i < NS; i ++)
    if (subs[i].rm_so != -1)
      {
	v.var_type = VAR2_DATA;
	v.v.v_str.s_siz = subs[i].rm_eo - subs[i].rm_so;
	v.v.v_str.s_val = (unsigned char*)string + subs[i].rm_so;
	(void) add_var_to_list(a, i, &v);
      }

  nasl_regfree(&re);
  return retc;
}

/*
 * Syntax: substr(s, i1) or substr(s, i1, i2)
 * Returns character from string s starting for position i1 till the end or
 * position i2 (start of string is 0)
 */
tree_cell* nasl_substr(lex_ctxt* lexic)
{
  char		*s1;
  int		sz1, sz2, i1, i2, typ;
  tree_cell	*retc;

  s1 = get_str_var_by_num(lexic, 0);
  sz1 = get_var_size_by_num(lexic, 0);
  typ = get_var_type_by_num(lexic, 0);
  i1 = get_int_var_by_num(lexic, 1, -1);
#ifndef MAX_INT
#define MAX_INT (~(1 << (sizeof(int) * 8 - 1)))
#endif
  i2 = get_int_var_by_num(lexic, 2, MAX_INT);
  if (i2 >= sz1) i2 = sz1-1;

  if (s1 == NULL || i1 < 0)
    {
      nasl_perror(lexic, "Usage: substr(string, idx_start [,idx_end])\n");
      return NULL;
    }

  retc = alloc_tree_cell(0, NULL);
  retc->type = (typ == CONST_STR ? CONST_STR : CONST_DATA);
  if (i1 > i2)
    {
      retc->x.str_val = emalloc(0);
      retc->size = 0;
      return retc;
    }
  sz2 = i2 - i1 + 1;
  retc->size = sz2;
  retc->x.str_val = emalloc(sz2);
  memcpy(retc->x.str_val, s1 + i1, sz2);
  return retc;
}
/*---------------------------------------------------------------------*/
/*
 * Syntax: insstr(s1, s2, i1, i2) or insstr(s1, s2, i1)
 * Insert string s2 into slice [i1:i2] of string s1 and returns the result
 * Warning: returns a CONST_DATA!
 */
tree_cell* nasl_insstr(lex_ctxt* lexic)
{
  char		*s1, *s2, *s3;
  int		sz1, sz2, sz3, i1, i2;
  tree_cell	*retc;

  s1 = get_str_var_by_num(lexic, 0);
  sz1 = get_var_size_by_num(lexic, 0);
  s2 = get_str_var_by_num(lexic, 1);
  sz2 = get_var_size_by_num(lexic, 1);

  i1 = get_int_var_by_num(lexic, 2, -1);
  i2 = get_int_var_by_num(lexic, 3, -1);
  if (i2 > sz1 || i2 == -1) i2 = sz1-1;

  if (s1 == NULL || s2 == NULL || i1 < 0 || i2 < 0)
    {
      nasl_perror(lexic, "Usage: insstr(str1, str2, idx_start [,idx_end])\n");
      return NULL;
    }

  if (i1 >= sz1)
    {
      nasl_perror(lexic, "insstr: cannot insert string2 after end of string1\n");
      return NULL;
    }

  retc = alloc_tree_cell(0, NULL);
  retc->type = CONST_DATA;

  if (i1 > i2)
    {
      nasl_perror(lexic," insstr: warning! 1st index %d greater than 2nd index %d\n", i1, i2);
      sz3 = sz2;
    }
  else
    sz3 = sz1 + i1 - i2 - 1 + sz2;

  s3 = retc->x.str_val = emalloc(sz3);
  retc->size = sz3;

  if (i1 <= sz1)
    {
      memcpy(s3, s1, i1);
      s3 += i1;
    }
  memcpy(s3, s2, sz2); s3 += sz2;
  if (i2 < sz1 - 1)
    memcpy(s3, s1 + i2 +1, sz1 - 1 - i2);
  
  return retc;
}



tree_cell*
nasl_match(lex_ctxt* lexic)
{
  char		*pattern = get_str_local_var_by_name(lexic, "pattern");
  char		*string  = get_str_local_var_by_name(lexic, "string");
  int		icase     = get_int_local_var_by_name(lexic, "icase", 0);
  tree_cell	*retc;
  
  if (pattern == NULL)
    {
      nasl_perror(lexic, "nasl_match: parameter 'pattern' missing\n");
      return NULL;
    }
  if (string == NULL)
    {
      nasl_perror(lexic, "nasl_match: parameter 'string' missing\n");
      return NULL;
    }

  retc = alloc_tree_cell(0, NULL);
  retc->type = CONST_INT;
  retc->x.i_val = str_match(string, pattern, icase);
  return retc;
}

tree_cell*
nasl_split(lex_ctxt* lexic)
{
  tree_cell	*retc;
  nasl_array	*a;
  char		*p, *str, *sep;
  int		i, i0, j, len, sep_len = 0, keep = 1;
  anon_nasl_var	v;


  str = get_str_var_by_num(lexic, 0);
  if (str == NULL) 
    {
#if NASL_DEBUG > 0
      nasl_perror(lexic, "split: missing string parameter\n");
#endif
      return NULL;
    }
  len = get_var_size_by_num(lexic, 0);
  if (len <= 0)
    len = strlen(str);
  if (len <= 0)
    return NULL;

  sep = get_str_local_var_by_name(lexic, "sep");
  if (sep != NULL)
    {
    sep_len = get_var_size_by_name(lexic, "sep");
    if ( sep_len <= 0 ) sep_len = strlen(sep);
    if ( sep_len <= 0 ) 
	{
      	   nasl_perror(lexic, "split: invalid 'seplen' parameter\n");
	   return NULL;
	}
    }

  keep = get_int_local_var_by_name(lexic, "keep", 1);

  retc = alloc_tree_cell(0, NULL);
  retc->type = DYN_ARRAY;
  retc->x.ref_val = a = emalloc(sizeof(nasl_array));

  bzero(&v, sizeof(v));
  v.var_type = VAR2_DATA;
  
  if (sep !=  NULL)
    {
      i = 0; j = 0;
      for(;;)
	{
	  if ((p = (char*)nasl_memmem(str + i, len - i, sep, sep_len)) == NULL)
	    {
	      v.v.v_str.s_siz = len - i;
	      v.v.v_str.s_val = (unsigned char*)str + i;
	      (void) add_var_to_list(a, j ++, &v);
	      return retc;
	    }
	  else
	    {
	      if (keep)
		v.v.v_str.s_siz = (p - (str + i)) + sep_len;
	      else
		v.v.v_str.s_siz = p - (str + i); 
	      v.v.v_str.s_val = (unsigned char*)str + i;
	      (void) add_var_to_list(a, j ++, &v);
	      i = (p - str) + sep_len;
	      if (i >= len)
		return retc;
	    }
	}
    }
  
  /* Otherwise, we detect the end of line. A little more subtle */
  for (i = i0 = j = 0; i < len; i ++)
    {
      if (str[i] == '\r' && str[i+1] == '\n')
	{
	  i ++;
	  if (keep)
	    v.v.v_str.s_siz = i - i0 + 1;
	  else
	    v.v.v_str.s_siz = i - i0 - 1;
	  v.v.v_str.s_val = (unsigned char*)str + i0;
	  i0 = i + 1;
	  (void) add_var_to_list(a, j ++, &v);
	}
      else if (str[i] == '\n')
	{
	  if (keep)
	    v.v.v_str.s_siz = i - i0 + 1;
	  else
	    v.v.v_str.s_siz = i - i0;
	  v.v.v_str.s_val = (unsigned char*)str + i0;
	  i0 = i + 1;
	  (void) add_var_to_list(a, j ++, &v);
	}
    }

  if (i > i0)
    {
      v.v.v_str.s_siz = i - i0;
      v.v.v_str.s_val = (unsigned char*)str + i0;
      (void) add_var_to_list(a, j ++, &v);
    }
  return retc;
}

tree_cell*
nasl_chomp(lex_ctxt* lexic)
{
  tree_cell	*retc;
  char		*p = NULL, *str;
  int		i, len;


  str = get_str_var_by_num(lexic, 0);
  if (str == NULL)
    return NULL;
  len = get_var_size_by_num(lexic, 0);

  retc = alloc_tree_cell(0, NULL);
  retc->type = CONST_DATA;

  for (i = 0; i < len; i ++)
    if (isspace(str[i]))
      {
	if (p == NULL)
	  p = str + i;
      }
    else
      p = NULL;

  if (p != NULL)
    len = (p - str);

  retc->x.str_val = emalloc(len);
  retc->size = len;
  memcpy(retc->x.str_val, str, len);
  retc->x.str_val[len] = '\0';
  return retc;
}


/*---------------------------------------------------------------------*/
tree_cell* nasl_crap(lex_ctxt* lexic)
{
  tree_cell	*retc;
  char		*data = get_str_local_var_by_name(lexic, "data");
  int		data_len = -1;
  int		len = get_int_local_var_by_name(lexic, "length", -1);
  int		len2 = get_int_var_by_num(lexic, 0, -1);


  if(len < 0 && len2 < 0)
    {
      nasl_perror(lexic, "crap: invalid or missing 'length' argument\n");
      return NULL;
    }
  if (len >= 0 && len2 >= 0)
    {
      nasl_perror(lexic, "crap: cannot set both unnamed and named 'length'\n");
      return NULL;
    }
  if (len < 0)
    len = len2;

  if( len == 0 )
  	return FAKE_CELL;
	
  if (data != NULL)
    {
      data_len = get_var_size_by_name(lexic, "data");
      if (data_len == 0)
	{
	  nasl_perror(lexic, "crap: invalid null 'data' parameter\n");
	  return NULL;
	}
    }

  retc = alloc_tree_cell(0, NULL);
  retc->type = CONST_DATA /*CONST_STR*/;
  retc->x.str_val = emalloc(len+1);
  retc->size = len;
  if (data == NULL)
    memset(retc->x.str_val, 'X', len);
  else
    {
      int	i,r;
      for(i = 0; i < len - data_len; i += data_len)
	memcpy(retc->x.str_val + i, data, data_len);
	
      if(data_len != 1)
       {
        if((r = (len % data_len)) > 0)
 	 memcpy(retc->x.str_val + (len - r), data, r);
	else
	 memcpy(retc->x.str_val + (len - data_len), data, data_len);
       }
      else 
         retc->x.str_val[ len - 1 ] = data[0];
    }
  retc->x.str_val[len] = '\0';
  return retc;
}
/*---------------------------------------------------------------------*/

tree_cell* nasl_strstr(lex_ctxt * lexic)
{
 char * a = get_str_var_by_num(lexic, 0);
 char * b = get_str_var_by_num(lexic, 1);
 int sz_a = get_var_size_by_num(lexic, 0);
 int sz_b = get_var_size_by_num(lexic, 1);
 
 char * c;
 tree_cell * retc;
 
 
 
 if(a == NULL || b == NULL)
  return NULL;
 
 if(sz_b > sz_a)
  return NULL;
 
 c = (char*)nasl_memmem(a, sz_a, b, sz_b);
 if(c == NULL)
  return FAKE_CELL;
 
 retc = alloc_tree_cell(0, NULL);
 retc->type = CONST_DATA;
 retc->size = sz_a - (c - a);
 retc->x.str_val = nasl_strndup(c, retc->size);
 return retc;
}


/*
 * stridx does the same job as strstr but returns the index of the substring
 * Returning NULL for "not found" is dangerous as automatic conversion to
 * to integer would change it into 0.
 * So we return (-1)
 */

tree_cell*
nasl_stridx(lex_ctxt * lexic)
{
  char		*a = get_str_var_by_num(lexic, 0);
  int		sz_a = get_var_size_by_num(lexic, 0);
  char		*b = get_str_var_by_num(lexic, 1);
  int		sz_b = get_var_size_by_num(lexic, 1);
  char		*c;
  int		start = get_int_var_by_num(lexic, 2, 0);
  tree_cell	*retc = alloc_typed_cell(CONST_INT);

  retc->x.i_val = -1;
  if (a == NULL || b == NULL)
    {
      nasl_perror(lexic, "stridx(string, substring [, start])\n");
      return retc;
    }
    
  if(start < 0 || start > sz_a)
    {
      nasl_perror(lexic, "stridx(string, substring [, start])\n");
      return retc;
    }
    
    
  if ((sz_a == start) || (sz_b > sz_a + start))
    return retc;

  c = (char*)nasl_memmem(a + start, sz_a - start, b, sz_b);
  if(c != NULL)
    retc->x.i_val = c - a;
  return retc;
}

/*
 * str_replace(string: s, find: f, replace: r [,count: n])
 */

tree_cell*
nasl_str_replace(lex_ctxt * lexic)
{
  char		*a, *b, *r, *s, *c;
  int		sz_a, sz_b, sz_r, count;
  int		i1, i2, sz2, n, l;
  tree_cell	*retc = NULL;


  a = get_str_local_var_by_name(lexic, "string");
  b = get_str_local_var_by_name(lexic, "find");
  r = get_str_local_var_by_name(lexic, "replace");
  sz_a = get_local_var_size_by_name(lexic, "string");
  sz_b = get_local_var_size_by_name(lexic, "find");
  sz_r = get_local_var_size_by_name(lexic, "replace");
  count = get_int_local_var_by_name(lexic, "count", 0);

  if (a == NULL || b == NULL)
    {
      nasl_perror(lexic, "Missing argument: str_replace(string: s, find: f, replace: r [,count: c])\n");
      return NULL;
    }

  if (sz_b == 0)
    {
      nasl_perror(lexic, "str_replace: illegal 'find' argument value\n");
      return NULL;
    }

  if (r == NULL)
    {
      r = "";
      sz_r = 0;
    }

  retc = alloc_typed_cell(CONST_DATA);
  s = emalloc(1);
  sz2 = 0;
  n = 0;
  for (i1 = i2 = 0; i1 <= sz_a - sz_b; )
    {
      c = (char*)nasl_memmem(a + i1, sz_a - i1, b, sz_b);
      if(c == NULL)
	break;
      l = (c - a) - i1; 
      sz2 += sz_r + l;
      s = erealloc(s, sz2+1);
      s[sz2] = '\0';
      if (c - a > i1)
	{
	  memcpy(s + i2, a + i1, l);
	  i2 += l;
	}
      if (sz_r > 0)
	{
	  memcpy(s + i2, r, sz_r);
	  i2 += sz_r;
	}
      i1 += l + sz_b;
      n ++;
      if (count > 0 && n >= count)
	break;
    }

  if (i1 < sz_a)
    {
      sz2 += (sz_a - i1);
      s = erealloc(s, sz2+1);
      s[sz2] = '\0';
      memcpy(s + i2, a + i1, sz_a - i1);
    }

  retc->x.str_val = s;
  retc->size = sz2;
  return retc;
}

/*---------------------------------------------------------------------*/
tree_cell* nasl_int(lex_ctxt * lexic)
{
 int r = get_int_var_by_num(lexic, 0, 0);
 tree_cell * retc;
 
 retc = alloc_tree_cell(0, NULL);
 retc->type = CONST_INT;
 retc->x.i_val = r;
 
 return retc;
}
/*EOF*/