prefs_dialog.c

网络编程

   v = arg_get_value(serv, "max_hosts");
   if(v)gtk_entry_set_text(GTK_ENTRY(gtkw), v);
  }
  
  gtkw = arg_get_value(t, "MAX_CHECKS");
  if(gtkw)
  {
   v = arg_get_value(serv, "max_checks");
   if(v)gtk_entry_set_text(GTK_ENTRY(gtkw), v);
  }
   
   gtkw = arg_get_value(t, "CGI_PATH");
   if(gtkw)
   {
    v = arg_get_value(serv, "cgi_path");
    if(v)gtk_entry_set_text(GTK_ENTRY(gtkw), v);
   }
   /*
    * User
    */
    
    t = arg_get_value(ctrls, "USER");
 
    gtkw = arg_get_value(t, "RULES");
    if(gtkw)
    {
     GtkWidget * item;
     GtkWidget * label;
          
     GList * dlist = NULL;
     GList * oldlist = (void *)arg_get_value(t, "RULES_DLIST");
     struct arglist * rules = arg_get_value(preferences, "RULES");
     
     if(oldlist)gtk_list_remove_items(GTK_LIST(gtkw), oldlist);
 
     while(rules && rules->next)
     {
      GtkWidget * box;
      if(strlen(rules->value))
      {
       item = gtk_list_item_new();
       gtk_object_set_data(GTK_OBJECT(item), "rule", rules->name);
       box = gtk_hbox_new(FALSE, 0);
       gtk_container_add(GTK_CONTAINER(item), box);
       gtk_widget_show(box);
       label = gtk_label_new(rules->value);
       gtk_widget_show(label);
       gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
       dlist = g_list_append(dlist, item);
       rules = rules->next;
       gtk_widget_show(item);
       }
     }
     if(arg_get_value(t, "RULES_DLIST"))
      arg_set_value(t, "RULES_DLIST", -1, dlist);
     else
      arg_add_value(t, "RULES_DLIST", ARG_PTR, -1, dlist);
     gtk_list_append_items(GTK_LIST(gtkw), dlist);
    }
    
#ifdef ENABLE_SAVE_KB
   prefs_dialog_kb_set_prefs(arg_get_value(ctrls, "SAVE_KB"),
   			     preferences);
#endif    
}
  
  
static void prefs_dialog_set_tooltips(ctrls)
 struct arglist * ctrls;
{
 struct arglist * t;
 GtkTooltips * tooltips;
 GtkWidget * w;
 tooltips = gtk_tooltips_new();

 t = arg_get_value(ctrls, "PLUGINS");
 w = arg_get_value(t, "ENABLE_DEPS_AT_RUNTIME");
 gtk_tooltips_set_tip(tooltips, w, HLP_ENABLE_DEPS_AT_RUNTIME,"");
 
 w = arg_get_value(t, "SILENT_DEPS");
 gtk_tooltips_set_tip(tooltips, w, HLP_SILENT_DEPS,"");
 t = arg_get_value(ctrls, "AUTH") ;
#ifdef USE_AF_INET
 w = arg_get_value(t, "HOSTNAME");
 gtk_tooltips_set_tip(tooltips, w, HLP_AUTH_SERVER,"");
 w = arg_get_value(t, "PORT");
 gtk_tooltips_set_tip(tooltips, w, HLP_AUTH_PORT,"");
#endif
 /*ENABLE_CRYPTO_LAYER*/
 w = arg_get_value(t, "USERNAME");
 gtk_tooltips_set_tip(tooltips, w, HLP_LOGIN_USER,"");
 
 t = arg_get_value(ctrls, "TARGET");
 w = arg_get_value(t, "DNS_EXPAND");
 gtk_tooltips_set_tip(tooltips, w, HLP_HOST_EXPANSION_DNS,"");
 
 w = arg_get_value(t, "TARGET");
 gtk_tooltips_set_tip(tooltips, w, HLP_TARGET_PRIMARY_TARGET, "");
 
 
 t = arg_get_value(ctrls, "SCAN_OPTIONS");
 w = arg_get_value(t, "PING_HOSTS");
 gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_PING,"");
 w = arg_get_value(t, "OPTIMIZE_TEST");
 gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_OPTIMIZE, "");
 
 w = arg_get_value(t, "SAFE_CHECKS");
 gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_SAFE_CHECKS, "");
 
 w = arg_get_value(t, "USE_MAC_ADDR");
 gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_USE_MAC_ADDR, "");

 w = arg_get_value(t, "REVERSE_LOOKUP");
 gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_REVERSE_LOOKUP, "");
 w = arg_get_value(t, "PORT_RANGE");
 gtk_tooltips_set_tip(tooltips, w,  HLP_SCAN_OPT_PORT_RANGE, "");
 w = arg_get_value(t, "UNSCANNED_CLOSED");
 gtk_tooltips_set_tip(tooltips, w, HLP_UNSCANNED_CLOSED, "");
 
 w = arg_get_value(t, "MAX_HOSTS");
 gtk_tooltips_set_tip(tooltips, w, HLP_MISC_MAX_HOSTS,"");
 w = arg_get_value(t, "MAX_CHECKS");
 gtk_tooltips_set_tip(tooltips, w, HLP_MISC_MAX_CHECKS, "");
 w = arg_get_value(t, "CGI_PATH");
 gtk_tooltips_set_tip(tooltips, w, HLP_CGI_PATH, "");
 t = arg_get_value(ctrls, "USER");
 gtk_tooltips_enable(tooltips);
}


