Problem mit CAsyncSocket

hi,
wie der Titel schon sagt, hab ich ein kleines (oder auch großes) Problem mit einem Netzwerk porg und CAsyncSocket.
Das Prog soll nur beliebige Daten vom Client zum Server schicken. Eigentlich geht auch alles, aber wenn man x Daten gesendet (bzw. empfangen) hat, kommt nix mehr an.. d.h. die OnReceive Funktion beim Server wird nicht mehr aufgerufen.
Der Client gibt immer die gesendeten Bytes zurück (also keine Fehlermeldung)

Auffällig ist:
Wenn ich die Länge der Daten vorher festlege, also z.b. immer 255 bytes sende und beim Server immer 255 bytes abrufe, funzt es. Wenn ich jedoch erst die größe Sende, dann die Daten selber und beim Server erst die Größe abrufe und dann die Daten selber, geht es irgendwann nicht mehr.
Wann genau ist immer unterschiedlich, mal schon nach 200 bytes, mal nach 2000..

Bsp:
in der Send Funktion:

char text[255];
int length;

strcpy(text,"das ist ein Testtext!");
length = strlen(text);

csock->Send(&length,4);
csock->Send(text,&length);

und bei OnReceive:

static void* buff;
static int received;
static int datasize = 0;
static int peekbuff;

if (!datasize)
{
    if (Receive(peekbuff,4,MSG_PEEK)<4) return;
    else
    {
        Receive(&datasize,4);
        return;
    }
}
else
{
    buff = malloc(datasize);

    if (Receive(buff,datasize,MSG_PEEK)<datasize) return;
    else
    {
        received = Receive(buff,datasize);
    }
}

wie gesagt.. eigentlich gehts, nur irgendwann kommen keine daten mehr an..
danke schonmal, fürs lesen

gruß, Thrawn

sorry, hab in meinem beispiel was vergessen, hab dadurch aber den fehler gefunden (auch wenn ich trotzdem nicht versteh warums nicht geht )
falls mal wieder jemand das selbe problem hat, hier meine erkenntnisse

folgendes geht:

//Send Funktion:
char buff[255];
int length;

strcpy(buff,"das ist ein Testtext!");
length = strlen(buff);
int command = 1;

BYTE* b = (BYTE*) malloc(8);

memcpy(b,&length,4);
memcpy(b+4,&command,4);

csock->Send(b,8);
csock->Send(buff,length);

//OnReceive Funktion:
static void* buff;
static int datasize = 0;
static int command = 0;
static BYTE b[8];

if (!datasize)
{
    if (Receive(b,8,MSG_PEEK)<8) return;
    else
    {
        Receive(b,8);
        memcpy(&datasize,b,4);
        memcpy(&command,b+4,4);*/
        return;
    }
}
else
{
    buff = malloc(datasize);

    if (Receive(buff,datasize,MSG_PEEK)<datasize) return;
    else
    {
        Receive(buff,datasize);
    }
}

switch (command)
{   
case 1:
    .....
    .....
    break;
}

datasize = 0;
command = 0;
free(buff);

und folgendes bringt mir den oben beschriebenen Fehler:

//Send Funktion:
char buff[255];
int length;

strcpy(buff,"das ist ein Testtext!");
length = strlen(buff);
int command = 1;

BYTE* b = (BYTE*) malloc(8);

memcpy(b,&length,4);
memcpy(b+4,&command,4);

csock->Send(b,8);
csock->Send(buff,length);

//OnReceive Funktion:
static void* buff;
static int datasize = 0;
static int command = 0;
static BYTE b[8];

if (!datasize)
{
    if (Receive(b,8,MSG_PEEK)<8) return;
    else
    {
        Receive(&datasize,4);   //
        Receive(&command,4);    // hier liegt der einzige unterschied...
        return;         //
    }
}
else
{
    buff = malloc(datasize);

    if (Receive(buff,datasize,MSG_PEEK)<datasize) return;
    else
    {
        Receive(buff,datasize);
    }
}

switch (command)
{   
case 1:
    .....
    .....
    break;
}

datasize = 0;
command = 0;
free(buff);

tjo.. also der einzige unterschied ist, das ich bei der 2. variante einmal 8 bytes sende, aber zweimal 4 bytes abrufe.. weis zwar nu wie ichs machen kann dasses geht, wär aber trotzdem dankbar wenn mir jemand sagen kann warums bei der 2. variante nicht geht

gruß, Thrawn