Message-ID:	<3A69FEFF.7020104@operamail.com>
From:	Sahab Yazdani <sahaby AT operamail DOT com>
Organization:	PheonixSoft Interactive
User-Agent:	Mozilla/5.0 (Windows; U; Win98; en-US; m18) Gecko/20010107
X-Accept-Language:	en
MIME-Version:	1.0
Newsgroups:	comp.os.msdos.djgpp
Subject:	libsocket over the net...
Lines:	364
Date:	Sat, 20 Jan 2001 16:11:27 -0500
NNTP-Posting-Host:	149.99.117.26
X-Complaints-To:	abuse AT sprint DOT ca
X-Trace:	newscontent-01.sprint.ca 980025367 149.99.117.26 (Sat, 20 Jan 2001 16:16:07 EST)
NNTP-Posting-Date:	Sat, 20 Jan 2001 16:16:07 EST
To:	djgpp AT delorie DOT com
DJ-Gateway:	from newsgroup comp.os.msdos.djgpp
Reply-To:	djgpp AT delorie DOT com

This is a multi-part message in MIME format.
--------------090007030306020405000808
Content-Type: text/plain; charset=us-ascii; format=flowed
Content-Transfer-Encoding: 7bit

hello again,
i am attempting to test my application (which uses libsocket) for over 
the net usage.  It doesn't work.  It accepts the connection from the 
client, but then whatever packets I send get garbled up (do I have to 
make everything in packet structures network edian??)  I am completely 
lost and dont have a clue what to do..  I have included the source code 
for the actual transmission and receive of packets with this message in 
the hope that somebody on this newsgroup might be able to help me out...


-- 
***********************************************************
* Sahab Yazdani * "Wizard's Third Rule: Passion rules     *
* Thornhill S.S * Reason." - Kolo's Journal               *
***********************************************************
* http://pheonixsoft.virtualave.net/                      *
***********************************************************

--------------090007030306020405000808
Content-Type: text/plain;
 name="packet.cc"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
 filename="packet.cc"

// Tank Massacre V2.1
// Module: Network Code Helper (Packet Sender/Receiver)
// By: Sahab Yazdani

#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <lsck/lsck.h>
#include <sys/socket.h>

#include "packet.h"

//#define DEBUG

MassacreHeader CreateHeader( unsigned char packetType, unsigned char multiples ) {
	MassacreHeader retType;

	strcpy(retType.header, "MASS.NET\0" );
	retType.packetType = packetType;
	retType.multiples = multiples;

	return retType;
}

MassacreBriefingRoomPacket CreateBriefingRoomPacket( char update, unsigned char player, unsigned char type, char name[] ) {
	MassacreBriefingRoomPacket retType;

	retType.update = update;
	retType.player = player;
	retType.type = type;
	strcpy( retType.name, name );

	return retType;
}

MassacreChatPacket CreateChatPacket( char message[] ) {
	MassacreChatPacket retType;

	strcpy( retType.message, message );

	return retType;
}

bool SendHeader( int sock, unsigned char packetType, unsigned char multiples = 1 ) {
	MassacreHeader header;

	strcpy( header.header, "MASS.NET\0" );
	header.packetType = packetType;
	header.multiples = multiples;

	if ( send( sock, (void *) &header, sizeof( MassacreHeader ), 0 )!=sizeof( MassacreHeader ) )
		return false;
	else
		return true;
}

MassacreHeader ReceiveHeader( int sock ) {
	unsigned char *tempBuffer = new unsigned char[sizeof( MassacreHeader )];
	MassacreHeader header;
	int len=0, len1=0, smH;
	bool err=false;
	
	smH = sizeof( MassacreHeader );
	while ( len = recv( sock, ( void * ) tempBuffer, smH, MSG_WAITALL ) ) {
		if ( len == - 1 ) {
			err = true;
			break;
		}
		while ( len < smH ) {
			printf( "len: %i, smH: %i, neccessary: %i\n", len, smH, smH - len );
			len1 = recv( sock, ( void * ) &tempBuffer[len], smH - len, 0 );
			if ( len1 == -1 ) {
			    lsck_perror("ERROR");
				err=true;
				break;
			}
			len += len1;
		}
	}

	memcpy( (void *) &header, (void *) tempBuffer, smH );	
	
	if (!err) {
		printf( "HEADER: %s PACKETTYPE: %i MULTIPLES: %i\n", header.header, header.packetType, header.multiples );
		if ( strstr( header.header, "MASS.NET" )==NULL )
			header.packetType = PACKETSTYLE_ERROR;
	} else {
		header.packetType=PACKETSTYLE_ERROR;
		header.multiples = errno;
	}

	delete tempBuffer;
	
	return header;
}

