Datenversand über SDL_net [gelöst]

Programmiersprachen, APIs, Bibliotheken, Open Source Engines, Debugging, Quellcode Fehler und alles was mit praktischer Programmierung zu tun hat.
Antworten
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Datenversand über SDL_net [gelöst]

Beitrag von Felian »

Hi,
ich weiß nicht warum, aber ich bastel seit Wochen herum und bekomme nicht einmal ein Byte über SDL_net versendet. Ich habe eine Client- und eine Serverversion meines Programms, welche über UDP laufen. Nach viel Gebastel (weil SDL_net bei mir sowohl unter Windows, als auch unter Linux die Bytereihenfolge nur bei den Read16/32 und nicht bei den Write16/32 umdreht bzw. anpasst) erhält mein Server auch UDP-Pakte von meinem Clienten. Doch ich schaffe es beim besten Willen nicht, auch nur ein einzelnes Byte oder gar einen umgewandelten String zu versenden.

Ich bin mir auch nicht sicher, ob ich den Paket->data Zeiger richtig verwende. Laut Doku ist dies ein Uint8* also quasie ein char* Zeiger. Schreibe ich meine Daten an die Adresse von Paket->data erhalte ich einen Speicherzugriffsfehler. Also liegt dort wohl kein reservierter Speicher vor. Weise ich Paket->data die Adresse des erstes Bytes meiner Daten, oder, im einfachsten Fall, meines einzigen Bytes zu, passiert trotzdem noch nichts.
Beim Lesen des empfangenen Paketes greife ich einfach auf die Zeigeradresse zu, dort ich erhalte dort nie etwas.

Hier meine Testsendefunktion:

Code: Alles auswählen

void GLNet::SendUDP(void* daten, int laenge)

{

	//Wenn keine UDP-Verbindung, abbrechen

	if(State == 0 || State == 1 || State == 2) return;



	Uint8 Zahl = 5;
	Uint8* Zahlzeiger = &Zahl;
	Packet->data = Zahlzeiger;
	Packet->len = 1;


	//Wenn UDP-Server, an alle Clients senden, sonst an alle Server

	if(State == 3 || State == 5 || State == 7)

	{

		for(int i = 0; i < NumberClients; i++)

		{

			//IP zuweisen

			Packet->address.host = ClientIP[i].host;

			Packet->address.port = ClientIP[i].port;

			//An eine Adresse (Client) senden

			SDLNet_UDP_Send(UDPSocket, -1, Packet);

		}

	} else {

		for(int i = 0; i < NumberServer; i++)

		{

			//IP zuweisen

			Packet->address.host = ServerIP[i].host;

			Packet->address.port = ServerIP[i].port;

			//An eine Adresse (Server) senden

			SDLNet_UDP_Send(UDPSocket, -1, Packet);

		}

	}



	//Zeiger auf temporäre Variablen löschen

	Packet->data = 0;

}
Die Empfangesfunktion und die Funktion welche sie aufruft:

Code: Alles auswählen

bool GLNet::RecvUDP(void* daten, int& maxlaenge, int& number, bool& server)			//Liefert true zurück, wenn neue Daten vorhanden (z.B. für Abfrageschleife)

{

	//Wenn keine UDP-Verbindung, abbrechen

	if(State == 0 || State == 1 || State == 2) return false;



	if(SDLNet_UDP_Recv(UDPSocket, Packet) != 1) return false;




	daten = (void*)Packet->data;

	maxlaenge = Packet->len;

	return true;

}

if(Netzwerk.RecvUDP(Daten, Laenge, SourceNumber, Server) && SourceNumber != -1)
		{
			//Daten konvertieren
			std::string Stringtext;
			if(*Daten == 5)
				Stringtext = "Juhu!";
			else
				Stringtext = "Mist!";

			std::string Ausgabe = "Empfangen: ";
			Ausgabe += Stringtext;
			Output.writel(Ausgabe, 0, 1);
		}
Mache ich selbst bei diesen einfachen Konvertierungen etwas falsch oder benutzte ich den Paket->data Zeiger einfach nur falsch? Kennt sich damit irgendjemand aus? Allgemein gibt es außer der Doku und einem einzigen, nicht viel sagendem, Tutorial scheinbar nichts über SDL_net im Internet. Würde mich freuen, wenn jemand weiter weiß. :-)
Zuletzt geändert von Felian am 23.06.2011, 21:04, insgesamt 1-mal geändert.
Dirk Schulz
Establishment
Beiträge: 130
Registriert: 01.03.2009, 14:21
Alter Benutzername: frittentuete

