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 Header deletion
 249
 250
 251 void
 252 BHttpHeaders::Clear()
 253 {
 254         _EraseData();
 255         fHeaderList.MakeEmpty();
 256 }
 257
 258
 259 // #pragma mark Overloaded operators
 260
 261
 262 BHttpHeaders&
 263 BHttpHeaders::operator=(const BHttpHeaders& other)
 264 {
 265         Clear();
 266
 267         for (int32 i = 0; i < other.CountHeaders(); i++)
 268                 AddHeader(other.HeaderAt(i).Name(), other.HeaderAt(i).Value());
 269
 270         return *this;
 271 }
 272
 273
 274 BHttpHeader&
 275 BHttpHeaders::operator[](int32 index) const
 276 {
 277         //! Note: Index _must_ be in-bounds
 278         BHttpHeader* header
 279                 = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAtFast(index));
 280
 281         return *header;
 282 }
 283
 284
 285 const char*
 286 BHttpHeaders::operator[](const char* name) const
 287 {
 288         return HeaderValue(name);
 289 }
 290
 291
 292 void
 293 BHttpHeaders::_EraseData()
 294 {
 295         // Free allocated data;
 296         for (int32 i = 0; i < fHeaderList.CountItems(); i++) {
 297                 BHttpHeader* header
 298                         = reinterpret_cast<BHttpHeader*>(fHeaderList.ItemAtFast(i));
 299
 300                 delete header;
 301         }
 302 }
 303
 304
 305 bool
 306 BHttpHeaders::_AddOrDeleteHeader(BHttpHeader* header)
 307 {
 308         if (header != NULL) {
 309                 if (fHeaderList.AddItem(header))
 310                         return true;
 311                 delete header;
 312         }
 313         return false;
 314 }