Gibt es ein einfaches Beispiel, wie man via bsdsocket.library Daten übertragen kann?

Ich möchte ein kleines Programm schreiben, das über einen Port kleine Datenpakete hin und her schiebt. Das Programm soll dabei auf beiden Rechnern zum Einsatz kommen.

Bei der Funktionsvielfalt der bsdsocket.library und meinen beschränkten Netzwerkkenntnissen blick ich das nicht so ganz.

TCP: oder externe Libraries möchte ich nicht benutzen.

Geit

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

So ich hab mal was zusammengebastelt. Es funktioniert auch Teilweise.

Zur erklärtung. TCP_Init() wird beim Programmstart ausgeführt. TCP_Open *in* der Programmschleife, damit z.B. später in der WBStart keine Probleme auftreten, wenn es die bsdsocket.library noch nicht gibt. Daher kann die Funktion mehrfach gestartet werden.

Das die Packete nicht in Sendereihenfolge eintreffen, ist wohl Netzwerk bedingt und ich komme um eine Sortierung nicht rum. Oder sehe ich das falsch?

IMHO können keine Packete verloren gehen, sondern nur auf sich warten lassen. Richtig?

Manchmal passiert es, dass ich einen Neustart des NetStacks machen muß, damit ich ohne Fehler wieder was einhängen kann, also scheint meine Routine nicht ganz optimal zu sein.

Kommentare, Anmerkungen sind willkommen. so ganz blick ich das immer noch nicht.

Geit

C code:

---

/* TCP stuff */

int                tcp_socketclientinfd;
struct sockaddr_in tcp_socketclient;
ULONG              tcp_sizeclient;

int                tcp_socketserverfd;
struct sockaddr_in tcp_socketserver;

int                tcp_socketclientoutfd;
struct sockaddr_in tcp_socketclientout;

BOOL               tcp_pipein;
BOOL               tcp_pipeout;


struct List paketlist;
struct TCPMessage *lasttcpmsg;

#define SERIALBUFFER_SIZEOF 8192

BYTE  serialbuffer[ SERIALBUFFER_SIZEOF ];
ULONG serialindex;


/* TCP Init */

void TCP_Init( void )
{
	List_Init( &paketlist );

	tcp_socketserverfd = -1;
	tcp_socketclientoutfd  = -1;

}

/* TCP Open */

ULONG TCP_Open(void)
{
ULONG arg;

	debug("TCP: setup...n");
	if( !SocketBase ) {
		SocketBase = (struct Library *) OpenLibrary( "bsdsocket.library", 4);
		debug("tried to open bsdsocket.libraryn");
	}
	if( SocketBase ) {

/* init incoming data pipe if needed */

		if( !tcp_pipein ) {
			if( -1 != (tcp_socketserverfd = socket( AF_INET, SOCK_STREAM, 0)) ) {

				/* fill sockaddr_in and bind socket to local port */

				tcp_socketserver.sin_family      = AF_INET;
				tcp_socketserver.sin_port        = htons(VKM_PORT);
				tcp_socketserver.sin_addr.s_addr = htonl(INADDR_ANY);
				//memset(&(tcp_socketserver.sin_zero), '', 8);
				arg = 1;
				if( -1 != IoctlSocket( tcp_socketserverfd, FIONBIO, &arg) ) {
					debug("TCP: in socket non blocking enabledn");
					if( -1 != bind( tcp_socketserverfd, (struct sockaddr *) &tcp_socketserver, sizeof(struct sockaddr) ) ) {
						debug("TCP: in socket bond to portn");
						if( -1 != listen( tcp_socketserverfd, 10) ) {
							debug("TCP: in socket listening to port - ready for actionn");
							tcp_pipein = TRUE;
						}
					}
				}
			}
			if( !tcp_pipein && tcp_socketserverfd != -1 ) { /* shut down pipe due error */
				debug("TCP: Closing in socket due failn");
				CloseSocket( tcp_socketserverfd );
				tcp_socketserverfd = -1;
			}
		}

/* init outgoing data pipe */

		if( !tcp_pipeout && readargs_array[ARG_IP ] ) {
			if( -1 != (tcp_socketclientoutfd = socket(AF_INET, SOCK_STREAM, 0)) ) {
				/* fill sockaddr_in struct for connection */
				tcp_socketclientout.sin_family      = AF_INET;
				tcp_socketclientout.sin_port        = htons( VKM_PORT);
				tcp_socketclientout.sin_addr.s_addr = inet_addr( (STRPTR) readargs_array[ARG_IP ]);
				//memset(&(tcp_socketfddest.sin_zero), '', 8);
				if( -1 != connect( tcp_socketclientoutfd, (struct sockaddr *) &tcp_socketclientout, sizeof(struct sockaddr)) ) {
					debug("TCP: out socket connected - ready for actionn");
					tcp_pipeout = TRUE;
				}
			}
			if( !tcp_pipeout && tcp_socketclientoutfd  != -1 ) { /* shut down pipe due error */
				debug("TCP: Closing in socket due failn");
				CloseSocket( tcp_socketclientoutfd );
				tcp_socketclientoutfd = -1;
			}
		}
	}
	debug("TCP: setup donen");
return( 0 );
}

