Hallo,

EDITED: Aufgrund von http://blogs.operationaldynamics.com/andrew/software/gnome-desktop/gtk-thread-awareness weiß ich, dass die Benutzung von pthreads mit GTK nur eingeschränkt möglich ist. Hätte jemand eine Idee, wie ich das am besten lösen könnte? Hab gelesen, dass die Glib auch Threads anbietet. Funktioniert es mit denen besser?

ich hätte eine Frage. Ich habe in C einen Chat geschrieben (Source-Code ist GPL, siehe unten) welcher auf UDP-Nachrichten wartet und diese dann in einem GtkTextView darstellt. Das Programm besteht aus einem GtkWindow mit Eingabefelder und dem TextView. Zusätzlich gibt es eine Funktion zum (UDP)-Versenden von Daten. Nachdem alle Widgets erstellt wurden, wird ein Server Thread gestartet, welches die UDP Nachrichten aus dem Socket abholt und in die TextView schreiben soll.

Also schematisch dargestellt

main()->alle Widgets erstellen und anzeigen->Socket1 zum versenden von daten->pthread_create(&server...)->gtk_main()

ab pthread_create wird parallel die server funktion ausgeführt. diese sieht so aus:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

char puffer[BUF];
static void *server_main(void *val)
{
	sock2 = create_socket( AF_INET, SOCK_DGRAM, 0);
	bind_socket(&sock2, INADDR_ANY, PORT);
	while (1)
	{
		memset(puffer, 0, BUF);
		UDP_recv(&sock2, puffer, BUF-1);
		gtk_text_buffer_insert_at_cursor(textpuffer, "Recv: ", -1);
		puffer[BUF-1] = '\0';
		gtk_text_buffer_insert_at_cursor(textpuffer, puffer, -1);
		gtk_text_buffer_insert_at_cursor(textpuffer, "\n", 1);
		
	}
}

wenn ich jetzt sämtliche gtk_text_buffer-Funktionen rausschwerfe und mir den inhalt der UDP-Pakete in der Konsole anzeigen lasse, dann funktioniert es dauerhaft (hab über eine stunde lang pakete gespammt). das lässt mich darauf schließen, dass UDP an sich ja funktioniert. Aber anscheinend gibt es immer Probleme, sobald Text angezeigt wird.

Sammlung von Fehlermeldungen:

*** glibc detected *** ./chat: malloc(): memory corruption: 0x

(chat:8294): Pango-CRITICAL **: pango_layout_get_cursor_pos: assertion index >= 0 && index <= layout->length' failed

(chat:8300): Gtk-CRITICAL **: gtk_text_layout_real_invalidate: assertion layout->wrap_loop_count == 0' failed

(chat:8300): GLib-GObject-CRITICAL **: g_object_unref: assertion object->ref_count > 0' failed *** glibc detected *** ./chat: free(): invalid pointer: 0x0981a6a0 *** ======= Backtrace: ========= /lib/tls/i686/cmov/libc.so.6(+0x6b591)[0xf11591] /lib/tls/i686/cmov/libc.so.6(+0x6cde8)[0xf12de8] /lib/tls/i686/cmov/libc.so.6(cfree+0x6d)[0xf15ecd] /lib/libglib-2.0.so.0(g_free+0x36)[0x776fc6] (...)

(chat:8333): Gtk-WARNING **: Invalid text buffer iterator: either the iterator is uninitialized, or the characters/pixbufs/widgets in the buffer have been modified since the iterator was created. You must use marks, character numbers, or line numbers to preserve a position across buffer modifications. You can apply tags and insert marks without invalidating your iterators, but any mutation that affects 'indexable' buffer contents (contents that can be referred to by character offset) will invalidate all outstanding iterators

Was mich wundert:

* 99% der Fehlermeldungen stammen von der Glib

* Übertragungsfehler gibt es de facto keine

* Objekte vom Typ GtkTextIter kommen im Quelltext nirgends vor und trotzdem kommt eine derartige Fehlermeldung (letzte fehlermeldung)

