src/kits/network/libnetapi/HttpHeaders.cpp

   1 /*
   2  * Copyright 2010 Haiku Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Christophe Huriaux, c.huriaux@gmail.com
   7  */
   8
   9
  10 #include <ctype.h>
  11 #include <string.h>
  12 #include <new>
  13
  14 #include <String.h>
  15 #include <HttpHeaders.h>
  16
  17
  18 // #pragma mark -- BHttpHeader
  19
  20
  21 BHttpHeader::BHttpHeader()
  22         :
  23         fName(),
  24         fValue(),
  25         fRawHeader(),
  26         fRawHeaderValid(true)
  27 {
  28 }
  29
  30
  31 BHttpHeader::BHttpHeader(const char* string)
  32         :
  33         fRawHeaderValid(true)
  34 {
  35         SetHeader(string);
  36 }
  37
  38
  39 BHttpHeader::BHttpHeader(const char* name, const char* value)
  40         :
  41         fRawHeaderValid(false)
  42 {
  43         SetName(name);
  44         SetValue(value);
  45 }
  46
  47
  48 BHttpHeader::BHttpHeader(const BHttpHeader& copy)
  49         :
  50         fName(copy.fName),
  51         fValue(copy.fValue),
  52         fRawHeaderValid(false)
  53 {
  54 }
  55
  56
  57 void
  58 BHttpHeader::SetName(const char* name)
  59 {
  60         fRawHeaderValid = false;
  61         fName = name;
  62         fName.Trim().CapitalizeEachWord();
  63 }
  64
  65
  66 void
  67 BHttpHeader::SetValue(const char* value)
  68 {
  69         fRawHeaderValid = false;
  70         fValue = value;
  71         fValue.Trim();
  72 }
  73
  74
  75 bool
  76 BHttpHeader::SetHeader(const char* string)
  77 {
  78         fRawHeaderValid = false;
  79         fName.Truncate(0);
  80         fValue.Truncate(0);
  81
  82         const char* separator = strchr(string, ':');
  83
  84         if (separator == NULL)
  85                 return false;
  86
  87         fName.SetTo(string, separator - string);
  88         fName.Trim().CapitalizeEachWord();
  89         SetValue(separator + 1);
  90         return true;
  91 }
  92
  93
  94 const char*
  95 BHttpHeader::Name() const
  96 {
  97         return fName.String();
  98 }
  99
 100
 101 const char*
 102 BHttpHeader::Value() const
 103 {
 104         return fValue.String();
 105 }
 106
 107
 108 const char*
 109 BHttpHeader::Header() const
 110 {
 111         if (!fRawHeaderValid) {
 112                 fRawHeaderValid = true;
 113
 114                 fRawHeader.Truncate(0);
 115                 fRawHeader << fName << ": " << fValue;
 116         }
 117
 118         return fRawHeader.String();
 119 }
 120
 121
 122 bool
 123 BHttpHeader::NameIs(const char* name) const
 124 {
 125         return fName == BString(name).Trim().CapitalizeEachWord();
 126 }
 127
 128
 129 BHttpHeader&
 130 BHttpHeader::operator=(const BHttpHeader& other)
 131 {
 132         fName = other.fName;
 133         fValue = other.fValue;
 134         fRawHeaderValid = false;
 135
 136         return *this;
 137 }
 138
 139
 140 // #pragma mark -- BHttpHeaders
 141
 142
 143 BHttpHeaders::BHttpHeaders()
 144         :
 145         fHeaderList()
 146 {
 147 }
 148
 149
 150 BHttpHeaders::BHttpHeaders(const BHttpHeaders& other)
 151         :
 152         fHeaderList()
 153 {
 154         *this = other;
 155 }
 156
 157
 158 BHttpHeaders::~BHttpHeaders()
 159 {
 160         _EraseData();
 161 }
 162
 163
 164 // #pragma mark Header access
 165
 166
 167 const char*
 168 BHttpHeaders::HeaderValue(const char* name) const
 169 {
 170         for (int32 i = 0; i < fHeaderList.CountItems(); i++) {
 171                 BHttpHeader* header
 172                         = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAtFast(i));
 173
 174                 if (header->NameIs(name))
 175                         return header->Value();
 176         }
 177
 178         return NULL;
 179 }
 180
 181
 182 BHttpHeader&
 183 BHttpHeaders::HeaderAt(int32 index) const
 184 {
 185         //! Note: index _must_ be in-bounds
 186         BHttpHeader* header
 187                 = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAtFast(index));
 188
 189         return *header;
 190 }
 191
 192
 193 // #pragma mark Header count
 194
 195
 196 int32
 197 BHttpHeaders::CountHeaders() const
 198 {
 199         return fHeaderList.CountItems();
 200 }
 201
 202
 203 // #pragma Header tests
 204
 205
 206 int32
 207 BHttpHeaders::HasHeader(const char* name) const
 208 {
 209         for (int32 i = 0; i < fHeaderList.CountItems(); i++) {
 210                 BHttpHeader* header
 211                         = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAt(i));
 212
 213                 if (header->NameIs(name))
 214                         return i;
 215         }
 216
 217         return -1;
 218 }
 219
 220
 221 // #pragma mark Header add/replace
 222
 223
 224 bool
 225 BHttpHeaders::AddHeader(const char* line)
 226 {
 227         return _AddOrDeleteHeader(new(std::nothrow) BHttpHeader(line));
 228 }
 229
 230
 231 bool
 232 BHttpHeaders::AddHeader(const char* name, const char* value)
 233 {
 234         return _AddOrDeleteHeader(new(std::nothrow) BHttpHeader(name, value));
 235 }
 236
 237
 238 bool
 239 BHttpHeaders::AddHeader(const char* name, int32 value)
 240 {
 241         BString strValue;
 242         strValue << value;
 243
 244         return AddHeader(name, strValue);
 245 }
 246
 247
 248 // #pragma mark Archiving
 249
 250
 251 void
 252 BHttpHeaders::PopulateFromArchive(BMessage* archive)
 253 {
 254         Clear();
 255
 256         int32 index = 0;
 257         char* nameFound;
 258         for (;;) {
 259                 if (archive->GetInfo(B_STRING_TYPE, index, &nameFound, NULL) != B_OK)
 260                         return;
 261
 262                 BString value = archive->FindString(nameFound);
 263                 AddHeader(nameFound, value);
 264
 265                 index++;
 266         }
 267 }
 268
 269
 270 void
 271 BHttpHeaders::Archive(BMessage* message) const
 272 {
 273         int32 count = CountHeaders();
 274
 275         for (int32 i = 0; i < count; i++) {
 276                 BHttpHeader& header = HeaderAt(i);
 277                 message->AddString(header.Name(), header.Value());
 278         }
 279 }
 280
 281
 282 // #pragma mark Header deletion
 283
 284
 285 void
 286 BHttpHeaders::Clear()
 287 {
 288         _EraseData();
 289         fHeaderList.MakeEmpty();
 290 }
 291
 292
 293 // #pragma mark Overloaded operators
 294
 295
 296 BHttpHeaders&
 297 BHttpHeaders::operator=(const BHttpHeaders& other)
 298 {
 299         if (&other == this)
 300                 return *this;
 301
 302         Clear();
 303
 304         for (int32 i = 0; i < other.CountHeaders(); i++)
 305                 AddHeader(other.HeaderAt(i).Name(), other.HeaderAt(i).Value());
 306
 307         return *this;
 308 }
 309
 310
 311 BHttpHeader&
 312 BHttpHeaders::operator[](int32 index) const
 313 {
 314         //! Note: Index _must_ be in-bounds
 315         BHttpHeader* header
 316                 = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAtFast(index));
 317
 318         return *header;
 319 }
 320
 321
 322 const char*
 323 BHttpHeaders::operator[](const char* name) const
 324 {
 325         return HeaderValue(name);
 326 }
 327
 328
 329 void
 330 BHttpHeaders::_EraseData()
 331 {
 332         // Free allocated data;
 333         for (int32 i = 0; i < fHeaderList.CountItems(); i++) {
 334                 BHttpHeader* header
 335                         = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAtFast(i));
 336
 337                 delete header;
 338         }
 339 }
 340
 341
 342 bool
 343 BHttpHeaders::_AddOrDeleteHeader(BHttpHeader* header)
 344 {
 345         if (header != NULL) {
 346                 if (fHeaderList.AddItem(header))
 347                         return true;
 348                 delete header;
 349         }
 350         return false;
 351 }