Re: Datenversand über SDL_net

Beitrag von Dirk Schulz »

Hi,

kenne mich mit der SDL nicht aus, ein kurzer Blick in die Doku zeigt mir allerdings die Funktionen SDLNet_AllocPacket und SDLNet_FreePacket.

Daher würde ich annehmen, dass das packet über Alloc erstellt wird, du dann in das packet->data Feld schreiben kannst (nicht Pointer zuweisen) und am Ende mit Free wieder den Speicher freigibst.


Aber wie gesagt, dass ist nur eine Vermutung. :D
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

Hi, danke für die Antwort, aber den Speicher reservier ich und gebe ihn wieder frei. Ich habe Funktionen um einen Netzwerkclienten bzw. Server zu erstellen. Diese setzen auch die zu Beginn meiner Sende- und Empfangsfunktionen abgefragte State-Variable. Wenn kein Paketspeicher reserviert ist, wird sofort abgebrochen.

Hier eine der beiden Funktionen als Beispiel. Die Speicherreservierung geht leider im Codeblock nicht farblich hervorheben. Sie steht ungefähr in der Mitte.(Es gibt auch zwei Funktionen zum Beenden, welche automatisch am Ende des Programms aufgerufen werden.)

Code: Alles auswählen

bool GLNet::UDPClient()

{

	//Falls UDPServer, Verbindung beenden

	if(State == 3 || State == 5 || State == 7)

		EndUDP();



	//Nur neu verbinden, wenn noch nicht UDPClient

	if(State != 4 && State != 6 && State != 8)

	{

		UDPSocket = SDLNet_UDP_Open(0);		//Nächsten freien Port auswählen, sicherer, dass funktioniert (Server erhält Clientports in Paketen)

		//Wenn Socket nicht erstellen geht, Status anpassen und abbrechen

		if(UDPSocket == NULL)

		{

			//Status passend ändern, da keine UDP-Verbindung mehr und Clientverbindung fehlgeschlagen

			switch(State)

			{

				case 3:

					//UDPServer -> nicht verbunden

					State = 0;

				break;



				case 5:

					//TCPServer/UDPServer -> TCPServer

					State = 1;

				break;



				case 7:

					//TCPClient/UDPServer -> TCPClient

					State = 2;

				break;

			}



			return false;

		}



		//Speicher für Paket reservieren

		Packet = SDLNet_AllocPacket(Plaenge);


		//Status aktualisieren

		switch(State)

		{

			case 0:

				//nicht verbunden -> UDPClient

				State = 4;

			break;



			case 1:

				//TCPServer -> TCPServer/UDPClient

				State = 6;

			break;



			case 2:

				//TCPClient -> TCPClient/UDPClient

				State = 8;

			break;



			case 3:

				//UDPServer -> UDPClient

				State = 4;

			break;



			case 5:

				//TCPServer/UDPServer -> TCPServer/UDPClient

				State = 6;

			break;



			case 7:

				//TCPClient/UDPServer -> TCPClient/UDPClient

				State = 8;

			break;

		}

	}

	return true;

}
EDIT: An der Größe des Paketes kann es auch nicht liegen, denn selbst wenn ich versuche meinen einen Byte aus der Funktion im ersten Post an die Zeigeradresse zu schreiben, erhalte ich einen Zugriffsfehler, obwohl ich 1024 Byte reserviert habe.
Dirk Schulz
Establishment
Beiträge: 130
Registriert: 01.03.2009, 14:21
Alter Benutzername: frittentuete

Re: Datenversand über SDL_net

Beitrag von Dirk Schulz »

Hi,

mit dem AllocPacket meinte ich vor allem, dass du im ersten Beitrag die Pointer auf packet->data veränderst, was ein Fehler ist.

eigentlich sollte

Code: Alles auswählen

*(packet->data) = Zahl 
ausreichen, um die Zahl zu übertragen. Wenn dort ein Zugriffsfehler passiert, dann stimmt etwas nicht in deinem Code. Am besten mal mit dem Debugger durchsteppen und darauf achten, ob alles mit rechten Dingen zugeht.

Du hältst dich an das Tutorial: http://gpwiki.org/index.php/SDL:Tutoria ... #Using_UDP ???
Benutzeravatar
Chromanoid
Moderator
Beiträge: 4254
Registriert: 16.10.2002, 19:39
Echter Name: Christian Kulenkampff
Wohnort: Lüneburg

