statusview.c

Linux系统下著名的个人防火墙

		if (g_pattern_match_string (pattern, line)) { /* Entry is an established connection */
			gchar *source, *destination, *port;
			gchar *key;
			Connection_entry *entry = NULL;
			
			source = get_text_between (line, "src=", " ");
			destination = get_text_between (line, "dst=", " ");
			port = get_text_between (line, "dport=", " ");

			key = g_strdup_printf ("%s%s%s",  source, destination, port);
			entry = g_hash_table_lookup (entries, key);
			if (entry == NULL) { /* Only append new connections to the table */
				GtkTreeIter *ref;
				gchar *service;

				service = service_get_name (atoi (port), "tcp");
				ref = connectionview_append_connection (source, destination, port, service);

				entry = g_new0 (Connection_entry, 1);
				entry->ref = ref;
				g_hash_table_insert (entries, key, entry);
				g_free (service);
			} else {
				GtkListStore *store = get_connectionstore ();

				g_free (key);
				/* Reset color for connections seen this update */
				gtk_list_store_set (store, entry->ref,
				                    CONNECTIONCOL_COLOR, NULL,
				                    -1);
			}

			entry->ttl = CONNTRACK_TTL; /* Refresh TTL for all seen connections */
			g_free (source);
			g_free (destination);
			g_free (port);
		}

		g_free (line);
	}

	g_io_channel_seek_position (in, 0, G_SEEK_SET, &error); /* Rewind */
}

void
status_events_reset (void)
{
	counter_events_in = 0;
	counter_serious_events_in = 0;
	counter_events_out = 0;
	counter_serious_events_out = 0;
	gtk_label_set_text (GTK_LABEL (events_in), "0");
	gtk_label_set_text (GTK_LABEL (events_serious_in), "0");
	gtk_label_set_text (GTK_LABEL (events_out), "0");
	gtk_label_set_text (GTK_LABEL (events_serious_out), "0");
}

void
status_event_in_inc (void)
{
	counter_events_in++;
	gchar *label = g_strdup_printf ("%d", counter_events_in);

	gtk_label_set_text (GTK_LABEL (events_in), label);
	g_free (label);
}

void
status_serious_event_in_inc (void)
{
	counter_serious_events_in++;
	gchar *label = g_strdup_printf ("%d", counter_serious_events_in);

	gtk_label_set_text (GTK_LABEL (events_serious_in), label);
	g_free (label);
}

void
status_event_out_inc (void)
{
	counter_events_out++;
	gchar *label = g_strdup_printf ("%d", counter_events_out);

	gtk_label_set_text (GTK_LABEL (events_out), label);
	g_free (label);
}

void
status_serious_event_out_inc (void)
{
	counter_serious_events_out++;
	gchar *label = g_strdup_printf ("%d", counter_serious_events_out);

	gtk_label_set_text (GTK_LABEL (events_serious_out), label);
	g_free (label);
}

/* [ status_set_fw_state ]
 * Update the state of the firewall
 */
static void
update_state_widgets (FirewallStatus state)
{
	GdkPixbuf *pixbuf;
	const guint8 *icon;
	gchar *label;

	switch (state) {
	  case STATUS_RUNNING: icon = icon_start_large;
	                       label = g_strdup (_("Active")); break;
	  case STATUS_STOPPED: icon = icon_stop_large;
	                       label = g_strdup (_("Disabled")); break;
	  case STATUS_LOCKED:  icon = icon_locked_large;
	                       label = g_strdup (_("Locked")); break;
	  case STATUS_HIT: return; // Don't change icon on hit
	  default: icon = icon_start_large;
	                  label = g_strdup (""); break;
	}

 	pixbuf = gdk_pixbuf_new_from_inline (-1, icon, FALSE, NULL);
	gtk_image_set_from_pixbuf (GTK_IMAGE (fw_state_icon), pixbuf);
	g_object_unref (G_OBJECT(pixbuf));

	gtk_label_set_markup (GTK_LABEL (fw_state_label), g_strconcat (
		"<small>", label, "</small>", NULL));


}

FirewallStatus
status_get_state (void)
{
	return current_status;
}

