RegisteredHeaders.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_HTTP_REGISTEREDHEADERS_H
#define SQUID_HTTP_REGISTEREDHEADERS_H
 
#include "base/LookupTable.h"
 
#include <iosfwd>
#include <vector>
 
namespace Http
{
enum HdrType {
    enumBegin_ = 0,                 // service value for WholeEnum iteration
    ACCEPT = enumBegin_,             /* MUST BE FIRST */
    ACCEPT_CHARSET,                 
    ACCEPT_ENCODING,                
    /*ACCEPT_FEATURES,*/            /* RFC 2295 */
    ACCEPT_LANGUAGE,                
    ACCEPT_RANGES,                  
    AGE,                            
    ALLOW,                          
    ALTERNATE_PROTOCOL,             
    AUTHENTICATION_INFO,            
    AUTHORIZATION,                  
    CACHE_CONTROL,                  
    CACHE_STATUS,                   
    CDN_LOOP,                       
    CONNECTION,                     
    CONTENT_BASE,                   
    CONTENT_DISPOSITION,            
    CONTENT_ENCODING,               
    CONTENT_LANGUAGE,               
    CONTENT_LENGTH,                 
    CONTENT_LOCATION,               
    CONTENT_MD5,                    
    CONTENT_RANGE,                  
    CONTENT_TYPE,                   
    COOKIE,                         
    COOKIE2,                        
    DATE,                           
    /*DAV,*/                        /* RFC 2518 */
    /*DEPTH,*/                      /* RFC 2518 */
    /*DERIVED_FROM,*/               /* deprecated RFC 2068 */
    /*DESTINATION,*/                /* RFC 2518 */
    ETAG,                           
    EXPECT,                         
    EXPIRES,                        
    FORWARDED,                      
    FROM,                           
    HOST,                           
    /*HTTP2_SETTINGS,*/             /* obsolete RFC 7540 */
    /*IF,*/                         /* RFC 2518 */
    IF_MATCH,                       
    IF_MODIFIED_SINCE,              
    IF_NONE_MATCH,                  
    IF_RANGE,                       
    IF_UNMODIFIED_SINCE,            
    KEEP_ALIVE,                     
    KEY,                            
    LAST_MODIFIED,                  
    LINK,                           
    LOCATION,                       
    /*LOCK_TOKEN,*/                 /* RFC 2518 */
    MAX_FORWARDS,                   
    MIME_VERSION,                   
    NEGOTIATE,                      
    /*OVERWRITE,*/                  /* RFC 2518 */
    ORIGIN,                         /* CORS Draft specification (see http://www.w3.org/TR/cors/) */
    PRAGMA,                         
    PRIORITY,                       
    PROXY_AUTHENTICATE,             
    PROXY_AUTHENTICATION_INFO,      
    PROXY_AUTHORIZATION,            
    PROXY_CONNECTION,               
    PROXY_SUPPORT,                  
    PUBLIC,                         
    RANGE,                          
    REFERER,                        
    REQUEST_RANGE,                  
    RETRY_AFTER,                    
    SERVER,                         
    SET_COOKIE,                     
    SET_COOKIE2,                    
    /*STATUS_URI,*/                 /* RFC 2518 */
    /*TCN,*/                        /* experimental RFC 2295 */
    TE,                             
    /*TIMEOUT,*/                    /* RFC 2518 */
    TITLE,                          /* obsolete draft suggested header */
    TRAILER,                        
    TRANSFER_ENCODING,              
    TRANSLATE,                      
    UNLESS_MODIFIED_SINCE,          
    UPGRADE,                        
    USER_AGENT,                     
    /*VARIANT_VARY,*/               /* experimental RFC 2295 */
    VARY,                           
    VIA,                            
    WWW_AUTHENTICATE,               
    X_FORWARDED_FOR,                
    X_REQUEST_URI,                  
    X_SQUID_ERROR,                  
    HDR_X_ACCELERATOR_VARY,             
    X_NEXT_SERVICES,                
    SURROGATE_CAPABILITY,           
    SURROGATE_CONTROL,              
    FRONT_END_HTTPS,                
    FTP_COMMAND,                    
    FTP_ARGUMENTS,                  
    FTP_PRE,                        
    FTP_STATUS,                     
    FTP_REASON,                     
    OTHER,                          
    BAD_HDR,                        
    enumEnd_                        // internal tag for end-of-headers
};
 
enum class HdrFieldType {
    ftInvalid,  
    ftInt,
    ftInt64,
    ftStr,
    ftDate_1123,
    ftETag,
    ftPCc,
    ftPContRange,
    ftPRange,
    ftPSc,
    ftDate_1123_or_ETag
};
 
enum HdrKind {
    None = 0,
    ListHeader = 1,
    RequestHeader = 1 << 1,
    ReplyHeader = 1 << 2,
    HopByHopHeader = 1 << 3,
    Denied304Header = 1 << 4, //see comment in HttpReply.cc for meaning
    GeneralHeader = RequestHeader | ReplyHeader,
    EntityHeader = RequestHeader | ReplyHeader
};
 
/* POD for HeaderTable */
class HeaderTableRecord {
public:
    HeaderTableRecord() = default;
    HeaderTableRecord(const char *n);
    HeaderTableRecord(const char *, Http::HdrType, Http::HdrFieldType, int /* HdrKind */);
 
    const char *name = "";
    Http::HdrType id = HdrType::BAD_HDR;
    Http::HdrFieldType type = HdrFieldType::ftInvalid;
    // flags set by constructor from HdrKind parameter
    bool list = false;; 
    bool request = false; 
    bool reply = false; 
    bool hopbyhop = false; 
    bool denied304 = false; 
};
 
class HeaderLookupTable_t {
public:
    HeaderLookupTable_t();
    const HeaderTableRecord& lookup (const char *buf, const std::size_t len) const;
    const HeaderTableRecord& lookup (const std::string &key) const {
        return lookup(key.data(), key.length());
    }
    const HeaderTableRecord& lookup (const SBuf &key) const {
        return lookup(key.rawContent(), key.length());
    }
    const HeaderTableRecord& lookup (Http::HdrType id) const {
        return *(idCache[static_cast<int>(id)]);
    }
 
private:
    void initCache();
    std::vector<const HeaderTableRecord *> idCache;
    static const HeaderTableRecord BadHdr; 
};
extern const HeaderLookupTable_t HeaderLookupTable;
 
inline bool
any_HdrType_enum_value (const Http::HdrType id)
{
    return (id >= Http::HdrType::enumBegin_ && id < Http::HdrType::enumEnd_);
}
 
inline bool
any_valid_header (const Http::HdrType id)
{
    return (id >= Http::HdrType::ACCEPT && id < Http::HdrType::BAD_HDR);
}
 
inline bool
any_registered_header (const Http::HdrType id)
{
    return (id >= Http::HdrType::ACCEPT && id < Http::HdrType::OTHER);
}
 
std::ostream &operator <<(std::ostream &, HdrType);
 
}; /* namespace Http */
 
#endif /* SQUID_HTTP_REGISTEREDHEADERS_H */