64 for (vi = 0; vi < vn; vi++)
73 newlen = retc->
size + sz;
86 if (*p1 ==
'\\' && p1[1] !=
'\0')
103 if (isxdigit (p1[2]) && isxdigit (p1[3]))
106 16 * (isdigit (p1[2]) ? p1[2] -
'0' : 10 +
107 tolower (p1[2]) -
'a') +
108 (isdigit (p1[3]) ? p1[3] -
'0' : 10 +
109 tolower (p1[3]) -
'a');
116 "Buggy hex value '\\x%c%c' skipped\n",
117 isprint (p1[2]) ? p1[2] :
'.',
118 isprint (p1[3]) ? p1[3] :
'.');
124 nasl_perror (lexic,
"Unknown escape sequence '\\%c' in the " 126 isprint (p1[1]) ? p1[1] :
'.', s);
142 #define RAW_STR_LEN 32768 158 for (vi = 0; vi < vn && total_len <
RAW_STR_LEN - 1; vi++)
180 nasl_perror (lexic,
"Error. Too long argument in raw_string()\n");
190 for (i = 0, j = 0; i < sz; i++)
199 else if (s[i + 1] ==
't')
204 else if (s[i + 1] ==
'r')
209 else if (s[i + 1] ==
'x' && isxdigit (s[i + 2])
210 && isxdigit (s[i + 3]))
212 if (isdigit (s[i + 2]))
213 x = (s[i + 2] -
'0') * 16;
215 x = (10 + tolower (s[i + 2]) -
'a') * 16;
216 if (isdigit (s[i + 3]))
219 x += tolower (s[i + 3]) + 10 -
'a';
223 else if (s[i + 1] ==
'\\')
245 nasl_perror (lexic,
"Error. Too long argument in raw_string()\n");
248 bcopy (str, retc->
x.
str_val + total_len, current_len);
249 total_len += current_len;
253 retc->
size = total_len;
286 for (vi = 0; vi < vn; vi++)
295 newlen = retc->
size + sz;
313 for (j = 0; j < r->
size; j++)
336 snprintf (ret,
sizeof (ret),
"0x%02x", (
unsigned char) v);
339 retc->
size = strlen (ret);
360 ret = g_malloc0 (len * 2 + 1);
361 for (i = 0; i < len; i++)
364 snprintf (ret + 2 * i, 3,
"%02x", (
unsigned char) s[i]);
369 retc->
size = strlen (ret);
384 nasl_perror (lexic,
"Usage : ord(char). The given char or string " 407 str = g_memdup (str, str_len + 1);
408 for (i = 0; i < str_len; i++)
409 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]);
436 retc->
size = str_len;
465 if (pattern == NULL ||
string == NULL)
468 if (regcomp (&re, pattern, REG_EXTENDED | REG_NOSUB | copt))
470 nasl_perror (lexic,
"ereg() : regcomp() failed\n");
476 string = g_strdup (
string);
480 s = strchr (
string,
'\n');
485 if (regexec (&re,
string, 0, NULL, 0) == 0)
506 _regreplace (
const char *pattern,
const char *replace,
const char *
string,
507 int icase,
int extended)
517 int pos, tmp, string_len, new_l;
520 string_len = strlen (
string);
525 copts |= REG_EXTENDED;
526 err = regcomp (&re, pattern, copts);
534 buf_len = 2 * string_len;
535 buf = g_malloc0 (buf_len + 1);
544 regexec (&re, &
string[pos], (
size_t)
NS, subs,
545 (pos ? REG_NOTBOL : 0));
547 if (
err &&
err != REG_NOMATCH)
560 new_l = strlen (buf) + subs[0].rm_so;
563 if (
'\\' == *walk &&
'0' <= walk[1] &&
'9' >= walk[1]
564 && subs[walk[1] -
'0'].rm_so > -1
565 && subs[walk[1] -
'0'].rm_eo > -1)
567 new_l += subs[walk[1] -
'0'].rm_eo - subs[walk[1] -
'0'].rm_so;
576 if (new_l + 1 > buf_len)
578 buf_len = buf_len + 2 * new_l;
579 nbuf = g_malloc0 (buf_len + 1);
580 strncpy (nbuf, buf, buf_len);
586 strncat (buf, &
string[pos], subs[0].rm_so);
589 walkbuf = &buf[tmp + subs[0].rm_so];
592 if (
'\\' == *walk &&
'0' <= walk[1] &&
'9' >= walk[1]
593 && subs[walk[1] -
'0'].rm_so > -1
594 && subs[walk[1] -
'0'].rm_eo > -1)
596 tmp = subs[walk[1] -
'0'].rm_eo - subs[walk[1] -
'0'].rm_so;
597 memcpy (walkbuf, &
string[pos + subs[walk[1] -
'0'].rm_so], tmp);
602 *walkbuf++ = *walk++;
606 if (subs[0].rm_so == subs[0].rm_eo)
608 if (subs[0].rm_so + pos >= string_len)
610 new_l = strlen (buf) + 1;
611 if (new_l + 1 > buf_len)
613 buf_len = buf_len + 2 * new_l;
614 nbuf = g_malloc0 (buf_len + 1);
615 strncpy (nbuf, buf, buf_len);
619 pos += subs[0].rm_eo + 1;
620 buf[new_l - 1] =
string[pos - 1];
625 pos += subs[0].rm_eo;
630 new_l = strlen (buf) + strlen (&
string[pos]);
631 if (new_l + 1 > buf_len)
634 nbuf = g_malloc0 (buf_len + 1);
635 strncpy (nbuf, buf, buf_len);
640 strcat (buf, &
string[pos]);
662 if (pattern == NULL || replace == NULL)
665 "Usage : ereg_replace(string:<string>, pattern:<pat>, replace:<replace>, icase:<TRUE|FALSE>\n");
671 nasl_perror (lexic,
"ereg_replace: string == NULL\n");
676 r = _regreplace (pattern, replace,
string, icase, 1);
682 retc->
size = strlen (r);
709 if (pattern == NULL ||
string == NULL)
712 bzero (subs,
sizeof (subs));
713 bzero (&re,
sizeof (re));
720 rets = g_malloc0 (max_size + 2);
721 string = g_strdup (
string);
728 t = strchr (s,
'\n');
735 bzero (&re,
sizeof (re));
736 if (regcomp (&re, pattern, REG_EXTENDED | copt))
738 nasl_perror (lexic,
"egrep() : regcomp() failed\n");
743 if (regexec (&re, s, (
size_t)
NS, subs, 0) == 0)
745 char *t = strchr (s,
'\n');
767 t = strchr (s,
'\n');
775 if (s == NULL || s[0] ==
'\0')
778 #ifdef I_WANT_MANY_DIRTY_ERROR_MESSAGES 790 retc->
size = strlen (rets);
819 if (pattern == NULL ||
string == NULL)
822 if (regcomp (&re, pattern, REG_EXTENDED | copt))
824 nasl_perror (lexic,
"regmatch() : regcomp() failed\n");
828 if (regexec (&re,
string, (
size_t)
NS, subs, 0) != 0)
838 for (i = 0; i <
NS; i++)
839 if (subs[i].rm_so != -1)
843 v.
v.
v_str.
s_val = (
unsigned char *)
string + subs[i].rm_so;
860 int sz1, sz2, i1, i2, typ;
868 #define MAX_INT (~(1 << (sizeof(int) * 8 - 1))) 876 nasl_perror (lexic,
"Usage: substr(string, idx_start [,idx_end])\n. " 877 "The given string is NULL");
882 nasl_perror (lexic,
"Usage: substr(string, idx_start [,idx_end]). " 883 "At least idx_start must be given to trim the " 884 "string '%s'.\n", s1);
898 retc->
x.
str_val = g_malloc0 (sz2 + 1);
899 memcpy (retc->
x.
str_val, s1 + i1, sz2);
913 int sz1, sz2, sz3, i1, i2;
923 if (i2 > sz1 || i2 == -1)
926 if (s1 == NULL || s2 == NULL || i1 < 0 || i2 < 0)
928 nasl_perror (lexic,
"Usage: insstr(str1, str2, idx_start [,idx_end])\n");
935 "insstr: cannot insert string2 after end of string1\n");
945 " insstr: warning! 1st index %d greater than 2nd index %d\n",
950 sz3 = sz1 + i1 - i2 - 1 + sz2;
952 s3 = retc->
x.
str_val = g_malloc0 (sz3 + 1);
960 memcpy (s3, s2, sz2);
963 memcpy (s3, s1 + i2 + 1, sz1 - 1 - i2);
979 nasl_perror (lexic,
"nasl_match: parameter 'pattern' missing\n");
984 nasl_perror (lexic,
"nasl_match: parameter 'string' missing\n");
1000 int i, i0, j, len, sep_len = 0, keep = 1;
1007 nasl_perror (lexic,
"split: missing string parameter\n");
1022 sep_len = strlen (sep);
1025 nasl_perror (lexic,
"split: invalid 'seplen' parameter\n");
1036 bzero (&v,
sizeof (v));
1045 if ((p = memmem (str + i, len - i, sep, sep_len)) == NULL)
1060 i = (p - str) + sep_len;
1068 for (i = i0 = j = 0; i < len; i++)
1070 if (str[i] ==
'\r' && str[i + 1] ==
'\n')
1081 else if (str[i] ==
'\n')
1106 char *p = NULL, *str;
1117 for (i = 0; i < len; i++)
1119 if (isspace (str[i]))
1130 retc->
x.
str_val = g_malloc0 (len + 1);
1132 memcpy (retc->
x.
str_val, str, len);
1147 if (len < 0 && len2 < 0)
1149 nasl_perror (lexic,
"crap: invalid or missing 'length' argument\n");
1152 if (len >= 0 && len2 >= 0)
1154 nasl_perror (lexic,
"crap: cannot set both unnamed and named 'length'\n");
1168 nasl_perror (lexic,
"crap: invalid null 'data' parameter\n");
1175 retc->
x.
str_val = g_malloc0 (len + 1);
1178 memset (retc->
x.
str_val,
'X', len);
1182 for (i = 0; i < len - data_len; i += data_len)
1183 memcpy (retc->
x.
str_val + i, data, data_len);
1187 if ((r = (len % data_len)) > 0)
1188 memcpy (retc->
x.
str_val + (len - r), data, r);
1190 memcpy (retc->
x.
str_val + (len - data_len), data, data_len);
1193 retc->
x.
str_val[len - 1] = data[0];
1212 if (a == NULL || b == NULL)
1218 c = memmem (a, sz_a, b, sz_b);
1224 retc->
size = sz_a - (c - a);
1253 if (a == NULL || b == NULL)
1255 nasl_perror (lexic,
"stridx(string, substring [, start])\n");
1259 if (start < 0 || start > sz_a)
1261 nasl_perror (lexic,
"stridx(string, substring [, start])\n");
1265 if ((sz_a == start) || (sz_b > sz_a + start))
1268 c = memmem (a + start, sz_a - start, b, sz_b);
1280 char *a, *b, *r, *s, *c;
1281 int sz_a, sz_b, sz_r, count;
1282 int i1, i2, sz2, n, l;
1294 if (a == NULL || b == NULL)
1297 "Missing argument: str_replace(string: s, find: f, replace: r [,count: c])\n");
1303 nasl_perror (lexic,
"str_replace: illegal 'find' argument value\n");
1317 for (i1 = i2 = 0; i1 <= sz_a - sz_b;)
1319 c = memmem (a + i1, sz_a - i1, b, sz_b);
1324 s = g_realloc (s, sz2 + 1);
1328 memcpy (s + i2, a + i1, l);
1333 memcpy (s + i2, r, sz_r);
1338 if (count > 0 && n >= count)
1345 s = g_realloc (s, sz2 + 1);
1347 memcpy (s + i2, a + i1, sz_a - i1);
tree_cell * nasl_chomp(lex_ctxt *lexic)
tree_cell * nasl_str_replace(lex_ctxt *lexic)
tree_cell * nasl_rawstring(lex_ctxt *lexic)
union st_a_nasl_var::@9 v
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)
long int get_int_local_var_by_name(lex_ctxt *, const char *, int)
int get_local_var_size_by_name(lex_ctxt *, const char *)
char * get_str_local_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)
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)
int str_match(const char *string, const char *pattern, int icase)
char * get_str_var_by_num(lex_ctxt *, int)
tree_cell * alloc_tree_cell(int lnb, char *s)
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.
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.