Re: Datenversand über SDL_net

Beitrag von Chromanoid »

Du machst das ganze lokal auf dem Rechner nehme ich an? :)
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

@ Dirk Schulz, hatte meinen Code nach deinem Post folgendermaßen geändert:

Code: Alles auswählen

void GLNet::SendUDP(void* daten, int laenge)

{

	//Wenn keine UDP-Verbindung, abbrechen

	if(State == 0 || State == 1 || State == 2) return;



	//Uint8 Zahl = 5;

	//Uint8* Zahlzeiger = &Zahl;

	*Packet->data = 5;



	//Wenn UDP-Server, an alle Clients senden, sonst an alle Server

	if(State == 3 || State == 5 || State == 7)

	{

		for(int i = 0; i < NumberClients; i++)

		{

			//IP zuweisen

			Packet->address.host = ClientIP[i].host;

			Packet->address.port = ClientIP[i].port;

			//An eine Adresse (Client) senden

			SDLNet_UDP_Send(UDPSocket, -1, Packet);

		}

	} else {

		for(int i = 0; i < NumberServer; i++)

		{

			//IP zuweisen

			Packet->address.host = ServerIP[i].host;

			Packet->address.port = ServerIP[i].port;

			//An eine Adresse (Server) senden

			SDLNet_UDP_Send(UDPSocket, -1, Packet);

		}

	}



	//Zeiger auf temporäre Variablen löschen

	//Packet->data = 0;

}
Und bei *Packet->data = 5; entsteht dann der Speicherzugriffsfehler. Im Prinzip halte ich mich an das Tutorial, verwende halt nur andere Technik.

@ Chromanoid, ja, mein Server lauscht auf Port 2000 und mein Client schickt auf Port 2000 Pakete an 127.0.0.1, also die localhost Adresse. SDLNet_UDP_Recv vom Server meldet auch einkommende Pakete, wenn ich welche sende. Aber ich kann machen was ich will, Packet->data des einkommenden Pakets zeigt immer auf eine leere Speicheradresse.
Benutzeravatar
Chromanoid
Moderator
Beiträge: 4254
Registriert: 16.10.2002, 19:39
Echter Name: Christian Kulenkampff
Wohnort: Lüneburg

Re: Datenversand über SDL_net

Beitrag von Chromanoid »

Ich kenne SDL_net nicht, noch bin ich Freund von C/C++ aber vielleicht kannst du dir einfach mal bestehenden SDL_net Code anschauen?
Ein kurzes Googlen:
http://bsdsockets.googlecode.com/files/udpserver.c //sieht sehr übersichtlich aus
https://port70.net/svn/misc/tard/net.c
http://mass.sourceforge.net/mass/network.c.txt
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

Bei Google wird auch direkt an die Speicherstelle Packet->data geschrieben. Habe mein Problem mit dem Speicherzugriffsfehler gefunden. Ich hatte noch eine Broadcastfunktion (frame(), nun auskommentiert) laufen, welche den Packet->data Zeiger immer auf 0 gesetzt hat. Jetzt kann ich zwar auch Daten in das Paket schreiben, aber empfangen kann ich sie trotzdem nicht. Ich schreib jetzt mal allen netzwerkrelevanten Code zusammen. Vielleicht sieht ja jemand einen Fehler, den ich übersehen habe:

Die gekürzte main.cpp, Client u. Server, haben den gleichen Quelltext, werden durch SERVER-Makro unterschieden:

Code: Alles auswählen