int prefs_dialog_ok(w, ctrls)
 GtkWidget * w;
 struct arglist * ctrls;
{
  struct arglist * prefs;
  struct arglist * serv;
  struct arglist * t;
  char expansion[30];
  char * s, *e;
  char * hostname;
  GtkWidget * gtkw;
  
  
  bzero(expansion, 30);
  prefs = arg_get_value(ctrls, "PREFERENCES");
  serv = arg_get_value(prefs, "SERVER_PREFS");
  if(!serv)
  {
   serv = emalloc(sizeof(struct arglist));
   arg_add_value(prefs, "SERVER_PREFS", ARG_ARGLIST, -1, serv);
  }
  
  
 t = arg_get_value(ctrls, "PLUGINS");
 gtkw = arg_get_value(t, "ENABLE_DEPS_AT_RUNTIME");
 if(gtkw)
 {
   char * s;
   if(GTK_TOGGLE_BUTTON(gtkw)->active)s = estrdup("yes");
   else s = estrdup("no");
  
   if(arg_get_value(serv, "auto_enable_dependencies"))
   arg_set_value(serv, "auto_enable_dependencies", strlen(s), s);
  else
   arg_add_value(serv, "auto_enable_dependencies", ARG_STRING, strlen(s), s);
  }
 
 
 gtkw = arg_get_value(t, "SILENT_DEPS");
 if(gtkw)
 {
   char * s;
   if(GTK_TOGGLE_BUTTON(gtkw)->active)s = estrdup("yes");
   else s = estrdup("no");
  
   if(arg_get_value(serv, "silent_dependencies"))
   arg_set_value(serv, "silent_dependencies", strlen(s), s);
  else
   arg_add_value(serv, "silent_dependencies", ARG_STRING, strlen(s), s);
  }
 
  
  
 /*
  * Host expansion
  */
  t = arg_get_value(ctrls, "TARGET");
  gtkw = arg_get_value(t, "DNS_EXPAND");
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
   	strcat(expansion, "dns;");
   
    strcat(expansion, "ip;");    
   
   if(!strlen(expansion))strncpy(expansion, "none;", 5);
   expansion[strlen(expansion)-1]=0;
   
#ifdef ENABLE_SAVE_TESTS   
  gtkw = arg_get_value(t, "SAVE_THIS_SESSION");
  if(GTK_TOGGLE_BUTTON(gtkw) -> active)
  	s = strdup("yes");
  else
  	s = strdup("no");

  if(arg_get_value(serv, "save_session"))
   arg_set_value(serv, "save_session", strlen(s), s);
  else
   arg_add_value(serv, "save_session", ARG_STRING, strlen(s), s);
   
   
   gtkw = arg_get_value(t, "SAVE_EMPTY_SESSIONS");
  if(GTK_TOGGLE_BUTTON(gtkw) -> active)
  	s = strdup("yes");
  else
  	s = strdup("no");

  if(arg_get_value(serv, "save_empty_sessions"))
   arg_set_value(serv, "save_empty_sessions", strlen(s), s);
  else
   arg_add_value(serv, "save_empty_sessions", ARG_STRING, strlen(s), s);
   
    
#endif 
   
   s = (char*)gtk_entry_get_text(GTK_ENTRY(arg_get_value(t, "TARGET")));
   hostname = target_translate(s); /* if the target is a file, then
   				      translate it */
   
   s = emalloc(strlen(expansion)+1);
   strncpy(s, expansion, strlen(expansion));
   
