prefs_plugins.c

网络编程

  
  gtk_signal_connect(GTK_OBJECT(list),
		     "selection_changed",
		     GTK_SIGNAL_FUNC(prefs_family_list_callback),
		     ctrls);
  
  list = gtk_list_new();                          
  arg_add_value(ctrls, "PLUGINS_LIST", ARG_PTR, -1, list);
#if GTK_VERSION < 11
  gtk_container_add(GTK_CONTAINER(plugins_window), list);
#else
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(plugins_window),list);
#endif
  gtk_widget_show(list);
  gtk_signal_connect(GTK_OBJECT(list),
		     "selection_changed",
		     GTK_SIGNAL_FUNC(prefs_plugin_list_callback),     
		     ctrls);   
 arg_add_value(ctrls, "FAMILIES", ARG_PTR, -1, families);                   
 fill_plugins_family(ctrls);
 gtk_widget_show(families_window);
 gtk_widget_show(plugins_window);
 gtk_widget_show(w_box);
 gtk_widget_show(frame);
 arg_add_value(ctrls, "PLUGINS_NUM", ARG_INT, sizeof(int), (void *)PluginsNum);
 arg_add_value(ctrls, "SCANNERS_NUM", ARG_INT, sizeof(int), (void*)ScannersNum);
 return(ctrls);
}



static void 
prefs_plugin_list_callback(widget, ctrls)
     GtkWidget * widget;
     struct arglist * ctrls;
{
  GtkObject * list_item;
  char * cur_plug;
  GList * dlist;
  GtkWidget * list = arg_get_value(ctrls, "PLUGINS_LIST");
  dlist = GTK_LIST(list)->selection;
  if(!dlist)return;
  
  list_item = GTK_OBJECT(dlist->data);
  cur_plug = gtk_object_get_data(list_item,"list_item_data");
  plugin_info_window_setup(Plugins, cur_plug);             
}

static void 
prefs_family_toggle_callback(w, ctrls)
     GtkWidget * w;
     struct arglist * ctrls;
{
  int enable = GTK_TOGGLE_BUTTON (w)->active;
  GList * dlist = NULL;
  GtkObject * list_item;
  char * name;
  GtkWidget * item;
  int check_manually = 1;
  
  if(gtk_object_get_data(GTK_OBJECT(w), "be_lazy"))
   return;
   

  item = w->parent->parent;
  list_item = GTK_OBJECT(item);
  name = gtk_object_get_data(list_item,"list_item_data");
  dlist = GTK_LIST(arg_get_value(ctrls, "PLUGINS_LIST"))->children;

 if(check_manually)family_enable(name, Plugins, enable);
 pluginset_reload(Plugins, Scanners);
 
 prefs_family_list_callback(arg_get_value(ctrls,"FAMILIES_LIST"), ctrls);
}

static 
void prefs_plugin_list_toggle_callback(w, plugin)
     GtkWidget * w;
     struct arglist * plugin;
{
  int state = GTK_TOGGLE_BUTTON(w)->active;
  
  plug_set_launch(plugin,state);
  pluginset_reload(Plugins, Scanners);
}

static
void 
prefs_family_list_callback(widget, ctrls)
     GtkWidget * widget; 
     struct arglist * ctrls;
{
  GList * dlist;
  GtkObject * list_item;
  char * cur_family;
  struct arglist * plugs = Plugins;
  GtkTooltips * tooltips;
  struct plugin_filter * filter = arg_get_value(ctrls, "FILTER");
  
  if(gtk_object_get_data(GTK_OBJECT(widget), "be_lazy"))
   return;
   
 
  
  
  dlist = GTK_LIST(arg_get_value(ctrls, "FAMILIES_LIST"))->selection;
  if(!dlist)return;
  
  list_item = GTK_OBJECT(dlist->data);
  cur_family = gtk_object_get_data(list_item,"list_item_data");
  dlist = GTK_LIST(arg_get_value(ctrls, "PLUGINS_LIST"))->children;
  if(dlist)gtk_list_remove_items(GTK_LIST(arg_get_value(ctrls, "PLUGINS_LIST")),dlist); 
  dlist = NULL;
  tooltips = gtk_tooltips_new();
  if(plugs)while(plugs->next)
    {
      GtkWidget * item;
      GtkWidget * box;
      GtkWidget * button;
      GtkWidget * label;
      
      
      if(arg_get_value(plugs->value, "FAMILY") &&
	 !strcmp(arg_get_value(plugs->value, "FAMILY"), cur_family))
	{
	  char * cat = arg_get_value(plugs->value, "CATEGORY");
	  int warning = cat? (!strcmp(cat, "denial") ||
			      !strcmp(cat, "kill_host") ||
			      !strcmp(cat, "flood") ||
	  		      !strcmp(cat, "destructive_attack")):0;
	  GtkWidget * sign = NULL;
	  	
	  if(filter)
	  {
	   if(filter_plugin(filter, plugs->value))
	    {
	     plugs = plugs->next;
	     continue;
	    }
	  }
	  item = gtk_list_item_new();
	  
	  
	  button = gtk_check_button_new();
	  gtk_widget_set_usize(button, 20, 20);
	  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
				      (int)plug_get_launch(plugs->value));
	  
	  label = gtk_label_new(plugs->name);
	  box = gtk_hbox_new(FALSE,5);
	  gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
	  gtk_widget_show(label);
	  
	 
	  gtk_box_pack_end(GTK_BOX(box), button, FALSE, FALSE,0);
	  if(warning)
	  {
	   sign = warning_sign(widget);
	   gtk_box_pack_end(GTK_BOX(box), sign, FALSE, FALSE, 0); 
	  }
	  gtk_container_add(GTK_CONTAINER(item), box);
	  gtk_signal_connect(GTK_OBJECT(button),
			     "clicked",
			     GTK_SIGNAL_FUNC(prefs_plugin_list_toggle_callback),
			     plugs->value);
	  gtk_widget_show(button);
	  if(warning)gtk_widget_show(sign);
	  gtk_widget_show(box);
	  gtk_widget_show(item);
	  if(arg_get_value(plugs->value, "SUMMARY"))
	    gtk_tooltips_set_tip(tooltips, item, 
				 (gchar *)arg_get_value(plugs->value, "SUMMARY"),"");
	  dlist = g_list_append(dlist, item);
	  gtk_object_set_data(GTK_OBJECT(item),
			      "list_item_data",
			      plugs->name);
	  gtk_object_set_data(GTK_OBJECT(item),
			      "button",
			      button);
	  gtk_object_set_data(GTK_OBJECT(item),
			      "plugin",
			      plugs->value);                                        
	}                    
      plugs = plugs->next;	
    }
  gtk_tooltips_enable(tooltips);
  dlist = g_list_sort(dlist, glist_cmp);
  gtk_list_append_items(GTK_LIST(arg_get_value(ctrls, "PLUGINS_LIST")), dlist);
  pluginset_reload(Plugins, Scanners);
}


