NET_WebResponse.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_WebResponse.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_WEBRESPONSE_H__
#define __NET_WEBRESPONSE_H__

#include "NET_API.h"

#include "NET_HTTPDefines.h"
#include "NET_Time.h"
#include "NET_WebTypes.h"

#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_Optional.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>

class NET_NetworkCookie;

// NOTE: Not a full list of http status codes
enum NET_HTTPStatusCode
{
    // Curl uses zero to indicate no status code received
    NET_HTTPNone = 0,
    // Info Codes
    NET_HTTPContinue = 100,
    NET_HTTPSwitchProtocol = 101,
    // Success Codes
    NET_HTTPOk = 200,
    NET_HTTPCreated = 201,
    NET_HTTPAccepted = 202,
    NET_HTTPNonAuthoritativeInfo = 203,
    NET_HTTPNoContent = 204,
    NET_HTTPResetContent = 205,
    NET_HTTPPartialContent = 206,
    // Redirect Codes
    NET_HTTPMultipleChoice = 300,
    NET_HTTPMovedPerm = 301,
    NET_HTTPFound = 302,
    NET_HTTPSeeOther = 303,
    NET_HTTPNotModified = 304,
    NET_HTTPTempRedirect = 307,
    NET_HTTPPermRedirect = 308,
    // Client Error Codes
    NET_HTTPBadRequest = 400,
    NET_HTTPUnauthorized = 401,
    NET_HTTPPaymentRequired = 402,
    NET_HTTPForbidden = 403,
    NET_HTTPNotFound = 404,
    NET_HTTPMethodNotAllowed = 405,
    NET_HTTPNotAcceptable = 406,
    NET_HTTPProxyAuthRequired = 407,
    NET_HTTPRequestTimeout = 408,
    NET_HTTPConflict = 409,
    NET_HTTPGone = 410,
    NET_HTTPLengthRequired = 411,
    NET_HTTPPreconditionFailed = 412,
    NET_HTTPPayloadLarge = 413,
    NET_HTTPURITooLong = 414,
    NET_HTTPUnsupportedMedia = 415,
    NET_HTTPRangeNotSatisfiable = 416,
    NET_HTTPExpectationFailed = 417,
    NET_HTTPUnprocessableEntity = 422,
    NET_HTTPTooEarly = 425,
    NET_HTTPUpgradeRequired = 426,
    NET_HTTPPreconditionRequired = 428,
    NET_HTTPTooManyRequests = 429,
    NET_HTTPHeadersFieldsTooLarge = 431,
    NET_HTTPLegalReasons = 451,
    // Server Error Codes
    NET_HTTPInternalServerError = 500,
    NET_HTTPNotImplemented = 501,
    NET_HTTPBadGateway = 502,
    NET_HTTPServiceUnavailable = 503,
    NET_HTTPGatewayTimeout = 504,
    NET_HTTPVersionNotSupported = 505,
    NET_HTTPNetworkAuthRequired = 511
};

/// Holds all common information between a client response and an object holding
/// the servers response to a client.
class NET_API NET_BaseWebResponse
{
public:
    using HeaderMap = UT_ArrayStringMap<UT_StringHolder>;
    NET_BaseWebResponse();
    NET_BaseWebResponse(NET_HTTPStatusCode code);
    NET_BaseWebResponse(NET_HTTPStatusCode code, const UT_StringHolder &data);
    NET_BaseWebResponse(
            NET_HTTPStatusCode code,
            const HeaderMap &headers,
            const UT_StringHolder &data);
    NET_BaseWebResponse(NET_HTTPStatusCode code, const HeaderMap &headers);

    explicit operator bool() const { return isSuccess(); }

    bool isSuccess() const { return myStatus == NET_HTTPOk; }

    bool isRequestNotFound() const { return myStatus == NET_HTTPNotFound; }
    bool isBadRequest() const { return myStatus == NET_HTTPBadRequest; }
    bool hasTimedout() const { return myStatus == NET_HTTPRequestTimeout; }

    UT_StringHolder headersAsString() const;

    // Does this response object have a specific option specified.
    bool hasHeader(const UT_StringRef &header) const;

    UT_Optional<const UT_StringHolder &> getHeaderContentType();
    UT_Optional<exint> getHeaderContentLength();

    bool hasContentType(const UT_StringRef &mime) const;

    NET_Time modTime() const;

    // Get the stock message based on the status code
    static void stockMsgFromCode(NET_HTTPStatusCode code, UT_WorkBuffer &msg);

