struct arglist * store_load_plugin(char * dir, char * file, char * md5, struct arglist * prefs)
{
char desc_file[PATH_MAX+1];
char plug_file[PATH_MAX+1];
char * str;
char store_dir[PATH_MAX+1];
struct plugin p;
struct pprefs pp[MAX_PREFS];
struct arglist * ret;
int i;
bzero(pp, sizeof(pp));
snprintf(desc_file, sizeof(desc_file), "%s/.desc/%s", dir, file);
str = strrchr(desc_file, '.');
if( str != NULL )
{
str[0] = '\0';
if( strlen(desc_file) + 6 < sizeof(desc_file) )
strcat(desc_file, ".desc");
}
snprintf(plug_file, sizeof(plug_file), "%s/%s", dir, file);
snprintf(store_dir, sizeof(store_dir), "%s/.desc", dir);
if(store_get_plugin_f(&p, pp, store_dir, file) < 0)
return NULL;
if(p.magic != MAGIC)
return NULL;
if(p.id > 0)
{
if(md5 != NULL && strcmp(p.md5, md5) != 0)
return NULL;
}
else return NULL;
ret = emalloc(sizeof(struct arglist));
plug_set_id(ret, p.id);
plug_set_category(ret, p.category);
plug_set_fname(ret, file);
arg_add_value(ret, "preferences", ARG_ARGLIST, -1, prefs);
if(p.has_prefs)
{
for(i=0;pp[i].type[0] != '\0';i++)
{
_add_plugin_preference(prefs, p.name, pp[i].name, pp[i].type, pp[i].dfl);
}
}
return ret;
}
tree_cell * script_category(lex_ctxt * lexic)
{
struct arglist * script_infos = lexic->script_infos;
int category = get_int_var_by_num(lexic, 0, -1);
if(category < 0){
nasl_perror(lexic, "Argument error in function script_category()\n");
nasl_perror(lexic, "Function usage is : script_category(<category>)\n");
return FAKE_CELL;
}
plug_set_category(script_infos, category);
return FAKE_CELL;
}
PlugExport int plugin_init(struct arglist *desc)
{
plug_set_id(desc, 10333);
plug_set_version(desc, "$Revision: 1.9 $");
plug_set_cve_id(desc, "CVE-1999-0183");
plug_set_name(desc, NAME, NULL);
plug_set_description(desc, FR_DESC, "francais");
plug_set_description(desc, DESC, NULL);
plug_set_summary(desc, SUMM,NULL);
plug_set_copyright(desc, COPYRIGHT,NULL);
plug_set_category(desc, ACT_ATTACK);
plug_set_family(desc, "Accès aux fichiers distants", "francais");
plug_set_family(desc, "Remote file access",NULL);
return(0);
}
struct arglist * store_load_plugin(char * dir, char * file, struct arglist * prefs)
{
char desc_file[PATH_MAX+1];
char plug_file[PATH_MAX+1];
char * str;
char store_dir[PATH_MAX+1];
struct plugin p;
struct pprefs pp[MAX_PREFS];
struct arglist * ret;
int i;
struct stat st1, st2;
struct arglist * al;
bzero(pp, sizeof(pp));
snprintf(desc_file, sizeof(desc_file), "%s/.desc/%s", dir, file);
str = strrchr(desc_file, '.');
if( str != NULL )
{
str[0] = '\0';
if( strlen(desc_file) + 6 < sizeof(desc_file) )
strcat(desc_file, ".desc");
}
snprintf(plug_file, sizeof(plug_file), "%s/%s", dir, file);
if ( stat(plug_file, &st1) < 0 ||
stat(desc_file, &st2) < 0 )
return NULL;
/*
* Look if the plugin is newer, and if that's the case also make sure that
* the plugin mtime is not in the future...
*/
if ( st1.st_mtime > st2.st_mtime && st1.st_mtime <= time(NULL) )
return NULL;
snprintf(store_dir, sizeof(store_dir), "%s/.desc", dir);
if(store_get_plugin_f(&p, pp, store_dir, file) < 0)
return NULL;
if(p.magic != MAGIC)
return NULL;
if(p.id <= 0) return NULL;
ret = emalloc(sizeof(struct arglist));
plug_set_id(ret, p.id);
plug_set_category(ret, p.category);
plug_set_fname(ret, file);
plug_set_path(ret, p.path);
plug_set_family(ret, p.family, NULL);
al = str2arglist(p.required_ports);
if ( al != NULL ) arg_add_value(ret, "required_ports", ARG_ARGLIST, -1, al);
al = str2arglist(p.required_keys);
if ( al != NULL ) arg_add_value(ret, "required_keys", ARG_ARGLIST, -1, al);
al = str2arglist(p.required_udp_ports);
if ( al != NULL ) arg_add_value(ret, "required_udp_ports", ARG_ARGLIST, -1, al)
;
al = str2arglist(p.excluded_keys);
if ( al != NULL ) arg_add_value(ret, "excluded_keys", ARG_ARGLIST, -1, al);
al = str2arglist(p.dependencies);
if ( al != NULL ) arg_add_value(ret, "DEPENDENCIES", ARG_ARGLIST, -1, al);
if ( p.timeout != 0 ) arg_add_value(ret, "TIMEOUT", ARG_INT, -1, (void*)p.timeout);
arg_add_value(ret, "NAME", ARG_STRING, strlen(p.name), estrdup(p.name));
arg_add_value(ret, "preferences", ARG_ARGLIST, -1, prefs);
if(p.has_prefs)
{
for(i=0;pp[i].type[0] != '\0';i++)
{
_add_plugin_preference(prefs, p.name, pp[i].name, pp[i].type, pp[i].dfl);
}
}
return ret;
}
struct arglist * store_plugin(struct arglist * plugin, char * file, char * md5)
{
char desc_file[PATH_MAX+1];
char path[PATH_MAX+1];
struct plugin plug;
struct pprefs pp[MAX_PREFS+1];
char * str;
char * dir;
struct arglist * arglist, * ret, *prefs;
int e;
int fd;
int num_plugin_prefs = 0;
if( current_mode == MODE_SYS )
dir = sys_store_dir;
else
dir = usr_store_dir;
if(strlen(file) + 2 > sizeof(path))
return NULL;
strncpy(path, dir, sizeof(path) - 2 - strlen(file));
str = strrchr(path, '/');
if(str != NULL)
{
str[0] = '\0';
}
strcat(path, "/");
strcat(path, file);
snprintf(desc_file, sizeof(desc_file), "%s/%s", dir, file);
str = strrchr(desc_file, '.');
if( str != NULL )
{
str[0] = '\0';
if(strlen(desc_file) + 6 < sizeof(desc_file) )
strcat(desc_file, ".desc");
}
bzero(&plug, sizeof(plug));
bzero(pp, sizeof(pp));
plug.magic = MAGIC;
plug.id = _plug_get_id(plugin);
e = safe_copy(path, plug.path, sizeof(plug.path), path, "path");
if(e < 0)return NULL;
e = safe_copy(md5, plug.md5, sizeof(plug.md5), path, "md5");
if(e < 0)return NULL;
plug.timeout = _plug_get_timeout(plugin);
plug.category = _plug_get_category(plugin);
str = _plug_get_name(plugin);
e = safe_copy(str, plug.name, sizeof(plug.name), path, "name");
if(e < 0)return NULL;
str = _plug_get_version(plugin);
e = safe_copy(str, plug.version, sizeof(plug.version), path, "version");
if(e < 0)return NULL;
str = _plug_get_summary(plugin);
e = safe_copy(str, plug.summary, sizeof(plug.summary), path, "summary");
if(e < 0)return NULL;
str = _plug_get_description(plugin);
e = safe_copy(str, plug.description, sizeof(plug.description), path, "description");
if(e < 0)return NULL;
str = _plug_get_copyright(plugin);
e = safe_copy(str, plug.copyright, sizeof(plug.copyright), path, "copyright");
if(e < 0)return NULL;
str = _plug_get_family(plugin);
e = safe_copy(str, plug.family, sizeof(plug.family), path, "family");
if(e < 0)return NULL;
str = _plug_get_cve_id(plugin);
e = safe_copy(str, plug.cve_id, sizeof(plug.cve_id), path, "cve_id");
if(e < 0)return NULL;
str = _plug_get_bugtraq_id(plugin);
e = safe_copy(str, plug.bid, sizeof(plug.bid), path, "bugtraq id");
if(e < 0)return NULL;
str = _plug_get_xref(plugin);
e = safe_copy(str, plug.xref, sizeof(plug.xref), path, "xref id");
if(e < 0)return NULL;
arglist = _plug_get_deps(plugin);
str = arglist2str(arglist);
e = safe_copy(str, plug.dependencies, sizeof(plug.dependencies), path, "dependencies");
efree(&str);
if(e < 0)return NULL;
arglist = _plug_get_required_keys(plugin);
str = arglist2str(arglist);
e = safe_copy(str, plug.required_keys, sizeof(plug.required_keys), path, "required keys");
efree(&str);
if(e < 0)return NULL;
arglist = _plug_get_excluded_keys(plugin);
str = arglist2str(arglist);
e = safe_copy(str, plug.excluded_keys, sizeof(plug.excluded_keys), path, "excluded_keys");
efree(&str);
if(e < 0)return NULL;
arglist = _plug_get_required_ports(plugin);
str = arglist2str(arglist);
e = safe_copy(str, plug.required_ports, sizeof(plug.required_ports), path, "required ports");
efree(&str);
if(e < 0)return NULL;
arglist = _plug_get_required_udp_ports(plugin);
str = arglist2str(arglist);
e = safe_copy(str, plug.required_udp_ports, sizeof(plug.required_udp_ports), path, "required udp ports");
efree(&str);
if(e < 0)return NULL;
prefs = arg_get_value(plugin, "preferences");
arglist = arg_get_value(plugin, "PLUGIN_PREFS");
if( arglist != NULL )
{
char * p_name = _plug_get_name(plugin);
while(arglist->next != NULL)
{
char * name = arglist->name;
char * dfl = arglist->value;
char * type, * str;
type = arglist->name;
str = strchr(type, '/');
str[0] = '\0';
name = str + 1;
e = safe_copy(type, pp[num_plugin_prefs].type, sizeof(pp[num_plugin_prefs].type), path, "preference-type");
if(e < 0)return NULL;
e = safe_copy(name, pp[num_plugin_prefs].name, sizeof(pp[num_plugin_prefs].name), path, "preference-name");
if(e < 0)return NULL;
e = safe_copy(dfl, pp[num_plugin_prefs].dfl, sizeof(pp[num_plugin_prefs].dfl), path, "preference-default");
if(e < 0)return NULL;
num_plugin_prefs ++;
if(num_plugin_prefs >= MAX_PREFS)
{
fprintf(stderr, "%s: too many preferences\n", path);
return NULL;
}
_add_plugin_preference(prefs, p_name, name, type, dfl);
str[0] = '/';
arglist = arglist->next;
}
}
if(num_plugin_prefs > 0)
plug.has_prefs = 1;
fd = open(desc_file, O_RDWR|O_CREAT|O_TRUNC, 0644);
if(fd < 0)
{
return NULL;
}
if(write(fd, &plug, sizeof(plug)) < 0)
{
perror("write ");
}
if(num_plugin_prefs > 0)
{
write(fd, pp, sizeof(pp));
}
close(fd);
ret = emalloc(sizeof(struct arglist));
plug_set_id(ret, _plug_get_id(plugin));
plug_set_category(ret, _plug_get_category(plugin));
plug_set_fname(ret, file);
arg_add_value(ret, "preferences", ARG_ARGLIST, -1, arg_get_value(plugin, "preferences"));
arg_set_value(plugin, "preferences", -1, NULL);
arg_free_all(plugin);
return ret;
}