int BroadcastHeader( int socks[], int sockets, int retSocket, MassacreHeader mH ) {
	int sC;
	int retVal=0;
	
	for ( sC=0;sC<sockets;sC++ ) {
#ifndef DEBUG
		if ( sC!=retSocket ) {
#endif
			if ( SendHeader( socks[sC], mH.packetType, mH.multiples ) ) {
				ReceiveFoo( socks[sC] );				
				retVal++;
			}
#ifndef DEBUG
		}
#endif
	}

	return retVal;
}

bool SendChatPacket( int sock, char message[] ) {
	MassacreChatPacket mCP;

	memset( &mCP, 0, sizeof( MassacreChatPacket ) );
	strcpy( mCP.message, message );
	if ( send( sock, (void *) &mCP, sizeof( MassacreChatPacket ), 0 )!=sizeof( MassacreChatPacket ) )
		return false;
	else
		return true;
}

MassacreChatPacket ReceiveChatPacket( int sock ) {
	unsigned char *tempBuffer = new unsigned char[sizeof( MassacreChatPacket )];
	MassacreChatPacket header;
	int len=0, len1=0, smH;
	bool err=false;
	
	smH = sizeof( MassacreChatPacket );
	while ( len = recv( sock, ( void * ) tempBuffer, smH, 0 ) ) {
		if ( len == - 1 ) {
			err=true;
			break;
		}
		while ( len < smH ) {
			len1 = recv( sock, ( void * ) &tempBuffer[len], smH - len, 0 );
			if ( len1 == -1 ) {
				err=true;
				break;
			}
			len += len1;
		}
	}

	memcpy( (void *) &header, (void *) tempBuffer, smH );
	if ( err )
		strcpy( header.message, "ERROR" );

	return header;
}

int BroadcastChatPacket( int socks[], int sockets, int retSocket, char message[], bool receiveResponse ) {
	int sC;
	int retVal=0;
	
	for ( sC=0;sC<sockets;sC++ ) {
#ifndef DEBUG
		if ( sC!=retSocket ) {
#endif DEBUG
			if ( SendChatPacket( socks[sC], message ) ) {
				if ( receiveResponse ) {
					MassacreHeader mH;
					
					mH = ReceiveHeader( socks[sC] );
 					if ( mH.packetType!=PACKETSTYLE_ERROR ) retVal++;
				} else
					retVal++;
			}
#ifndef DEBUG
		}
#endif
	}

	return retVal;
}

bool SendBriefingRoomPacket( int sock, unsigned char number, unsigned char type, char name[], char update ) {
	MassacreBriefingRoomPacket mBRP;

	mBRP.player = number;
	mBRP.type = type;
	mBRP.update = update;
	strcpy( mBRP.name, name );

	if ( send( sock, (void *) &mBRP, sizeof( MassacreBriefingRoomPacket ), 0 )!=sizeof( MassacreBriefingRoomPacket ) )
		return false;
	else
		return true;
}

MassacreBriefingRoomPacket ReceiveBriefingRoomPacket( int sock ) {
	unsigned char *tempBuffer = new unsigned char[sizeof( MassacreBriefingRoomPacket )];
	MassacreBriefingRoomPacket header;
	int len=0, len1=0, smH;
	bool err=false;
	
	smH = sizeof( MassacreBriefingRoomPacket );
	while ( len = recv( sock, ( void * ) tempBuffer, smH, 0 ) ) {
		if ( len == - 1 ) {
			err=true;
			break;
		}
		while ( len < smH ) {
			len1 = recv( sock, ( void * ) &tempBuffer[len], smH - len, 0 );
			if ( len1 == -1 ) {
				err=true;
				break;
			}
			len += len1;
		}
	}

	memcpy( (void *) &header, (void *) tempBuffer, smH );
	if (err)
		strcpy( header.name, "ERROR" );
		
	return header;
}