//#define SERVER

	//Netzwerkobjekt erstellen
	GLNet Netzwerk(&Zeit);

	char Daten[1024] = {0};
	int Laenge = 6;
	int SourceNumber = 0;
	bool Server = true;

	#ifdef SERVER
	//Als Empfängerserver verbinden
	Netzwerk.setName("Empfängerserver");
	Netzwerk.UDPServer();
	#else
	//Als Senderclient verbinden
	Netzwerk.setName("Senderclient");
	Netzwerk.UDPClient();
	Netzwerk.ClientToIP(127, 0, 0, 1);	//localhost
	#endif

	while(!Input.getQuit())
	{

		//Netzwerkframefunktion
		//Netzwerk.frame();

		#ifdef SERVER
		if(Netzwerk.RecvUDP(Daten, Laenge, SourceNumber, Server) && SourceNumber != -1)
		{
			//Daten konvertieren
			std::string Stringtext;
			if(Daten[0] == 5)
				Stringtext = "Juhu!";
			else
				Stringtext = "Mist!";

			std::string Ausgabe = "Empfangen: ";
			Ausgabe += Stringtext;
			Output.writel(Ausgabe, 0, 1);
		}
		#else
		//Daten senden
        	if(Input.isRepeated("enter") && Netzwerk.getState() != "Nicht verbunden/Not connected")
        	{
			char* Text = const_cast<char*> (Eingabe->getText().c_str());
			Netzwerk.SendUDP((void*)Text, Eingabe->getText().length());
			//Sendebericht ausgeben
			std::string Sendingmessage = (std::string)Text;
			Sendingmessage += " gesendet an ";
			//Anderer Benutzer muss erste Person in Datenbank sein
			if(Netzwerk.getState() == "UDPServer")
			{
		        	Sendingmessage += Netzwerk.getClientIP(0);
			} else {
				Sendingmessage += Netzwerk.getServerIP(0);
			}
			Output.writel(Sendingmessage, 0, 1);
			Eingabe->setText("");
		}
		#endif

	}
Die Sende- Empfangsfunktion:

Code: Alles auswählen

void GLNet::SendUDP(void* daten, int laenge)

{

	//Wenn keine UDP-Verbindung, abbrechen

	if(State == 0 || State == 1 || State == 2) return;



	Packet->data[0] = 5;

	Packet->len = 1;



	//Wenn UDP-Server, an alle Clients senden, sonst an alle Server

	if(State == 3 || State == 5 || State == 7)

	{

		for(int i = 0; i < NumberClients; i++)

		{

			//IP zuweisen

			Packet->address.host = ClientIP[i].host;

			Packet->address.port = ClientIP[i].port;

			//An eine Adresse (Client) senden

			SDLNet_UDP_Send(UDPSocket, -1, Packet);

		}

	} else {

		for(int i = 0; i < NumberServer; i++)

		{

			//IP zuweisen

			Packet->address.host = ServerIP[i].host;

			Packet->address.port = ServerIP[i].port;

			//An eine Adresse (Server) senden

			SDLNet_UDP_Send(UDPSocket, -1, Packet);

		}

	}


}

bool GLNet::RecvUDP(void* daten, int& maxlaenge, int& number, bool& server)			//Liefert true zurück, wenn neue Daten vorhanden (z.B. für Abfrageschleife)

{

	//Wenn keine UDP-Verbindung, abbrechen

	if(State == 0 || State == 1 || State == 2) return false;


	if(SDLNet_UDP_Recv(UDPSocket, Packet) != 1) return false;




	daten = (void*)Packet->data;

	maxlaenge = Packet->len;

	return true;

}
Ich erhalte keinerlei Fehlermeldungen, kann also Daten in das Paket schreiben. Aber die Serverversion meines Programms gibt mir wenn ich ein Paket absende immer "Empfangen: Mist!" aus, also keine "5" auf dem ersten Byte des Pakets.

Die Funktionen zum Verbindungsaufbau, stehen hier nur vorsichtshalber, eine Verbindung erhalte ich ja:

Code: Alles auswählen

void setName(std::string name) {if(State != 0 && State != 3 && State != 4) SendTCPNameChange(name); else Name = name;} //irrelevant, da der Name noch nicht verwendet wird

bool GLNet::UDPServer()

{

	//Falls UDPClient, Verbindung beenden

	if(State == 4 || State == 6 || State == 8)

		EndUDP();



	//Nur neu verbinden, wenn noch nicht UDPServer

	if(State != 3 && State != 5 && State != 7)

	{

		UDPSocket = SDLNet_UDP_Open(Port);

		//Wenn Socket auf diesem Port nicht erstellen geht, Status anpassen und abbrechen

		if(UDPSocket == NULL)

		{

			//Status passend ändern, da keine UDP-Verbindung mehr und Serververbindung fehlgeschlagen

			switch(State)

			{

				case 4:

					//UDPClient -> nicht verbunden

					State = 0;

				break;



				case 6:

					//TCPServer/UDPClient -> TCPServer

					State = 1;

				break;



				case 8:

					//TCPClient/UDPClient -> TCPClient

					State = 2;

				break;

			}



			return false;

		}



		//Speicher für Paket reservieren

		Packet = SDLNet_AllocPacket(Plaenge);



		//Status aktualisieren

		switch(State)

		{

			case 0:

				//nicht verbunden -> UDPServer

				State = 3;

			break;



			case 1:

				//TCPServer -> TCPServer/UDPServer

				State = 5;

			break;



			case 2:

				//TCPClient -> TCPClient/UDPServer

				State = 7;

			break;



			case 4:

				//UDPClient -> UDPServer

				State = 3;

			break;



			case 6:

				//TCPServer/UDPClient -> TCPServer/UDPServer

				State = 5;

			break;



			case 8:

				//TCPClient/UDPClient -> TCPClient/UDPServer

				State = 7;

			break;

		}

	}

	return true;

}

