ACE/apps/JAWS/clients/Caching/http_handler.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    http_handler.cpp
   5  *
   6  *  @author James Hu
   7  */
   8 //=============================================================================
   9
  10
  11 #include "ace/OS_NS_stdio.h"
  12 #include "ace/OS_NS_string.h"
  13 #include "ace/Filecache.h"
  14 #include "http_handler.h"
  15
  16 HTTP_Handler::HTTP_Handler ()
  17 {
  18 }
  19
  20 HTTP_Handler::HTTP_Handler (const char * path)
  21 {
  22   // How long is the request going to be?
  23   this->request_[0] = '\0';
  24   this->request_size_ =
  25     ACE_OS::strlen ("GET ")
  26     + ACE_OS::strlen (path)
  27     + ACE_OS::strlen (" HTTP/1.0\r\nAccept: HTTP/1.0\r\n\r\n");
  28
  29   // Make the request.
  30   if ((u_int) this->request_size_ < sizeof (this->request_))
  31     ACE_OS::sprintf (this->request_,
  32                      "GET %s HTTP/1.0\r\nAccept: HTTP/1.0\r\n\r\n",
  33                      path);
  34
  35   // Find the filename.
  36   const char *last = ACE_OS::strrchr (path, '/');
  37
  38   if (last == 0)
  39     last = path;
  40   else if (last[1] == '\0')
  41     last = "index.html";
  42   else
  43     last = last+1;
  44
  45   ACE_OS::sprintf (this->filename_, "%s", last);
  46 }
  47
  48 int
  49 HTTP_Handler::open (void *)
  50 {
  51   // If you want threads, use the activate stuff.
  52 #if 0
  53   if (this->activate () != 0)
  54     {
  55       ACE_ERROR_RETURN ((LM_ERROR, "HTTP_Handler::open, whups!\n"), -1);
  56     }
  57
  58   return 0;
  59 #else
  60   return this->svc ();
  61 #endif /* 0 */
  62 }
  63
  64 int
  65 HTTP_Handler::svc ()
  66 {
  67   static char buf[BUFSIZ];
  68   int count = 0;
  69
  70   ACE_DEBUG ((LM_DEBUG, "[%t] sending request --\n%s", this->request_));
  71
  72   this->peer ().send_n (this->request_, this->request_size_);
  73
  74   // Read in characters until encounter \r\n\r\n
  75   int done = 0;
  76   char *contentlength;
  77
  78   do
  79     {
  80       while (((count += this->peer ().recv_n (buf + count, 1)) > 0)
  81              && ((u_int) count < sizeof (buf)))
  82         {
  83           buf[count] = '\0';
  84
  85           if (count < 2)
  86             continue;
  87           done = ACE_OS::strcmp (buf + count - 4, "\n\n") == 0;
  88
  89           if (done)
  90             break;
  91
  92           if (count < 4)
  93             continue;
  94
  95           done = ACE_OS::strcmp (buf + count - 4, "\r\n\r\n") == 0;
  96
  97           if (done)
  98             break;
  99         }
 100
 101       if (!done)
 102         {
 103           char *last = ACE_OS::strrchr (buf, '\n');
 104           last[0] = '\0';
 105
 106           if ((contentlength = ACE_OS::strstr (buf, "\nContent-length:"))
 107               || (contentlength = ACE_OS::strstr (buf, "\nContent-Length:")))
 108             done = 1;
 109           else
 110             {
 111               last[0] = '\n';
 112               count = ACE_OS::strlen (last);
 113               ACE_OS::memmove (buf, last, count + 1);
 114             }
 115         }
 116       else
 117         {
 118           contentlength = ACE_OS::strstr (buf, "\nContent-length:");
 119
 120           if (!contentlength)
 121             contentlength =
 122               ACE_OS::strstr (buf, "\nContent-Length:");
 123         }
 124
 125     }
 126   while (!done);
 127
 128   // ASSERT (contentlength != 0)
 129   int size = 0;
 130   if (contentlength
 131       && (::sscanf (contentlength, "\nContent-%*[lL]ength: %d ",
 132                     &size) == 1))
 133     {
 134       this->response_size_ = size;
 135       ACE_Filecache_Handle afh (ACE_TEXT_CHAR_TO_TCHAR (this->filename_),
 136                                 this->response_size_);
 137
 138       this->peer ().recv_n (afh.address (), this->response_size_);
 139
 140       ACE_DEBUG ((LM_DEBUG,
 141                   "  ``%s'' is now cached.\n",
 142                   this->filename_));
 143     }
 144   else
 145     {
 146       // Maybe we should do something more clever here, such as extend
 147       // ACE_Filecache_Handle to allow the creation of cache objects
 148       // whose size is unknown?
 149
 150       // Another possibility is to write the contents out to a file,
 151       // and then cache it.
 152
 153       // Perhaps make ACE_Filecache_Handle more savvy, and allow a
 154       // constructor which accepts a PEER as a parameter.
 155       ACE_DEBUG ((LM_DEBUG,
 156                   "HTTP_Handler, no content-length header!\n"));
 157     }
 158
 159   return 0;
 160 }
 161
 162 const char *
 163 HTTP_Handler::filename () const
 164 {
 165   return this->filename_;
 166 }
 167
 168 int
 169 HTTP_Connector::connect (const char * url)
 170 {
 171   char host[BUFSIZ];
 172   u_short port;
 173   char path[BUFSIZ];
 174
 175   if (this->parseurl (url, host, &port, path) == -1)
 176     {
 177       ACE_DEBUG ((LM_DEBUG,
 178                   "HTTP_Connector, error parsing url: %s\n",
 179                   url));
 180       return -1;
 181     }
 182
 183   HTTP_Handler hh (path);
 184   HTTP_Handler *hhptr = &hh;
 185
 186   // First check the cache.
 187   if (ACE_Filecache::instance ()->find (ACE_TEXT_CHAR_TO_TCHAR (hh.filename ())) == 0)
 188     {
 189       ACE_DEBUG ((LM_DEBUG, "  ``%s'' is already cached.\n",
 190                   hh.filename ()));
 191       return 0;
 192     }
 193
 194   return this->connector_.connect (hhptr, ACE_INET_Addr (port, host));
 195 }
 196
 197 #define DEFAULT_SERVER_PORT 80
 198
 199 // extract the main components of a URL
 200 int
 201 HTTP_Connector::parseurl (const char *url,
 202                           char *host,
 203                           u_short *port,
 204                           char *path)
 205 {
 206   int status = 0;
 207
 208   // hackish, but useful
 209   if (3 != ::sscanf (url, "http://%[^:/]:%hu%s", host, port, path))
 210     {
 211       if (2 != ::sscanf (url, "http://%[^:/]:%hu", host, port))
 212         {
 213           if (2 != ::sscanf (url, "http://%[^:/]%s", host, path))
 214             {
 215               if (1 != ::sscanf (url, "http://%[^:/]", host))
 216                 status = -1;
 217               else
 218                 {
 219                   *port = DEFAULT_SERVER_PORT;
 220                   ACE_OS::strcpy (path, "/");
 221                 }
 222             }
 223           else
 224             *port = DEFAULT_SERVER_PORT;
 225         }
 226       else ACE_OS::strcpy (path, "/");
 227     }
 228
 229   // 0 => success
 230   // -1 => error
 231   return status;
 232 }
 233