4. Speicher allokieren Problem

Speicher allokieren Problem

  • M

    Nabend zusammen,

    ich hab hier was ganz komisches.

    ich schreib euch erstmal den code:

    req->headerSend		= (char*) malloc( sizeof(char*) * strlen(headerSend));

    req = Instanz von HttpRequest

    So, wenn headerSend nur eine kleine größe hat, dann funktioniert das alles ohne Probleme, wenn ich dort aber einen größeren String übergebe, hat er ein Problem beim reservieren des Speichers und stürzt mit einer unbehandelten Außnahme ab.

    Warum macht er das? *Wein*

    0
  • U

    MSS-Software schrieb:

    So, wenn headerSend nur eine kleine größe hat, dann funktioniert das alles ohne Probleme, wenn ich dort aber einen größeren String übergebe, hat er ein Problem beim reservieren des Speichers und stürzt mit einer unbehandelten Außnahme ab.

    wie gross wird denn das sizeof(char) * strlen(headerSend)?
    und wieso multiplizierst du mit sizeof(char    )? brauchst du soviele char*, oder meinst du eher einzelne zeichen?
    btw: den type-cast vor 'malloc' kannst du weglassen.
    🙂

    0
  • M

    hi

    es ist eine größe von: 20244

    den typecast kann ich leider nicht weglassen, weil ich im VS arbeite 😉

    0
  • U

    MSS-Software schrieb:

    es ist eine größe von: 20244

    sollte auf PC's eigentlich problemlos gehen. der wurm ist wohl wo anders drin. lass es mal im debugger laufen (der von VS ist spitze).

    MSS-Software schrieb:

    den typecast kann ich leider nicht weglassen, weil ich im VS arbeite 😉

    doch, du musste deine source-files einfach von xxx.cpp in xxx.c umbenennen und - schwupps - versteht VS richtigen C code.
    🙂

    0
  • M

    hi

    genau das hab ich ja schon gemacht. dadurch weiß ich ja, dass dort das Problem ist.

    Genauere Informationen bekomme ich leider nicht. Ich kann nur noch den Dissasembly anzeigen lassen.

    Aber das bringt mich ja nicht weiter

    0
  • G

    zeig mal den code drumherum.

    0
  • M

    hier ist jetzt die komplette methode

    Zeile 123 ist die "Problemzeile"

    int Request::SendHTTP(LPCSTR url,LPCSTR headerReceive,BYTE *post,
        DWORD postLength,HTTPRequest *req)
{
    WSADATA			WsaData;
    SOCKADDR_IN		sin;
    SOCKET			sock;
    char			buffer[512];
    char			protocol[20],host[256],request[1024];
    int				l,port,chars,err;
    MemBuffer		headersBuffer,messageBuffer;
	char			headerSend[1024];
    BOOL			done;

    ParseURL(url,protocol,sizeof(protocol),host,sizeof(host),		// Parse the URL
        request,sizeof(request),&port);
    if(strcmp(protocol,"HTTP"))
        return 1;

    err = WSAStartup (0x0101, &WsaData);							// Init Winsock
    if(err!=0)
        return 1;

    sock = socket (AF_INET, SOCK_STREAM, 0);
    //if (socket == INVALID_SOCKET)
	if (sock == INVALID_SOCKET)
        return 1;

    sin.sin_family = AF_INET;										//Connect to web sever
    sin.sin_port = htons( (unsigned short)port );
    sin.sin_addr.s_addr = GetHostAddress(host);

    if( connect (sock,(LPSOCKADDR)&sin, sizeof(SOCKADDR_IN) ) )
	{

        return 1;
	}

	//printf("\r\n\r\n <<SEND   HTTP   REQUEST  : >> \r\n\r\n");		 //Send request

    if( !*request )
        lstrcpyn(request,"/",sizeof(request));

    if( post == NULL )
	{
        SendString(sock,"GET ");
		strcpy(headerSend, "GET ");
	}
    else 
	{
		SendString(sock,"POST ");
		strcpy(headerSend, "POST ");
	}
    SendString(sock,request);
		strcat(headerSend, request);

    SendString(sock," HTTP/1.0\r\n");
		strcat(headerSend, " HTTP/1.0\r\n");

    SendString(sock,"Accept: image/gif, image/x-xbitmap,"
        " image/jpeg, image/pjpeg, application/vnd.ms-excel,"
        " application/msword, application/vnd.ms-powerpoint,"
        " */*\r\n");
		strcat(headerSend, "Accept: image/gif, image/x-xbitmap,"
        " image/jpeg, image/pjpeg, application/vnd.ms-excel,"
        " application/msword, application/vnd.ms-powerpoint,"
        " */*\r\n");

    SendString(sock,"Accept-Language: en-us\r\n");
		strcat(headerSend, "Accept-Language: en-us\r\n");

    SendString(sock,"Accept-Encoding: gzip, deflate\r\n");
		strcat(headerSend, "Accept-Encoding: gzip, deflate\r\n");

    SendString(sock,"User-Agent: Mozilla/4.0\r\n");
		strcat(headerSend, "User-Agent: Mozilla/4.0\r\n");

    if(postLength)
    {
        wsprintf(buffer,"Content-Length: %ld\r\n",postLength);
        SendString(sock,buffer);
		strcat(headerSend, buffer);
    }
	//SendString(sock,"Cookie: mycookie=blablabla\r\n");
	//	printf("Cookie: mycookie=blablabla\r\n");
    SendString(sock,"Host: ");
		strcat(headerSend, "Host: ");

    SendString(sock,host);
		strcat(headerSend, host);

    SendString(sock,"\r\n");
		strcat(headerSend, "\r\n");

    if( (headerReceive!=NULL) && *headerReceive )
	{
        SendString(sock,headerReceive);
		strcat(headerSend, headerReceive);
	}

    SendString(sock,"\r\n");								// Send a blank line to signal end of HTTP headerReceive
		strcat(headerSend, "\r\n");

    if( (post!=NULL) && postLength )
	{
        send(sock,(const char*)post,postLength,0);
		post[postLength]	= '\0';

		strcat(headerSend, (const char*)post);
	}
    //hier
	//strcpy(req->headerSend, headerSend);

	ULONGLONG ausgabe = sizeof(char*) * strlen(headerSend);

	req->headerSend		= (char*) malloc( sizeof(char*) * strlen(headerSend));

	strcpy(req->headerSend, (char*) headerSend );
//	req->headerSend		= (char*)* headerSend ;

//	free(req->headerSend);

    // Read the result
	//printf("\r\n\r\n <<RECEIVE   HTTP   REQUEST  : >> \r\n\r\n\r\n");	// First read HTTP headerReceive

    MemBufferCreate(&headersBuffer );
    chars = 0;
    done = FALSE;

    while(!done)
    {
        l = recv(sock,buffer,1,0);
        if(l<0)
            done=TRUE;

        switch(*buffer)
        {
            case '\r':
                break;
            case '\n':
                if(chars==0)
                    done = TRUE;
                chars=0;
                break;
            default:
                chars++;
                break;
        }

        MemBufferAddByte(&headersBuffer,*buffer);
    }

    req->headerReceive	= (char*) headersBuffer.buffer;
    *(headersBuffer.position) = 0;

    MemBufferCreate(&messageBuffer);							// Now read the HTTP body

    do
    {
        l = recv(sock,buffer,sizeof(buffer)-1,0);
        if(l<0)
            break;
        *(buffer+l)=0;
        MemBufferAddBuffer(&messageBuffer, (unsigned char*)&buffer, l);
    } while(l>0);
    *messageBuffer.position = 0;
    req->message = (char*) messageBuffer.buffer;
    req->messageLength = (messageBuffer.position - messageBuffer.buffer);

    closesocket(sock);											// Cleanup

    return 0;
}
    0
  • G

    das problem ist wohl eher die zeile 11. da legst du ein statisches array für 1024 zeichen an und belegst es hinter deutlich über seine grenzen hinweg, nämlich mit 20224 zeichen. mich wundert ehrlich gesagt eher, dass der code nicht viel früher krachen geht. könnte aber daran liegen, dass du vorher nicht an den stackgrenzen angekommen bist.

    edit nachtrag: ich dachte undertaker hätte es schon erklärt. das:

    ULONGLONG ausgabe = sizeof(char*) * strlen(headerSend); 

     req->headerSend = (char*) malloc( sizeof(char*)*strlen(headerSend));

    ist mit ziemlicher sicherheit nicht das, was du willst. so sähe es richtig aus:

    ULONGLONG ausgabe = sizeof(char) * (strlen(headerSend)+1); //strlen liefert die länge ohne \0 
                   //und du willst keine menge von zeigern auf char sondern von char

     req->headerSend        = (char*) malloc( sizeof(char)*(strlen(headerSend)+1));
    0
  • M

    ja sicher

    sicher, das kann ja dann auch nur knallen

    stimmt, da hab ich gar net mehr dran gedacht.

    gut, dann kann ich ja sicherlich die sache mit dem array dynamisch machen gell?

    0
  • U

    ghorst schrieb:

    so sähe es richtig aus:

    ULONGLONG ausgabe = sizeof(char) * (strlen(headerSend)+1); //strlen liefert die länge ohne \0 
                   //und du willst keine menge von zeigern auf char sondern von char
 
     req->headerSend        = (char*) malloc( sizeof(char)*(strlen(headerSend)+1));

    und noch die sizeof(char)'s weg machen, denn malnehmen mit 1 bringt selten was 😉

    0
Anmelden zum Antworten