Mail Archives: djgpp/2001/01/21/00:27:49
This is a multi-part message in MIME format.
--------------020309040203060107010000
Content-Type: text/plain; charset=us-ascii; format=flowed
Content-Transfer-Encoding: 7bit
Richard Dawe wrote:
[snipped my own comments]
>
> How are they garbled? Are the data in the wrong order? Do you get any of
> the sent data when you do recv()?
ok, i've been messing around with it a bit and have made a great deal of
headway... i have gotten it to transmit a "MassacreHeader" structure
over the network everytime perfectly. The problem now comes when I try
to transmit the other two structure types: "MassacreChatPacket" and
"MassacreBriefingRoomPacket".
It doesn't seem to be getting any of the right data.. for instance when
run the application, the proper numbers should be:
mBRP.type = 0;
mBRP.player = 2;
mBRP.name = [A VALID ENGLSH NAME];
except we are getting...
mBRP.type = 10;
mBRP.player = 252;
mBRP.name = "ERROR";
I believe that this is because the packets are not getting there
completely, and that my method just trucates it and then the error
checking routines convert the data into error values (which is only the
*name* field, the type and player field are garbled by the routines).
as a side note, when I print out the error using either lsck_perror or
perror, i get this message "RETRIEVE1: Resource temporarily not
available (EAGAIN)" over and over again with a stray "RETREIVE2: " " " "
popping in there sometimes (only when data is being sent over the network).
>
>
[snip]
> I have some comments below:
>
> You don't need to use a nul character to terminate a string in "".
> "MASS.NET" is a nul-terminated string. 'MASS.NET' is not nul-terminated
> (notice the single quotes).
you learn something new everyday, thanks!
>
> [snip]
>
>> if ( send( sock, (void *) &header, sizeof( MassacreHeader ), 0 )!=sizeof( MassacreHeader ) )
>
>
> I recommend that you always store the send() return code. It makes
> debugging and recovery from error easier. E.g.:
>
> ...
> ret = send(...);
> if (ret < 0)
> perror("uh-oh");
> ...
thank you, i have changed it... but obviously it doesn't make a
difference for the current problem.
>
> [snip]
>
as the code has changed a bit since the last time, i have again included
the souce code for the packet transmitting routines again.
thank you for any help you may provide.
--
***********************************************************
* Sahab Yazdani * "Wizard's Third Rule: Passion rules *
* Thornhill S.S * Reason." - Kolo's Journal *
***********************************************************
* http://pheonixsoft.virtualave.net/ *
***********************************************************
--------------020309040203060107010000
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 <sys/socket.h>
#include "packet.h"
//#define DEBUG
MassacreHeader CreateHeader( unsigned char packetType, unsigned char multiples ) {
MassacreHeader retType;
strcpy(retType.header, "MASS" );
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;
ssize_t ret;
strcpy( header.header, "MASS" );
header.packetType = packetType;
header.multiples = multiples;
ret = send( sock, (void *) &header, sizeof( MassacreHeader ), 0 );
if ( ret!=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 );
memset( (void *) tempBuffer, 0, smH );
len = recv( sock, ( void *) tempBuffer, smH, 0 );
if ( len == 0 )
err = true;
else {
// printf( "len: %i\n", len );
if ( len == -1 ) {
if ( errno!=EAGAIN ) {
perror( "RETRIEVE1" );
err=true;
}
} else {
while ( len < smH ) {
len1 = recv( sock, ( void * ) &tempBuffer[len], smH - len, 0 );
if ( len1 == -1 ) {
if ( errno!=EAGAIN ) {
perror( "RETRIEVE2" );
err=true;
}
break;
}
len += len1;
}
}
}
if (!err) {
memcpy( (void *) &header, (void *) tempBuffer, smH );
if ( strstr( header.header, "MASS" )==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;
ssize_t ret;
memset( &mCP, 0, sizeof( MassacreChatPacket ) );
strcpy( mCP.message, message );
ret = send( sock, (void *) &mCP, sizeof( MassacreChatPacket ), 0 );
if ( ret!=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 );
memset( (void *) tempBuffer, 0, smH );
len = recv( sock, ( void *) tempBuffer, smH, 0 );
if ( len == 0 )
err = true;
else {
// printf( "len: %i\n", len );
if ( len == -1 ) {
if (errno!=EAGAIN){
perror( "RETRIEVE1" );
err=true;
}
} else {
while ( len < smH ) {
len1 = recv( sock, ( void * ) &tempBuffer[len], smH - len, 0 );
if ( len1 == -1 ) {
if ( errno!=EAGAIN) {
perror( "RETRIEVE2" );
err=true;
}
break;
}
len += len1;
}
}
}
memcpy( (void *) &header, (void *) tempBuffer, smH );
if (!err) {
} else {
strcpy( header.message, "ERROR" );
}
delete tempBuffer;
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;
ssize_t ret;
mBRP.player = number;
mBRP.type = type;
mBRP.update = update;
strcpy( mBRP.name, name );
ret = send( sock, (void *) &mBRP, sizeof( MassacreBriefingRoomPacket ), 0 );
if ( ret!=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 );
memset( (void *) tempBuffer, 0, smH );
len = recv( sock, ( void *) tempBuffer, smH, 0 );
if ( len == 0 )
err = true;
else {
// printf( "len: %i\n", len );
if ( len == -1 ) {
if ( errno==EAGAIN ) {
perror( "RETRIEVE1" );
err=true;
}
} else {
while ( len < smH ) {
len1 = recv( sock, ( void * ) &tempBuffer[len], smH - len, 0 );
if ( len1 == -1 ) {
if ( errno==EAGAIN ) {
perror( "RETRIEVE2" );
err=true;
}
break;
}
len += len1;
}
}
}
memcpy( (void *) &header, (void *) tempBuffer, smH );
if (err)
strcpy( header.name, "ERROR" );
delete tempBuffer;
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 );
}
--------------020309040203060107010000
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[4] __attribute__ ((packed)); // 'MASS'
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[26] __attribute__ ((packed));
};
struct MassacreChatPacket {
char message[54] __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
--------------020309040203060107010000--
- Raw text -