Registere om der modtages flere data

Jeg arbejder på et studie-projekt omhandlende udvikling af proxy-server.

Jeg arbejder med connection-oriented forbindelser.

Problemet er forbindelsen mellem min proxy og web-serveren.
Ved HTTP 1.0: Når web-serveren har sendt alle data lukker den forbindelse og dette kan jeg registrere ved at recv() returnerer 0.
Ved HTPP 1.1: Web-serveren lukker ikke forbindelsen, når den har sendt alle data.
Hvordan kan jeg som klient registere om web-serveren er færsig med at sende?

Jeg har prøvet følgende:
Indsætte et alarm signal, men recv() blokerer, så alarm bliver aldrig udløst.

Undersøge det sidst modtage tegn, som ofte er ASCII-værdien 10. Virker måske i 95% af tilfældene.

Håber i kan komme med nogle ideer/forslag til løsning af dette.

/Sune

Sprog: C (ikke C++)
OS: Linux

--- Udrag af koden ---
//PROGRAM KODE
//FUNKTION: Main
int main(int argc, char *argv[])
{
  int sockfd;
  int newsockfd;
  pthread_t thr;

  struct sockaddr_in server;

  //Ignorer Broken pipe
  signal(SIGPIPE, SIG_IGN);

  if(argc!=2)
  {
    exit(1);
  }

  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  server.sin_family = AF_INET;
  server.sin_addr.s_addr = INADDR_ANY;
  server.sin_port = htons (atoi(argv[1])); // port should be a parameter

//Bind
if(bind(sockfd, (struct sockaddr*) &server, sizeof(server)))
  {
      perror("Fejl: Bind");
      close(sockfd);
      exit(2);
  }

  //Listen
  if(listen(sockfd,25)==-1)
  {
      perror("Fejl: Listen");
      exit(3);
  }

  //Opretter ny thread for hver ny connection
  while (1)
  {
      newsockfd = (int)accept(sockfd, NULL, NULL);
      pthread_create(&thr, NULL, (void *)forbindelse_oprettet, (int*)newsockfd);
  }
}

//FUNKTION; forbindelse_oprettet
int forbindelse_oprettet(int newsockfd)
{
        struct hostent *h;

        char symbolfolge[50][80];//URL lexet i symboler
        char inputData[1001];//URL'en modtaget fra klienten

        int recva;//retur-værdien fra recv()
        int senda;//retur-værdien fra send()

        recva=recv(newsockfd, (char *)&inputData, 1000, 0);

        //Lexer
        if(lexer(inputData, symbolfolge)==1)
        {
        }
        //Parser
        else if(parser(symbolfolge)==1)
        {
        }
        //Requester hostname
        else if((h=gethostbyname(symbolfolge[2]))==NULL)
        {
            herror("Fejl: gethostbyname");
        }
        else
        {
            int sockfd;
            struct sockaddr_in client;
            int retry_connect=1;
            int retry_send=1;

            //TCP - connection
            sockfd = socket(AF_INET, SOCK_STREAM, 0);

            client.sin_family = AF_INET;
            client.sin_addr.s_addr = inet_addr(inet_ntoa(*((struct in_addr *)h->h_addr)));
            client.sin_port = htons(80);

            //Connect til web-server
            for(;retry_connect<6 && retry_connect!=0;)
            {
                if(connect(sockfd, (struct sockaddr*) &client, sizeof(client))==-1)
                {
                    perror("Fejl: Connect: Forbindelse til webserver");
                    sleep((retry_connect));
                    retry_connect++;
                }
                else
                {
                    retry_connect=0;
                }
            }

            //Videre sendelse af header fra browser til web-server
            for(;retry_send<6 && retry_send!=0;)
            {
                if(send(sockfd, &inputData, recva,0)==-1)
                {
                    sleep(retry_send);
                    retry_send++;
                }
                else
                {
                    retry_send=0;
                }
            }
            modtagBinary((int*)newsockfd, (int*)sockfd);
            //Lukker forbindelsen til web-server
            close(sockfd);
        }
    //Lukker forbindelsen til browser
    close(newsockfd);
    //Nedlægger thread
    pthread_exit(NULL);
}

void modtagBinary(int newsockfd, int sockfd)
{
    int buffer_str
    unsigned char outputDataBinary[buffer_str];

    int recva=buffer_str;//
    int senda=buffer_str;
    int retry_send;

    for(;recva>1;)
    {
        bzero(outputDataBinary, 1000);
        //Modtager fra web-server
        recva=recv(sockfd, &outputDataBinary, 1000, 0);
        if(recva==0 || recva==-1)
        {
            return;
        }
        else
        {
            retry_send=0;
            for(;retry_send<5 && retry_send!=-1;)
            {
                //Videre sendelse af data til browser
                senda=send(newsockfd, &outputDataBinary, recva, 0);
                if(senda!=recva)
                {
                    //Venter inden nyt forsøg
                    sleep(retry_send);
                    retry_send++;
                }
                else
                {
                    retry_send=-1;
                }
            }
        }
       
        //Kontrollerer om sidste byte er ASCII-værdien 10
        if(outputDataBinary[(recva-1)]==10)
        {
            return;
        }
    }
}