[C++] Request lezen lukt niet

[SPee]

Ik probeer een HTML server te maken. Maar nu lukt het lezen van een request van een client niet.
Ik kan een verbinding maken, maar als ik een GET aanvraag doe, dan komt hij niet verder.

code:

void Client(){

getpeername( cs, (struct sockaddr *)&c_address, (socklen_t*)&size_csa);
printf("Een verbinding is gemaakt met %s.\n",inet_ntoa(*((struct in_addr *)&c_address.sin_addr )));

int status=0;
struct timeval waarde= {50, 0};
char buffer[BUFLEN];

fd_set lezen;
FD_ZERO( &lezen );
FD_SET( cs, &lezen  );

status = select( cs+1, &lezen , NULL, NULL, &waarde);

if( FD_ISSET( cs, &lezen) ){
    printf("lees de socket\n");
    //input van de socket hier komt hij...
     status = recv( cs, buffer, BUFLEN, 0 ); //hier gaat het fout
                 //hier komt hij niet. 
     printf("komt hij hier?");
     sscanf(buffer, "%s %s %s", cmd, path, vers);
     printf("cmd: %s path: %s", cmd, path);

    while( (status = recv(cs, buffer, BUFLEN, 0)) >0){
          if( status ==2 && buffer[0] == '\r' && buffer[1] =='\n')
               break;
    }

    if( strcmp( cmd, "GET" )==0 ){
            printf("het is een GET aanvraag");
                       GETrequest();
     }else{.....}

Hij blijft steeds hangen op de status=recv(.,.,.,.); Wat doe ik hier fout? Ik heb het bijna net zoals in een voorbeeld die ik heb gevonden?
[edit]
code even aangepast zoals hij is, icm onder. (geen grote aanpassing)

[ Voor 12% gewijzigd door SPee op 08-04-2003 20:58 ]

[.oisyn]

gebruik je blocking sockets? Zo ja, dan is het logisch, want je leest BUFLEN bytes. En dus wacht ie fijn tot de server jouw BUFLEN bytes heeft gestuurd.

Je kunt het beste eerst even kijken hoeveel bytes er beschikbaar zijn (met ioctlsocket ()), en dan vervolgens zoveel bytes inlezen. Maar dan moet je er wel rekening houden dat misschien nog niet alle data verstuurd is

[madwizard]

.oisyn::
gebruik je blocking sockets? Zo ja, dan is het logisch, want je leest BUFLEN bytes. En dus wacht ie fijn tot de server jouw BUFLEN bytes heeft gestuurd.

Dat gebeurt bij send maar niet bij recv hoor. Die ontvangt gewoon zoveel als op dat moment beschikbaar is:

For connection-oriented sockets (type SOCK_STREAM for example), calling recv will return as much information as is currently available—up to the size of the buffer specified.

Bovendien is sscanf aanroepen op een buffer die mogelijk niet null terminated is niet echt veilig. Zorg er in ieder geval voor dat er een 0 aan het eind staat door de recv parameter op BUFLEN-1 zetten en bij een succesvolle recv buffer[returnval] = 0 te doen Dan kan er ook nog in de ontvangen data een 0 zitten maar iig crasht ie daar niet op.

edit:
Ook mag je er niet vanuit gaan dat de eerste recv toevallig de hele eerste request regel inleest. Het kan best zijn dat je alleen "GET /file" ontvangt of alleen "GE" of meteen 20 request regels, je zal de hele handel moeten bufferen en per regel verwerken.

[ Voor 18% gewijzigd door madwizard op 08-04-2003 19:15 ]

[curry684]

Ik kan geen fouten ontdekken. Kun je wellicht even doorposten hoe je de serversocket zelf aanmaakt, inclusief alle setsockopts etc.?

[SPee]

Hier is de code van het begin. Het eerste stuk was van Client().

code:

#define PORT    7312
#define BUFLEN  1024

void Client();
void SendHeader(int code, int length, string type);
void GETrequest();
void POSTrequest();
void UNKNOWNrequest();
std::string FileType( char *File );

char request[BUFLEN];
char file[BUFLEN], *m;
char cmd[16], path[64], vers[16];
int ss;
int cs;
int bestand;
struct sockaddr_in c_address;
int size_csa;

//---------------------------------------------------------------------------

int main(int argc, char* argv[]){

        struct sockaddr_in s_address;

        memset(&s_address, 0, sizeof(s_address));
        s_address.sin_family = AF_INET;
        s_address.sin_port = htons(PORT);
        s_address.sin_addr.s_addr = INADDR_ANY;
        bzero(&(s_address.sin_zero), 8);

        ss = socket(AF_INET, SOCK_STREAM, 0);

        if(ss<0){ perror("socket: allocation failed."); exit(1); }

        int sa = bind(ss, (struct sockaddr *)&s_address, sizeof(s_address) );

        if(sa){  perror("bind failed."); exit(2);}


        sa = listen(ss, 5);

        int whil = 0;
        while(whil < 1000){
            whil++;
            cs = accept(ss, (struct sockaddr *)&c_address, (socklen_t*)&size_csa);

            if(fork() ){
                close(cs);
            }else{
                close(ss);
                //client
                Client();
                exit(0);
            }
        }
}

Volgens mij zou het moeten kloppen. Misschien dat het komt door die blocking streams Maar hoe stel je dat in of uit?

[edit]
BTW. Het is voor Linux.

[ Voor 3% gewijzigd door SPee op 08-04-2003 21:05 ]

[curry684]

Je vergeet setsocket(..., SO_KEEPALIVE, ...). Is denk ik niet fataal... maar kan zo snel niets anders ontdekken. Wat voor platform schrijf je?

[.oisyn]

madwizard schreef op 08 April 2003 @ 19:07:
Dat gebeurt bij send maar niet bij recv hoor. Die ontvangt gewoon zoveel als op dat moment beschikbaar is:

je hebt gelijk, ik was in de war