void
status_set_state (FirewallStatus status)
{
	if (gui_get_active_view () == STATUS_VIEW)
		menus_update_firewall_controls_state (status);

	tray_update (status);
	update_state_widgets (status);

	current_status = status;
}

/* [ status_sync_timeout ]
 * Correct the GUI state in case outside factors change the firewall state
 */
gint
status_sync_timeout (gpointer data)
{
	FirewallStatus state = status_get_state ();

	if (state == STATUS_HIT)
		return TRUE;

	if (firestarter_is_locked ()) {
		if (state != STATUS_LOCKED)
			status_set_state (STATUS_RUNNING);
	} else if (state == STATUS_LOCKED)
		status_set_state (STATUS_LOCKED);
	else
		status_set_state (STATUS_STOPPED);

	return TRUE;
}

/* [ refresh_network_data ]
 * Refresh all available data for all the network interfaces in the machine
 */
static void
refresh_network_data (GHashTable *interfaces)
{
	gint line_num = 0;
	gchar *line;
	static GIOChannel *in = NULL;
	GError *error = NULL;
	gchar *str;
	gchar *interface;
	Interface_info *info = NULL;

	if (in == NULL) {
		in = g_io_channel_new_file (DEV_FILE, "r", &error);

		if (in == NULL) {
			printf ("Error reading %s: %s\n", DEV_FILE, error->message);
			return;
		}
	}

	while (TRUE) {
		unsigned long int values[16];
		
		g_io_channel_read_line (in, &line, NULL, NULL, &error);

		if (line == NULL) // EOF reached
			break;
		line_num++;
		if (line_num <= 2) { // Skip dev headers
			g_free (line);
			continue;
		}

		interface = g_strstrip(g_strndup (line, 6)); /* Extract interface */

		/* Interface blacklist */
		if (g_str_equal (interface, "lo")) {
			g_free (line);
			continue;
		}

		info = g_hash_table_lookup (interfaces, interface); /* Retrieve info for updating */
		if (info == NULL) { /* Initialize new interface info structure */
			gint i;
			info = g_new0 (Interface_info, 1);

			/* Initialize interface traffic history, for counting average activity */
			info->traffic_history = (float*)malloc (HISTORY_LENGTH * sizeof (float));
			info->history_index = 0;
			for (i = 0; i < HISTORY_LENGTH; i++)
				info->traffic_history[i] = 0.0;
			info->previous_total = 0;

			g_hash_table_insert (interfaces, g_strdup (interface), info);
		}
		g_free (interface);
			
		str = line+7; // Continue parsing after interface

		/* values array:
		recieve:  0 bytes 1 packets 2 errs 3 drop 4 fifo 5 frame 6 compressed 7 multicast
		transmit: 8 bytes 9 packets 10 errs 11 drop 12 fifo 13 colls 14 carrier 15 compressed */
		sscanf(str,
			"%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
			&values[0], &values[1], &values[2], &values[3], &values[4],
			&values[5], &values[6], &values[7], &values[8], &values[9],
			&values[10], &values[11], &values[12], &values[13], &values[14],
			&values[15]);

		info->received = values[0];
		info->sent = values[8];

		g_free (line);
	}

	g_io_channel_seek_position (in, 0, G_SEEK_SET, &error); // Rewind
}

/* [ refresh_traffic_average ]
 * Recalculate the average traffic for a network interface
 */
static void
refresh_traffic_average (gint seconds, Interface_info *info)
{
	float current = info->received + info->sent;
	float last = info->previous_total;
	float difference = current - last;
	float average = 0.0;
	gint i;

	if (last == 0) {
		info->previous_total = current;
		return;
	}

	difference /= seconds;

	/* Update the history */
	info->traffic_history[info->history_index++] = difference;
	if (info->history_index == HISTORY_LENGTH)
		info->history_index = 0;

	/* Calculate the average */
	for (i = 0; i < HISTORY_LENGTH; i++) {
		average += info->traffic_history[i];
	}
	average /= HISTORY_LENGTH;

	/* Store current total for next refresh */
	info->previous_total = current;

	info->average = average;
}

/* [ refresh_interface_widgets ]
 * Update the onscreen widgets for a particular network interface
 */