   if(arg_get_value(serv, "host_expansion"))
    arg_set_value(serv, "host_expansion", strlen(s), s);
   else
    arg_add_value(serv, "host_expansion", ARG_STRING, strlen(s), s);
    

 
  /*
   * Plugins preferences
   */
  {
   struct arglist * plugs[2];
   int i;
   
   plugs[0] = Plugins;
   plugs[1] = Scanners;
   for(i=0;i<2;i++)
   {
    struct arglist  * plugins = plugs[i];
    
    while(plugins && plugins->next)
    {
     struct arglist * pref;
     char * type;
     char * value;
    
     if((pref = arg_get_value(plugins->value, "plugin_prefs")))
      while(pref && pref->next)
      {
       if((type = (char*)arg_get_value(pref->value, "type")))
       {
        if(!strcmp(type, PREF_ENTRY) ||
	   !strcmp(type, PREF_FILE) ||
	   !strcmp(type, PREF_PASSWORD))
         {
	  GtkWidget * entry = arg_get_value(pref->value, "ENTRY");
	  if(entry)
	  {
	  value = (char*)gtk_entry_get_text(GTK_ENTRY(entry));			      
	  arg_set_value(pref->value, "value", strlen(value), 
	 	       estrdup(value));
	  }
	 }
	 else if(!strcmp(type, PREF_CHECKBOX))
	 {
	  GtkWidget * button = arg_get_value(pref->value, "CHECKBOX");
	
  	  if(button)
	  {
	   char * value = GTK_TOGGLE_BUTTON(button)->active ? "yes":"no";
	   arg_set_value(pref->value, "value", strlen(value),
	 		estrdup(value));		
	  }
	 }
       else if(!strcmp(type, PREF_RADIO))
       {
        GSList * list = arg_get_value(pref->value, "RADIOBUTTONS");
        char * value = NULL;
       
        if(list)while(list && !value)
        {
          GtkWidget * button = list->data;
	  if(GTK_TOGGLE_BUTTON(button)->active)
	   value = (char*)gtk_object_get_data(GTK_OBJECT(button), "name");
	  list = list->next;
        }
        else {
         char * t;
	 if(pref->value)
           value = arg_get_value(pref->value, "value");
 	 if(value&&(t = strchr(value, ';')))t[0] = 0;
	 }
       if(value)arg_set_value(pref->value, "value", strlen(value),
      		             estrdup(value));
        }		  
       }
      pref = pref->next;
      }	   				      
    plugins = plugins->next;
   }
  }
  }
      
   
  
  /*
   * Scan options
   */
  
   t = arg_get_value(ctrls, "SCAN_OPTIONS");
   gtkw = arg_get_value(t, "PING_HOSTS");
   s = emalloc(4);
   
   if(GTK_TOGGLE_BUTTON(gtkw)->active)strncpy(s, "yes", 3);
   else strncpy(s, "no", 4);
   
   if(arg_get_value(serv, "ping_hosts"))
    arg_set_value(serv, "ping_hosts", strlen(s), s);
   else
    arg_add_value(serv, "ping_hosts", ARG_STRING, strlen(s), s);
    
    
   gtkw = arg_get_value(t, "REVERSE_LOOKUP");
   s = emalloc(4);
   if(GTK_TOGGLE_BUTTON(gtkw)->active)strncpy(s, "yes", 3);
   else strncpy(s, "no", 4);
   
   if(arg_get_value(serv, "reverse_lookup"))
    arg_set_value(serv, "reverse_lookup", strlen(s), s);
   else
    arg_add_value(serv, "reverse_lookup", ARG_STRING, strlen(s), s);
     
   gtkw = arg_get_value(t, "OPTIMIZE_TEST");
   s = emalloc(4);
   if(GTK_TOGGLE_BUTTON(gtkw)->active)strncpy(s, "yes", 3);
   else strncpy(s, "no", 4);
   
   if(arg_get_value(serv, "optimize_test"))
    arg_set_value(serv, "optimize_test", strlen(s), s);
   else
    arg_add_value(serv, "optimize_test", ARG_STRING, strlen(s), s);
    
    
   gtkw = arg_get_value(t, "SAFE_CHECKS");
   s = emalloc(4);
   if(GTK_TOGGLE_BUTTON(gtkw)->active)strncpy(s, "yes", 3);
   else strncpy(s, "no", 4);
   
   if(arg_get_value(serv, "safe_checks"))
    arg_set_value(serv, "safe_checks", strlen(s), s);
   else
    arg_add_value(serv, "safe_checks", ARG_STRING, strlen(s), s);
    
    
   gtkw = arg_get_value(t, "USE_MAC_ADDR");
   s = emalloc(4);
   if(GTK_TOGGLE_BUTTON(gtkw)->active)strncpy(s, "yes", 3);
   else strncpy(s, "no", 4);
   
   if(arg_get_value(serv, "use_mac_addr"))
    arg_set_value(serv, "use_mac_addr", strlen(s), s);
   else
    arg_add_value(serv, "use_mac_addr", ARG_STRING, strlen(s), s);  
  
  
  
#if 0 
#ifdef ENABLE_SAVE_KB
   gtkw = arg_get_value(t, "DETACHED_SCAN");
   if(GTK_TOGGLE_BUTTON(gtkw)->active){
   	 s = strdup("yes");
	 DetachedMode = 1;
	}
   else {
   	 s = strdup("no");
    	 DetachedMode = 0;
        }
   if(arg_get_value(serv, "detached_scan"))
    arg_set_value(serv, "detached_scan", strlen(s), s);
   else
    arg_add_value(serv, "detached_scan", ARG_STRING, strlen(s), s);  
  
