DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (5b81998bb7ab)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsHttpResponseHead_h__
#define nsHttpResponseHead_h__

#include "nsHttpHeaderArray.h"
#include "nsHttp.h"
#include "nsString.h"

//-----------------------------------------------------------------------------
// nsHttpResponseHead represents the status line and headers from an HTTP
// response.
//-----------------------------------------------------------------------------

class nsHttpResponseHead
{
public:
    nsHttpResponseHead() : mVersion(NS_HTTP_VERSION_1_1)
                         , mStatus(200)
                         , mContentLength(LL_MAXUINT)
                         , mCacheControlNoStore(false)
                         , mCacheControlNoCache(false)
                         , mPragmaNoCache(false) {}
    
    const nsHttpHeaderArray & Headers()   const { return mHeaders; }
    nsHttpHeaderArray    &Headers()             { return mHeaders; }
    nsHttpVersion         Version()       const { return mVersion; }
    uint16_t              Status()        const { return mStatus; }
    const nsAFlatCString &StatusText()    const { return mStatusText; }
    int64_t               ContentLength() const { return mContentLength; }
    const nsAFlatCString &ContentType()   const { return mContentType; }
    const nsAFlatCString &ContentCharset() const { return mContentCharset; }
    bool                  NoStore() const { return mCacheControlNoStore; }
    bool                  NoCache() const { return (mCacheControlNoCache || mPragmaNoCache); }
    /**
     * Full length of the entity. For byte-range requests, this may be larger
     * than ContentLength(), which will only represent the requested part of the
     * entity.
     */
    int64_t               TotalEntitySize() const;

    const char *PeekHeader(nsHttpAtom h) const      { return mHeaders.PeekHeader(h); }
    nsresult SetHeader(nsHttpAtom h, const nsACString &v, bool m=false);
    nsresult GetHeader(nsHttpAtom h, nsACString &v) const { return mHeaders.GetHeader(h, v); }
    void     ClearHeader(nsHttpAtom h)              { mHeaders.ClearHeader(h); }
    void     ClearHeaders()                         { mHeaders.Clear(); }

    const char *FindHeaderValue(nsHttpAtom h, const char *v) const
    {
      return mHeaders.FindHeaderValue(h, v);
    }
    bool        HasHeaderValue(nsHttpAtom h, const char *v) const
    {
      return mHeaders.HasHeaderValue(h, v);
    }

    void     SetContentType(const nsACString &s)    { mContentType = s; }
    void     SetContentCharset(const nsACString &s) { mContentCharset = s; }
    void     SetContentLength(int64_t);

    // write out the response status line and headers as a single text block,
    // optionally pruning out transient headers (ie. headers that only make
    // sense the first time the response is handled).
    void     Flatten(nsACString &, bool pruneTransients);

    // parse flattened response head. block must be null terminated. parsing is
    // destructive.
    nsresult Parse(char *block);

    // parse the status line. line must be null terminated.
    void     ParseStatusLine(const char *line);

    // parse a header line. line must be null terminated. parsing is destructive.
    nsresult ParseHeaderLine(const char *line);

    // cache validation support methods
    nsresult ComputeFreshnessLifetime(uint32_t *) const;
    nsresult ComputeCurrentAge(uint32_t now, uint32_t requestTime, uint32_t *result) const;
    bool     MustValidate() const;
    bool     MustValidateIfExpired() const;

    // returns true if the server appears to support byte range requests.
    bool     IsResumable() const;

    // returns true if the Expires header has a value in the past relative to the
    // value of the Date header.
    bool     ExpiresInPast() const;

    // update headers...
    nsresult UpdateHeaders(const nsHttpHeaderArray &headers); 

    // reset the response head to it's initial state
    void     Reset();

    // these return failure if the header does not exist.
    nsresult ParseDateHeader(nsHttpAtom header, uint32_t *result) const;
    nsresult GetAgeValue(uint32_t *result) const;
    nsresult GetMaxAgeValue(uint32_t *result) const;
    nsresult GetDateValue(uint32_t *result) const
    {
        return ParseDateHeader(nsHttp::Date, result);
    }
    nsresult GetExpiresValue(uint32_t *result) const ;
    nsresult GetLastModifiedValue(uint32_t *result) const
    {
        return ParseDateHeader(nsHttp::Last_Modified, result);
    }

private:
    void     ParseVersion(const char *);
    void     ParseCacheControl(const char *);
    void     ParsePragma(const char *);

private:
    // All members must be copy-constructable and assignable
    nsHttpHeaderArray mHeaders;
    nsHttpVersion     mVersion;
    uint16_t          mStatus;
    mozilla::net::InfallableCopyCString mStatusText;
    int64_t           mContentLength;
    mozilla::net::InfallableCopyCString mContentType;
    mozilla::net::InfallableCopyCString mContentCharset;
    bool              mCacheControlNoStore;
    bool              mCacheControlNoCache;
    bool              mPragmaNoCache;

    friend struct IPC::ParamTraits<nsHttpResponseHead>;
};

#endif // nsHttpResponseHead_h__