Meine Vermutungen:

* Glib ist mit großer Datenmenge anscheinend überlastet (was mich aber sehr wundern würde)

* Problem mit den Zeichenkodierungen

* Das Problem MUSS mit der Darstellung zu tun haben, weil das Programm ohne gtk_text_buffer-Funktionen funktioniert.

* Funktionen für den Netzwerkzugriff sind sauber

kann mir jmd einen guten Tipp geben?

Quellcode ist hier: http://pastebin.com/Rq6kv5iQ (Netzwerkspezifische Sachen sind weggelassen)

Für Hilfe wäre ich dankbar und wer Mitarbeiten will, ist herzlich willkommen

GTK+ ist, wie so ziemlich alle anderen GUI-Toolkits auch, single-threaded. Alle GUI-Funktionen müssen aus dem GUI-Thread heraus aufgerufen werden. Wenn du Ereignisse aus einem anderen Thread verarbeiten willst, sollte man eine Producer-Consumer-Beziehung aufbauen, wie in dem von dir verlinkten Blogeintrag erwähnt wird.

Du musst die Ereignisse also in den Kontext der Mainloop reinbekommen. Am besten du benutzt die Netzwerkfunktionen von GIO, auf dem GTK+ sowieso schon aufbaut:

http://developer.gnome.org/gio/stable/

Das bietet dir mit g_socket_create_source genau die Möglichkeit, eine Event-Source für den Socket zu erstellen, die von der Mainloop konsumiert werden kann.

Hier Beispielcode (der Einfachheit wegen ohne Fehlerbehandlung):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <gtk/gtk.h>

#define PORT 1234
#define BUF_SIZE 255

static GtkTextBuffer *textbuf;

static gboolean on_socket_in(GSocket *socket, GIOCondition condition, gpointer user_data)
{
	gchar buffer[BUF_SIZE];
	gsize read = g_socket_receive(socket, buffer, BUF_SIZE - 1, NULL, NULL);
	buffer[read] = 0;

	gtk_text_buffer_insert_at_cursor(textbuf, "Recv: ", -1);
	gtk_text_buffer_insert_at_cursor(textbuf, buffer, -1);
	gtk_text_buffer_insert_at_cursor(textbuf, "\n", -1);

	return TRUE;
}

static void watch_udp()
{
	GSocket *socket;
	GInetAddress *ia;
	GSocketAddress *sa;
	GSource *source;

	socket = g_socket_new(G_SOCKET_FAMILY_IPV4,
	                      G_SOCKET_TYPE_DATAGRAM, 
	                      G_SOCKET_PROTOCOL_UDP,
	                      NULL);

	ia = g_inet_address_new_any(G_SOCKET_FAMILY_IPV4);
	sa = g_inet_socket_address_new(ia, PORT);
	g_socket_bind(socket, sa, TRUE, NULL);

	source = g_socket_create_source(socket, G_IO_IN, NULL);
	g_source_set_callback(source, (GSourceFunc) on_socket_in, NULL, NULL);
	g_source_attach(source, g_main_context_default());

	g_source_unref(source);
	g_object_unref(sa);
	g_object_unref(ia);
	g_object_unref(socket);
}

int main(int argc, char *argv[])
{
	GtkWidget *win, *text;

	gtk_init(&argc, &argv);
	win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	text = gtk_text_view_new();
	textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));

	g_signal_connect(win, "destroy", gtk_main_quit, NULL);
	
	gtk_container_add(GTK_CONTAINER(win), text);
	gtk_widget_show_all(win);

	watch_udp();

	gtk_main();
}

aha, die Glib bietet also eine eigene socket-implementierung an, die den Signalhandler auslöst, sobald ein UDP Paket eintrifft. Das ist natürlich genial. Vielen Dank, ich werde es testen sobald ich das nächste mal bei meinem computer bin