bool GLNet::UDPClient()

{

	//Falls UDPServer, Verbindung beenden

	if(State == 3 || State == 5 || State == 7)

		EndUDP();



	//Nur neu verbinden, wenn noch nicht UDPClient

	if(State != 4 && State != 6 && State != 8)

	{

		UDPSocket = SDLNet_UDP_Open(0);		//Nächsten freien Port auswählen, sicherer, dass funktioniert (Server erhält Clientports in Paketen)

		//Wenn Socket nicht erstellen geht, Status anpassen und abbrechen

		if(UDPSocket == NULL)

		{

			//Status passend ändern, da keine UDP-Verbindung mehr und Clientverbindung fehlgeschlagen

			switch(State)

			{

				case 3:

					//UDPServer -> nicht verbunden

					State = 0;

				break;



				case 5:

					//TCPServer/UDPServer -> TCPServer

					State = 1;

				break;



				case 7:

					//TCPClient/UDPServer -> TCPClient

					State = 2;

				break;

			}



			return false;

		}



		//Speicher für Paket reservieren

		Packet = SDLNet_AllocPacket(Plaenge);



		//Status aktualisieren

		switch(State)

		{

			case 0:

				//nicht verbunden -> UDPClient

				State = 4;

			break;



			case 1:

				//TCPServer -> TCPServer/UDPClient

				State = 6;

			break;



			case 2:

				//TCPClient -> TCPClient/UDPClient

				State = 8;

			break;



			case 3:

				//UDPServer -> UDPClient

				State = 4;

			break;



			case 5:

				//TCPServer/UDPServer -> TCPServer/UDPClient

				State = 6;

			break;



			case 7:

				//TCPClient/UDPServer -> TCPClient/UDPClient

				State = 8;

			break;

		}

	}

	return true;

}

bool GLNet::ClientToIP(unsigned char IP1, unsigned char IP2, unsigned char IP3, unsigned char IP4)

{

	return add(IP1, IP2, IP3, IP4, true);

}

bool GLNet::add(unsigned char IP1, unsigned char IP2, unsigned char IP3, unsigned char IP4, bool server, std::string userName, int ping, double lastAnswer)

{

	//IP konvertieren

	Uint32 IP = (IP1 << 24) + (IP2 << 16) + (IP3 << 8) + IP4 ;

	unsigned char Puffer[4] = {0};

	SDLNet_Write32(IP, Puffer);

	IPaddress Adresse;

	Adresse.host = (Puffer[3] << 24) + (Puffer[2] << 16) + (Puffer[1] << 8) + Puffer[0];



	unsigned char SmallPuffer[2] = {0};

	SDLNet_Write16(Port, SmallPuffer);

	Adresse.port = (SmallPuffer[1] << 8) + SmallPuffer[0];

	//SDLNet_ResolveHost(&Adresse, "localhost", Port);	//Nur für Testzwecke



	//Schauen ob Server oder Client hinzugefügt wird

	if(server)

	{

		if(NumberServer <= 255)

		{

			//In Adressdatenbank eintragen

			ServerIP[NumberServer] = Adresse;

			ServerName[NumberServer] = userName;    //Entweder ein Name gesetzt oder ist leer

			ServerPing[NumberServer] = ping;    //Entweder ein Ping gesetzt oder ist 0

			if(lastAnswer != -1) LastServerAnswer[NumberServer] = lastAnswer; else LastServerAnswer[NumberServer] = Time->getGametime();

			NumberServer++;

			return true;

		} else {

			return false;

		}

	} else {

		if(NumberClients <= 255)

		{

			//In Adressdatenbank eintragen

			ClientIP[NumberClients] = Adresse;

			ClientName[NumberClients] = userName;    //Entweder ein Name gesetzt oder ist leer

			ClientPing[NumberClients] = ping;    //Entweder ein Ping gesetzt oder ist 0

			if(lastAnswer != -1) LastClientAnswer[NumberClients] = lastAnswer; else LastClientAnswer[NumberClients] = Time->getGametime();

			NumberClients++;

			return true;

		} else {

			return false;

		}

	}

}

