okay i got this code (please dont ask what for ):

struct CharDataPacket2
{
	char data[65536]; /* data */
};

struct CharDataPacket3
{
	int16 size; /* data */
};

bool CharHandler(SOCKET sd)
{
	struct CharDataPacket2 p;
	struct CharDataPacket3 d;

	int nTemp5 = 0;
	int nTemp6 = 0;
	int bytesIn33 = 0;

int peer[] = {
0x22, 0x00, 0xb4, 0x1c, 0xad, 0xa2, 0x17, 0xe8, 
0x81, 0xe9, 0x86, 0xf4, 0x7c, 0xf2, 0xaa, 0x55, 
0x3c, 0x75, 0x2e, 0x7d, 0xb8, 0x00, 0x60, 0xa6, 
0xfc, 0xb8, 0xd7, 0xa4, 0x74, 0xaf, 0xf7, 0x94, 
0x2c, 0x76, 0x2a, 0x00, 0xbb, 0x2b, 0x2f, 0x14, 
0x60, 0x9e, 0x76, 0xf7, 0xa0, 0x1f, 0x71, 0xb8, 
0xa3, 0x5c, 0xb5, 0x0b, 0x6c, 0xf2, 0xb9, 0x42, 
0x6d, 0x92, 0x71, 0xe5, 0xb0, 0x0c, 0x6b, 0xbc, 
0xa7, 0x58, 0xb0, 0x21, 0x71, 0xc0, 0x2b, 0x10, 
0x74, 0x86, 0x6e, 0xc6, 0x22, 0x00, 0x32, 0x9b, 
0xad, 0xa3, 0x90, 0x6e, 0x09, 0xfa, 0x95, 0xe4, 
0x05, 0x8c, 0x52, 0xac, 0xcb, 0x51, 0x0c, 0x4f, 
0x96, 0x3f, 0xc9, 0x06, 0x53, 0xc4, 0xab, 0xdb, 
0x65, 0xec, 0x32, 0xcd, 0xa2, 0x1c, 0x2a, 0x00, 
0x1f, 0x8e, 0x2f, 0x0b, 0xc5, 0x3a, 0xdc, 0x5a, 
0x0d, 0xb3, 0xd7, 0x13, 0xb2, 0x4c, 0xab, 0x66, 
0x01, 0x9e, 0xd5, 0x25, 0xb7, 0x69, 0xa7, 0x72, 
0x16, 0x9a, 0xcc, 0x2c, 0x8d, 0x7b, 0x9c, 0x7d, 
0x2c, 0x9d, 0xcb, 0x03, 0xa2, 0x5c, 0xba, 0x61, 
0x22, 0x00, 0x89, 0x20, 0xad, 0xa2, 0x2b, 0xdc, 
0xb9, 0x6c, 0x02, 0x6c, 0x91, 0x18, 0x7c, 0x82, 
0xe6, 0xcd, 0x97, 0xc8, 0x10, 0xb9, 0xf5, 0x3a, 
0x69, 0x4f, 0x20, 0x49, 0xb3, 0x3f, 0x51, 0xaf, 
0xca, 0xc5, 0x22, 0x00, 0x9a, 0x0b, 0x2f, 0x08, 
0x40, 0xbe, 0x5a, 0x57, 0x01, 0xbe, 0x47, 0x8e, 
0xa9, 0x57, 0xb3, 0xa0, 0xc0, 0x48, 0x17, 0xfe, 
0xf1, 0x3e, 0xef, 0xe8, 0x96, 0x28, 0x47, 0xb1, 
0xc7, 0x96, 0xb8, 0x4a, 0x22, 0x00, 0x05, 0xaf, 
0xad, 0xa3, 0xa4, 0x59, 0x3a, 0x1a, 0x74, 0x19, 
0xeb, 0x62, 0x88, 0x75, 0x16, 0x52, 0x0a, 0x50, 
0x8c, 0x25, 0xe7, 0x29, 0x7b, 0x32, 0x5d, 0x31, 
0x10, 0xb5, 0xd2, 0x54, 0xab, 0xb6, 0x22, 0x00, 
0x14, 0x86, 0x2f, 0x0f, 0xcd, 0x30, 0xd2, 0xec, 
0xbf, 0x01, 0x6b, 0xa2, 0x0f, 0xf2, 0x10, 0xbc, 
0xdc, 0x55, 0x08, 0xe1, 0x64, 0xac, 0x67, 0xef, 
0xb8, 0xdc, 0xd6, 0xf3, 0x6c, 0x5c, 0x1c, 0x88, 
0x22, 0x00, 0x9e, 0x34, 0xad, 0xa2, 0x3f, 0xc2, 
0xa3, 0x27, 0x49, 0x23, 0x80, 0x09, 0x79, 0x84, 
0xe5, 0x70, 0x28, 0x75, 0xab, 0x02, 0x5a, 0x90, 
0xc9, 0x51, 0x3e, 0x55, 0xd3, 0xe6, 0x31, 0x94, 
0x45, 0xd5, 0x22, 0x00, 0x89, 0x1b, 0x2f, 0x0c, 
0x50, 0xad, 0x4d, 0xaa, 0xfc, 0x43, 0x5a, 0x91, 
0xa2, 0x5f, 0xbf, 0x42, 0x22, 0xaa, 0xf2, 0x1b, 
0x00, 0xcb, 0x18, 0xf1, 0x8f, 0x31, 0x5e, 0xac, 
0x9f, 0x65, 0x8d, 0x54, 0x22, 0x00, 0x18, 0xb3, 
0xad, 0xa3, 0xb8, 0x44, 0x1b, 0x21, 0x4f, 0x26, 
0x17, 0x9e, 0x68, 0x94, 0xcb, 0xed, 0xb5, 0xeb, 
0x3e, 0x97, 0x49, 0x87, 0xea, 0xd8, 0x9e, 0xf6, 
0x1b, 0xe4, 0xf3, 0x79, 0x2b, 0x10, 0x22, 0x00, 
0x0d, 0x9e, 0x2f, 0x03, 0xd5, 0x29, 0xf7, 0xea, 
0xbc, 0x02, 0x63, 0xaa, 0x13, 0xef, 0x31, 0x3f, 
0x5f, 0xd7, 0x88, 0x61, 0xf0, 0x3d, 0xd7, 0xd4, 
0x83, 0x3c, 0x6a, 0xbd, 0xce, 0x6f, 0x10, 0x90, 
0x1a, 0x00, 0x93, 0x38, 0xad, 0xa2, 0x33, 0xcd, 
0x90, 0xf0, 0x9f, 0xf9, 0x15, 0x9c, 0xe0, 0x1c, 
0x41, 0x36, 0x6e, 0x30, 0xe5, 0x6c, 0x10, 0xc8, 
0xec, 0x50, 0x1a, 0x00, 0x88, 0x1b, 0x2f, 0x00, 
0x50, 0xac, 0x70, 0xcd, 0x9b, 0x24, 0x4a, 0x83, 
0xbc, 0x40, 0x9c, 0xc3, 0xa5, 0x2b, 0x77, 0x89, 
0xb6, 0x4a, 0x7a, 0x51, 0x1a, 0x00, 0xec, 0x47, 
0xad, 0xa3, 0x4c, 0xb0, 0xeb, 0x90, 0xfe, 0x9b, 
0x77, 0xfe, 0xfc, 0x00, 0x5b, 0xdb, 0x85, 0xd0, 
0x0d, 0xb2, 0xb0, 0x4c, 0xc0, 0xb0, 0x22, 0x00, 
0x72, 0xe6, 0x2f, 0x07, 0xad, 0x5f, 0x85, 0x93, 
0xc5, 0x7b, 0x16, 0xdf, 0x1a, 0xe1, 0x3b, 0xd3, 
0xb5, 0x3e, 0x63, 0x9e, 0x7b, 0xa8, 0x40, 0xa5, 
0xf2, 0x4d, 0x39, 0x14, 0x22, 0xa0, 0x51, 0x8d, 
0x1a, 0x00, 0x64, 0xe4, 0xad, 0x8a, 0xef, 0x30, 
0x5e, 0x92, 0xc5, 0x86, 0x43, 0xee, 0x57, 0x9d, 
0xf3, 0x2f, 0x40, 0x56, 0x10, 0x9b, 0x49, 0x22, 
0xb2, 0x16, 0x1a, 0x00, 0xeb, 0x7f, 0x2f, 0x10, 
0x34, 0xe4, 0x0c, 0x31, 0x6e, 0xe6, 0xbd, 0x54, 
0x37, 0xe8, 0x09, 0x3d, 0x46, 0xa9, 0xce, 0xe6, 
0xc9, 0x9e, 0x21, 0xd3, 0x1a, 0x00, 0x78, 0xf2, 
0xed, 0x98, 0x7b, 0x80, 0xd7, 0x91, 0xfe, 0x8a, 
0x67, 0xee, 0xe0, 0x1b, 0x4c, 0x0a, 0x65, 0x11, 
0xeb, 0x9c, 0x63, 0xa6, 0x1e, 0xb0, 0x2a, 0x00, 
0x2a, 0xc5, 0xad, 0xf2, 0xce, 0x32, 0xe5, 0x83, 
0xf2, 0x92, 0x74, 0xf1, 0x2c, 0xc4, 0x1f, 0x78, 
0x3c, 0x5c, 0x84, 0x0d, 0xc5, 0x3f, 0xf0, 0x9e, 
0xe7, 0x41, 0x82, 0xfd, 0x7f, 0x80, 0x45, 0x0c, 
0x7c, 0x1c, 0xf1, 0x78, 0xa9, 0x5e, 0x88, 0xdb, 
0x12, 0x00, 0xbe, 0x10, 0x6f, 0x22, 0xd9, 0x23, 
0x76, 0xe1, 0xf4, 0x58, 0x37, 0xfe, 0x8a, 0x6b, 
0x72, 0xef, 0x2a, 0x00, 0xb8, 0x2a, 0x4f, 0xa4, 
0x1c, 0x2a, 0x7c, 0x83, 0xd7, 0xe2, 0x8d, 0x50, 
0x07, 0xfd, 0x28, 0x96, 0xc2, 0x7d, 0x12, 0xfc, 
0xaa, 0x11, 0xa9, 0x60, 0x34, 0x8b, 0xe0, 0x29, 
0x7e, 0x84, 0x50, 0xef, 0xbb, 0x04, 0x94, 0x5d, 
0x0a, 0xf7, 0x2b, 0x94, 0x2a, 0x00, 0x54, 0xfa, 
0x0b, 0x66, 0xec, 0x1b, 0xcf, 0x13, 0x7b, 0x18, 
0x08, 0xf5, 0xee, 0x14, 0x47, 0xae, 0xc6, 0x9c, 
0x8c, 0x98, 0x7d, 0xa3, 0xc2, 0x1c, 0x43, 0x19, 
0x09, 0xe0, 0xfa, 0x00, 0x53, 0xbb, 0xd3, 0x89, 
0x99, 0x8f, 0x95, 0x6c, 0x51, 0x7f, 0x2a, 0x00, 
0x0e, 0x9f, 0x70, 0xa0, 0x92, 0xd8, 0x86, 0xbc, 
0xe8, 0x6e, 0x01, 0xe7, 0x3c, 0xc5, 0x17, 0x06, 
0x52, 0xed, 0x82, 0x8d, 0xaf, 0x72, 0x92, 0xb4, 
0xd7, 0x68, 0x07, 0xf5, 0x28, 0xd1, 0x03, 0x13, 
0x47, 0xf8, 0x97, 0x9a, 0x47, 0xbd, 0x56, 0x76, 
0x2a, 0x00, 0xff, 0x52, 0x0f, 0x70, 0x40, 0x11, 
0x5c, 0x25, 0x4d, 0x2f, 0x3f, 0xd2, 0x75, 0x8c, 
0xdd, 0xe5, 0x8d, 0xd7, 0xc7, 0xd4, 0x8b, 0x56, 
0x32, 0x32, 0x5a, 0x00, 0x10, 0xfd, 0x5d, 0xa4, 
0xf5, 0xcc, 0xa4, 0xfe, 0x11, 0xfc, 0x5e, 0x90, 
0x0a, 0xf3, 0x2a, 0x00, 0xa7, 0x36, 0x4a, 0xb7, 
0x3b, 0xc4, 0x0d, 0x2c, 0x78, 0xe9, 0x86, 0x74, 
0x11, 0xe8, 0x38, 0x58, 0x0c, 0xa5, 0xca, 0xc6, 
0x5a, 0x87, 0x62, 0x3a, 0x6e, 0xc7, 0xa8, 0x5a, 
0x39, 0xc0, 0x10, 0x71, 0x25, 0x8c, 0x1c, 0xee, 
0x8f, 0x77, 0xcd, 0x9e, 0x0a, 0x00, 0x34, 0xa0, 
0x50, 0xc3, 0xf5, 0x0d, 0x85, 0x06, 0x0a, 0x00, 
0xe5, 0x46, 0x4f, 0xaa, 0xb7, 0x0f, 0xc1, 0x43, 
0x0a, 0x00, 0xdb, 0x42, 0x35, 0x2f, 0x2c, 0xd4, 
0x1c, 0xc1, 0x0a, 0x00, 0xa4, 0x07, 0x8b, 0x0e, 
0xea, 0x12, 0xd3, 0xfc, 0x0a, 0x00, 0x32, 0xab, 
0x43, 0x21, 0xaa, 0x52, 0x45, 0x4c, 0x0a, 0x00, 
0xa4, 0x08, 0x19, 0x57, 0xc2, 0x35, 0x79, 0x91, 
0x0a, 0x00, 0xb2, 0x24, 0x47, 0x12, 0x12, 0xe5, 
0x63, 0x0d, 0x0a, 0x00, 0x3a, 0x96, 0x0a, 0x80, 
0x2b, 0xdc, 0x68, 0x4e, 0x0a, 0x00, 0xbe, 0x28, 
0xcc, 0x96, 0x64, 0x93, 0xa2, 0x8d, 0x12, 0x00, 
0xb8, 0x65, 0xf8, 0x63, 0xae, 0xbc, 0x05, 0xe8, 
0x09, 0xb3, 0xfd, 0xb0, 0xb1, 0x42, 0x8c, 0x7a
};

	d.size=sizeof(peer);
	memcpy(&p.data,&peer,d.size);

	char buf[sizeof(p.data)+2];
	char* buf_ptr= buf; // done so we can mover buf_ptr to were we need to memcpy
	memcpy(buf_ptr,p.data, d.size); // now you have a buf with size, and data in it no padding and ready to send

	nTemp5 = send(sd, (char*)buf, d.size, 0);

	WriteDataStr(hData, "Send Packet 4");

	if (nTemp5 > 0)
	{
	
	char buffer3[60];
	bytesIn33 = recv(sd, buffer3, 20, 0);
	WriteDataStr(hData, "Recv Packet 2 - info");
	return false;
	}

	if (bytesIn33 > 0)
	{

	struct ChattestData1 test2;
	struct CharDataPacket p;
		
	test2.data1=0x577ff00b1e890012;
	test2.data2=0xc93afe864dfd576d;
	test2.data3=0x1c6676aa00129b84;
	test2.data4=0x80b86bde3f62d9c9;
	test2.data5=0x7d3af607;

	p.size=sizeof(test2)+2;
	memcpy(&p.data,&test2,p.size);

	char buf[sizeof(p.size)+sizeof(p.data)];
	char* buf_ptr= buf;
	memcpy(buf_ptr,p.data,p.size);
	nTemp6 = send(sd, (char*)buf, p.size, 0);

	WriteDataStr(hData, "Send Packet 4");

	}
	return true;
}
 

but it never sends that huge packet, it gives me a stack overflow when it hits that. anyone can spot any problems with this ? i want it to send peer. (i know it aint pretty, sorry for that :D )

My rough count has you sticking about 400 kilobytes of data on the stack. This is non-kosher on current operating systems with default link settings. If you want to use that many data structures and buffers of that size, you should allocate them on the heap. Since you seem to be using pure C in your code, try malloc()ing everything bigger than a couple kilobytes. That includes your CharDataPacket2 structures, and most of your buffers. And while you''re at it, since you don''t seem to be modifying the peer array, you might consider making in a static variable.

*.* i just passed out, okay thanks, ill have a look into that.

actually i fixed it alot easier

changed

int peer[] = { ............

to

unsigned char peer[] = { .........

then send it with

send(sd, (char*)&peer, sizeof(peer), 0);

or like that anyways, dont have the sources right here right now, but o well.. it works like this :D

You can also use auto_ptr<> and new to create those large arrays and the large packet structs. Or just declare them static. Or instruct your linker to make the stack larger.