ein kleines Problem gibts noch: wie mach ich das wenn ich SSL Support implementieren will? geht das auch über die Glib?

Btw noch ein kleines Problem am Rande: wie realisiere ich Autoscroll? es hat bei mir mit den Google Ergebnissen (scroll_to_iter etc) nicht funktioniert. Hätte hier jmd eine Idee?

Hallo JW1,

JW1 schrieb:

ein kleines Problem gibts noch: wie mach ich das wenn ich SSL Support implementieren will? geht das auch über die Glib?

In der Referenz die YEPHENAS dir verlinkt hat findet sich auch der Abschnitt TLS (SSL): http://developer.gnome.org/gio/stable/tls.html

Gruß

Streamstormer

JW1 schrieb:

aha, die Glib bietet also eine eigene socket-implementierung an, die den Signalhandler auslöst, sobald ein UDP Paket eintrifft.

Es ist ein plattformunabhängiges Abstraktions-API. Unter Windows wird dann von der Implementierung Winsock verwendet, unter Linux die Unix-Sockets.

ein kleines Problem gibts noch: wie mach ich das wenn ich SSL Support implementieren will? geht das auch über die Glib?

Ja, siehe Link meines Vorposters.

Btw noch ein kleines Problem am Rande: wie realisiere ich Autoscroll? es hat bei mir mit den Google Ergebnissen (scroll_to_iter etc) nicht funktioniert. Hätte hier jmd eine Idee?

gtk_text_view_scroll_to_iter ist eigentlich schon das Richtige, vielleicht waren die Parameter falsch. Aber die GtkTextview Klasse implementiert seit GTK+ 3 auch das Interface GtkScrollable. Dadurch kannst du das vertikale Adjustment bekommen und dessen Wert setzen. Das Adjustment ist quasi das Model eines Scrollables.

1
2

GtkAdjustment *adjustment = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(textview));
gtk_adjustment_set_value(adjustment, gtk_adjustment_get_upper(adjustment));

Vielen Dank für alles, bis auf das scrolling funktioniert alle super.

Scrollen geht leider immer noch nicht, und ich hab leider kein GTK3+. muss ich noch mit dem scroll_to_iter herumprobieren.

btw eine frage zum TLS-Support von der Glib ... Worauf wird hier zurückgegriffen? Wenn ich bei Ubuntu eine GTls-Connection mache, basiert das dann auf OpenSSL oder auf GnuTLS?

Mal eine ganz andere frage, wieso benutzt du denn für sowas UDP und nicht TCP.

BodomBeachTerror schrieb:

Mal eine ganz andere frage, wieso benutzt du denn für sowas UDP und nicht TCP.

Weil das alles ohne Server ablaufen sollte. sobald man als "server" mehrere Clients gleichzeitig bedienen will, muss man threads, oder fork oder sonst was machen. aber mir wird sowieso nichts übrig bleiben, weil ich früher oder später SSL-Support haben will (geht um ein Projekt mit X509 Zertifikaten).

ich wäre aber für Verbesserungsvorschläge jederzeit offen.

JW1 schrieb:

BodomBeachTerror schrieb:

Mal eine ganz andere frage, wieso benutzt du denn für sowas UDP und nicht TCP.

Weil das alles ohne Server ablaufen sollte. sobald man als "server" mehrere Clients gleichzeitig bedienen will, muss man threads, oder fork oder sonst was machen. aber mir wird sowieso nichts übrig bleiben, weil ich früher oder später SSL-Support haben will (geht um ein Projekt mit X509 Zertifikaten).

ich wäre aber für Verbesserungsvorschläge jederzeit offen.

Achso, ich dachte eigentlich nur daran, weil bei UDP Pakete die nicht ankommen, vertauscht oder sogar doppelt ankommen nicht unüblich sind, und du das eben alles selber dann noch absichern müsstest. Bei TCP ist das ja schon alles im Protokoll gelöst und bei einem Chat ist die Geschwindigkeit von TCP ja auch sicherlich ausreichend.