void GLNet::EndUDP()

{

	if(UDPSocket) SDLNet_UDP_Close(UDPSocket);

	UDPSocket = NULL;

	if(Packet) SDLNet_FreePacket(Packet);
	Packet = NULL;





	//Status aktualisieren

	switch(State)

	{

		case 3:

			//UDPServer -> nicht verbunden

			State = 0;

		break;



		case 4:

			//UDPClient -> nicht verbunden

			State = 0;

		break;



		case 5:

			//TCPServer/UDPServer -> TCPServer

			State = 1;

		break;



		case 6:

			//TCPServer/UDPClient -> TCPServer

			State = 1;

		break;



		case 7:

			//TCPClient/UDPServer -> TCPClient

			State = 2;

		break;



		case 8:

			//TCPClient/UDPClient -> TCPClient

			State = 2;

		break;

	}

}
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

Habe mal geschaut, ich schreibe folgendes in das Paket:

Code: Alles auswählen

Packet->data[0] = 5;
Packet->len = 1;
Und folgendes empfange ich:

Code: Alles auswählen

Packet->data[0] = 0;
Packet->len = 1;
Die Länge wird übermittelt, aber der Inhalt ist leer.

Übermittel ich:

Code: Alles auswählen

Packet->data[0] = 5;
Packet->len = 2;
So erhalte ich:

Code: Alles auswählen

Packet->data[0] = 0;
Packet->len = 2;
Also an einer terminierenden 0 kann es auch nicht liegen.
Benutzeravatar
Chromanoid
Moderator
Beiträge: 4254
Registriert: 16.10.2002, 19:39
Echter Name: Christian Kulenkampff
Wohnort: Lüneburg

Re: Datenversand über SDL_net

Beitrag von Chromanoid »

Hast du dir mal SDLNet_Read32 und SDLNet_Write32 angeschaut?
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

Ja, aber solange ich von meinem PC an mich selbst sende brauche ich ja keine Konvertierung der Bytereihenfolge. Vor allem nicht, wenn ich nur ein Byte versende.
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

Hab neue Erkenntnisse gewonnen. Das Problem muss irgendwie beim Empfänger liegen. habe meine Empfangsfunktion folgendermaßen abgewandelt:

Code: Alles auswählen

bool GLNet::RecvUDP(void* daten, int& maxlaenge, int& number, bool& server)			//Liefert true zurück, wenn neue Daten vorhanden (z.B. für Abfrageschleife)

{

	//Wenn keine UDP-Verbindung, abbrechen

	if(State == 0 || State == 1 || State == 2) return false;

	if(!Packet) return false;	//Fehler hervorrufen wenn gar kein Speicher für Paket reserviert


	Packet->data[0] = 1;
	Packet->data[1] = 2;


	if(SDLNet_UDP_Recv(UDPSocket, Packet) != 1) return false;



	daten = Packet->data;

	Packet->data[0] = 2;
	Packet->data[1] = 1;


	maxlaenge = Packet->len;

	return true;

}
Erst checke ich, ob Speicher für das Paket reserviert wurde, dann schreibe ich 1 und 2 in das Paket. Anschließend fülle ich das Paket mit den empfangenen Daten und weise meinen Datenzeiger zu. Dann überschreibe ich das Paket ein drittes Mal mit 2 und 1.

Und jetzt kommt das Problem, wenn ich anschließend über meinen Datenzeiger in das Paket schaue, enthält es immer noch nur 0 und 0. Werde jetzt nochmal schauen, ob meine Werte überhaupt ins Paket geschrieben werden oder an welcher Stelle sie mit 0 überschrieben werden.
Felian
Beiträge: 14
Registriert: 07.02.2006, 19:05
Wohnort: Rosbach v.d.H.
Kontaktdaten:

Re: Datenversand über SDL_net

Beitrag von Felian »

Ok, alle Probleme gelöst.

Obwohl der Speicher für das Paket dauerhaft reserviert ist, stehen die Daten in dem Paket nur innerhalb der aufrufenden Funktion lokal zur Verfügung. Ich muss also in meiner Empfangsfunktion die Daten in einen zweiten, eigenen Puffer kopieren, dieser enthält dann den Inhalt des Pakets. Und dafür sitz ich hier seit Wochen dran :-/.

Aber danke für die Antworten. :-)
Antworten