Comment un serveur Web peut-il savoir quand une requête HTTP est entièrement reçue?

J'écris actuellement un serveur Web très simple pour en savoir plus sur la programmation de socket de bas niveau. Plus précisément, j'utilise C ++ comme langage principal et j'essaie d'encapsuler les appels système de bas niveau C dans des classes C ++ avec une API de plus haut niveau.

J'ai écrit une classe Socket qui gère un descripteur de fichier de socket et gère l'ouverture et la fermeture à l'aide de RAII. Cette classe expose également les opérations de socket standard pour une socket orientée connexion (TCP) comme lier, écouter, accepter, se connecter, etc.

Après avoir lu les pages de manuel pour send et recv appels système J'ai réalisé que je devais appeler ces fonctions dans une certaine forme de boucle afin de garantir que tous les octets sont correctement envoyés / reçus. p >

Mon API d'envoi et de réception ressemble à ceci

template<typename T>
T Receive(const int fd)
{
   using SizeType = typename T::size_type;
   using ValueType = typename T::value_type;

   T result;

   const SizeType bufSize{1024};
   ValueType buf[bufSize];
   while (true)
   {
      const ssize_t retVal{recv(fd, buf, bufSize, 0)};
      if (retVal < 0)
      {
          throw ch::NetworkError{"Failed to receive."};
      }

      if (retVal == 0)
      {
          break; /* Connection is closed. */
      }

      const SizeType offset{static_cast<SizeType>(retVal)};
      result.insert(std::end(result), buf, buf + offset);
   }

   return result;
}

Pour la fonctionnalité d'envoi, j'ai décidé d'utiliser un appel de blocage send dans un boucle comme celle-ci (c'est une fonction d'assistance interne qui fonctionne à la fois pour std :: string et std :: vector).

template<typename T>
void Send(const int fd, const T& bytes)
{
   using ValueType = typename T::value_type;
   using SizeType = typename T::size_type;

   const ValueType *const data{bytes.data()};
   SizeType bytesToSend{bytes.size()};
   SizeType bytesSent{0};
   while (bytesToSend > 0)
   {
      const ValueType *const buf{data + bytesSent};
      const ssize_t retVal{send(fd, buf, bytesToSend, 0)};
      if (retVal < 0)
      {
          throw ch::NetworkError{"Failed to send."};
      }
      const SizeType sent{static_cast<SizeType>(retVal)};
      bytesSent += sent;
      bytesToSend -= sent;
   }
}

Cela semble fonctionner correctement et garantit que tout les octets sont envoyés une fois que la fonction membre est renvoyée sans lever d'exception.

Cependant, j'ai commencé à rencontrer des problèmes lorsque j'ai commencé à implémenter la fonctionnalité de réception. Pour ma première tentative, j'ai utilisé un appel de blocage recv dans une boucle et j'ai quitté la boucle si recv retournait 0 indiquant que la connexion TCP sous-jacente était fermée.

void SendBytes(const std::vector<std::uint8_t>& bytes) const;
void SendStr(const std::string& str) const;
std::vector<std::uint8_t> ReceiveBytes() const;
std::string ReceiveStr() const;

Cela fonctionne bien tant que la connexion est fermée par l'expéditeur après que tous les octets ont été envoyés. Cependant, ce n'est pas le cas lors de l'utilisation par ex. Chrome pour demander une page Web. La connexion est maintenue ouverte et ma fonction de réception membre est bloquée lors de l'appel système recv après avoir reçu tous les octets de la requête. J'ai réussi à contourner ce problème en définissant un délai d'expiration sur l'appel recv en utilisant setsockopt . Fondamentalement, je renvoie tous les octets reçus jusqu'à présent une fois le délai expiré. Cela semble être une solution très inélégante et je ne pense pas que ce soit la façon dont les serveurs Web gèrent ce problème en réalité.

Alors, passons à ma question.

Comment un serveur Web sait-il quand une requête HTTP a été entièrement reçue?

Une requête GET dans HTTP 1.1 ne semble pas inclure d'en-tête Content-Length. Voir par exemple ce lien . p >