    bool hasJSONBody() const;
    static bool isJSONBody(const HeaderMap &headers);

    // The status of the response
    NET_HTTPStatusCode myStatus;
    // The headers of the response
    HeaderMap myHeaders;
    UT_StringArray myCookies;
    // The body of the response
    UT_StringHolder myData;
};

/// Response object used by a client from a response by a server.
class NET_API NET_HTTPResponse : public NET_BaseWebResponse
{
public:
    struct NET_API Error
    {
        // This are all of the protocol independent error codes.
        //
        // The currently match curls error code number but do not make the
        // assumption that will always be the case. Use a translate function if
        // you need to go between the two.
        enum Code
        {
            INTERNAL_ERROR = -1,
            OK = 0,
            UNSUPPORTED_PROTOCOL,
            FAILED_INIT,
            URL_MALFORMAT,
            NOT_BUILT_IN,
            COULDNT_RESOLVE_PROXY,
            COULDNT_RESOLVE_HOST,
            COULDNT_CONNECT,
            WEIRD_SERVER_REPLY,
            REMOTE_ACCESS_DENIED,
            FTP_ACCEPT_FAILED,
            FTP_WEIRD_PASS_REPLY,
            FTP_ACCEPT_TIMEOUT,
            FTP_WEIRD_PASV_REPLY,
            FTP_WEIRD_227_FORMAT,
            FTP_CANT_GET_HOST,
            HTTP2_PROBLEM,
            FTP_COULDNT_SET_TYPE,
            PARTIAL_FILE,
            FTP_COULDNT_RETR_FILE,
            QUOTE_ERROR,
            HTTP_RETURNED_ERROR,
            WRITE_ERROR,
            UPLOAD_FAILED,
            READ_ERROR,
            OUT_OF_MEMORY,
            OPERATION_TIMEDOUT,
            FTP_PORT_FAILED,
            FTP_COULDNT_USE_REST,
            RANGE_ERROR,
            HTTP_POST_ERROR,
            SSL_CONNECT_ERROR,
            BAD_DOWNLOAD_RESUME,
            FILE_COULDNT_READ_FILE,
            LDAP_CANNOT_BIND,
            LDAP_SEARCH_FAILED,
            FUNCTION_NOT_FOUND,
            ABORTED_BY_CALLBACK,
            BAD_FUNCTION_ARGUMENT,
            INTERFACE_FAILED,
            TOO_MANY_REDIRECTS,
            UNKNOWN_OPTION,
            TELNET_OPTION_SYNTAX,
            GOT_NOTHING,
            SSL_ENGINE_NOTFOUND,
            SSL_ENGINE_SETFAILED,
            SEND_ERROR,
            RECV_ERROR,
            SSL_CERTPROBLEM,
            SSL_CIPHER,
            PEER_FAILED_VERIFICATION,
            BAD_CONTENT_ENCODING,
            LDAP_INVALID_URL,
            FILESIZE_EXCEEDED,
            USE_SSL_FAILED,
            SEND_FAIL_REWIND,
            SSL_ENGINE_INITFAILED,
            LOGIN_DENIED,
            TFTP_NOTFOUND,
            REMOTE_DISK_FULL,
            TFTP_ILLEGAL,
            TFTP_UNKNOWNID,
            REMOTE_FILE_EXISTS,
            TFTP_NOSUCHUSER,
            CONV_FAILED,
            CONV_REQD,
            SSL_CACERT_BADFILE,
            REMOTE_FILE_NOT_FOUND,
            SSH_ERROR,
            SSL_SHUTDOWN_FAILED,
            AGAIN_ERROR,
            SSL_CRL_BADFILE,
            SSL_ISSUER_ERROR,
            FTP_PRET_FAILED,
            RTSP_CSEQ_ERROR,
            RTSP_SESSION_ERROR,
            FTP_BAD_FILE_LIST,
            CHUNK_FAILED,
            NO_CONNECTION_AVAILABLE,
            SSL_PINNEDPUBKEYNOMATCH,
            SSL_INVALIDCERTSTATUS,
            HTTP2_STREAM,
            RECURSIVE_API_CALL,
            AUTH_ERROR,
            HTTP3_ERROR,
            QUIC_CONNECT_ERROR,
            OBSOLETE
        };

        UT_StringHolder buildErrorMessage() const;
        static Code translateErrorToCode(int err);
        static UT_StringHolder codeToString(Code code);

