llurlrequest.h

Go to the documentation of this file.

#ifndef LL_LLURLREQUEST_H
#define LL_LLURLREQUEST_H

#include <string>
#include "lliopipe.h"
#include "llchainio.h"

class LLURLRequestDetail;

class LLURLRequestComplete;

class LLURLRequest : public LLIOPipe
{
public:
        enum ERequestAction
        {
                INVALID,
                HTTP_GET,
                HTTP_PUT,
                HTTP_POST,
                HTTP_DELETE,
                REQUEST_ACTION_COUNT
        };

        LLURLRequest(ERequestAction action);

        LLURLRequest(ERequestAction action, const std::string& url);

        virtual ~LLURLRequest();

        /* @name Instance methods
         */

        void setURL(const std::string& url);

        void addHeader(const char* header);

        void checkRootCertificate(bool check, const char* caBundle = NULL);

        void requestEncoding(const char* encoding);

        void setBodyLimit(U32 size);

        void setCallback(LLURLRequestComplete* callback);

        static void setCertificateAuthorityFile(const std::string& file_name);

        static void setCertificateAuthorityPath(const std::string& path);

        /* @name LLIOPipe virtual implementations
         */

    void useProxy(bool use_proxy);

public:
        virtual EStatus handleError(EStatus status, LLPumpIO* pump);
        
protected:
        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:
        enum EState
        {
                STATE_INITIALIZED,
                STATE_WAITING_FOR_RESPONSE,
                STATE_PROCESSING_RESPONSE,
                STATE_HAVE_RESPONSE,
        };
        EState mState;
        ERequestAction mAction;
        LLURLRequestDetail* mDetail;
        LLIOPipe::ptr_t mCompletionCallback;

private:
        void initialize();

        bool configure();

        static size_t downCallback(
                void* data,
                size_t size,
                size_t nmemb,
                void* user);

        static size_t upCallback(
                void* data,
                size_t size,
                size_t nmemb,
                void* user);

        LLURLRequest(const LLURLRequest&);
};


class LLContextURLExtractor : public LLIOPipe
{
public:
        LLContextURLExtractor(LLURLRequest* req) : mRequest(req) {}
        ~LLContextURLExtractor() {}

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:
        LLURLRequest* mRequest;
};


class LLURLRequestComplete : public LLIOPipe
{
public:
        
        virtual void header(const std::string& header, const std::string& value);

        virtual void httpStatus(U32 status, const std::string& reason);

        virtual void complete(
                const LLChannelDescriptors& channels,
                const buffer_ptr_t& buffer);

        virtual void response(
                const LLChannelDescriptors& channels,
                const buffer_ptr_t& buffer);

        virtual void noResponse();

        void responseStatus(EStatus status);

        // constructor & destructor.
        LLURLRequestComplete();
        virtual ~LLURLRequestComplete();

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

        // value to note if we actually got the response. This value
        // depends on correct useage from the LLURLRequest instance.
        EStatus mRequestStatus;
};


#if 0
template<class Client>
class LLURLRequestClientFactory : public LLChainIOFactory
{
public:
        LLURLRequestClientFactory(LLURLRequest::ERequestAction action) {}
        LLURLRequestClientFactory(
                LLURLRequest::ERequestAction action,
                const std::string& fixed_url) :
                mAction(action),
                mURL(fixed_url)
        {
        }
        virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
        {
                lldebugs << "LLURLRequestClientFactory::build" << llendl;
                LLIOPipe::ptr_t service(new Client);
                chain.push_back(service);
                LLURLRequest* http(new LLURLRequest(mAction));
                LLIOPipe::ptr_t http_pipe(http);
                // *FIX: how do we know the content type?
                //http->addHeader("Content-Type: text/llsd");
                if(mURL.empty())
                {
                        chain.push_back(LLIOPipe::ptr_t(new LLContextURLExtractor(http)));
                }
                else
                {
                        http->setURL(mURL);
                }
                chain.push_back(http_pipe);
                chain.push_back(service);
                return true;
        }

protected:
        LLURLRequest::ERequestAction mAction;
        std::string mURL;
};
#endif

extern const std::string CONTEXT_DEST_URI_SD_LABEL;

#endif // LL_LLURLREQUEST_H

---