ApacheTrafficServer: MIME.h Source File

Go to the documentation of this file.
00001 /** @file
00002 
00003   A brief file description
00004 
00005   @section license License
00006 
00007   Licensed to the Apache Software Foundation (ASF) under one
00008   or more contributor license agreements.  See the NOTICE file
00009   distributed with this work for additional information
00010   regarding copyright ownership.  The ASF licenses this file
00011   to you under the Apache License, Version 2.0 (the
00012   "License"); you may not use this file except in compliance
00013   with the License.  You may obtain a copy of the License at
00014 
00015       http://www.apache.org/licenses/LICENSE-2.0
00016 
00017   Unless required by applicable law or agreed to in writing, software
00018   distributed under the License is distributed on an "AS IS" BASIS,
00019   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00020   See the License for the specific language governing permissions and
00021   limitations under the License.
00022  */
00023 
00024 #ifndef __MIME_H__
00025 #define __MIME_H__
00026 
00027 #include <sys/time.h>
00028 
00029 #include "ink_assert.h"
00030 #include "ink_apidefs.h"
00031 #include "ink_string++.h"
00032 #include "HdrHeap.h"
00033 #include "HdrToken.h"
00034 
00035 /***********************************************************************
00036  *                                                                     *
00037  *                              Defines                                *
00038  *                                                                     *
00039  ***********************************************************************/
00040 
00041 enum MIMEParseResult
00042 {
00043   PARSE_ERROR = -1,
00044   PARSE_DONE = 0,
00045   PARSE_OK = 1,
00046   PARSE_CONT = 2
00047 };
00048 
00049 enum
00050 {
00051   UNDEFINED_COUNT = -1
00052 };
00053 
00054 /// Parsing state.
00055 enum MimeParseState {
00056   MIME_PARSE_BEFORE, ///< Before a field.
00057   MIME_PARSE_FOUND_CR, ///< Before a field, found a CR.
00058   MIME_PARSE_INSIDE, ///< Inside a field.
00059   MIME_PARSE_AFTER,  ///< After a field.
00060 };
00061 
00062 #define MIME_SCANNER_TYPE_LINE                          0
00063 #define MIME_SCANNER_TYPE_FIELD                         1
00064 
00065 /***********************************************************************
00066  *                                                                     *
00067  *                              Assertions                             *
00068  *                                                                     *
00069  ***********************************************************************/
00070 
00071 #ifdef DEBUG
00072 #define MIME_HDR_SANITY_CHECK mime_hdr_sanity_check
00073 #else
00074 #define MIME_HDR_SANITY_CHECK (void)
00075 #endif
00076 
00077 #define MIME_FIELD_SLOT_READINESS_EMPTY         0
00078 #define MIME_FIELD_SLOT_READINESS_DETACHED      1
00079 #define MIME_FIELD_SLOT_READINESS_LIVE          2
00080 #define MIME_FIELD_SLOT_READINESS_DELETED       3
00081 
00082 #define MIME_FIELD_SLOT_FLAGS_DUP_HEAD          (1 << 0)
00083 #define MIME_FIELD_SLOT_FLAGS_COOKED            (1 << 1)
00084 
00085 #define MIME_FIELD_BLOCK_SLOTS                  16
00086 
00087 #define MIME_FIELD_SLOTNUM_BITS                 4
00088 #define MIME_FIELD_SLOTNUM_MASK                 ((1 << MIME_FIELD_SLOTNUM_BITS) - 1)
00089 #define MIME_FIELD_SLOTNUM_MAX                  (MIME_FIELD_SLOTNUM_MASK - 1)
00090 #define MIME_FIELD_SLOTNUM_UNKNOWN              MIME_FIELD_SLOTNUM_MAX
00091 
00092 /***********************************************************************
00093  *                                                                     *
00094  *                    MIMEField & MIMEFieldBlockImpl                   *
00095  *                                                                     *
00096  ***********************************************************************/
00097 
00098 struct MIMEHdrImpl;
00099 
00100 struct MIMEField
00101 {
00102   const char *m_ptr_name;       // 4
00103   const char *m_ptr_value;      // 4
00104   MIMEField *m_next_dup;        // 4
00105   int16_t m_wks_idx;              // 2
00106   uint16_t m_len_name;            // 2
00107   uint32_t m_len_value:24;        // 3
00108   uint8_t m_n_v_raw_printable:1;  // 1/8
00109   uint8_t m_n_v_raw_printable_pad:3;      // 3/8
00110   uint8_t m_readiness:2;          // 2/8
00111   uint8_t m_flags:2;              // 2/8
00112 
00113   bool is_dup_head() const {
00114     return (m_flags & MIME_FIELD_SLOT_FLAGS_DUP_HEAD);
00115   }
00116 
00117   bool is_cooked() {
00118     return (m_flags & MIME_FIELD_SLOT_FLAGS_COOKED);
00119   }
00120 
00121   bool is_live() const {
00122     return (m_readiness == MIME_FIELD_SLOT_READINESS_LIVE);
00123   }
00124 
00125   bool is_detached() const {
00126     return (m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
00127   }
00128 
00129   bool supports_commas() const {
00130     if (m_wks_idx >= 0)
00131       return (hdrtoken_index_to_flags(m_wks_idx) & MIME_FLAGS_COMMAS);
00132     else
00133       return true;               // by default, assume supports commas
00134   }
00135 
00136   const char *name_get(int *length);
00137 
00138   const char *value_get(int *length);
00139   int32_t value_get_int();
00140   uint32_t value_get_uint();
00141   int64_t value_get_int64();
00142   time_t value_get_date();
00143   int value_get_comma_list(StrList * list);
00144 
00145   void name_set(HdrHeap * heap, MIMEHdrImpl * mh, const char *name, int length);
00146 
00147   void value_set(HdrHeap * heap, MIMEHdrImpl * mh, const char *value, int length);
00148   void value_set_int(HdrHeap * heap, MIMEHdrImpl * mh, int32_t value);
00149   void value_set_uint(HdrHeap * heap, MIMEHdrImpl * mh, uint32_t value);
00150   void value_set_int64(HdrHeap * heap, MIMEHdrImpl * mh, int64_t value);
00151   void value_set_date(HdrHeap * heap, MIMEHdrImpl * mh, time_t value);
00152   void value_clear(HdrHeap * heap, MIMEHdrImpl * mh);
00153   // MIME standard separator ',' is used as the default value
00154   // Other separators (e.g. ';' in Set-cookie/Cookie) are also possible
00155   void value_append(HdrHeap * heap, MIMEHdrImpl * mh, const char *value,
00156                     int length, bool prepend_comma = false, const char separator = ',');
00157   int has_dups();
00158 };
00159 
00160 struct MIMEFieldBlockImpl:public HdrHeapObjImpl
00161 {
00162   // HdrHeapObjImpl is 4 bytes
00163   uint32_t m_freetop;
00164   MIMEFieldBlockImpl *m_next;
00165   MIMEField m_field_slots[MIME_FIELD_BLOCK_SLOTS];
00166   // mime_hdr_copy_onto assumes that m_field_slots is last --
00167   // don't add any new fields afterit.
00168 
00169   // Marshaling Functions
00170   int marshal(MarshalXlate * ptr_xlate, int num_ptr, MarshalXlate * str_xlate, int num_str);
00171   void unmarshal(intptr_t offset);
00172   void move_strings(HdrStrHeap * new_heap);
00173   size_t strings_length();
00174 
00175   // Sanity Check Functions
00176   void check_strings(HeapCheck * heaps, int num_heaps);
00177 };
00178 
00179 /***********************************************************************
00180  *                                                                     *
00181  *                              MIMECooked                             *
00182  *                                                                     *
00183  ***********************************************************************/
00184 
00185 enum MIMECookedMask
00186 {
00187   MIME_COOKED_MASK_CC_MAX_AGE = (1 << 0),
00188   MIME_COOKED_MASK_CC_NO_CACHE = (1 << 1),
00189   MIME_COOKED_MASK_CC_NO_STORE = (1 << 2),
00190   MIME_COOKED_MASK_CC_NO_TRANSFORM = (1 << 3),
00191   MIME_COOKED_MASK_CC_MAX_STALE = (1 << 4),
00192   MIME_COOKED_MASK_CC_MIN_FRESH = (1 << 5),
00193   MIME_COOKED_MASK_CC_ONLY_IF_CACHED = (1 << 6),
00194   MIME_COOKED_MASK_CC_PUBLIC = (1 << 7),
00195   MIME_COOKED_MASK_CC_PRIVATE = (1 << 8),
00196   MIME_COOKED_MASK_CC_MUST_REVALIDATE = (1 << 9),
00197   MIME_COOKED_MASK_CC_PROXY_REVALIDATE = (1 << 10),
00198   MIME_COOKED_MASK_CC_S_MAXAGE = (1 << 11),
00199   MIME_COOKED_MASK_CC_NEED_REVALIDATE_ONCE = (1 << 12),
00200   MIME_COOKED_MASK_CC_EXTENSION = (1 << 13)
00201 };
00202 
00203 struct MIMECookedCacheControl
00204 {
00205   uint32_t m_mask;
00206   int32_t m_secs_max_age;
00207   int32_t m_secs_s_maxage;
00208   int32_t m_secs_max_stale;
00209   int32_t m_secs_min_fresh;
00210 };
00211 
00212 struct MIMECookedPragma
00213 {
00214   bool m_no_cache;
00215 };
00216 
00217 struct MIMECooked
00218 {
00219   MIMECookedCacheControl m_cache_control;
00220   MIMECookedPragma m_pragma;
00221 };
00222 
00223 /***********************************************************************
00224  *                                                                     *
00225  *                                MIMEHdr                              *
00226  *                                                                     *
00227  ***********************************************************************/
00228 
00229 struct MIMEHdrImpl:public HdrHeapObjImpl
00230 {
00231   // HdrHeapObjImpl is 4 bytes, so this will result in 4 bytes padding
00232   uint64_t m_presence_bits;
00233   uint32_t m_slot_accelerators[4];
00234 
00235   MIMECooked m_cooked_stuff;
00236 
00237   MIMEFieldBlockImpl *m_fblock_list_tail;
00238   MIMEFieldBlockImpl m_first_fblock;    // 1 block inline
00239   // mime_hdr_copy_onto assumes that m_first_fblock is last --
00240   // don't add any new fields after it.
00241 
00242   // Marshaling Functions
00243   int marshal(MarshalXlate * ptr_xlate, int num_ptr, MarshalXlate * str_xlate, int num_str);
00244   void unmarshal(intptr_t offset);
00245   void move_strings(HdrStrHeap * new_heap);
00246   size_t strings_length();
00247 
00248   // Sanity Check Functions
00249   void check_strings(HeapCheck * heaps, int num_heaps);
00250 
00251   // Cooked values
00252   void recompute_cooked_stuff(MIMEField * changing_field_or_null = NULL);
00253   void recompute_accelerators_and_presence_bits();
00254 };
00255 
00256 /***********************************************************************
00257  *                                                                     *
00258  *                                Parser                               *
00259  *                                                                     *
00260  ***********************************************************************/
00261 
00262 struct MIMEScanner
00263 {
00264   char *m_line;                 // buffered line being built up
00265   //int m_type;               // what kind of scanner: raw line, or field (this has never been used)
00266   int m_line_length;            // size of real live data in buffer
00267   int m_line_size;              // total allocated size of buffer
00268 //  int m_state;                  // state of scanning state machine
00269   MimeParseState m_state; ///< Parsing machine state.
00270 };
00271 
00272 
00273 struct MIMEParser
00274 {
00275   MIMEScanner m_scanner;
00276   int32_t m_field;
00277   int m_field_flags;
00278   int m_value;
00279 };
00280 
00281 /***********************************************************************
00282  *                                                                     *
00283  *                                SDK                                  *
00284  *                                                                     *
00285  ***********************************************************************/
00286 
00287 /********************************************/
00288 /* SDK Handles to Fields are special structures */
00289 /********************************************/
00290 struct MIMEFieldSDKHandle:public HdrHeapObjImpl
00291 {
00292   MIMEHdrImpl *mh;
00293   MIMEField *field_ptr;
00294 };
00295 
00296 /***********************************************************************
00297  *                                                                     *
00298  *                     Well-Known Field Name Tokens                    *
00299  *                                                                     *
00300  ***********************************************************************/
00301 
00302 extern const char *MIME_FIELD_ACCEPT;
00303 extern const char *MIME_FIELD_ACCEPT_CHARSET;
00304 extern const char *MIME_FIELD_ACCEPT_ENCODING;
00305 extern const char *MIME_FIELD_ACCEPT_LANGUAGE;
00306 extern const char *MIME_FIELD_ACCEPT_RANGES;
00307 extern const char *MIME_FIELD_AGE;
00308 extern const char *MIME_FIELD_ALLOW;
00309 extern const char *MIME_FIELD_APPROVED;
00310 extern const char *MIME_FIELD_AUTHORIZATION;
00311 extern const char *MIME_FIELD_BYTES;
00312 extern const char *MIME_FIELD_CACHE_CONTROL;
00313 extern const char *MIME_FIELD_CLIENT_IP;
00314 extern const char *MIME_FIELD_CONNECTION;
00315 extern const char *MIME_FIELD_CONTENT_BASE;
00316 extern const char *MIME_FIELD_CONTENT_ENCODING;
00317 extern const char *MIME_FIELD_CONTENT_LANGUAGE;
00318 extern const char *MIME_FIELD_CONTENT_LENGTH;
00319 extern const char *MIME_FIELD_CONTENT_LOCATION;
00320 extern const char *MIME_FIELD_CONTENT_MD5;
00321 extern const char *MIME_FIELD_CONTENT_RANGE;
00322 extern const char *MIME_FIELD_CONTENT_TYPE;
00323 extern const char *MIME_FIELD_CONTROL;
00324 extern const char *MIME_FIELD_COOKIE;
00325 extern const char *MIME_FIELD_DATE;
00326 extern const char *MIME_FIELD_DISTRIBUTION;
00327 extern const char *MIME_FIELD_ETAG;
00328 extern const char *MIME_FIELD_EXPECT;
00329 extern const char *MIME_FIELD_EXPIRES;
00330 extern const char *MIME_FIELD_FOLLOWUP_TO;
00331 extern const char *MIME_FIELD_FROM;
00332 extern const char *MIME_FIELD_HOST;
00333 extern const char *MIME_FIELD_IF_MATCH;
00334 extern const char *MIME_FIELD_IF_MODIFIED_SINCE;
00335 extern const char *MIME_FIELD_IF_NONE_MATCH;
00336 extern const char *MIME_FIELD_IF_RANGE;
00337 extern const char *MIME_FIELD_IF_UNMODIFIED_SINCE;
00338 extern const char *MIME_FIELD_KEEP_ALIVE;
00339 extern const char *MIME_FIELD_KEYWORDS;
00340 extern const char *MIME_FIELD_LAST_MODIFIED;
00341 extern const char *MIME_FIELD_LINES;
00342 inkcoreapi extern const char *MIME_FIELD_LOCATION;
00343 extern const char *MIME_FIELD_MAX_FORWARDS;
00344 extern const char *MIME_FIELD_MESSAGE_ID;
00345 extern const char *MIME_FIELD_NEWSGROUPS;
00346 extern const char *MIME_FIELD_ORGANIZATION;
00347 extern const char *MIME_FIELD_PATH;
00348 extern const char *MIME_FIELD_PRAGMA;
00349 extern const char *MIME_FIELD_PROXY_AUTHENTICATE;
00350 extern const char *MIME_FIELD_PROXY_AUTHORIZATION;
00351 extern const char *MIME_FIELD_PROXY_CONNECTION;
00352 extern const char *MIME_FIELD_PUBLIC;
00353 extern const char *MIME_FIELD_RANGE;
00354 extern const char *MIME_FIELD_REFERENCES;
00355 extern const char *MIME_FIELD_REFERER;
00356 extern const char *MIME_FIELD_REPLY_TO;
00357 extern const char *MIME_FIELD_RETRY_AFTER;
00358 extern const char *MIME_FIELD_SENDER;
00359 extern const char *MIME_FIELD_SERVER;
00360 extern const char *MIME_FIELD_SET_COOKIE;
00361 extern const char *MIME_FIELD_STRICT_TRANSPORT_SECURITY;
00362 extern const char *MIME_FIELD_SUBJECT;
00363 extern const char *MIME_FIELD_SUMMARY;
00364 extern const char *MIME_FIELD_TE;
00365 extern const char *MIME_FIELD_TRANSFER_ENCODING;
00366 extern const char *MIME_FIELD_UPGRADE;
00367 extern const char *MIME_FIELD_USER_AGENT;
00368 extern const char *MIME_FIELD_VARY;
00369 extern const char *MIME_FIELD_VIA;
00370 extern const char *MIME_FIELD_WARNING;
00371 extern const char *MIME_FIELD_WWW_AUTHENTICATE;
00372 extern const char *MIME_FIELD_XREF;
00373 extern const char *MIME_FIELD_INT_DATA_INFO;
00374 extern const char *MIME_FIELD_X_ID;
00375 extern const char *MIME_FIELD_X_FORWARDED_FOR;
00376 extern const char *MIME_FIELD_SEC_WEBSOCKET_KEY;
00377 extern const char *MIME_FIELD_SEC_WEBSOCKET_VERSION;
00378 
00379 extern const char *MIME_VALUE_BYTES;
00380 extern const char *MIME_VALUE_CHUNKED;
00381 extern const char *MIME_VALUE_CLOSE;
00382 extern const char *MIME_VALUE_COMPRESS;
00383 extern const char *MIME_VALUE_DEFLATE;
00384 extern const char *MIME_VALUE_GZIP;
00385 extern const char *MIME_VALUE_IDENTITY;
00386 extern const char *MIME_VALUE_KEEP_ALIVE;
00387 extern const char *MIME_VALUE_MAX_AGE;
00388 extern const char *MIME_VALUE_MAX_STALE;
00389 extern const char *MIME_VALUE_MIN_FRESH;
00390 extern const char *MIME_VALUE_MUST_REVALIDATE;
00391 extern const char *MIME_VALUE_NONE;
00392 extern const char *MIME_VALUE_NO_CACHE;
00393 extern const char *MIME_VALUE_NO_STORE;
00394 extern const char *MIME_VALUE_NO_TRANSFORM;
00395 extern const char *MIME_VALUE_ONLY_IF_CACHED;
00396 extern const char *MIME_VALUE_PRIVATE;
00397 extern const char *MIME_VALUE_PROXY_REVALIDATE;
00398 extern const char *MIME_VALUE_PUBLIC;
00399 extern const char *MIME_VALUE_S_MAXAGE;
00400 extern const char *MIME_VALUE_NEED_REVALIDATE_ONCE;
00401 extern const char *MIME_VALUE_WEBSOCKET;
00402 
00403 extern int MIME_LEN_ACCEPT;
00404 extern int MIME_LEN_ACCEPT_CHARSET;
00405 extern int MIME_LEN_ACCEPT_ENCODING;
00406 extern int MIME_LEN_ACCEPT_LANGUAGE;
00407 extern int MIME_LEN_ACCEPT_RANGES;
00408 extern int MIME_LEN_AGE;
00409 extern int MIME_LEN_ALLOW;
00410 extern int MIME_LEN_APPROVED;
00411 extern int MIME_LEN_AUTHORIZATION;
00412 extern int MIME_LEN_BYTES;
00413 extern int MIME_LEN_CACHE_CONTROL;
00414 extern int MIME_LEN_CLIENT_IP;
00415 extern int MIME_LEN_CONNECTION;
00416 extern int MIME_LEN_CONTENT_BASE;
00417 extern int MIME_LEN_CONTENT_ENCODING;
00418 extern int MIME_LEN_CONTENT_LANGUAGE;
00419 extern int MIME_LEN_CONTENT_LENGTH;
00420 extern int MIME_LEN_CONTENT_LOCATION;
00421 extern int MIME_LEN_CONTENT_MD5;
00422 extern int MIME_LEN_CONTENT_RANGE;
00423 extern int MIME_LEN_CONTENT_TYPE;
00424 extern int MIME_LEN_CONTROL;
00425 extern int MIME_LEN_COOKIE;
00426 extern int MIME_LEN_DATE;
00427 extern int MIME_LEN_DISTRIBUTION;
00428 extern int MIME_LEN_ETAG;
00429 extern int MIME_LEN_EXPECT;
00430 extern int MIME_LEN_EXPIRES;
00431 extern int MIME_LEN_FOLLOWUP_TO;
00432 extern int MIME_LEN_FROM;
00433 extern int MIME_LEN_HOST;
00434 extern int MIME_LEN_IF_MATCH;
00435 extern int MIME_LEN_IF_MODIFIED_SINCE;
00436 extern int MIME_LEN_IF_NONE_MATCH;
00437 extern int MIME_LEN_IF_RANGE;
00438 extern int MIME_LEN_IF_UNMODIFIED_SINCE;
00439 extern int MIME_LEN_KEEP_ALIVE;
00440 extern int MIME_LEN_KEYWORDS;
00441 extern int MIME_LEN_LAST_MODIFIED;
00442 extern int MIME_LEN_LINES;
00443 inkcoreapi extern int MIME_LEN_LOCATION;
00444 extern int MIME_LEN_MAX_FORWARDS;
00445 extern int MIME_LEN_MESSAGE_ID;
00446 extern int MIME_LEN_NEWSGROUPS;
00447 extern int MIME_LEN_ORGANIZATION;
00448 extern int MIME_LEN_PATH;
00449 extern int MIME_LEN_PRAGMA;
00450 extern int MIME_LEN_PROXY_AUTHENTICATE;
00451 extern int MIME_LEN_PROXY_AUTHORIZATION;
00452 extern int MIME_LEN_PROXY_CONNECTION;
00453 extern int MIME_LEN_PUBLIC;
00454 extern int MIME_LEN_RANGE;
00455 extern int MIME_LEN_REFERENCES;
00456 extern int MIME_LEN_REFERER;
00457 extern int MIME_LEN_REPLY_TO;
00458 extern int MIME_LEN_RETRY_AFTER;
00459 extern int MIME_LEN_SENDER;
00460 extern int MIME_LEN_SERVER;
00461 extern int MIME_LEN_SET_COOKIE;
00462 extern int MIME_LEN_STRICT_TRANSPORT_SECURITY;
00463 extern int MIME_LEN_SUBJECT;
00464 extern int MIME_LEN_SUMMARY;
00465 extern int MIME_LEN_TE;
00466 extern int MIME_LEN_TRANSFER_ENCODING;
00467 extern int MIME_LEN_UPGRADE;
00468 extern int MIME_LEN_USER_AGENT;
00469 extern int MIME_LEN_VARY;
00470 extern int MIME_LEN_VIA;
00471 extern int MIME_LEN_WARNING;
00472 extern int MIME_LEN_WWW_AUTHENTICATE;
00473 extern int MIME_LEN_XREF;
00474 extern int MIME_LEN_INT_DATA_INFO;
00475 extern int MIME_LEN_X_ID;
00476 extern int MIME_LEN_X_FORWARDED_FOR;
00477 
00478 extern int MIME_LEN_BYTES;
00479 extern int MIME_LEN_CHUNKED;
00480 extern int MIME_LEN_CLOSE;
00481 extern int MIME_LEN_COMPRESS;
00482 extern int MIME_LEN_DEFLATE;
00483 extern int MIME_LEN_GZIP;
00484 extern int MIME_LEN_IDENTITY;
00485 extern int MIME_LEN_KEEP_ALIVE;
00486 extern int MIME_LEN_MAX_AGE;
00487 extern int MIME_LEN_MAX_STALE;
00488 extern int MIME_LEN_MIN_FRESH;
00489 extern int MIME_LEN_MUST_REVALIDATE;
00490 extern int MIME_LEN_NONE;
00491 extern int MIME_LEN_NO_CACHE;
00492 extern int MIME_LEN_NO_STORE;
00493 extern int MIME_LEN_NO_TRANSFORM;
00494 extern int MIME_LEN_ONLY_IF_CACHED;
00495 extern int MIME_LEN_PRIVATE;
00496 extern int MIME_LEN_PROXY_REVALIDATE;
00497 extern int MIME_LEN_PUBLIC;
00498 extern int MIME_LEN_S_MAXAGE;
00499 extern int MIME_LEN_NEED_REVALIDATE_ONCE;
00500 
00501 extern int MIME_LEN_SEC_WEBSOCKET_KEY;
00502 extern int MIME_LEN_SEC_WEBSOCKET_VERSION;
00503 
00504 extern int MIME_WKSIDX_ACCEPT;
00505 extern int MIME_WKSIDX_ACCEPT_CHARSET;
00506 extern int MIME_WKSIDX_ACCEPT_ENCODING;
00507 extern int MIME_WKSIDX_ACCEPT_LANGUAGE;
00508 extern int MIME_WKSIDX_ACCEPT_RANGES;
00509 extern int MIME_WKSIDX_AGE;
00510 extern int MIME_WKSIDX_ALLOW;
00511 extern int MIME_WKSIDX_APPROVED;
00512 extern int MIME_WKSIDX_AUTHORIZATION;
00513 extern int MIME_WKSIDX_BYTES;
00514 extern int MIME_WKSIDX_CACHE_CONTROL;
00515 extern int MIME_WKSIDX_CLIENT_IP;
00516 extern int MIME_WKSIDX_CONNECTION;
00517 extern int MIME_WKSIDX_CONTENT_BASE;
00518 extern int MIME_WKSIDX_CONTENT_ENCODING;
00519 extern int MIME_WKSIDX_CONTENT_LANGUAGE;
00520 extern int MIME_WKSIDX_CONTENT_LENGTH;
00521 extern int MIME_WKSIDX_CONTENT_LOCATION;
00522 extern int MIME_WKSIDX_CONTENT_MD5;
00523 extern int MIME_WKSIDX_CONTENT_RANGE;
00524 extern int MIME_WKSIDX_CONTENT_TYPE;
00525 extern int MIME_WKSIDX_CONTROL;
00526 extern int MIME_WKSIDX_COOKIE;
00527 extern int MIME_WKSIDX_DATE;
00528 extern int MIME_WKSIDX_DISTRIBUTION;
00529 extern int MIME_WKSIDX_ETAG;
00530 extern int MIME_WKSIDX_EXPECT;
00531 extern int MIME_WKSIDX_EXPIRES;
00532 extern int MIME_WKSIDX_FOLLOWUP_TO;
00533 extern int MIME_WKSIDX_FROM;
00534 extern int MIME_WKSIDX_HOST;
00535 extern int MIME_WKSIDX_IF_MATCH;
00536 extern int MIME_WKSIDX_IF_MODIFIED_SINCE;
00537 extern int MIME_WKSIDX_IF_NONE_MATCH;
00538 extern int MIME_WKSIDX_IF_RANGE;
00539 extern int MIME_WKSIDX_IF_UNMODIFIED_SINCE;
00540 extern int MIME_WKSIDX_KEEP_ALIVE;
00541 extern int MIME_WKSIDX_KEYWORDS;
00542 extern int MIME_WKSIDX_LAST_MODIFIED;
00543 extern int MIME_WKSIDX_LINES;
00544 extern int MIME_WKSIDX_LOCATION;
00545 extern int MIME_WKSIDX_MAX_FORWARDS;
00546 extern int MIME_WKSIDX_MESSAGE_ID;
00547 extern int MIME_WKSIDX_NEWSGROUPS;
00548 extern int MIME_WKSIDX_ORGANIZATION;
00549 extern int MIME_WKSIDX_PATH;
00550 extern int MIME_WKSIDX_PRAGMA;
00551 extern int MIME_WKSIDX_PROXY_AUTHENTICATE;
00552 extern int MIME_WKSIDX_PROXY_AUTHORIZATION;
00553 extern int MIME_WKSIDX_PROXY_CONNECTION;
00554 extern int MIME_WKSIDX_PUBLIC;
00555 extern int MIME_WKSIDX_RANGE;
00556 extern int MIME_WKSIDX_REFERENCES;
00557 extern int MIME_WKSIDX_REFERER;
00558 extern int MIME_WKSIDX_REPLY_TO;
00559 extern int MIME_WKSIDX_RETRY_AFTER;
00560 extern int MIME_WKSIDX_SENDER;
00561 extern int MIME_WKSIDX_SERVER;
00562 extern int MIME_WKSIDX_SET_COOKIE;
00563 extern int MIME_WKSIDX_STRICT_TRANSPORT_SECURITY;
00564 extern int MIME_WKSIDX_SUBJECT;
00565 extern int MIME_WKSIDX_SUMMARY;
00566 extern int MIME_WKSIDX_TE;
00567 extern int MIME_WKSIDX_TRANSFER_ENCODING;
00568 extern int MIME_WKSIDX_UPGRADE;
00569 extern int MIME_WKSIDX_USER_AGENT;
00570 extern int MIME_WKSIDX_VARY;
00571 extern int MIME_WKSIDX_VIA;
00572 extern int MIME_WKSIDX_WARNING;
00573 extern int MIME_WKSIDX_WWW_AUTHENTICATE;
00574 extern int MIME_WKSIDX_XREF;
00575 extern int MIME_WKSIDX_INT_DATA_INFO;
00576 extern int MIME_WKSIDX_X_ID;
00577 extern int MIME_WKSIDX_SEC_WEBSOCKET_KEY;
00578 extern int MIME_WKSIDX_SEC_WEBSOCKET_VERSION;
00579 
00580 /***********************************************************************
00581  *                                                                     *
00582  *                           Internal C API                            *
00583  *                                                                     *
00584  ***********************************************************************/
00585 
00586 uint64_t mime_field_presence_mask(const char *well_known_str);
00587 uint64_t mime_field_presence_mask(int well_known_str_index);
00588 int mime_field_presence_get(MIMEHdrImpl * h, const char *well_known_str);
00589 int mime_field_presence_get(MIMEHdrImpl * h, int well_known_str_index);
00590 void mime_hdr_presence_set(MIMEHdrImpl * h, const char *well_known_str);
00591 void mime_hdr_presence_set(MIMEHdrImpl * h, int well_known_str_index);
00592 void mime_hdr_presence_unset(MIMEHdrImpl * h, const char *well_known_str);
00593 void mime_hdr_presence_unset(MIMEHdrImpl * h, int well_known_str_index);
00594 
00595 void mime_hdr_sanity_check(MIMEHdrImpl * mh);
00596 
00597 void mime_init();
00598 void mime_init_cache_control_cooking_masks();
00599 void mime_init_date_format_table();
00600 
00601 MIMEHdrImpl *mime_hdr_create(HdrHeap * heap);
00602 void _mime_hdr_field_block_init(MIMEFieldBlockImpl * fblock);
00603 void mime_hdr_cooked_stuff_init(MIMEHdrImpl * mh, MIMEField * changing_field_or_null = NULL);
00604 void mime_hdr_init(MIMEHdrImpl * mh);
00605 MIMEFieldBlockImpl *_mime_field_block_copy(MIMEFieldBlockImpl * s_fblock, HdrHeap * s_heap, HdrHeap * d_heap);
00606 void _mime_field_block_destroy(HdrHeap * heap, MIMEFieldBlockImpl * fblock);
00607 void mime_hdr_destroy_field_block_list(HdrHeap * heap, MIMEFieldBlockImpl * head);
00608 void mime_hdr_destroy(HdrHeap * heap, MIMEHdrImpl * mh);
00609 void mime_hdr_copy_onto(MIMEHdrImpl * s_mh, HdrHeap * s_heap,
00610                         MIMEHdrImpl * d_mh, HdrHeap * d_heap, bool inherit_strs = true);
00611 MIMEHdrImpl *mime_hdr_clone(MIMEHdrImpl * s_mh, HdrHeap * s_heap, HdrHeap * d_heap, bool inherit_strs = true);
00612 void mime_hdr_field_block_list_adjust(int block_count, MIMEFieldBlockImpl * old_list, MIMEFieldBlockImpl * new_list);
00613 int mime_hdr_length_get(MIMEHdrImpl * mh);
00614 
00615 void mime_hdr_fields_clear(HdrHeap * heap, MIMEHdrImpl * mh);
00616 
00617 MIMEField *_mime_hdr_field_list_search_by_wks(MIMEHdrImpl * mh, int wks_idx);
00618 MIMEField *_mime_hdr_field_list_search_by_string(MIMEHdrImpl * mh, const char *field_name_str, int field_name_len);
00619 MIMEField *_mime_hdr_field_list_search_by_slotnum(MIMEHdrImpl * mh, int slotnum);
00620 inkcoreapi MIMEField *mime_hdr_field_find(MIMEHdrImpl * mh, const char *field_name_str, int field_name_len);
00621 
00622 MIMEField *mime_hdr_field_get(MIMEHdrImpl * mh, int idx);
00623 MIMEField *mime_hdr_field_get_slotnum(MIMEHdrImpl * mh, int slotnum);
00624 int mime_hdr_fields_count(MIMEHdrImpl * mh);
00625 
00626 void mime_field_init(MIMEField * field);
00627 MIMEField *mime_field_create(HdrHeap * heap, MIMEHdrImpl * mh);
00628 MIMEField *mime_field_create_named(HdrHeap * heap, MIMEHdrImpl * mh, const char *name, int length);
00629 
00630 void mime_hdr_field_attach(MIMEHdrImpl * mh, MIMEField * field, int check_for_dups, MIMEField * prev_dup);
00631 void mime_hdr_field_detach(MIMEHdrImpl * mh, MIMEField * field, bool detach_all_dups = false);
00632 void mime_hdr_field_delete(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, bool delete_all_dups = false);
00633 
00634 int mime_hdr_field_slotnum(MIMEHdrImpl * mh, MIMEField * field);
00635 inkcoreapi MIMEField *mime_hdr_prepare_for_value_set(HdrHeap * heap, MIMEHdrImpl * mh, const char *name,
00636                                                      int name_length);
00637 
00638 void mime_field_destroy(MIMEHdrImpl * mh, MIMEField * field);
00639 
00640 const char *mime_field_name_get(MIMEField * field, int *length);
00641 void mime_field_name_set(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field,
00642                          int16_t name_wks_idx_or_neg1, const char *name, int length, bool must_copy_string);
00643 
00644 inkcoreapi const char *mime_field_value_get(MIMEField * field, int *length);
00645 int32_t mime_field_value_get_int(MIMEField * field);
00646 uint32_t mime_field_value_get_uint(MIMEField * field);
00647 int64_t mime_field_value_get_int64(MIMEField * field);
00648 time_t mime_field_value_get_date(MIMEField * field);
00649 const char *mime_field_value_get_comma_val(MIMEField * field, int *length, int idx);
00650 int mime_field_value_get_comma_val_count(MIMEField * field);
00651 int mime_field_value_get_comma_list(MIMEField * field, StrList * list);
00652 
00653 void mime_field_value_set_comma_val(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, int idx,
00654                                     const char *new_piece_str, int new_piece_len);
00655 void mime_field_value_delete_comma_val(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, int idx);
00656 void mime_field_value_extend_comma_val(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, int idx,
00657                                        const char *new_piece_str, int new_piece_len);
00658 void mime_field_value_insert_comma_val(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, int idx,
00659                                        const char *new_piece_str, int new_piece_len);
00660 
00661 inkcoreapi void mime_field_value_set(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field,
00662                                      const char *value, int length, bool must_copy_string);
00663 void mime_field_value_set_int(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, int32_t value);
00664 void mime_field_value_set_uint(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, uint32_t value);
00665 void mime_field_value_set_int64(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, int64_t value);
00666 void mime_field_value_set_date(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field, time_t value);
00667 void mime_field_name_value_set(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field,
00668                                int16_t name_wks_idx_or_neg1, const char *name,
00669                                int name_length, const char *value,
00670                                int value_length, int n_v_raw_printable, int n_v_raw_length, bool must_copy_strings);
00671 
00672 void mime_field_value_append(HdrHeap * heap, MIMEHdrImpl * mh, MIMEField * field,
00673                              const char *value, int length, bool prepend_comma, const char separator);
00674 
00675 void mime_scanner_init(MIMEScanner * scanner);
00676 void mime_scanner_clear(MIMEScanner * scanner);
00677 void mime_scanner_append(MIMEScanner * scanner, const char *data, int data_size);
00678 MIMEParseResult mime_scanner_get(MIMEScanner * S, const char **raw_input_s, const char *raw_input_e,
00679                                  const char **output_s, const char **output_e,
00680                                  bool * output_shares_raw_input, bool raw_input_eof, int raw_input_scan_type);
00681 
00682 void mime_parser_init(MIMEParser * parser);
00683 void mime_parser_clear(MIMEParser * parser);
00684 MIMEParseResult mime_parser_parse(MIMEParser * parser, HdrHeap * heap, MIMEHdrImpl * mh,
00685                                   const char **real_s, const char *real_e, bool must_copy_strings, bool eof);
00686 
00687 void mime_hdr_describe(HdrHeapObjImpl * raw, bool recurse);
00688 void mime_field_block_describe(HdrHeapObjImpl * raw, bool recurse);
00689 
00690 int mime_hdr_print(HdrHeap * heap, MIMEHdrImpl * mh, char *buf_start,
00691                    int buf_length, int *buf_index_inout, int *buf_chars_to_skip_inout);
00692 int mime_mem_print(const char *src_d, int src_l, char *buf_start, int buf_length,
00693                    int *buf_index_inout, int *buf_chars_to_skip_inout);
00694 int mime_field_print(MIMEField * field, char *buf_start, int buf_length,
00695                      int *buf_index_inout, int *buf_chars_to_skip_inout);
00696 
00697 const char *mime_str_u16_set(HdrHeap * heap, const char *s_str, int s_len,
00698                              const char **d_str, uint16_t * d_len, bool must_copy);
00699 
00700 int mime_field_length_get(MIMEField * field);
00701 int mime_format_int(char *buf, int32_t val, size_t buf_len);
00702 int mime_format_uint(char *buf, uint32_t val, size_t buf_len);
00703 int mime_format_int64(char *buf, int64_t val, size_t buf_len);
00704 
00705 void mime_days_since_epoch_to_mdy_slowcase(unsigned int days_since_jan_1_1970,
00706                                            int *m_return, int *d_return, int *y_return);
00707 void mime_days_since_epoch_to_mdy(unsigned int days_since_jan_1_1970, int *m_return, int *d_return, int *y_return);
00708 int mime_format_date(char *buffer, time_t value);
00709 
00710 int32_t mime_parse_int(const char *buf, const char *end = NULL);
00711 uint32_t mime_parse_uint(const char *buf, const char *end = NULL);
00712 int64_t mime_parse_int64(const char *buf, const char *end = NULL);
00713 int mime_parse_rfc822_date_fastcase(const char *buf, int length, struct tm *tp);
00714 time_t mime_parse_date(const char *buf, const char *end = NULL);
00715 int mime_parse_day(const char *&buf, const char *end, int *day);
00716 int mime_parse_month(const char *&buf, const char *end, int *month);
00717 int mime_parse_mday(const char *&buf, const char *end, int *mday);
00718 int mime_parse_year(const char *&buf, const char *end, int *year);
00719 int mime_parse_time(const char *&buf, const char *end, int *hour, int *min, int *sec);
00720 int mime_parse_integer(const char *&buf, const char *end, int *integer);
00721 
00722 /***********************************************************************
00723  *                                                                     *
00724  *                          MIMEField Methods                          *
00725  *                                                                     *
00726  ***********************************************************************/
00727 
00728 /*-------------------------------------------------------------------------
00729   -------------------------------------------------------------------------*/
00730 
00731 inline const char *
00732 MIMEField::name_get(int *length)
00733 {
00734   return (mime_field_name_get(this, length));
00735 }
00736 
00737 /*-------------------------------------------------------------------------
00738   -------------------------------------------------------------------------*/
00739 
00740 inline void
00741 MIMEField::name_set(HdrHeap * heap, MIMEHdrImpl * mh, const char *name, int length)
00742 {
00743   int16_t name_wks_idx;
00744   const char *name_wks;
00745 
00746   if (hdrtoken_is_wks(name)) {
00747     name_wks_idx = hdrtoken_wks_to_index(name);
00748     mime_field_name_set(heap, mh, this, name_wks_idx, name, length, 1);
00749   } else {
00750     int field_name_wks_idx = hdrtoken_tokenize(name, length, &name_wks);
00751     mime_field_name_set(heap, mh, this, field_name_wks_idx, (field_name_wks_idx == -1 ? name : name_wks), length, 1);
00752   }
00753 }
00754 
00755 /*-------------------------------------------------------------------------
00756   -------------------------------------------------------------------------*/
00757 
00758 inline const char *
00759 MIMEField::value_get(int *length)
00760 {
00761   return (mime_field_value_get(this, length));
00762 }
00763 
00764 inline int32_t
00765 MIMEField::value_get_int()
00766 {
00767   return (mime_field_value_get_int(this));
00768 }
00769 
00770 inline uint32_t
00771 MIMEField::value_get_uint()
00772 {
00773   return (mime_field_value_get_uint(this));
00774 }
00775 
00776 inline int64_t
00777 MIMEField::value_get_int64()
00778 {
00779   return (mime_field_value_get_int64(this));
00780 }
00781 
00782 inline time_t
00783 MIMEField::value_get_date()
00784 {
00785   return (mime_field_value_get_date(this));
00786 }
00787 
00788 inline int
00789 MIMEField::value_get_comma_list(StrList * list)
00790 {
00791   return (mime_field_value_get_comma_list(this, list));
00792 }
00793 
00794 /*-------------------------------------------------------------------------
00795   -------------------------------------------------------------------------*/
00796 
00797 inline void
00798 MIMEField::value_set(HdrHeap * heap, MIMEHdrImpl * mh, const char *value, int length)
00799 {
00800   mime_field_value_set(heap, mh, this, value, length, 1);
00801 }
00802 
00803 inline void
00804 MIMEField::value_set_int(HdrHeap * heap, MIMEHdrImpl * mh, int32_t value)
00805 {
00806   mime_field_value_set_int(heap, mh, this, value);
00807 }
00808 
00809 inline void
00810 MIMEField::value_set_uint(HdrHeap * heap, MIMEHdrImpl * mh, uint32_t value)
00811 {
00812   mime_field_value_set_uint(heap, mh, this, value);
00813 }
00814 
00815 inline void
00816 MIMEField::value_set_int64(HdrHeap * heap, MIMEHdrImpl * mh, int64_t value)
00817 {
00818   mime_field_value_set_int64(heap, mh, this, value);
00819 }
00820 
00821 inline void
00822 MIMEField::value_set_date(HdrHeap * heap, MIMEHdrImpl * mh, time_t value)
00823 {
00824   mime_field_value_set_date(heap, mh, this, value);
00825 }
00826 
00827 /*-------------------------------------------------------------------------
00828   -------------------------------------------------------------------------*/
00829 
00830 inline void
00831 MIMEField::value_clear(HdrHeap * heap, MIMEHdrImpl * mh)
00832 {
00833   value_set(heap, mh, "", 0);
00834 }
00835 
00836 /*-------------------------------------------------------------------------
00837   -------------------------------------------------------------------------*/
00838 
00839 inline void
00840 MIMEField::value_append(HdrHeap * heap, MIMEHdrImpl * mh, const char *value,
00841                         int length, bool prepend_comma, const char separator)
00842 {
00843   mime_field_value_append(heap, mh, this, value, length, prepend_comma, separator);
00844 }
00845 
00846 inline int
00847 MIMEField::has_dups()
00848 {
00849   return (m_next_dup != NULL);
00850 }
00851 
00852 /***********************************************************************
00853  *                                                                     *
00854  *                           MIMEFieldIter                             *
00855  *                                                                     *
00856  ***********************************************************************/
00857 
00858 struct MIMEFieldIter
00859 {
00860   uint32_t m_slot;
00861   MIMEFieldBlockImpl *m_block;
00862 };
00863 
00864 /*-------------------------------------------------------------------------
00865   -------------------------------------------------------------------------*/
00866 
00867 /***********************************************************************
00868  *                                                                     *
00869  *                            MIMEHdr Class                            *
00870  *                                                                     *
00871  ***********************************************************************/
00872 
00873 class MIMEHdr:public HdrHeapSDKHandle
00874 {
00875 public:
00876 
00877   MIMEHdrImpl * m_mime;
00878 
00879   MIMEHdr();
00880   ~MIMEHdr();
00881 
00882   int valid() const;
00883 
00884   void create(HdrHeap * heap = NULL);
00885   void copy(const MIMEHdr * hdr);
00886 
00887   int length_get();
00888 
00889   void fields_clear();
00890   int fields_count();
00891 
00892   MIMEField *field_create(const char *name = NULL, int length = -1);
00893   MIMEField *field_find(const char *name, int length);
00894   void field_attach(MIMEField * field);
00895   void field_detach(MIMEField * field, bool detach_all_dups = true);
00896   void field_delete(MIMEField * field, bool delete_all_dups = true);
00897   void field_delete(const char *name, int name_length);
00898 
00899   MIMEField *iter_get_first(MIMEFieldIter * iter);
00900   MIMEField *iter_get_next(MIMEFieldIter * iter);
00901 
00902   uint64_t presence(uint64_t mask);
00903 
00904   int print(char *buf, int bufsize, int *bufindex, int *chars_to_skip);
00905 
00906   int parse(MIMEParser * parser, const char **start, const char *end, bool must_copy_strs, bool eof);
00907 
00908   const char *value_get(const char *name, int name_length, int *value_length);
00909   int32_t value_get_int(const char *name, int name_length);
00910   uint32_t value_get_uint(const char *name, int name_length);
00911   int64_t value_get_int64(const char *name, int name_length);
00912   time_t value_get_date(const char *name, int name_length);
00913   int value_get_comma_list(const char *name, int name_length, StrList * list);
00914 
00915   void value_set(const char *name, int name_length, const char *value, int value_length);
00916   void value_set_int(const char *name, int name_length, int32_t value);
00917   void value_set_uint(const char *name, int name_length, uint32_t value);
00918   void value_set_int64(const char *name, int name_length, int64_t value);
00919   void value_set_date(const char *name, int name_length, time_t value);
00920   // MIME standard separator ',' is used as the default value
00921   // Other separators (e.g. ';' in Set-cookie/Cookie) are also possible
00922   void value_append(const char *name, int name_length,
00923                     const char *value, int value_length, bool prepend_comma = false, const char separator = ',');
00924 
00925   void field_value_set(MIMEField * field, const char *value, int value_length);
00926   void field_value_set_int(MIMEField * field, int32_t value);
00927   void field_value_set_uint(MIMEField * field, uint32_t value);
00928   void field_value_set_int64(MIMEField * field, int64_t value);
00929   void field_value_set_date(MIMEField * field, time_t value);
00930   // MIME standard separator ',' is used as the default value
00931   // Other separators (e.g. ';' in Set-cookie/Cookie) are also possible
00932   void field_value_append(MIMEField * field,
00933                           const char *value, int value_length, bool prepend_comma = false, const char separator = ',');
00934   time_t get_age();
00935   int64_t get_content_length();
00936   time_t get_date();
00937   time_t get_expires();
00938   time_t get_if_modified_since();
00939   time_t get_if_unmodified_since();
00940   time_t get_last_modified();
00941   time_t get_if_range_date();
00942   int32_t get_max_forwards();
00943   int32_t get_warning(int idx = 0);
00944 
00945   uint32_t get_cooked_cc_mask();
00946   int32_t get_cooked_cc_max_age();
00947   int32_t get_cooked_cc_s_maxage();
00948   int32_t get_cooked_cc_max_stale();
00949   int32_t get_cooked_cc_min_fresh();
00950   bool get_cooked_pragma_no_cache();
00951 
00952   /** Get the value of the host field.
00953       This parses the host field for brackets and port value.
00954       @return The mime HOST field if it has a value, @c NULL otherwise.
00955   */
00956   MIMEField* get_host_port_values(
00957                             char const** host_ptr, ///< [out] Pointer to host.
00958                             int* host_len, ///< [out] Length of host.
00959                             char const** port_ptr, ///< [out] Pointer to port.
00960                             int* port_len ///< [out] Length of port.
00961                             );
00962 
00963   void set_cooked_cc_need_revalidate_once();
00964   void unset_cooked_cc_need_revalidate_once();
00965 
00966   void set_age(time_t value);
00967   void set_content_length(int64_t value);
00968   void set_date(time_t value);
00969   void set_expires(time_t value);
00970   void set_if_modified_since(time_t value);
00971   void set_if_unmodified_since(time_t value);
00972   void set_last_modified(time_t value);
00973   void set_max_forwards(int32_t value);
00974   void set_warning(int32_t value);
00975   void set_server(const char *server_id_tag, int server_id_tag_size);
00976 
00977 private:
00978 
00979   // No gratuitous copies & refcounts!
00980     MIMEHdr(const MIMEHdr & m);
00981     MIMEHdr & operator =(const MIMEHdr & m);
00982 };
00983 
00984 /*-------------------------------------------------------------------------
00985   -------------------------------------------------------------------------*/
00986 
00987 inline MIMEHdr::MIMEHdr():HdrHeapSDKHandle()
00988 {
00989 }
00990 
00991 /*-------------------------------------------------------------------------
00992   -------------------------------------------------------------------------*/
00993 
00994 inline MIMEHdr::~MIMEHdr()
00995 {
00996 }
00997 
00998 /*-------------------------------------------------------------------------
00999   -------------------------------------------------------------------------*/
01000 
01001 inline int
01002 MIMEHdr::valid() const
01003 {
01004   return (m_mime && m_heap);
01005 }
01006 
01007 /*-------------------------------------------------------------------------
01008   -------------------------------------------------------------------------*/
01009 
01010 inline void
01011 MIMEHdr::create(HdrHeap * heap)
01012 {
01013   if (heap) {
01014     m_heap = heap;
01015   } else if (!m_heap) {
01016     m_heap = new_HdrHeap();
01017   }
01018 
01019   m_mime = mime_hdr_create(m_heap);
01020 }
01021 
01022 /*-------------------------------------------------------------------------
01023   -------------------------------------------------------------------------*/
01024 
01025 inline void
01026 MIMEHdr::copy(const MIMEHdr * src_hdr)
01027 {
01028   if (valid()) {
01029     mime_hdr_copy_onto(src_hdr->m_mime, src_hdr->m_heap, m_mime, m_heap, (m_heap != src_hdr->m_heap) ? true : false);
01030   } else {
01031     m_heap = new_HdrHeap();
01032     m_mime = mime_hdr_clone(src_hdr->m_mime, src_hdr->m_heap, m_heap);
01033   }
01034 }
01035 
01036 /*-------------------------------------------------------------------------
01037   -------------------------------------------------------------------------*/
01038 
01039 inline int
01040 MIMEHdr::length_get()
01041 {
01042   return mime_hdr_length_get(m_mime);
01043 }
01044 
01045 /*-------------------------------------------------------------------------
01046   -------------------------------------------------------------------------*/
01047 
01048 inline void
01049 MIMEHdr::fields_clear()
01050 {
01051   mime_hdr_fields_clear(m_heap, m_mime);
01052 }
01053 
01054 /*-------------------------------------------------------------------------
01055   -------------------------------------------------------------------------*/
01056 
01057 inline int
01058 MIMEHdr::fields_count()
01059 {
01060   return mime_hdr_fields_count(m_mime);
01061 }
01062 
01063 /*-------------------------------------------------------------------------
01064   -------------------------------------------------------------------------*/
01065 
01066 inline MIMEField *
01067 MIMEHdr::field_create(const char *name, int length)
01068 {
01069   MIMEField *field = mime_field_create(m_heap, m_mime);
01070 
01071   if (name) {
01072     int field_name_wks_idx = hdrtoken_tokenize(name, length);
01073     mime_field_name_set(m_heap, m_mime, field, field_name_wks_idx, name, length, 1);
01074   }
01075 
01076   return (field);
01077 }
01078 
01079 /*-------------------------------------------------------------------------
01080   -------------------------------------------------------------------------*/
01081 
01082 inline MIMEField *
01083 MIMEHdr::field_find(const char *name, int length)
01084 {
01085 //    ink_assert(valid());
01086   return mime_hdr_field_find(m_mime, name, length);
01087 }
01088 
01089 /*-------------------------------------------------------------------------
01090   -------------------------------------------------------------------------*/
01091 
01092 inline void
01093 MIMEHdr::field_attach(MIMEField * field)
01094 {
01095   mime_hdr_field_attach(m_mime, field, 1, NULL);
01096 }
01097 
01098 /*-------------------------------------------------------------------------
01099   -------------------------------------------------------------------------*/
01100 
01101 inline void
01102 MIMEHdr::field_detach(MIMEField * field, bool detach_all_dups)
01103 {
01104   mime_hdr_field_detach(m_mime, field, detach_all_dups);
01105 }
01106 
01107 /*-------------------------------------------------------------------------
01108   -------------------------------------------------------------------------*/
01109 
01110 inline void
01111 MIMEHdr::field_delete(MIMEField * field, bool delete_all_dups)
01112 {
01113   mime_hdr_field_delete(m_heap, m_mime, field, delete_all_dups);
01114 }
01115 
01116 inline void
01117 MIMEHdr::field_delete(const char *name, int name_length)
01118 {
01119   MIMEField *field = field_find(name, name_length);
01120   if (field)
01121     field_delete(field);
01122 }
01123 
01124 inline MIMEField *
01125 MIMEHdr::iter_get_first(MIMEFieldIter * iter)
01126 {
01127   iter->m_block = &m_mime->m_first_fblock;
01128   iter->m_slot = (unsigned int) -1;
01129   return iter_get_next(iter);
01130 }
01131 
01132 inline MIMEField *
01133 MIMEHdr::iter_get_next(MIMEFieldIter * iter)
01134 {
01135   MIMEField *f;
01136   MIMEFieldBlockImpl *b = iter->m_block;
01137 
01138   int slot = iter->m_slot + 1;
01139 
01140   while (b) {
01141     for (; slot < (int) b->m_freetop; slot++) {
01142       f = &(b->m_field_slots[slot]);
01143       if (f->is_live()) {
01144         iter->m_slot = slot;
01145         iter->m_block = b;
01146         return f;
01147       }
01148     }
01149     b = b->m_next;
01150     slot = 0;
01151   }
01152 
01153   iter->m_block = NULL;
01154   return NULL;
01155 }
01156 
01157 /*-------------------------------------------------------------------------
01158   -------------------------------------------------------------------------*/
01159 
01160 inline uint64_t
01161 MIMEHdr::presence(uint64_t mask)
01162 {
01163   return (m_mime->m_presence_bits & mask);
01164 }
01165 
01166 /*-------------------------------------------------------------------------
01167   -------------------------------------------------------------------------*/
01168 
01169 inline int
01170 MIMEHdr::print(char *buf, int bufsize, int *bufindex, int *chars_to_skip)
01171 {
01172   return mime_hdr_print(m_heap, m_mime, buf, bufsize, bufindex, chars_to_skip);
01173 }
01174 
01175 /*-------------------------------------------------------------------------
01176   -------------------------------------------------------------------------*/
01177 
01178 inline int
01179 MIMEHdr::parse(MIMEParser * parser, const char **start, const char *end, bool must_copy_strs, bool eof)
01180 {
01181   if (!m_heap)
01182     m_heap = new_HdrHeap();
01183 
01184   if (!m_mime)
01185     m_mime = mime_hdr_create(m_heap);
01186 
01187   return mime_parser_parse(parser, m_heap, m_mime, start, end, must_copy_strs, eof);
01188 }
01189 
01190 /*-------------------------------------------------------------------------
01191   -------------------------------------------------------------------------*/
01192 
01193 inline const char *
01194 MIMEHdr::value_get(const char *name, int name_length, int *value_length_return)
01195 {
01196 //    ink_assert(valid());
01197   MIMEField *field = field_find(name, name_length);
01198 
01199   if (field)
01200     return (mime_field_value_get(field, value_length_return));
01201   else
01202     return (NULL);
01203 }
01204 
01205 inline int32_t
01206 MIMEHdr::value_get_int(const char *name, int name_length)
01207 {
01208   MIMEField *field = field_find(name, name_length);
01209 
01210   if (field)
01211     return (mime_field_value_get_int(field));
01212   else
01213     return (0);
01214 }
01215 
01216 inline uint32_t
01217 MIMEHdr::value_get_uint(const char *name, int name_length)
01218 {
01219   MIMEField *field = field_find(name, name_length);
01220 
01221   if (field)
01222     return (mime_field_value_get_uint(field));
01223   else
01224     return (0);
01225 }
01226 
01227 inline int64_t
01228 MIMEHdr::value_get_int64(const char *name, int name_length)
01229 {
01230   MIMEField *field = field_find(name, name_length);
01231 
01232   if (field)
01233     return (mime_field_value_get_int64(field));
01234   else
01235     return (0);
01236 }
01237 
01238 inline time_t
01239 MIMEHdr::value_get_date(const char *name, int name_length)
01240 {
01241   MIMEField *field = field_find(name, name_length);
01242 
01243   if (field)
01244     return (mime_field_value_get_date(field));
01245   else
01246     return (0);
01247 }
01248 
01249 inline int
01250 MIMEHdr::value_get_comma_list(const char *name, int name_length, StrList * list)
01251 {
01252   MIMEField *field = field_find(name, name_length);
01253 
01254   if (field)
01255     return (field->value_get_comma_list(list));
01256   else
01257     return (0);
01258 }
01259 
01260 /*-------------------------------------------------------------------------
01261   -------------------------------------------------------------------------*/
01262 
01263 inline void
01264 MIMEHdr::field_value_set(MIMEField * field, const char *value, int value_length)
01265 {
01266   field->value_set(m_heap, m_mime, value, value_length);
01267 }
01268 
01269 inline void
01270 MIMEHdr::field_value_set_int(MIMEField * field, int32_t value)
01271 {
01272   field->value_set_int(m_heap, m_mime, value);
01273 }
01274 
01275 inline void
01276 MIMEHdr::field_value_set_uint(MIMEField * field, uint32_t value)
01277 {
01278   field->value_set_uint(m_heap, m_mime, value);
01279 }
01280 
01281 inline void
01282 MIMEHdr::field_value_set_int64(MIMEField * field, int64_t value)
01283 {
01284   field->value_set_int64(m_heap, m_mime, value);
01285 }
01286 
01287 inline void
01288 MIMEHdr::field_value_set_date(MIMEField * field, time_t value)
01289 {
01290   field->value_set_date(m_heap, m_mime, value);
01291 }
01292 
01293 /*-------------------------------------------------------------------------
01294   -------------------------------------------------------------------------*/
01295 
01296 inline void
01297 MIMEHdr::field_value_append(MIMEField * field,
01298                             const char *value_str, int value_len, bool prepend_comma, const char separator)
01299 {
01300   field->value_append(m_heap, m_mime, value_str, value_len, prepend_comma, separator);
01301 }
01302 
01303 /*-------------------------------------------------------------------------
01304   -------------------------------------------------------------------------*/
01305 
01306 inline void
01307 MIMEHdr::value_set(const char *name, int name_length, const char *value, int value_length)
01308 {
01309   MIMEField *field;
01310   field = mime_hdr_prepare_for_value_set(m_heap, m_mime, name, name_length);
01311   field->value_set(m_heap, m_mime, value, value_length);
01312 }
01313 
01314 inline void
01315 MIMEHdr::value_set_int(const char *name, int name_length, int32_t value)
01316 {
01317   MIMEField *field;
01318   field = mime_hdr_prepare_for_value_set(m_heap, m_mime, name, name_length);
01319   field->value_set_int(m_heap, m_mime, value);
01320 }
01321 
01322 inline void
01323 MIMEHdr::value_set_uint(const char *name, int name_length, uint32_t value)
01324 {
01325   MIMEField *field;
01326   field = mime_hdr_prepare_for_value_set(m_heap, m_mime, name, name_length);
01327   field->value_set_uint(m_heap, m_mime, value);
01328 }
01329 
01330 inline void
01331 MIMEHdr::value_set_int64(const char *name, int name_length, int64_t value)
01332 {
01333   MIMEField *field;
01334   field = mime_hdr_prepare_for_value_set(m_heap, m_mime, name, name_length);
01335   field->value_set_int64(m_heap, m_mime, value);
01336 }
01337 
01338 inline void
01339 MIMEHdr::value_set_date(const char *name, int name_length, time_t value)
01340 {
01341   MIMEField *field;
01342   field = mime_hdr_prepare_for_value_set(m_heap, m_mime, name, name_length);
01343   field->value_set_date(m_heap, m_mime, value);
01344 }
01345 
01346 /*-------------------------------------------------------------------------
01347   -------------------------------------------------------------------------*/
01348 
01349 inline void
01350 MIMEHdr::value_append(const char *name, int name_length,
01351                       const char *value, int value_length, bool prepend_comma, const char separator)
01352 {
01353   MIMEField *field;
01354 
01355   field = field_find(name, name_length);
01356   if (field) {
01357     while (field->m_next_dup)
01358       field = field->m_next_dup;
01359     field->value_append(m_heap, m_mime, value, value_length, prepend_comma, separator);
01360   } else {
01361     field = field_create(name, name_length);
01362     field_attach(field);
01363     field->value_set(m_heap, m_mime, value, value_length);
01364   }
01365 }
01366 
01367 /*-------------------------------------------------------------------------
01368   -------------------------------------------------------------------------*/
01369 inline time_t
01370 MIMEHdr::get_age()
01371 {
01372   int64_t age = value_get_int64(MIME_FIELD_AGE, MIME_LEN_AGE);
01373 
01374   if (age < 0) // We should ignore negative Age: values
01375     return 0;
01376 
01377   if ((4 == sizeof(time_t)) && (age > INT_MAX)) // Overflow
01378     return -1;
01379 
01380   return age;
01381 }
01382 
01383 /*-------------------------------------------------------------------------
01384   -------------------------------------------------------------------------*/
01385 
01386 inline int64_t
01387 MIMEHdr::get_content_length()
01388 {
01389   return (value_get_int64(MIME_FIELD_CONTENT_LENGTH, MIME_LEN_CONTENT_LENGTH));
01390 }
01391 
01392 /*-------------------------------------------------------------------------
01393   -------------------------------------------------------------------------*/
01394 
01395 inline time_t
01396 MIMEHdr::get_date()
01397 {
01398   return (value_get_date(MIME_FIELD_DATE, MIME_LEN_DATE));
01399 }
01400 
01401 /*-------------------------------------------------------------------------
01402   -------------------------------------------------------------------------*/
01403 
01404 inline time_t
01405 MIMEHdr::get_expires()
01406 {
01407   return (value_get_date(MIME_FIELD_EXPIRES, MIME_LEN_EXPIRES));
01408 }
01409 
01410 /*-------------------------------------------------------------------------
01411   -------------------------------------------------------------------------*/
01412 
01413 inline time_t
01414 MIMEHdr::get_if_modified_since()
01415 {
01416   return (value_get_date(MIME_FIELD_IF_MODIFIED_SINCE, MIME_LEN_IF_MODIFIED_SINCE));
01417 }
01418 
01419 /*-------------------------------------------------------------------------
01420   -------------------------------------------------------------------------*/
01421 
01422 inline time_t
01423 MIMEHdr::get_if_unmodified_since()
01424 {
01425   return (value_get_date(MIME_FIELD_IF_UNMODIFIED_SINCE, MIME_LEN_IF_UNMODIFIED_SINCE));
01426 }
01427 
01428 /*-------------------------------------------------------------------------
01429   -------------------------------------------------------------------------*/
01430 
01431 inline time_t
01432 MIMEHdr::get_last_modified()
01433 {
01434   return (value_get_date(MIME_FIELD_LAST_MODIFIED, MIME_LEN_LAST_MODIFIED));
01435 }
01436 
01437 /*-------------------------------------------------------------------------
01438   -------------------------------------------------------------------------*/
01439 
01440 inline time_t
01441 MIMEHdr::get_if_range_date()
01442 {
01443   return (value_get_date(MIME_FIELD_IF_RANGE, MIME_LEN_IF_RANGE));
01444 }
01445 
01446 /*-------------------------------------------------------------------------
01447   -------------------------------------------------------------------------*/
01448 
01449 inline int32_t
01450 MIMEHdr::get_max_forwards()
01451 {
01452   return (value_get_int(MIME_FIELD_MAX_FORWARDS, MIME_LEN_MAX_FORWARDS));
01453 }
01454 
01455 /*-------------------------------------------------------------------------
01456   -------------------------------------------------------------------------*/
01457 
01458 inline int32_t
01459 MIMEHdr::get_warning(int idx)
01460 {
01461   (void) idx;
01462   // FIXME: what do we do here?
01463   ink_release_assert(!"unimplemented");
01464   return (0);
01465 }
01466 
01467 /*-------------------------------------------------------------------------
01468   -------------------------------------------------------------------------*/
01469 
01470 inline uint32_t
01471 MIMEHdr::get_cooked_cc_mask()
01472 {
01473   return (m_mime->m_cooked_stuff.m_cache_control.m_mask);
01474 }
01475 
01476 /*-------------------------------------------------------------------------
01477   -------------------------------------------------------------------------*/
01478 
01479 inline int32_t
01480 MIMEHdr::get_cooked_cc_max_age()
01481 {
01482   return (m_mime->m_cooked_stuff.m_cache_control.m_secs_max_age);
01483 }
01484 
01485 /*-------------------------------------------------------------------------
01486   -------------------------------------------------------------------------*/
01487 
01488 inline int32_t
01489 MIMEHdr::get_cooked_cc_s_maxage()
01490 {
01491   return (m_mime->m_cooked_stuff.m_cache_control.m_secs_s_maxage);
01492 }
01493 
01494 /*-------------------------------------------------------------------------
01495   -------------------------------------------------------------------------*/
01496 
01497 inline int32_t
01498 MIMEHdr::get_cooked_cc_max_stale()
01499 {
01500   return (m_mime->m_cooked_stuff.m_cache_control.m_secs_max_stale);
01501 }
01502 
01503 /*-------------------------------------------------------------------------
01504   -------------------------------------------------------------------------*/
01505 
01506 inline int32_t
01507 MIMEHdr::get_cooked_cc_min_fresh()
01508 {
01509   return (m_mime->m_cooked_stuff.m_cache_control.m_secs_min_fresh);
01510 }
01511 
01512 /*-------------------------------------------------------------------------
01513   -------------------------------------------------------------------------*/
01514 
01515 inline bool
01516 MIMEHdr::get_cooked_pragma_no_cache()
01517 {
01518   return (m_mime->m_cooked_stuff.m_pragma.m_no_cache);
01519 }
01520 
01521 /*-------------------------------------------------------------------------
01522   -------------------------------------------------------------------------*/
01523 
01524 inline void
01525 MIMEHdr::set_cooked_cc_need_revalidate_once()
01526 {
01527   m_mime->m_cooked_stuff.m_cache_control.m_mask |= MIME_COOKED_MASK_CC_NEED_REVALIDATE_ONCE;
01528 }
01529 
01530 /*-------------------------------------------------------------------------
01531   -------------------------------------------------------------------------*/
01532 
01533 inline void
01534 MIMEHdr::unset_cooked_cc_need_revalidate_once()
01535 {
01536   m_mime->m_cooked_stuff.m_cache_control.m_mask &= ~((uint32_t) MIME_COOKED_MASK_CC_NEED_REVALIDATE_ONCE);
01537 }
01538 
01539 /*-------------------------------------------------------------------------
01540   -------------------------------------------------------------------------*/
01541 
01542 inline void
01543 MIMEHdr::set_age(time_t value)
01544 {
01545   if (value < 0)
01546     value_set_uint(MIME_FIELD_AGE, MIME_LEN_AGE, (uint32_t)INT_MAX + 1);
01547   else {
01548     if (sizeof(time_t) > 4) {
01549       value_set_int64(MIME_FIELD_AGE, MIME_LEN_AGE, value);
01550     } else {
01551       value_set_uint(MIME_FIELD_AGE, MIME_LEN_AGE, value);
01552     }
01553   }
01554 }
01555 
01556 /*-------------------------------------------------------------------------
01557   -------------------------------------------------------------------------*/
01558 
01559 inline void
01560 MIMEHdr::set_content_length(int64_t value)
01561 {
01562   value_set_int64(MIME_FIELD_CONTENT_LENGTH, MIME_LEN_CONTENT_LENGTH, value);
01563 }
01564 
01565 /*-------------------------------------------------------------------------
01566   -------------------------------------------------------------------------*/
01567 
01568 inline void
01569 MIMEHdr::set_date(time_t value)
01570 {
01571   value_set_date(MIME_FIELD_DATE, MIME_LEN_DATE, value);
01572 }
01573 
01574 /*-------------------------------------------------------------------------
01575   -------------------------------------------------------------------------*/
01576 
01577 inline void
01578 MIMEHdr::set_expires(time_t value)
01579 {
01580   value_set_date(MIME_FIELD_EXPIRES, MIME_LEN_EXPIRES, value);
01581 }
01582 
01583 /*-------------------------------------------------------------------------
01584   -------------------------------------------------------------------------*/
01585 
01586 inline void
01587 MIMEHdr::set_if_modified_since(time_t value)
01588 {
01589   value_set_date(MIME_FIELD_IF_MODIFIED_SINCE, MIME_LEN_IF_MODIFIED_SINCE, value);
01590 }
01591 
01592 /*-------------------------------------------------------------------------
01593   -------------------------------------------------------------------------*/
01594 
01595 inline void
01596 MIMEHdr::set_if_unmodified_since(time_t value)
01597 {
01598   value_set_date(MIME_FIELD_IF_UNMODIFIED_SINCE, MIME_LEN_IF_UNMODIFIED_SINCE, value);
01599 }
01600 
01601 /*-------------------------------------------------------------------------
01602   -------------------------------------------------------------------------*/
01603 
01604 inline void
01605 MIMEHdr::set_last_modified(time_t value)
01606 {
01607   value_set_date(MIME_FIELD_LAST_MODIFIED, MIME_LEN_LAST_MODIFIED, value);
01608 }
01609 
01610 /*-------------------------------------------------------------------------
01611   -------------------------------------------------------------------------*/
01612 
01613 inline void
01614 MIMEHdr::set_max_forwards(int32_t value)
01615 {
01616   value_set_int(MIME_FIELD_MAX_FORWARDS, MIME_LEN_MAX_FORWARDS, value);
01617 }
01618 
01619 /*-------------------------------------------------------------------------
01620   -------------------------------------------------------------------------*/
01621 
01622 inline void
01623 MIMEHdr::set_warning(int32_t value)
01624 {
01625   value_set_int(MIME_FIELD_WARNING, MIME_LEN_WARNING, value);
01626 }
01627 
01628 /*-------------------------------------------------------------------------
01629   -------------------------------------------------------------------------*/
01630 
01631 inline void
01632 MIMEHdr::set_server(const char *server_id_tag, int server_id_tag_size)
01633 {
01634   value_set(MIME_FIELD_SERVER, MIME_LEN_SERVER, server_id_tag, server_id_tag_size);
01635 }
01636 
01637 #endif /* __MIME_H__ */