        Code myErrorCode = Code::OK;
        // Explenation of the error
        UT_StringHolder myErrorMsg;
        // Extra details we provide about the error. Most of the time this error
        // string will be empty. Its meant to give extra information to a
        // standard error. (ie. cert error)
        UT_StringHolder myExtraDetails;
    };

    NET_HTTPResponse();
    NET_HTTPResponse(NET_HTTPStatusCode code);
    NET_HTTPResponse(NET_HTTPStatusCode code, const UT_StringHolder &data);
    NET_HTTPResponse(
            NET_HTTPStatusCode code,
            const HeaderMap &headers,
            const UT_StringHolder &data);
    NET_HTTPResponse(NET_HTTPStatusCode code, const HeaderMap &headers);

    void parseCookies(UT_Array<NET_NetworkCookie> &cookies);
    bool errorReceivedNothing() const
    {
        return myError.myErrorCode == Error::GOT_NOTHING;
    }
    void clear();

    Error myError;
};

/// Response object used for responding to request in the server.
class NET_API NET_WebResponse : public NET_BaseWebResponse
{
public:
    NET_WebResponse()
        : NET_BaseWebResponse(), myDeleteFile(false), myRanges(), myErrors()
    {
    }
    NET_WebResponse(NET_HTTPStatusCode code)
        : NET_BaseWebResponse(code), myDeleteFile(false), myRanges(), myErrors()
    {
    }
    NET_WebResponse(NET_HTTPStatusCode code, const UT_StringHolder &data)
        : NET_BaseWebResponse(code, data)
        , myDeleteFile(false)
        , myRanges()
        , myErrors()
    {
    }
    NET_WebResponse(
            NET_HTTPStatusCode code,
            const HeaderMap &headers,
            const UT_StringHolder &data)
        : NET_BaseWebResponse(code, headers, data)
        , myDeleteFile(false)
        , myRanges()
        , myErrors()
    {
    }
    NET_WebResponse(NET_HTTPStatusCode code, const HeaderMap &headers)
        : NET_BaseWebResponse(code, headers)
        , myDeleteFile(false)
        , myRanges()
        , myErrors()
    {
    }

    NET_WebResponse(const NET_WebResponse &resp)
        : NET_BaseWebResponse(resp)
        , myDeleteFile(resp.myDeleteFile)
        , myFile(resp.myFile)
        , myRanges(resp.myRanges)
        , myErrors(resp.myErrors)
    {
    }
    NET_WebResponse &operator=(const NET_WebResponse &resp)
    {
        NET_BaseWebResponse::operator=(resp);
        myDeleteFile = resp.myDeleteFile;
        myFile = resp.myFile;
        myRanges = resp.myRanges;
        myErrors = resp.myErrors;
        return *this;
    }
    NET_WebResponse(NET_WebResponse &&resp)
        : NET_BaseWebResponse(resp)
        , myDeleteFile(resp.myDeleteFile)
        , myFile(std::move(resp.myFile))
        , myRanges(std::move(resp.myRanges))
        , myErrors(std::move(resp.myErrors))
    {
    }
    NET_WebResponse &operator=(NET_WebResponse &&resp)
    {
        NET_BaseWebResponse::operator=(resp);
        myDeleteFile = resp.myDeleteFile;
        myFile = std::move(resp.myFile);
        myRanges = std::move(resp.myRanges);
        myErrors = std::move(resp.myErrors);
        return *this;
    }

    // Convience operators to forward a client response as a server response
    NET_WebResponse(const NET_HTTPResponse &resp)
        : NET_BaseWebResponse(resp), myDeleteFile(false), myFile(), myErrors()
    {
    }
    NET_WebResponse &operator=(const NET_HTTPResponse &resp)
    {
        NET_BaseWebResponse::operator=(resp);
        myFile.clear();
        myDeleteFile = false;
        myRanges.clear();
        myErrors.clear();
        return *this;
    }

    void clear();

    bool isFile() const { return myFile.isstring(); }

    bool isChunked() const
    {
        auto it = myHeaders.find(HTTP_TRANSFER_ENCODING);
        if (it == myHeaders.end())
            return false;
        return it->second.startsWith("chunked");
    }

    NET_RequestRangeList myRanges;
    UT_StringHolder myFile;
    bool myDeleteFile;
    // Error that you might want hidden
    UT_StringHolder myErrors;
};

#endif // __NET_WEBRESPONSE_H__