int prefs_plugins_redraw(w, dumb, ctrls)
 GtkWidget * w;
 void * dumb;
 struct arglist * ctrls;
{
 int num;
 
 num = (int)arg_get_value(ctrls, "PLUGINS_NUM");
 if(num != PluginsNum){
  fill_plugins_family(ctrls);
  arg_set_value(ctrls, "PLUGINS_NUM", sizeof(int), (void *)PluginsNum);
 }
 return 0;
}

static int glist_cmp( gconstpointer a, gconstpointer b)
{
     GtkWidget * item_a = (GtkWidget*)a;
     GtkWidget * item_b = (GtkWidget*)b;

     char * str_a, * str_b;

     str_a = gtk_object_get_data(GTK_OBJECT(item_a), "list_item_data");
     str_b = gtk_object_get_data(GTK_OBJECT(item_b), "list_item_data");
     return strcmp(str_a, str_b);
}

void 
fill_plugins_family(ctrls)
 struct arglist * ctrls;
{
 GtkTooltips * tooltips;
 struct arglist * plugs = Plugins;
 struct plugin_families * lfamilies, *f;
 struct arglist * buttons;
 GList * dlist = NULL;
 
 

 

 buttons = arg_get_value(ctrls, "families_buttons");
 if(buttons)
 {
  /* arg_free(buttons); */
   buttons = emalloc(sizeof(struct arglist));
  arg_set_value(ctrls,"families_buttons",-1, buttons);
 }
 else 
 {
  buttons = emalloc(sizeof(struct arglist));
  arg_add_value(ctrls, "families_buttons", ARG_ARGLIST, -1, buttons);
 }
 

 tooltips = gtk_tooltips_new();
 lfamilies = families = family_init();
 if(plugs)
  while(plugs->next)
    {
      family_add(families, plugs->value);
      plugs = plugs->next;
    }
 plugs = Plugins;
  

 if(lfamilies)
  while(lfamilies->next)
   {
     GtkWidget * item;
     GtkWidget * box;
     GtkWidget * button;
     GtkWidget * label;
     struct plugin_families * old = arg_get_value(ctrls, "FAMILIES");
     int flag = 0;
     if(old)
      while(old->next && !flag)
      {
      if(old->name)flag = !strcmp(old->name, lfamilies->name);
      old = old->next;
      }
      
     if(flag){
     	lfamilies = lfamilies->next;
	continue;
	}
     	
     item = gtk_list_item_new();
     
     
     button = gtk_check_button_new();
     arg_add_value(buttons, lfamilies->name, ARG_PTR, -1, button);
     gtk_tooltips_set_tip(tooltips, button, lfamilies->name, "");
     
     gtk_widget_set_usize(button, 15, 15);
     gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
				 family_enabled(lfamilies->name, Plugins) ? TRUE:FALSE);
     label = gtk_label_new(lfamilies->name);
     box = gtk_hbox_new(FALSE,5);
     gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
     gtk_widget_show(label);
     gtk_box_pack_end(GTK_BOX(box), button, FALSE, FALSE,0);
	
     gtk_container_add(GTK_CONTAINER(item), box);
     gtk_signal_connect(GTK_OBJECT(button),
			"clicked",
			GTK_SIGNAL_FUNC(prefs_family_toggle_callback),
			ctrls);
     
     gtk_widget_show(button);
     gtk_widget_show(box);
     gtk_widget_show(item);
     dlist = g_list_append(dlist, item);
     gtk_object_set_data(GTK_OBJECT(item),
     			 "list_item_checkbox",
			 button);
     gtk_object_set_data(GTK_OBJECT(item),
			 "list_item_data",
			 lfamilies->name);
     lfamilies = lfamilies->next;
   }

   dlist = g_list_sort(dlist, glist_cmp);
   gtk_tooltips_enable(tooltips);
   gtk_list_append_items(GTK_LIST(arg_get_value(ctrls, "FAMILIES_LIST")), dlist);
   f = arg_get_value(ctrls, "FAMILIES");
   arg_set_value(ctrls, "FAMILIES", -1, families);
   while(f && f->next)
   {
    struct plugin_families * prev;
    efree(&f->name);
    prev = f;
    f = f->next;
    efree(&prev);
   }
}
#endif