/* TCP_Close */

void TCP_Close(void)
{
struct TCPMessage *tcpmsg;

/* tcp */

	if( tcp_pipein ) {
		CloseSocket( tcp_socketserverfd );
	}
	if( tcp_pipeout ) {
		CloseSocket( tcp_socketclientoutfd );
	}
	if( SocketBase ) {
		CloseLibrary( (struct Library *) SocketBase );
		SocketBase = NULL;
	}

/* free used memory */

	if( paketlist.lh_Head ) {

		while( (tcpmsg = (APTR) paketlist.lh_Head)->tcp_Node.ln_Succ ) {
			TCP_UnqeuePaket ( tcpmsg );
		}
	}

}

/* TCP_TransferHandle */

void TCP_TransferHandle( void )
{
ULONG num;

	if( tcp_pipeout ) {
		if( (lasttcpmsg = (APTR) paketlist.lh_Head)->tcp_Node.ln_Succ ) {
			num = send( tcp_socketclientoutfd, &lasttcpmsg->tcp_Command, lasttcpmsg->tcp_Command.cmd_Size, 0 );
			if( num != -1 && num != 0 ) {
				TCP_UnqeuePaket( lasttcpmsg ); /* remove packet from packet list */
				debug("TCP: Send %ld Bytesn", num);
			}
		}
	}
	if( tcp_pipein ) {
		if( !tcp_socketclientinfd || tcp_socketclientinfd == -1 ) {
			tcp_socketclientinfd = accept( tcp_socketserverfd, (struct sockaddr *)&tcp_socketclient, &tcp_sizeclient);
			//debug("accept: %ldn",tcp_socketclientinfd );
		}
		if( SERIALBUFFER_SIZEOF - serialindex ) {
			if( -1 != (num = recv( tcp_socketclientinfd, &serialbuffer[ serialindex ], SERIALBUFFER_SIZEOF - serialindex , 0) )) {
#if DEBUG
				if( num ) {
					debug("TCP: got %ld Bytes: %80lhn", num, &serialbuffer[ serialindex ]);
				}
#endif
				serialindex += num;
			}
		}
		//TCP_HandleBuffer(); /* read and proccess packets from cache */
	}
}

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von geit:
Das die Packete nicht in Sendereihenfolge eintreffen, ist wohl Netzwerk bedingt und ich komme um eine Sortierung nicht rum. Oder sehe ich das falsch?

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von geit:
Jedes der Programme verschickt ermittelte Daten/Kommandos an das andere.

Da die Daten allerdings zur Laufzeit ermittelt werden, ergeben sich daraus "Pakete". Jedes Paket wird mit
send() verschickt und daten via recv() empfangen. Wenn ich jetzt 5 mal send mit einem paket anwende, dann kommen auf dem anderen Rechner 5 Pakete an, die aber durcheinander sind.

---

Zitat:

---

Original von Der_Wanderer:
Wenn ich es richig Verstanden habe, sind deine "Packete" bereits in der "Anwender Schicht" (7 Schichten Model), also z.B. eine GIF Bild auf einer Website kommt als ein Packet an (was natürlich in vielen kleine TCP Packets geschickt wird).

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Zitat:

---

Jedes der Programme verschickt ermittelte Daten/Kommandos an das andere.

Da die Daten allerdings zur Laufzeit ermittelt werden, ergeben sich daraus "Pakete". Jedes Paket wird mit
send() verschickt und daten via recv() empfangen. Wenn ich jetzt 5 mal send mit einem paket anwende, dann kommen auf dem anderen Rechner 5 Pakete an, die aber durcheinander sind.

---

Du solltest Dich erst einmal entscheiden, was Du nun wirklich willst, TCP oder Pakete. Es geht nur eins von beiden.

---

Zitat:

---

Wenn Du das geschafft hast, kannst Du Dich auch entscheiden, ob Du die Funktionen für TCP oder für Pakete verwendest.

---

Zitat:

---

Zitat:

---

Wenn ich es richig Verstanden habe, sind deine "Packete" bereits in der "Anwender Schicht".

---

Das hast Du nicht richtig verstanden.

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Aber wenn die Daten auf dem Quellrechner nicht schnell genug kommen, dann kommen hinten am zweiten Rechner mehrere Packete in unterschiedlicher Reihenfolge an. Das kann ich anhand der Daten im Puffer lesen.

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von geit:
Ob ich die empfangenen Dateien wieder in Packete teile ist doch schnuppe. Ich will nur Daten verschicken und am anderen Ende in einem
zusammenhängenden Puffer empfangen. Also wie bei einer seriellen übertragung.

---

Zitat:

---

Zitat:

---

Das hast Du nicht richtig verstanden.

---

Doch hat er. Der serielle Puffer wird von meinem Programm in Pakete zerlegt, die dann IM Rechner als solche behandelt werden.

---

[ - Antworten - Zitieren - Direktlink - ]