29 #include "../misc/strutils.h" 49 #define G_LOG_DOMAIN "lib nasl" 65 for (vi = 0; vi < vn; vi++)
76 newlen = retc->
size + sz;
89 if (*p1 ==
'\\' && p1[1] !=
'\0')
106 if (isxdigit (p1[2]) && isxdigit (p1[3]))
110 * (isdigit (p1[2]) ? p1[2] -
'0' 111 : 10 + tolower (p1[2]) -
'a')
112 + (isdigit (p1[3]) ? p1[3] -
'0' 113 : 10 + tolower (p1[3]) -
'a');
120 "Buggy hex value '\\x%c%c' skipped\n",
121 isprint (p1[2]) ? p1[2] :
'.',
122 isprint (p1[3]) ? p1[3] :
'.');
129 "Unknown escape sequence '\\%c' in the " 131 isprint (p1[1]) ? p1[1] :
'.', s);
147 #define RAW_STR_LEN 32768 162 for (vi = 0; vi < vn && total_len <
RAW_STR_LEN - 1; vi++)
186 nasl_perror (lexic,
"Error. Too long argument in raw_string()\n");
196 for (i = 0, j = 0; i < sz; i++)
205 else if (s[i + 1] ==
't')
210 else if (s[i + 1] ==
'r')
215 else if (s[i + 1] ==
'x' && isxdigit (s[i + 2])
216 && isxdigit (s[i + 3]))
218 if (isdigit (s[i + 2]))
219 x = (s[i + 2] -
'0') * 16;
221 x = (10 + tolower (s[i + 2]) -
'a') * 16;
222 if (isdigit (s[i + 3]))
225 x += tolower (s[i + 3]) + 10 -
'a';
229 else if (s[i + 1] ==
'\\')
251 nasl_perror (lexic,
"Error. Too long argument in raw_string()\n");
254 bcopy (str, retc->
x.
str_val + total_len, current_len);
255 total_len += current_len;
259 retc->
size = total_len;
288 for (vi = 0; vi < vn; vi++)
297 newlen = retc->
size + sz;
315 msg = g_malloc0 (r->
size + 1);
316 for (j = 0; j < r->
size; j++)
321 g_message (
"%s", msg);
341 snprintf (ret,
sizeof (ret),
"0x%02x", (
unsigned char) v);
343 retc->
size = strlen (ret);
363 ret = g_malloc0 (len * 2 + 1);
364 for (i = 0; i < len; i++)
367 snprintf (ret + 2 * i, 3,
"%02x", (
unsigned char) s[i]);
371 retc->
size = strlen (ret);
386 nasl_perror (lexic,
"Usage : ord(char). The given char or string " 408 str = g_memdup (str, str_len + 1);
409 for (i = 0; i < str_len; i++)
410 str[i] = tolower (str[i]);
413 retc->
size = str_len;
430 str = g_memdup (str, str_len + 1);
431 for (i = 0; i < str_len; i++)
432 str[i] = toupper (str[i]);
435 retc->
size = str_len;
463 if (pattern == NULL ||
string == NULL)
466 if (regcomp (&re, pattern, REG_EXTENDED | REG_NOSUB | copt))
468 nasl_perror (lexic,
"ereg() : regcomp() failed\n");
473 string = g_strdup (
string);
477 s = strchr (
string,
'\n');
482 if (regexec (&re,
string, 0, NULL, 0) == 0)
503 _regreplace (
const char *pattern,
const char *replace,
const char *
string,
504 int icase,
int extended)
514 int pos, tmp, string_len, new_l;
517 string_len = strlen (
string);
522 copts |= REG_EXTENDED;
523 err = regcomp (&re, pattern, copts);
531 buf_len = 2 * string_len;
532 buf = g_malloc0 (buf_len + 1);
540 regexec (&re, &
string[pos], (
size_t)
NS, subs, (pos ? REG_NOTBOL : 0));
542 if (err && err != REG_NOMATCH)
555 new_l = strlen (buf) + subs[0].rm_so;
558 if (
'\\' == *walk &&
'0' <= walk[1] &&
'9' >= walk[1]
559 && subs[walk[1] -
'0'].rm_so > -1
560 && subs[walk[1] -
'0'].rm_eo > -1)
562 new_l += subs[walk[1] -
'0'].rm_eo - subs[walk[1] -
'0'].rm_so;
571 if (new_l + 1 > buf_len)
573 buf_len = buf_len + 2 * new_l;
574 nbuf = g_malloc0 (buf_len + 1);
575 strncpy (nbuf, buf, buf_len);
581 strncat (buf, &
string[pos], subs[0].rm_so);
584 walkbuf = &buf[tmp + subs[0].rm_so];
587 if (
'\\' == *walk &&
'0' <= walk[1] &&
'9' >= walk[1]
588 && subs[walk[1] -
'0'].rm_so > -1
589 && subs[walk[1] -
'0'].rm_eo > -1)
591 tmp = subs[walk[1] -
'0'].rm_eo - subs[walk[1] -
'0'].rm_so;
592 memcpy (walkbuf, &
string[pos + subs[walk[1] -
'0'].rm_so], tmp);
597 *walkbuf++ = *walk++;
601 if (subs[0].rm_so == subs[0].rm_eo)
603 if (subs[0].rm_so + pos >= string_len)
605 new_l = strlen (buf) + 1;
606 if (new_l + 1 > buf_len)
608 buf_len = buf_len + 2 * new_l;
609 nbuf = g_malloc0 (buf_len + 1);
610 strncpy (nbuf, buf, buf_len);
614 pos += subs[0].rm_eo + 1;
615 buf[new_l - 1] =
string[pos - 1];
620 pos += subs[0].rm_eo;
625 new_l = strlen (buf) + strlen (&
string[pos]);
626 if (new_l + 1 > buf_len)
629 nbuf = g_malloc0 (buf_len + 1);
630 strncpy (nbuf, buf, buf_len);
635 strcat (buf, &
string[pos]);
655 if (pattern == NULL || replace == NULL)
658 "Usage : ereg_replace(string:<string>, pattern:<pat>, " 659 "replace:<replace>, icase:<TRUE|FALSE>\n");
665 r =
_regreplace (pattern, replace,
string, icase, 1);
670 retc->
size = strlen (r);
697 if (pattern == NULL ||
string == NULL)
700 bzero (subs,
sizeof (subs));
701 bzero (&re,
sizeof (re));
708 rets = g_malloc0 (max_size + 2);
709 string = g_strdup (
string);
715 t = strchr (s,
'\n');
722 bzero (&re,
sizeof (re));
723 if (regcomp (&re, pattern, REG_EXTENDED | copt))
725 nasl_perror (lexic,
"egrep() : regcomp() failed\n");
729 if (regexec (&re, s, (
size_t)
NS, subs, 0) == 0)
731 char *t = strchr (s,
'\n');
753 t = strchr (s,
'\n');
761 if (s == NULL || s[0] ==
'\0')
764 #ifdef I_WANT_MANY_DIRTY_ERROR_MESSAGES 775 retc->
size = strlen (rets);
804 if (pattern == NULL ||
string == NULL)
807 if (regcomp (&re, pattern, REG_EXTENDED | copt))
809 nasl_perror (lexic,
"regmatch() : regcomp() failed\n");
813 if (regexec (&re,
string, (
size_t)
NS, subs, 0) != 0)
822 for (i = 0; i <
NS; i++)
823 if (subs[i].rm_so != -1)
827 v.
v.
v_str.
s_val = (
unsigned char *)
string + subs[i].rm_so;
844 int sz1, sz2, i1, i2, typ;
852 #define MAX_INT (~(1 << (sizeof (int) * 8 - 1))) 860 nasl_perror (lexic,
"Usage: substr(string, idx_start [,idx_end])\n. " 861 "The given string is NULL");
867 "Usage: substr(string, idx_start [,idx_end]). " 868 "At least idx_start must be given to trim the " 885 retc->
x.
str_val = g_malloc0 (sz2 + 1);
886 memcpy (retc->
x.
str_val, s1 + i1, sz2);
900 int sz1, sz2, sz3, i1, i2;
910 if (i2 > sz1 || i2 == -1)
913 if (s1 == NULL || s2 == NULL || i1 < 0 || i2 < 0)
915 nasl_perror (lexic,
"Usage: insstr(str1, str2, idx_start [,idx_end])\n");
922 "insstr: cannot insert string2 after end of string1\n");
931 " insstr: warning! 1st index %d greater than 2nd index %d\n",
936 sz3 = sz1 + i1 - i2 - 1 + sz2;
938 s3 = retc->
x.
str_val = g_malloc0 (sz3 + 1);
946 memcpy (s3, s2, sz2);
949 memcpy (s3, s1 + i2 + 1, sz1 - 1 - i2);
964 nasl_perror (lexic,
"nasl_match: parameter 'pattern' missing\n");
969 nasl_perror (lexic,
"nasl_match: parameter 'string' missing\n");
984 int i, i0, j, len, sep_len = 0, keep = 1;
1001 sep_len = strlen (sep);
1004 nasl_perror (lexic,
"split: invalid 'seplen' parameter\n");
1014 bzero (&v,
sizeof (v));
1023 if ((p = memmem (str + i, len - i, sep, sep_len)) == NULL)
1038 i = (p - str) + sep_len;
1046 for (i = i0 = j = 0; i < len; i++)
1048 if (str[i] ==
'\r' && str[i + 1] ==
'\n')
1059 else if (str[i] ==
'\n')
1101 retc->
x.
str_val = g_malloc0 (len + 1);
1103 memcpy (retc->
x.
str_val, str, len);
1117 if (len < 0 && len2 < 0)
1119 nasl_perror (lexic,
"crap: invalid or missing 'length' argument\n");
1122 if (len >= 0 && len2 >= 0)
1124 nasl_perror (lexic,
"crap: cannot set both unnamed and named 'length'\n");
1138 nasl_perror (lexic,
"crap: invalid null 'data' parameter\n");
1144 retc->
x.
str_val = g_malloc0 (len + 1);
1147 memset (retc->
x.
str_val,
'X', len);
1151 for (i = 0; i < len - data_len; i += data_len)
1152 memcpy (retc->
x.
str_val + i, data, data_len);
1156 if ((r = (len % data_len)) > 0)
1157 memcpy (retc->
x.
str_val + (len - r), data, r);
1159 memcpy (retc->
x.
str_val + (len - data_len), data, data_len);
1162 retc->
x.
str_val[len - 1] = data[0];
1181 if (a == NULL || b == NULL)
1187 c = memmem (a, sz_a, b, sz_b);
1192 retc->
size = sz_a - (c - a);
1220 if (a == NULL || b == NULL)
1222 nasl_perror (lexic,
"stridx(string, substring [, start])\n");
1226 if (start < 0 || start > sz_a)
1228 nasl_perror (lexic,
"stridx(string, substring [, start])\n");
1232 if ((sz_a == start) || (sz_b > sz_a + start))
1235 c = memmem (a + start, sz_a - start, b, sz_b);
1247 char *a, *b, *r, *s, *c;
1248 int sz_a, sz_b, sz_r, count;
1249 int i1, i2, sz2, n, l;
1260 if (a == NULL || b == NULL)
1262 nasl_perror (lexic,
"Missing argument: str_replace(string: s, find: f, " 1263 "replace: r [,count: c])\n");
1269 nasl_perror (lexic,
"str_replace: illegal 'find' argument value\n");
1283 for (i1 = i2 = 0; i1 <= sz_a - sz_b;)
1285 c = memmem (a + i1, sz_a - i1, b, sz_b);
1290 s = g_realloc (s, sz2 + 1);
1294 memcpy (s + i2, a + i1, l);
1299 memcpy (s + i2, r, sz_r);
1304 if (count > 0 && n >= count)
1311 s = g_realloc (s, sz2 + 1);
1313 memcpy (s + i2, a + i1, sz_a - i1);
tree_cell * nasl_chomp(lex_ctxt *lexic)
Takes an unnamed string argument and removes any spaces at the end of it. "Space" means white space...
tree_cell * nasl_str_replace(lex_ctxt *lexic)
tree_cell * nasl_rawstring(lex_ctxt *lexic)
tree_cell * nasl_ereg_replace(lex_ctxt *lexic)
tree_cell * nasl_split(lex_ctxt *lexic)
tree_cell * nasl_crap(lex_ctxt *lexic)
void deref_cell(tree_cell *c)
tree_cell * nasl_tolower(lex_ctxt *lexic)
char * get_str_var_by_name(lex_ctxt *, const char *)
int add_var_to_list(nasl_array *a, int i, const anon_nasl_var *v)
tree_cell * alloc_typed_cell(int typ)
tree_cell * nasl_hexstr(lex_ctxt *lexic)
tree_cell * nasl_hex(lex_ctxt *lexic)
int get_var_size_by_num(lex_ctxt *, int)
tree_cell * nasl_ord(lex_ctxt *lexic)
tree_cell * nasl_string(lex_ctxt *lexic)
int str_match(const gchar *string, const gchar *pattern, int icase)
Matches a string against a pattern.
long int get_int_var_by_num(lex_ctxt *, int, int)
tree_cell * nasl_strcat(lex_ctxt *lexic)
tree_cell * nasl_insstr(lex_ctxt *lexic)
void nasl_perror(lex_ctxt *lexic, char *msg,...)
tree_cell * nasl_match(lex_ctxt *lexic)
char * get_str_var_by_num(lex_ctxt *, int)
long int get_int_var_by_name(lex_ctxt *, const char *, int)
union st_a_nasl_var::@4 v
tree_cell * nasl_substr(lex_ctxt *lexic)
tree_cell * nasl_display(lex_ctxt *lexic)
tree_cell * nasl_egrep(lex_ctxt *lexic)
int array_max_index(nasl_array *a)
tree_cell * nasl_toupper(lex_ctxt *lexic)
tree_cell * nasl_strstr(lex_ctxt *lexic)
tree_cell * nasl_stridx(lex_ctxt *lexic)
Returns index of a substring.
static char * _regreplace(const char *pattern, const char *replace, const char *string, int icase, int extended)
tree_cell * nasl_eregmatch(lex_ctxt *lexic)
Does extended regular expression pattern matching.
tree_cell * nasl_strlen(lex_ctxt *lexic)
int get_var_size_by_name(lex_ctxt *, const char *)
tree_cell * nasl_ereg(lex_ctxt *lexic)
tree_cell * nasl_int(lex_ctxt *lexic)
int get_var_type_by_num(lex_ctxt *, int)
Returns NASL variable/cell type, VAR2_UNDEF if value is NULL.