static void
refresh_interface_widgets (gchar *interface, Interface_info *info, GHashTable *all_widgets)
{
	Interface_widgets *widgets;
	gchar *received, *sent, *activity;

	widgets = g_hash_table_lookup (all_widgets, interface);
	if (widgets == NULL) {
		gint row = g_hash_table_size (all_widgets)+1;
		gchar *type;
		gchar *ext_if, *int_if;
		
		ext_if = preferences_get_string (PREFS_FW_EXT_IF);
		int_if = preferences_get_string (PREFS_FW_INT_IF);

		if (ext_if != NULL && g_str_equal (interface, ext_if))
			type = g_strdup (_("Internet"));
		else if (preferences_get_bool (PREFS_FW_NAT) && int_if != NULL &&
		         g_str_equal (interface, int_if))
			type = g_strdup (_("Local"));
		else
			type = get_pretty_device_name (interface, FALSE);

		if (ext_if != NULL)
			g_free (ext_if);
		if (int_if != NULL)
			g_free (int_if);

		widgets = g_new (Interface_widgets, 1);

		widgets->device = gtk_label_new (NULL);
		gtk_label_set_markup (GTK_LABEL (widgets->device),
			g_strconcat ("<span size=\"smaller\">", interface ,"</span>", NULL));
		gtk_misc_set_alignment (GTK_MISC (widgets->device), 1.0, 0.0);

		widgets->type = gtk_label_new (NULL);
		gtk_label_set_markup (GTK_LABEL (widgets->type),
			g_strconcat ("<span size=\"smaller\">", type ,"</span>", NULL));
		gtk_misc_set_alignment (GTK_MISC (widgets->type), 1.0, 0.0);

		widgets->received = gtk_label_new ("-");
		gtk_misc_set_alignment (GTK_MISC (widgets->received), 1.0, 0.0);

		widgets->sent = gtk_label_new ("-");
		gtk_misc_set_alignment (GTK_MISC (widgets->sent), 1.0, 0.0);

		widgets->activity = gtk_label_new ("-");
		gtk_misc_set_alignment (GTK_MISC (widgets->activity), 1.0, 0.0);

		g_hash_table_insert (all_widgets, g_strdup (interface), widgets);

		gtk_table_attach (GTK_TABLE (device_table), widgets->device, 0, 1, row, row+1,
			GTK_FILL, GTK_FILL, GNOME_PAD, 2);	
		gtk_table_attach (GTK_TABLE (device_table), widgets->type, 1, 2, row, row+1,
			GTK_FILL, GTK_FILL, GNOME_PAD, 2);	
		gtk_table_attach (GTK_TABLE (device_table), widgets->received, 2, 3, row, row+1,
			GTK_FILL, GTK_FILL, GNOME_PAD, 2);	
		gtk_table_attach (GTK_TABLE (device_table), widgets->sent, 3, 4, row, row+1,
			GTK_FILL, GTK_FILL, GNOME_PAD, 2);	
		gtk_table_attach (GTK_TABLE (device_table), widgets->activity, 4, 5, row, row+1,
			GTK_FILL, GTK_FILL, GNOME_PAD, 2);
			
		gtk_widget_show_all (device_table);
	}

	received = g_strdup_printf ("<span size=\"smaller\">%.1f MB</span>", (float)(info->received)/1048576);
	sent = g_strdup_printf ("<span size=\"smaller\">%.1f MB</span>", (float)(info->sent)/1048576);
	activity = g_strdup_printf ("<span size=\"smaller\">%.1f KB/s</span>", info->average/1024);
	gtk_label_set_markup (GTK_LABEL (widgets->received), received);
	gtk_label_set_markup (GTK_LABEL (widgets->sent), sent);
	gtk_label_set_markup (GTK_LABEL (widgets->activity), activity);
	g_free (received);
	g_free (sent);
	g_free (activity);
}

static void
refresh_interface (gchar *interface, Interface_info *info, GHashTable *all_widgets)
{
	refresh_traffic_average (REFRESH_RATE, info);
	refresh_interface_widgets (interface, info, all_widgets);
}

/* [ update_conntrack_ttl ]
 * Decrement connection track entries time to live and check it they are ready for removal
 */