tree_cell*
nasl_strcat(lex_ctxt* lexic)
{
tree_cell *retc;
char *s;
int vi, vn, newlen;
int sz;
retc = alloc_tree_cell(0, NULL);
retc->type = CONST_DATA;
retc->size = 0;
retc->x.str_val = emalloc(0);
vn = array_max_index(&lexic->ctx_vars);
for (vi = 0; vi < vn; vi ++)
{
s = get_str_var_by_num(lexic, vi);
if (s == NULL)
continue;
sz = get_var_size_by_num(lexic, vi);
if (sz <= 0)
sz = strlen(s);
newlen = retc->size + sz;
retc->x.str_val = erealloc(retc->x.str_val, newlen + 1);
memcpy(retc->x.str_val + retc->size, s, sz);
retc->size = newlen;
}
retc->x.str_val[retc->size] = '\0';
return retc;
}
tree_cell*
nasl_max_index(lex_ctxt* lexic)
{
tree_cell *retc;
anon_nasl_var *v;
nasl_array *a;
v = nasl_get_var_by_num(&lexic->ctx_vars, 0, 0);
if (v == NULL)
return NULL;
if (v->var_type != VAR2_ARRAY)
return NULL;
a = &v->v.v_arr;
retc = alloc_tree_cell(0, NULL);
retc->type = CONST_INT;
retc->x.i_val = array_max_index(a);
return retc;
}
tree_cell* nasl_string(lex_ctxt* lexic)
{
tree_cell *retc;
int vi, vn, newlen;
int sz, typ;
const char *s, *p1;
char *p2;
retc = alloc_tree_cell(0, NULL);
retc->type = CONST_DATA;
retc->size = 0;
retc->x.str_val = emalloc(0);
vn = array_max_index(&lexic->ctx_vars);
for (vi = 0; vi < vn; vi ++)
{
if ((typ = get_var_type_by_num(lexic, vi)) == VAR2_UNDEF)
continue;
s = get_str_var_by_num(lexic, vi);
sz = get_var_size_by_num(lexic, vi);
if (sz <= 0)
sz = strlen(s);
newlen = retc->size + sz;
retc->x.str_val = erealloc(retc->x.str_val, newlen + 1);
p2 = retc->x.str_val + retc->size;
p1 = s;
retc->size = newlen;
if (typ != VAR2_STRING)
{
memcpy(p2, p1, sz);
p2[sz] = '\0';
}
else
while (*p1 != '\0')
{
if(*p1 == '\\' && p1[1] != '\0')
{
switch (p1[1])
{
case 'n':
*p2 ++ = '\n';
break;
case 't':
*p2 ++ = '\t';
break;
case 'r':
*p2++ = '\r';
break;
case '\\':
*p2++ = '\\';
break;
case 'x':
if (isxdigit(p1[2]) && isxdigit(p1[3]))
{
*p2++ =
16 *
(isdigit(p1[2]) ? p1[2]-'0' : 10+tolower(p1[2])-'a')
+
(isdigit(p1[3]) ? p1[3]-'0' : 10+tolower(p1[3])-'a');
p1 += 2;
retc->size -= 2;
}
else
{
nasl_perror(lexic, "Buggy hex value '\\x%c%c' skipped\n",
isprint(p1[2]) ? p1[2] : '.',
isprint(p1[3]) ? p1[3] : '.' );
/* We do not increment p1 by 4,
we may miss the end of the string */
}
break;
default:
nasl_perror(lexic, "Unknown%d escape sequence '\\%c'\n", getpid(),
isprint(p1[1]) ? p1[1] : '.' );
retc->size --;
break;
}
p1 += 2;
retc->size --;
}
else
*p2++ = *p1++;
}
}
retc->x.str_val[retc->size] = '\0';
return retc;
}
tree_cell* nasl_rawstring(lex_ctxt* lexic)
{
tree_cell *retc;
int vi, vn, i, j, x;
int sz, typ;
const char *s;
int total_len = 0;
retc = alloc_tree_cell(0, NULL);
retc->type = CONST_DATA;
retc->size = 0;
retc->x.str_val = emalloc(RAW_STR_LEN);
vn = array_max_index(&lexic->ctx_vars);
for (vi = 0; vi < vn && total_len < RAW_STR_LEN-1; vi ++)
{
if ((typ = get_var_type_by_num(lexic, vi)) == VAR2_UNDEF)
continue;
sz = get_var_size_by_num(lexic, vi);
if (typ == VAR2_INT)
{
x = get_int_var_by_num(lexic, vi, 0);
retc->x.str_val[total_len ++] = x;
}
else
{
int current_len = sz;
char str[RAW_STR_LEN];
s = get_str_var_by_num(lexic, vi);
if (sz <= 0)
sz = strlen(s);
if (sz >= RAW_STR_LEN)
{
nasl_perror(lexic, "Error. Too long argument in raw_string()\n");
break;
}
/* Should we test if the variable is composed only of digits? */
if(typ == VAR2_STRING)
{
/* TBD:I should decide at last if we keep those "purified"
* string or not, and if we do, if "CONST_STR" & "VAR2_STR" are
* "not pure" strings */
for(i=0, j=0; i < sz; i++)
{
if(s[i]=='\\')
{
if (s[i+1] == 'n')
{
str[j++]='\n';
i++;
}
else if (s[i+1] == 't')
{
str[j++]='\t';
i++;
}
else if (s[i+1] == 'r')
{
str[j++] = '\r';
i++;
}
else if (s[i+1] == 'x' &&
isxdigit(s[i+2]) && isxdigit(s[i+3]))
{
x = 0;
if(isdigit(s[i+2]))
x = (s[i+2]-'0')*16;
else
x=(10+tolower(s[i+2])-'a')*16;
if(isdigit(s[i+3]))
x += s[i+3]-'0';
else
x += tolower(s[i+3])+10-'a';
str[j++]=x;
i+=3;
}
else if(s[i+1] == '\\')
{
str[j++] = s[i];
i++;
}
else
i++;
}
else
str[j++] = s[i];
}
current_len = j;
}
else
{
memcpy(str, s, sz);
str[sz] = '\0';
current_len = sz;
}
if(total_len + current_len > RAW_STR_LEN)
{
nasl_perror(lexic, "Error. Too long argument in raw_string()\n");
break;
}
bcopy(str, retc->x.str_val + total_len, current_len);
total_len += current_len;
}
}
retc->size = total_len;
return retc;
}
