NET_HTTPUploadedFile.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_HTTPUploadedFile.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_HTTPUPLOADEDFILE_H__
#define __NET_HTTPUPLOADEDFILE_H__

#include "NET_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_IStream.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_OFStream.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>

#include <SYS/SYS_Compiler.h>

class NET_API NET_HTTPUploadedFile
{
public:
    static constexpr int64 DefaultMaxInMemorySize = 2500000;   // 2.5MB

    enum SentinelType
    {
        SENTINEL
    };

    NET_HTTPUploadedFile();
    NET_HTTPUploadedFile(const UT_StringRef &name);
    NET_HTTPUploadedFile(SentinelType) :
        myName(UT_StringRef::SENTINEL),
        myContentType(UT_StringRef::SENTINEL),
        mySize(0),
        myInMemoryValue(),
        myTempFileName(UT_StringRef::SENTINEL),
        myMaxInMemorySize(DefaultMaxInMemorySize)
    {
    }

    ~NET_HTTPUploadedFile();

    // Movable
    NET_HTTPUploadedFile(NET_HTTPUploadedFile &&) = default;
    NET_HTTPUploadedFile &operator=(NET_HTTPUploadedFile &&) = default;

    // But not copyable
    UT_NON_COPYABLE(NET_HTTPUploadedFile)

    /// The name of the file found in the Content-Disposition header.
    SYS_FORCE_INLINE const UT_StringHolder &name() const { return myName; }
    /// The size of the file.
    SYS_FORCE_INLINE int64 size() const { return mySize; }
    /// The content type of the file.
    SYS_FORCE_INLINE const UT_StringHolder &contentType() const
    {
        return myContentType;
    }
    /// The temp file location. This is only filled out if isInMemory()
    /// return false
    const UT_StringHolder &fileLocation() const { return myTempFileName; }

    /// Is this file in memory or stored on disk
    SYS_FORCE_INLINE bool isInMemory() const
    {
        return !myTempFileName.isstring();
    }

    void forceToStorage();

    /// Determine if the file needs to be read in multiple chunks. This is
    /// useful to determining if you can perform read() safeully.
    /// Default uses the servers max size of 2.5MB
    bool multipleChunks(int64 chunk_size = -1) const;

    /// Remove the temp file. This does nothing if the file is in memory
    void removeTempFile();

    SYS_FORCE_INLINE
    void makeSentinel()
    {
        myName.makeSentinel();
        myContentType.makeSentinel();
        mySize = 0;
        myInMemoryValue.clear();
        myTempFileName.makeSentinel();
    }

    SYS_FORCE_INLINE
    bool isSentinel() const
    {
        // Name is required no matter what.
        return myName.isSentinel();
    }

    void setMaxInMemorySize(int64 max_size)
    {
        myMaxInMemorySize = max_size;
    }

    /// Read data from an uploaded file
    class NET_API IStream
    {
    public:
        IStream(NET_HTTPUploadedFile &ufile);
        ~IStream();

        /// Read the entire uploaded data from the file. Use chunks() if you
        /// are not certain about the total file size.
        bool read(UT_WorkBuffer &data);
        bool read(std::string &data);

        /// Read in chunks of the file. It is often best to use this function
        /// instead of read() to avoid overwhelming your system's memory.
        int64 readNextChunk(int64 chunk_size, UT_WorkBuffer &data);
        int64 readNextChunk(int64 chunk_size, std::string &data);

        void close();

        NET_HTTPUploadedFile &myFile;

    private:
        int64 myAmountRead;
        UT_IFStream myStream;
    };

private:
    friend class NET_HttpIO;

    void write(const char *data, int64 length);
    void writeToStorage(const char* data, int64 length);

    void convertInMemoryToStorage();
    /// Clear out this object to read again.
    void clear();

    /// Parse the upload info from the header line
    /// Content-Disposition: form-data; name=<name>; file<name>
    void parseInfo(const UT_StringRef &header_value, UT_StringHolder &name);

    UT_StringHolder myName;

    UT_StringHolder myContentType;
    int64 mySize;
    UT_Array<char> myInMemoryValue;
    UT_StringHolder myTempFileName;
    int64 myMaxInMemorySize;
};

namespace UT
{
template <>
struct DefaultClearer<NET_HTTPUploadedFile>
{
    static void clear(NET_HTTPUploadedFile &ufile) { ufile.makeSentinel(); }
    static bool isClear(NET_HTTPUploadedFile &ufile) { return ufile.isSentinel(); }
    static void clearConstruct(NET_HTTPUploadedFile *ufile)
    {
        new ((void*)ufile) NET_HTTPUploadedFile(NET_HTTPUploadedFile::SENTINEL);
    }
    static const bool clearNeedsDestruction = false;
};
}

#endif // __NET_HTTPUPLOADEDFILE_H__