src/adaptation/ecap/MessageRep.cc

   1 /*
   2  * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 /* DEBUG: section 93    eCAP Interface */
  10
  11 #include "squid.h"
  12 #include "BodyPipe.h"
  13 #include "HttpReply.h"
  14 #include "HttpRequest.h"
  15 #include <libecap/common/names.h>
  16 #include <libecap/common/area.h>
  17 #include <libecap/common/version.h>
  18 #include <libecap/common/named_values.h>
  19 #include "adaptation/ecap/Host.h" /* for protocol constants */
  20 #include "adaptation/ecap/MessageRep.h"
  21 #include "adaptation/ecap/XactionRep.h"
  22 #include "base/TextException.h"
  23 #include "URL.h"
  24
  25 /* HeaderRep */
  26
  27 Adaptation::Ecap::HeaderRep::HeaderRep(HttpMsg &aMessage): theHeader(aMessage.header),
  28     theMessage(aMessage)
  29 {
  30 }
  31
  32 bool
  33 Adaptation::Ecap::HeaderRep::hasAny(const Name &name) const
  34 {
  35     const Http::HdrType squidId = TranslateHeaderId(name);
  36     // XXX: optimize to remove getByName: we do not need the value here
  37     return squidId == Http::HdrType::OTHER ?
  38            theHeader.getByName(name.image().c_str()).size() > 0:
  39            (bool)theHeader.has(squidId);
  40 }
  41
  42 Adaptation::Ecap::HeaderRep::Value
  43 Adaptation::Ecap::HeaderRep::value(const Name &name) const
  44 {
  45     const Http::HdrType squidId = TranslateHeaderId(name);
  46     const String value = squidId == Http::HdrType::OTHER ?
  47                          theHeader.getByName(name.image().c_str()) :
  48                          theHeader.getStrOrList(squidId);
  49     return value.size() > 0 ?
  50            Value::FromTempString(value.termedBuf()) : Value();
  51 }
  52
  53 void
  54 Adaptation::Ecap::HeaderRep::add(const Name &name, const Value &value)
  55 {
  56     const Http::HdrType squidId = TranslateHeaderId(name); // Http::HdrType::OTHER OK
  57     HttpHeaderEntry *e = new HttpHeaderEntry(squidId, name.image().c_str(),
  58             value.toString().c_str());
  59     theHeader.addEntry(e);
  60
  61     if (squidId == Http::HdrType::CONTENT_LENGTH)
  62         theMessage.content_length = theHeader.getInt64(Http::HdrType::CONTENT_LENGTH);
  63 }
  64
  65 void
  66 Adaptation::Ecap::HeaderRep::removeAny(const Name &name)
  67 {
  68     const Http::HdrType squidId = TranslateHeaderId(name);
  69     if (squidId == Http::HdrType::OTHER)
  70         theHeader.delByName(name.image().c_str());
  71     else
  72         theHeader.delById(squidId);
  73
  74     if (squidId == Http::HdrType::CONTENT_LENGTH)
  75         theMessage.content_length = theHeader.getInt64(Http::HdrType::CONTENT_LENGTH);
  76 }
  77
  78 void
  79 Adaptation::Ecap::HeaderRep::visitEach(libecap::NamedValueVisitor &visitor) const
  80 {
  81     HttpHeaderPos pos = HttpHeaderInitPos;
  82     while (HttpHeaderEntry *e = theHeader.getEntry(&pos)) {
  83         const Name name(e->name.termedBuf()); // optimize: find std Names
  84         name.assignHostId(e->id);
  85         visitor.visit(name, Value(e->value.rawBuf(), e->value.size()));
  86     }
  87 }
  88
  89 libecap::Area
  90 Adaptation::Ecap::HeaderRep::image() const
  91 {
  92     MemBuf mb;
  93     mb.init();
  94     theMessage.packInto(&mb, true);
  95     return Area::FromTempBuffer(mb.content(), mb.contentSize());
  96 }
  97
  98 // throws on failures
  99 void
 100 Adaptation::Ecap::HeaderRep::parse(const Area &buf)
 101 {
 102     Http::StatusCode error;
 103     Must(theMessage.parse(buf.start, buf.size, true, &error));
 104 }
 105
 106 Http::HdrType
 107 Adaptation::Ecap::HeaderRep::TranslateHeaderId(const Name &name)
 108 {
 109     if (name.assignedHostId())
 110         return static_cast<Http::HdrType>(name.hostId());
 111     return Http::HdrType::OTHER;
 112 }
 113
 114 /* FirstLineRep */
 115
 116 Adaptation::Ecap::FirstLineRep::FirstLineRep(HttpMsg &aMessage): theMessage(aMessage)
 117 {
 118 }
 119
 120 libecap::Version
 121 Adaptation::Ecap::FirstLineRep::version() const
 122 {
 123     return libecap::Version(theMessage.http_ver.major,
 124                             theMessage.http_ver.minor);
 125 }
 126
 127 void
 128 Adaptation::Ecap::FirstLineRep::version(const libecap::Version &aVersion)
 129 {
 130     theMessage.http_ver.major = aVersion.majr;
 131     theMessage.http_ver.minor = aVersion.minr;
 132 }
 133
 134 libecap::Name
 135 Adaptation::Ecap::FirstLineRep::protocol() const
 136 {
 137     // TODO: optimize?
 138     switch (theMessage.http_ver.protocol) {
 139     case AnyP::PROTO_HTTP:
 140         return libecap::protocolHttp;
 141     case AnyP::PROTO_HTTPS:
 142         return libecap::protocolHttps;
 143     case AnyP::PROTO_FTP:
 144         return libecap::protocolFtp;
 145     case AnyP::PROTO_GOPHER:
 146         return libecap::protocolGopher;
 147     case AnyP::PROTO_WAIS:
 148         return libecap::protocolWais;
 149     case AnyP::PROTO_WHOIS:
 150         return libecap::protocolWhois;
 151     case AnyP::PROTO_URN:
 152         return libecap::protocolUrn;
 153     case AnyP::PROTO_ICP:
 154         return protocolIcp;
 155 #if USE_HTCP
 156     case AnyP::PROTO_HTCP:
 157         return protocolHtcp;
 158 #endif
 159     case AnyP::PROTO_CACHE_OBJECT:
 160         return protocolCacheObj;
 161     case AnyP::PROTO_ICY:
 162         return protocolIcy;
 163     case AnyP::PROTO_COAP:
 164     case AnyP::PROTO_COAPS: // use 'unknown' until libecap supports coap:// and coaps://
 165     case AnyP::PROTO_UNKNOWN:
 166         return protocolUnknown; // until we remember the protocol image
 167     case AnyP::PROTO_NONE:
 168         return Name();
 169
 170     case AnyP::PROTO_MAX:
 171         break; // should not happen
 172         // no default to catch AnyP::PROTO_ additions
 173     }
 174     Must(false); // not reached
 175     return Name();
 176 }
 177
 178 void
 179 Adaptation::Ecap::FirstLineRep::protocol(const Name &p)
 180 {
 181     // TODO: what happens if we fail to translate some protocol?
 182     theMessage.http_ver.protocol = TranslateProtocolId(p);
 183 }
 184
 185 AnyP::ProtocolType
 186 Adaptation::Ecap::FirstLineRep::TranslateProtocolId(const Name &name)
 187 {
 188     if (name.assignedHostId())
 189         return static_cast<AnyP::ProtocolType>(name.hostId());
 190     return AnyP::PROTO_UNKNOWN;
 191 }
 192
 193 /* RequestHeaderRep */
 194
 195 Adaptation::Ecap::RequestLineRep::RequestLineRep(HttpRequest &aMessage):
 196     FirstLineRep(aMessage), theMessage(aMessage)
 197 {
 198 }
 199
 200 void
 201 Adaptation::Ecap::RequestLineRep::uri(const Area &aUri)
 202 {
 203     // TODO: if method is not set, urlPath will assume it is not connect;
 204     // Can we change urlParse API to remove the method parameter?
 205     // TODO: optimize: urlPath should take constant URL buffer
 206     char *buf = xstrdup(aUri.toString().c_str());
 207     const bool ok = urlParse(theMessage.method, buf, &theMessage);
 208     xfree(buf);
 209     Must(ok);
 210 }
 211
 212 Adaptation::Ecap::RequestLineRep::Area
 213 Adaptation::Ecap::RequestLineRep::uri() const
 214 {
 215     const SBuf &fullUrl = theMessage.effectiveRequestUri();
 216     // XXX: effectiveRequestUri() cannot return NULL or even empty string, some other problem?
 217     Must(!fullUrl.isEmpty());
 218     // optimize: avoid copying by having an Area::Detail that locks theMessage
 219     return Area::FromTempBuffer(fullUrl.rawContent(), fullUrl.length());
 220 }
 221
 222 void
 223 Adaptation::Ecap::RequestLineRep::method(const Name &aMethod)
 224 {
 225     if (aMethod.assignedHostId()) {
 226         const int id = aMethod.hostId();
 227         Must(Http::METHOD_NONE < id && id < Http::METHOD_ENUM_END);
 228         Must(id != Http::METHOD_OTHER);
 229         theMessage.method = HttpRequestMethod(static_cast<Http::MethodType>(id));
 230     } else {
 231         const std::string &image = aMethod.image();
 232         theMessage.method.HttpRequestMethodXXX(image.c_str());
 233     }
 234 }
 235
 236 Adaptation::Ecap::RequestLineRep::Name
 237 Adaptation::Ecap::RequestLineRep::method() const
 238 {
 239     switch (theMessage.method.id()) {
 240     case Http::METHOD_GET:
 241         return libecap::methodGet;
 242     case Http::METHOD_POST:
 243         return libecap::methodPost;
 244     case Http::METHOD_PUT:
 245         return libecap::methodPut;
 246     case Http::METHOD_HEAD:
 247         return libecap::methodHead;
 248     case Http::METHOD_CONNECT:
 249         return libecap::methodConnect;
 250     case Http::METHOD_DELETE:
 251         return libecap::methodDelete;
 252     case Http::METHOD_TRACE:
 253         return libecap::methodTrace;
 254     default:
 255         return Name(theMessage.method.image().toStdString());
 256     }
 257 }
 258
 259 libecap::Version
 260 Adaptation::Ecap::RequestLineRep::version() const
 261 {
 262     return FirstLineRep::version();
 263 }
 264
 265 void
 266 Adaptation::Ecap::RequestLineRep::version(const libecap::Version &aVersion)
 267 {
 268     FirstLineRep::version(aVersion);
 269 }
 270
 271 libecap::Name
 272 Adaptation::Ecap::RequestLineRep::protocol() const
 273 {
 274     return FirstLineRep::protocol();
 275 }
 276
 277 void
 278 Adaptation::Ecap::RequestLineRep::protocol(const Name &p)
 279 {
 280     FirstLineRep::protocol(p);
 281 }
 282
 283 /* ReplyHeaderRep */
 284
 285 Adaptation::Ecap::StatusLineRep::StatusLineRep(HttpReply &aMessage):
 286     FirstLineRep(aMessage), theMessage(aMessage)
 287 {
 288 }
 289
 290 void
 291 Adaptation::Ecap::StatusLineRep::statusCode(int code)
 292 {
 293     theMessage.sline.set(theMessage.sline.version, static_cast<Http::StatusCode>(code), nullptr);
 294 }
 295
 296 int
 297 Adaptation::Ecap::StatusLineRep::statusCode() const
 298 {
 299     // TODO: remove cast when possible
 300     return static_cast<int>(theMessage.sline.status());
 301 }
 302
 303 void
 304 Adaptation::Ecap::StatusLineRep::reasonPhrase(const Area &)
 305 {
 306     // Squid does not support external custom reason phrases so we have
 307     // to just reset it (in case there was a custom internal reason set)
 308     theMessage.sline.resetReason();
 309 }
 310
 311 Adaptation::Ecap::StatusLineRep::Area
 312 Adaptation::Ecap::StatusLineRep::reasonPhrase() const
 313 {
 314     return Area::FromTempString(std::string(theMessage.sline.reason()));
 315 }
 316
 317 libecap::Version
 318 Adaptation::Ecap::StatusLineRep::version() const
 319 {
 320     return FirstLineRep::version();
 321 }
 322
 323 void
 324 Adaptation::Ecap::StatusLineRep::version(const libecap::Version &aVersion)
 325 {
 326     FirstLineRep::version(aVersion);
 327 }
 328
 329 libecap::Name
 330 Adaptation::Ecap::StatusLineRep::protocol() const
 331 {
 332     return FirstLineRep::protocol();
 333 }
 334
 335 void
 336 Adaptation::Ecap::StatusLineRep::protocol(const Name &p)
 337 {
 338     FirstLineRep::protocol(p);
 339 }
 340
 341 /* BodyRep */
 342
 343 Adaptation::Ecap::BodyRep::BodyRep(const BodyPipe::Pointer &aBody): theBody(aBody)
 344 {
 345 }
 346
 347 void
 348 Adaptation::Ecap::BodyRep::tie(const BodyPipe::Pointer &aBody)
 349 {
 350     Must(!theBody);
 351     Must(aBody != NULL);
 352     theBody = aBody;
 353 }
 354
 355 Adaptation::Ecap::BodyRep::BodySize
 356 Adaptation::Ecap::BodyRep::bodySize() const
 357 {
 358     return (theBody != nullptr && theBody->bodySizeKnown()) ? BodySize(theBody->bodySize()) : BodySize();
 359 }
 360
 361 /* MessageRep */
 362
 363 Adaptation::Ecap::MessageRep::MessageRep(HttpMsg *rawHeader):
 364     theMessage(rawHeader), theFirstLineRep(NULL),
 365     theHeaderRep(NULL), theBodyRep(NULL)
 366 {
 367     Must(theMessage.header); // we do not want to represent a missing message
 368
 369     if (HttpRequest *req = dynamic_cast<HttpRequest*>(theMessage.header))
 370         theFirstLineRep = new RequestLineRep(*req);
 371     else if (HttpReply *rep = dynamic_cast<HttpReply*>(theMessage.header))
 372         theFirstLineRep = new StatusLineRep(*rep);
 373     else
 374         Must(false); // unknown message header type
 375
 376     theHeaderRep = new HeaderRep(*theMessage.header);
 377
 378     if (theMessage.body_pipe != NULL)
 379         theBodyRep = new BodyRep(theMessage.body_pipe);
 380 }
 381
 382 Adaptation::Ecap::MessageRep::~MessageRep()
 383 {
 384     delete theBodyRep;
 385     delete theHeaderRep;
 386     delete theFirstLineRep;
 387 }
 388
 389 libecap::shared_ptr<libecap::Message>
 390 Adaptation::Ecap::MessageRep::clone() const
 391 {
 392     HttpMsg *hdr = theMessage.header->clone();
 393     hdr->body_pipe = NULL; // if any; TODO: remove pipe cloning from ::clone?
 394     libecap::shared_ptr<libecap::Message> res(new MessageRep(hdr));
 395
 396     // restore indication of a body if needed, but not the pipe
 397     if (theMessage.header->body_pipe != NULL)
 398         res->addBody();
 399
 400     return res;
 401 }
 402
 403 libecap::FirstLine &
 404 Adaptation::Ecap::MessageRep::firstLine()
 405 {
 406     return *theFirstLineRep;
 407 }
 408
 409 const libecap::FirstLine &
 410 Adaptation::Ecap::MessageRep::firstLine() const
 411 {
 412     return *theFirstLineRep;
 413 }
 414
 415 libecap::Header &
 416 Adaptation::Ecap::MessageRep::header()
 417 {
 418     return *theHeaderRep;
 419 }
 420
 421 const libecap::Header &
 422 Adaptation::Ecap::MessageRep::header() const
 423 {
 424     return *theHeaderRep;
 425 }
 426
 427 libecap::Body *
 428 Adaptation::Ecap::MessageRep::body()
 429 {
 430     return theBodyRep;
 431 }
 432
 433 void
 434 Adaptation::Ecap::MessageRep::addBody()
 435 {
 436     Must(!theBodyRep);
 437     Must(!theMessage.body_pipe); // set in tieBody()
 438     theBodyRep = new BodyRep(NULL);
 439 }
 440
 441 void
 442 Adaptation::Ecap::MessageRep::tieBody(Adaptation::Ecap::XactionRep *x)
 443 {
 444     Must(theBodyRep != NULL); // addBody must be called first
 445     Must(!theMessage.header->body_pipe);
 446     Must(!theMessage.body_pipe);
 447     theMessage.header->body_pipe = new BodyPipe(x);
 448     theMessage.body_pipe = theMessage.header->body_pipe;
 449     theBodyRep->tie(theMessage.body_pipe);
 450 }
 451
 452 const libecap::Body *Adaptation::Ecap::MessageRep::body() const
 453 {
 454     return theBodyRep;
 455 }
 456