static HRESULT WINAPI HTMLTable_put_width(IHTMLTable *iface, VARIANT v)
{
HTMLTable *This = impl_from_IHTMLTable(iface);
nsAString val;
HRESULT hres;
nsresult nsres;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
hres = var2str(&v, &val);
if (FAILED(hres)){
ERR("Set Width(%s) failed when initializing a nsAString, err = %08x\n",
debugstr_variant(&v), hres);
return hres;
}
nsres = nsIDOMHTMLTableElement_SetWidth(This->nstable, &val);
nsAString_Finish(&val);
if (NS_FAILED(nsres)){
ERR("Set Width(%s) failed, err = %08x\n", debugstr_variant(&v), nsres);
return E_FAIL;
}
return S_OK;
}
tree_cell*
nasl_make_array(lex_ctxt* lexic)
{
tree_cell *retc = NULL;
int i, vi;
anon_nasl_var *v, *v2;
nasl_array *a;
retc = alloc_tree_cell(0, NULL);
retc->type = DYN_ARRAY;
retc->x.ref_val = a = emalloc(sizeof(nasl_array));
i = vi = 0;
while ((v = nasl_get_var_by_num(&lexic->ctx_vars, vi ++, 0)) != NULL)
{
v2 = nasl_get_var_by_num(&lexic->ctx_vars, vi ++, 0);
if (v2 == NULL)
{
nasl_perror(lexic, "make_array: odd number (%d) of argument?\n", vi);
break;
}
switch (v2->var_type)
{
case VAR2_INT:
case VAR2_STRING:
case VAR2_DATA:
switch (v->var_type)
{
case VAR2_INT:
add_var_to_list(a, v->v.v_int, v2);
break;
case VAR2_STRING:
case VAR2_DATA:
add_var_to_array(a, (char*)var2str(v) , v2);
break;
}
break;
case VAR2_UNDEF:
default:
nasl_perror(lexic, "make_array: bad value type %d for arg #%d\n",
v2->var_type, vi);
break;
}
}
return retc;
}
/** @todo Supspects to glib replacements, all path related stuff. */
tree_cell *
nasl_pread (lex_ctxt * lexic)
{
tree_cell *retc = NULL, *a;
anon_nasl_var *v;
nasl_array *av;
int i, j, n, sz, sz2, cd, nice;
char **args = NULL, *cmd, *str, *str2, buf[8192];
FILE *fp;
char cwd[MAXPATHLEN], newdir[MAXPATHLEN];
if (pid != 0)
{
nasl_perror (lexic, "nasl_pread is not reentrant!\n");
return NULL;
}
a = get_variable_by_name (lexic, "argv");
cmd = get_str_local_var_by_name (lexic, "cmd");
if (cmd == NULL || a == NULL || (v = a->x.ref_val) == NULL)
{
nasl_perror (lexic, "pread() usage: cmd:..., argv:...\n");
return NULL;
}
nice = get_int_local_var_by_name (lexic, "nice", 0);
if (v->var_type == VAR2_ARRAY)
av = &v->v.v_arr;
else
{
nasl_perror (lexic, "pread: argv element must be an array (0x%x)\n",
v->var_type);
return NULL;
}
cd = get_int_local_var_by_name (lexic, "cd", 0);
cwd[0] = '\0';
if (cd)
{
char *p;
if (cmd[0] == '/')
{
strncpy (newdir, cmd, sizeof (newdir) - 1); /* Flawfinder: ignore
(\0-termination taken
care of) */
p = strrchr (newdir, '/');
if (p != newdir)
*p = '\0';
}
else
{
p = find_in_path (cmd, 0);
if (p != NULL)
strncpy (newdir, p, sizeof (newdir) - 1); /* Flawfinder: ignore
(\0-termination taken
care of) */
else
{
nasl_perror (lexic, "pread: '%s' not found in $PATH\n", cmd);
return NULL;
}
}
newdir[sizeof (newdir) - 1] = '\0';
if (getcwd (cwd, sizeof (cwd)) == NULL)
{
nasl_perror (lexic, "pread(): getcwd: %s\n", strerror (errno));
*cwd = '\0';
}
if (chdir (newdir) < 0)
{
nasl_perror (lexic, "pread: could not chdir to %s\n", newdir);
return NULL;
}
if (cmd[0] != '/' && strlen (newdir) + strlen (cmd) + 1 < sizeof (newdir))
{
strcat (newdir, "/"); /* Flawfinder: ignore (if-command above checks
for size) */
strcat (newdir, cmd); /* Flawfinder: ignore (if-command above checks
for size) */
cmd = newdir;
}
}
if (av->hash_elt != NULL)
nasl_perror (lexic, "pread: named elements in 'cmd' are ignored!\n");
n = av->max_idx;
args = emalloc (sizeof (char **) * (n + 2)); /* Last arg is NULL */
for (j = 0, i = 0; i < n; i++)
{
str = (char *) var2str (av->num_elt[i]);
if (str != NULL)
args[j++] = estrdup (str);
}
args[j++] = NULL;
old_sig_t = signal (SIGTERM, sig_h);
old_sig_i = signal (SIGINT, sig_h);
old_sig_c = signal (SIGCHLD, sig_c);
fp = openvas_popen4 ((const char *) cmd, args, &pid, nice);
for (i = 0; i < n; i++)
efree (&args[i]);
efree (&args);
if (fp != NULL)
{
sz = 0;
str = emalloc (1);
errno = 0;
while ((n = fread (buf, 1, sizeof (buf), fp)) > 0 || errno == EINTR) /* && kill(pid, 0) >= 0) */
{
if (errno == EINTR)
{
errno = 0;
continue;
}
sz2 = sz + n;
str2 = erealloc (str, sz2);
if (str2 == NULL)
{
nasl_perror (lexic, "nasl_pread: erealloc failed\n");
break;
}
str = str2;
memcpy (str + sz, buf, n);
sz = sz2;
}
if (ferror (fp) && errno != EINTR)
nasl_perror (lexic, "nasl_pread: fread(): %s\n", strerror (errno));
(void) openvas_pclose (fp, pid);
pid = 0;
if (*cwd != '\0')
if (chdir (cwd) < 0)
nasl_perror (lexic, "pread(): chdir(%s): %s\n", cwd,
strerror (errno));
retc = alloc_typed_cell (CONST_DATA);
retc->x.str_val = str;
retc->size = sz;
}
signal (SIGINT, old_sig_i);
signal (SIGTERM, old_sig_t);
signal (SIGCHLD, old_sig_c);
return retc;
}
char *
get_str_local_var_by_name(lex_ctxt * lexic, const char * name)
{
named_nasl_var *v = get_var_ref_by_name(lexic, name, 0);
return (char*)var2str(&v->u);
}
char*
get_str_var_by_num(lex_ctxt* lexic, int num)
{
anon_nasl_var *v = get_var_ref_by_num(lexic, num);
return (char*)var2str(v);
}
static void
dump_tree (const tree_cell * c, int n, int idx)
{
int i;
if (c == NULL)
return;
prefix (n, idx);
if (c == FAKE_CELL)
{
puts ("* FAKE *");
return;
}
if (c->line_nb > 0)
printf ("L%d: ", c->line_nb);
#if 0
if ((int) c < 0x1000)
{
printf ("* INVALID PTR 0x%x *\n", (int) c);
return;
}
#endif
if (c->type < 0 || c->type >= sizeof (node_names) / sizeof (node_names[0]))
printf ("* UNKNOWN %d (0x%x)*\n", c->type, c->type);
else
printf ("%s (%d)\n", node_names[c->type], c->type);
prefix (n, idx);
printf ("Ref_count=%d", c->ref_count);
if (c->size > 0)
{
/*prefix(n, idx); */
printf ("\tSize=%d (0x%x)", c->size, c->size);
}
putchar ('\n');
switch (c->type)
{
case CONST_INT:
prefix (n, 0);
printf ("Val=%d\n", c->x.i_val);
break;
case CONST_STR:
case CONST_DATA:
case NODE_VAR:
case NODE_FUN_DEF:
case NODE_FUN_CALL:
case NODE_DECL:
case NODE_ARG:
case NODE_ARRAY_EL:
case ARRAY_ELEM:
prefix (n, 0);
if (c->x.str_val == NULL)
printf ("Val=(null)\n");
else
printf ("Val=\"%s\"\n", c->x.str_val);
break;
case REF_VAR:
prefix (n, 0);
if (c->x.ref_val == NULL)
printf ("Ref=(null)\n");
else
{
named_nasl_var *v = c->x.ref_val;
printf ("Ref=(type=%d, name=%s, value=%s)\n", v->u.var_type,
v->var_name != NULL ? v->var_name : "(null)",
var2str (&v->u));
}
break;
case REF_ARRAY:
case DYN_ARRAY:
break;
}
for (i = 0; i < 4; i++)
{
dump_tree (c->link[i], n + 3, i + 1);
}
}