int BroadcastBriefingRoomPacket( int socks[], int sockets, int retSocket, MassacreBriefingRoomPacket mBRP, bool receiveResponse ) {
	int sC;
	int retVal=0;
	
	for ( sC=0;sC<sockets;sC++ ) {
#ifndef DEBUG
		if ( sC!=retSocket ) {
#endif
			if ( SendBriefingRoomPacket( socks[sC], mBRP.player, mBRP.type, mBRP.name, mBRP.update ) ) {
				if ( receiveResponse ) {
					MassacreHeader mH;
					
					mH = ReceiveHeader( socks[sC] );
 					if ( mH.packetType!=PACKETSTYLE_ERROR ) retVal++;
				} else
					retVal++;
			}
#ifndef DEBUG
		}
#endif
	}

	return retVal;
}

void SendFoo( int sock ) {
	char a = 0;

	send( sock, (void *) &a, sizeof( char ), 0 );
}

void ReceiveFoo( int sock ) {
	char a;

	recv( sock, (void *) &a, sizeof( char ), 0 );
}

--------------090007030306020405000808
Content-Type: text/plain;
 name="packet.h"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
 filename="packet.h"

#ifndef PACKET_H
#define PACKET_H

#define PACKETSTYLE_NODATA									0
#define PACKETSTYLE_ERROR									255
#define PACKETSTYLE_ACKNOWLEDGE							254
#define PACKETSTYLE_CONNECT								253
#define PACKETSTYLE_DISCONNECT							252
#define PACKETSTYLE_SERVERDISCONNECT					251
#define PACKETSTYLE_BRIEFINGROOM_DATA					1
#define PACKETSTYLE_BRIEFINGROOM_CHAT					2
#define PACKETSTYLE_BRIEFINGROOM_PROCEED				3

#define PORT								3940
#define BACKLOG							9

#define SENTIENT							0
#define COMPUTER							1

struct MassacreHeader {
	char header[10]						__attribute__ ((packed)); // 'MASS.NET'
	unsigned char packetType			__attribute__ ((packed));
	unsigned char multiples				__attribute__ ((packed));
};

struct MassacreBriefingRoomPacket {
	char update								__attribute__ ((packed));
	unsigned char player					__attribute__ ((packed));
	unsigned char type					__attribute__ ((packed));
	char name[40]							__attribute__ ((packed));
};

struct MassacreChatPacket {
	char message[235]						__attribute__ ((packed));
};

MassacreHeader					CreateHeader( unsigned char packetType, unsigned char multiples );
MassacreBriefingRoomPacket CreateBriefingRoomPacket( char update, unsigned char player, unsigned char type, char name[] );
MassacreChatPacket			CreateChatPacket( char message[] );

// Server/Client
bool SendHeader( int sock, unsigned char packetType, unsigned char multiples = 1 );
MassacreHeader ReceiveHeader( int sock );
// Server Only
int BroadcastHeader( int socks[], int sockets, int retSocket, MassacreHeader mH );

// Server/Client
bool SendChatPacket( int sock, char message[] );
MassacreChatPacket ReceiveChatPacket( int sock );
// Server Only
int BroadcastChatPacket( int socks[], int sockets, int retSocket, char message[], bool receiveResponse=false );

// Server/Client
bool SendBriefingRoomPacket( int sock, unsigned char number, unsigned char type, char name[], char update );
MassacreBriefingRoomPacket ReceiveBriefingRoomPacket( int sock );
// Server Only
int BroadcastBriefingRoomPacket( int socks[], int sockets, int retSocket, MassacreBriefingRoomPacket mBRP, bool receiveResponse=false );

// Retardo
void SendFoo( int sock );
void ReceiveFoo( int sock );

#endif

--------------090007030306020405000808--

- Raw text -