errorpage.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.
 */
 
/* DEBUG: section 04    Error Generation */
 
#ifndef SQUID_SRC_ERRORPAGE_H
#define SQUID_SRC_ERRORPAGE_H
 
#include "cbdata.h"
#include "comm/forward.h"
#include "error/Detail.h"
#include "error/forward.h"
#include "http/forward.h"
#include "http/StatusCode.h"
#include "ip/Address.h"
#include "log/forward.h"
#include "sbuf/SBuf.h"
#include "SquidString.h"
/* auth/UserRequest.h is empty unless USE_AUTH is defined */
#include "auth/UserRequest.h"
 
#include <optional>
 
typedef void ERCB(int fd, void *, size_t);
 
class MemBuf;
class StoreEntry;
class wordlist;
 
namespace ErrorPage {
 
class Build;
 
} // namespace ErrorPage
 
class ErrorState
{
    CBDATA_CLASS(ErrorState);
 
public:
    ErrorState(err_type type, Http::StatusCode, HttpRequest * request, const AccessLogEntryPointer &al);
    ErrorState() = delete; // not implemented.
 
    ErrorState(HttpRequest * request, HttpReply *, const AccessLogEntryPointer &);
 
    ~ErrorState();
 
    static ErrorState *NewForwarding(err_type, HttpRequestPointer &, const AccessLogEntryPointer &);
 
    HttpReply *BuildHttpReply(void);
 
    void detailError(const ErrorDetail::Pointer &dCode) { detail = dCode; }
 
    void validate();
 
    SBuf inputLocation;
 
private:
    typedef ErrorPage::Build Build;
 
    ErrorState(err_type, const AccessLogEntryPointer &);
 
    SBuf buildBody();
 
    SBuf compileBody(const char *text, bool allowRecursion);
 
    void compileLegacyCode(Build &build);
 
    void compileLogformatCode(Build &build);
 
    SBuf compile(const char *input, bool building_deny_info_url, bool allowRecursion);
 
    void noteBuildError(const char *const msg, const char * const errorLocation) {
        noteBuildError_(msg, errorLocation, false);
    }
 
    void bypassBuildErrorXXX(const char *const msg, const char * const errorLocation) {
        noteBuildError_(msg, errorLocation, true);
    }
 
    int Dump(MemBuf * mb);
 
public:
    err_type type = ERR_NONE;
    int page_id = ERR_NONE;
    char *err_language = nullptr;
    Http::StatusCode httpStatus = Http::scNone;
#if USE_AUTH
    Auth::UserRequest::Pointer auth_user_request;
#endif
    HttpRequestPointer request;
    char *url = nullptr;
    int xerrno = 0;
    std::optional<SBuf> dnsError; 
    time_t ttl = 0;
 
    Ip::Address src_addr;
    char *redirect_url = nullptr;
    ERCB *callback;
    void *callback_data = nullptr;
 
    struct {
        wordlist *server_msg = nullptr;
        char *request = nullptr;
        char *reply = nullptr;
        char *cwd_msg = nullptr;
        MemBuf *listing = nullptr;
    } ftp;
 
    char *request_hdrs = nullptr;
    char *err_msg = nullptr; /* Preformatted error message from the cache */
 
    AccessLogEntryPointer ale; 
 
    // TODO: Replace type, xerrno and detail with Error while adding a virtual
    // Error::Detail::sysError() method to extract errno in detailError().
    ErrorDetail::Pointer detail;
 
    HttpReplyPointer response_;
 
private:
    void noteBuildError_(const char *msg, const char *errorLocation, bool forceBypass);
 
    static const SBuf LogformatMagic; 
};
 
void errorInitialize(void);
 
void errorClean(void);
 
void errorSend(const Comm::ConnectionPointer &conn, ErrorState *err);
 
void errorAppendEntry(StoreEntry *entry, ErrorState *err);
 
err_type errorReservePageId(const char *page_name, const SBuf &cfgLocation);
 
const char *errorPageName(int pageId); 
 
class TemplateFile
{
public:
    TemplateFile(const char *name, const err_type code);
    virtual ~TemplateFile() {}
 
    bool loaded() const {return wasLoaded;}
 
    void loadDefault();
 
    bool loadFor(const HttpRequest *request);
 
    bool loadFromFile(const char *path);
 
    const char *language() {return errLanguage.termedBuf();}
 
    SBuf filename; 
 
    bool silent; 
 
protected:
    virtual bool parse() { return true; }
 
    virtual void setDefault() {}
 
    bool tryLoadTemplate(const char *lang);
 
    SBuf template_; 
    bool wasLoaded; 
    String errLanguage; 
    String templateName; 
    err_type templateCode; 
};
 
bool strHdrAcptLangGetItem(const String &hdr, char *lang, int langLen, size_t &pos);
 
std::ostream &operator <<(std::ostream &, const ErrorState *);
 
#endif /* SQUID_SRC_ERRORPAGE_H */