   gtkw = arg_get_value(t, "EMAIL_ADDR");
   s = estrdup(gtk_entry_get_text(GTK_ENTRY(gtkw)));
   arg_set_value(serv, "detached_scan_email_address", strlen(s), s);
   
   
   
   gtkw = arg_get_value(t, "CONTINUOUS_SCAN");
  
   
   if(GTK_TOGGLE_BUTTON(gtkw)->active)s = strdup("yes");
   else s = strdup("no");
   
   if(arg_get_value(serv, "continuous_scan"))
    arg_set_value(serv, "continuous_scan", strlen(s), s);
   else
    arg_add_value(serv, "continuous_scan", ARG_STRING, strlen(s), s);  
   
   gtkw = arg_get_value(t, "DELAY");
   s = strdup(gtk_entry_get_text(GTK_ENTRY(gtkw)));
   if(arg_get_value(serv, "delay_between_scan_loops"))
    arg_set_value(serv, "delay_between_scan_loops", strlen(s), s);
   else
    arg_add_value(serv, "delay_between_scan_loops", ARG_STRING, strlen(s), s); 
    
#endif     
#endif
 gtkw = arg_get_value(t, "PORT_RANGE");
 s = emalloc(strlen(gtk_entry_get_text(GTK_ENTRY(gtkw)))+1);
 strncpy(s, gtk_entry_get_text(GTK_ENTRY(gtkw)), 
 	strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))));
 
 if(arg_get_value(serv, "port_range"))
  arg_set_value(serv, "port_range", strlen(s), s);
 else
  arg_add_value(serv, "port_range", ARG_STRING, strlen(s), s);
         
	 
 gtkw = arg_get_value(t, "UNSCANNED_CLOSED");
 s = emalloc(4);
 if(GTK_TOGGLE_BUTTON(gtkw)->active)strncpy(s, "yes", 3);
 else strncpy(s, "no", 4);
   
 if(arg_get_value(serv, "unscanned_closed"))
    arg_set_value(serv, "unscanned_closed", strlen(s), s);
   else
    arg_add_value(serv, "unscanned_closed", ARG_STRING, strlen(s), s);
    
    	 
 gtkw = arg_get_value(t, "MAX_HOSTS");
 
 s = emalloc(strlen(gtk_entry_get_text(GTK_ENTRY(gtkw)))+1);
  
 strncpy(s, gtk_entry_get_text(GTK_ENTRY(gtkw)), 
  	strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))));
  
 if(arg_get_value(serv, "max_hosts"))
    arg_set_value(serv, "max_hosts", strlen(s), s);
  else
    arg_add_value(serv, "max_hosts", ARG_STRING, strlen(s), s); 
    
    
 gtkw = arg_get_value(t, "MAX_CHECKS");
 
 s = emalloc(strlen(gtk_entry_get_text(GTK_ENTRY(gtkw)))+1);
  
 strncpy(s, gtk_entry_get_text(GTK_ENTRY(gtkw)), 
  	strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))));
  
 if(arg_get_value(serv, "max_checks"))
    arg_set_value(serv, "max_checks", strlen(s), s);
  else
    arg_add_value(serv, "max_checks", ARG_STRING, strlen(s), s);      
 
 
 gtkw = arg_get_value(t, "CGI_PATH");
 s = estrdup((char*)gtk_entry_get_text(GTK_ENTRY(gtkw)));

        
  if(arg_get_value(serv, "cgi_path"))
    arg_set_value(serv, "cgi_path", strlen(s), s);
  else
    arg_add_value(serv, "cgi_path", ARG_STRING, strlen(s), s);   

#ifdef ENABLE_SAVE_KB
  t = arg_get_value(ctrls, "SAVE_KB");
  prefs_dialog_kb_get_prefs(t);
#endif

  
 /* 
  * User
  * We don't handle the rules here, since a special callback has been 
  * set up for this one...
  */
  
  
 t = arg_get_value(ctrls, "USER");
 e = NULL;
 
  /*
   * Check for the errors
   */
 
  if(GlobalSocket < 0)
  {
   show_error("You must connect to a nessusd host before you start \n\
a scan in the 'nessusd' section");
   return(0);
  }
  
  
  if( hostname == NULL || hostname[0] == '\0' )
  { 
   show_error("You must enter the name of the primary target\n\
to attack in the 'target' section");
   return(0);
  }
 

  
  /*
   * Set up the GUI for the attack, and start it !
   */
  close_window(w, arg_get_value(ctrls, "WINDOW"));
  monitor_dialog_setup(hostname, 0);
  
  return(0);
}
#endif