Clarification: string obtenir à partir de l'URL

  string serverReply;
  //connect to server
  try {
   ClientSocket clientSocket("www.yourdomain.com", 80, 2);

   try {
     clientSocket << "GET http://www.yourdomain.com/ HTTP/1.0\n";
     clientSocket << "Host: www.yourdomain.com\n\n";
     clientSocket >> serverReply;
   }
   catch(SocketException& e) {
     cout << "Exception was caught: " << e.description() << "<br>" << endl;
   }

   cout << "Response from server: " << serverReply << "<br><br>" << endl;

  }
  catch(SocketException& e) {
   cout << "Exception was caught: " << e.description() << "<br>" << endl;
  }

#ifndef __clientsocket_h
#define __clientsocket_h  // Prevent multiple #includes

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/time.h>

const int MAXHOSTNAME = 200;
const int MAXCONNECTIONS = 5;
const int MAXRECV = 50000;

class Socket {
private:
  int m_sock;
  sockaddr_in m_addr;

public:
  Socket();
  virtual ~Socket();

  // Server initialization
  bool create();
  bool bind (const int port);
  bool listen() const;
  bool accept (Socket&) const;

  // Client initialization
  bool connect (const std::string host, const int port, const int timeOut);

  // Data Transimission
  bool send (const std::string) const;
  int recv (std::string&) const;

  void set_non_blocking (const bool);
  bool is_valid() const { return m_sock != -1; }

};


class ClientSocket : private Socket {
public:
  ClientSocket (std::string host, int port, int timeOut);
  virtual ~ClientSocket(){};

  const ClientSocket& operator << (const std::string&) const;
  const ClientSocket& operator >> (std::string&) const;
};


class SocketException {
private:
  std::string m_s;
public:
  SocketException(std::string s) : m_s(s) {};
  ~SocketException(){};

  std::string description() { return m_s; }
};


#endif // __clientsocket_h

#include "clientsocket.h"

Socket::Socket() : m_sock (-1)
{
  memset (&m_addr, 0, sizeof(m_addr));
}

Socket::~Socket()
{
  if (is_valid())
   ::close (m_sock);
}

bool Socket::create()
{
  m_sock = socket(AF_INET, SOCK_STREAM, 0);

  if (! is_valid())
   return false;

  // TIME_WAIT - argh
  int on = 1;
  if (setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*) &on, sizeof(on)) == -1)
   return false;

  return true;
}

bool Socket::bind (const int port)
{
  if (! is_valid())
   return false;

  m_addr.sin_family = AF_INET;
  m_addr.sin_addr.s_addr = INADDR_ANY;
  m_addr.sin_port = htons(port);

  int bind_return = ::bind(m_sock, (struct sockaddr *) &m_addr, sizeof(m_addr));

  if(bind_return == -1)
   return false;

  return true;
}


bool Socket::listen() const
{
  if(! is_valid())
   return false;

  int listen_return = ::listen(m_sock, MAXCONNECTIONS);

  if (listen_return == -1)
   return false;

  return true;
}

bool Socket::accept(Socket& new_socket) const
{
  int addr_length = sizeof(m_addr);
  new_socket.m_sock = ::accept (m_sock, (sockaddr *) &m_addr, (socklen_t *) &addr_length);

  if (new_socket.m_sock <= 0)
   return false;
  else
   return true;
}

bool Socket::send(const std::string s) const
{
  int status = ::send(m_sock, s.c_str(), s.size(), 0);

  if (status == -1)
   return false;
  else
   return true;
}


int Socket::recv(std::string& s) const
{
  char buf[MAXRECV + 1];
  s = "";

  memset(buf, 0, MAXRECV + 1);

  int status = ::recv(m_sock, buf, MAXRECV, 0);

  if (status == -1) {
//   std::cout << "status == -1  errno == " << errno << ", " << strerror(errno) << " in Socket::recv\n";
   return 0;
  }
  else if (status == 0)
   return 0;
  else {
   s = buf;
   return status;
  }
}



bool Socket::connect(const std::string host, const int port, const int timeOut)
{
  struct hostent *hp;
  struct timeval tv;
  fd_set writefds;
  tv.tv_sec = timeOut;
  tv.tv_usec = 500000;
     
  FD_ZERO(&writefds);
  FD_SET(m_sock, &writefds);

  if (! is_valid()) return false;

  if((hp = gethostbyname(host.c_str()))) {
   memset((char *) &m_addr, 0, sizeof(m_addr));
   memmove((char *) &m_addr.sin_addr, hp->h_addr, hp->h_length);
  }
  else return false;

  m_addr.sin_family = AF_INET;
  m_addr.sin_port = htons(port);

  if (errno == EAFNOSUPPORT) return false;

  ::connect(m_sock, (sockaddr *) &m_addr, sizeof (m_addr));

  select(m_sock+1, NULL, &writefds, NULL, &tv);

  if (FD_ISSET(m_sock, &writefds))
   return true;
  else
   return false;

}

void Socket::set_non_blocking(const bool b)
{
  int opts;

  opts = fcntl (m_sock, F_GETFL);

  if (opts < 0)
   return;

  if (b)
   opts = (opts | O_NONBLOCK);
  else
   opts = (opts & ~O_NONBLOCK);

  fcntl (m_sock, F_SETFL,opts);
}



ClientSocket::ClientSocket(std::string host, int port, int timeOut)
{
  if(! Socket::create())
   throw SocketException ( "Could not create client socket." );

  Socket::set_non_blocking(true);

  if(! Socket::connect (host, port, timeOut))
   throw SocketException ("Could not bind to port.");

  Socket::set_non_blocking(false);
}

const ClientSocket& ClientSocket::operator << (const std::string& s) const
{
  if (! Socket::send (s))
   throw SocketException ("Could not write to socket.");

  return *this;
}

const ClientSocket& ClientSocket::operator >> (std::string& s) const
{
  if (! Socket::recv(s))
   throw SocketException("Could not read from socket.");

  return *this;
}