MultipartParser Class Reference

Parses and processes multipart/form-data uploads over HTTP. More...

#include <MultipartParser.h>

Collaboration diagram for MultipartParser:

Public Member Functions
	MultipartParser ()
	Construct a new Multipart Parser object.
bool	handleMultipart (HttpRequest &req, HttpResponse &res)
	Begin processing the multipart upload from the socket.
void	setBoundaryFromContentType (const std::string &contentType)
	sets the boundary from the Content-Type header.

Private Member Functions
bool	extractFilename (const std::string &contentDisposition)
	Extract the filename from a Content-Disposition header.
bool	processFileData (const std::string &fileData)
	Append a chunk of file data to the output file.
bool	handleChunk (std::string &chunkData)
	Handle an incoming chunk of multipart data.
int	appendFileToSD (const char *filename, const char *data, size_t size)
	Append file data to storage (e.g., SD card).
int	file_exists (const std::string &filename)
	Check if a file already exists in storage.
int	findDataStart (std::string &currentData)
	Find the start of the file content in a chunk (after headers).
bool	handleFinalBoundary (std::string &fileData)
	Detect and handle the final multipart boundary.
void	sendHttpResponse (int statusCode, const std::string &message)
	Send a simple HTTP response to the client.

Private Attributes
Tcp *	tcp
	The client TCP connection.
std::string	boundary
std::string	filename
std::string	leftoverData
std::string	buffer

Static Private Attributes
static State	currentState = SEARCHING_FOR_BOUNDARY

Detailed Description

MultipartParser is responsible for:

• Detecting boundaries and parsing multipart headers
• Extracting uploaded filenames
• Writing uploaded file data to SD or other storage
• Sending appropriate HTTP responses

Definition at line 43 of file MultipartParser.h.

Constructor & Destructor Documentation

MultipartParser()

MultipartParser::MultipartParser

(

)

Construct a new Multipart Parser object.

Parameters

clientSocket	The socket for the HTTP client connection.
request	The full HTTP request object.

Parameters

clientSocket	The socket for the HTTP client connection.
request	The full HTTP request object.

Definition at line 49 of file MultipartParser.cpp.

{
 
}

Member Function Documentation

appendFileToSD()

int MultipartParser::appendFileToSD ( const char *  filename, const char *  data, size_t  size  )

private

Parameters

filename	Name of the file to write to.
data	Pointer to raw data.
size	Length of the data buffer.

Returns

0 on success, non-zero on failure.

extractFilename()

bool MultipartParser::extractFilename ( const std::string &  contentDisposition )

private

Extract the filename from a Content-Disposition header.

Parameters

contentDisposition

The raw header line.

Returns

true if a valid filename is found.

Parameters

contentDisposition

The raw header line.

Returns

true if a valid filename is found.

Definition at line 259 of file MultipartParser.cpp.

{
    std::size_t start = contentDisposition.find("filename=\"");
    if (start == std::string::npos)
        return false;
 
    start += 10;
    std::size_t end = contentDisposition.find("\"", start);
    if (end == std::string::npos)
        return false;
    // Ensure upload directory exists
    auto storage = AppContext::get<StorageManager>();
    if(!storage) {
        printf("[MultipartParser] StorageManager service not available\n");
        sendHttpResponse(500, "StorageManager service not available");
        return false;
    }
    storage->mount(); // ensure mounted
    std::string uploads(MULTIPART_UPLOAD_PATH); 
    TRACE("Checking if upload directory exists: %s\n", uploads.c_str());
    if (!storage->exists(uploads)) {
        TRACE("Upload directory does not exist, creating: %s\n", uploads.c_str());
        if(!(storage->createDirectory(uploads))) {
            TRACE("Failed to create upload directory: %s\n", uploads.c_str());
            sendHttpResponse(500, "Failed to create upload directory");
            return false;
        }
    }
    filename = std::string(MULTIPART_UPLOAD_PATH) + "/" + contentDisposition.substr(start, end - start);
    TRACE("checking if filename: %s exists\n", filename.c_str());
    if (file_exists(filename))
    {
        printf("[MultipartParser] File already exists: %s\n", filename.c_str());
        return false;
    }
    return true;
}

References file_exists(), filename, AppContext::getTypeKey(), MULTIPART_UPLOAD_PATH, sendHttpResponse(), and TRACE.

Referenced by handleChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

file_exists()

int MultipartParser::file_exists ( const std::string &  filename )

private

Check if a file already exists in storage.

Parameters

filename

Name of the file to check.

Returns

1 if exists, 0 if not.

Parameters

filename

Name of the file to check.

Returns

1 if exists, 0 if not.

Definition at line 320 of file MultipartParser.cpp.

{
    StorageManager *storage = AppContext::get<StorageManager>();
    TRACE("[MultipartParser] Checking if file exists: %s\n", filename.c_str());
    return storage->exists(filename);
}

References StorageManager::exists(), filename, AppContext::getTypeKey(), and TRACE.

Referenced by extractFilename().

Here is the call graph for this function:

Here is the caller graph for this function:

findDataStart()

int MultipartParser::findDataStart ( std::string &  currentData )

private

Find the start of the file content in a chunk (after headers).

Parameters

currentData

The buffer containing headers + data.

Returns

Byte offset of start of data, or -1 if not found.

Parameters

currentData

The buffer containing headers + data.

Returns

Byte offset of start of data, or -1 if not found.

Definition at line 328 of file MultipartParser.cpp.

{
    std::size_t pos = currentData.find("\r\n\r\n");
    return (pos != std::string::npos) ? static_cast<int>(pos + 4) : -1;
}

handleChunk()

bool MultipartParser::handleChunk ( std::string &  chunkData )

private

Handle an incoming chunk of multipart data.

Parameters

chunkData

The raw data received.

Returns

true if processing should continue.

Parameters

chunkData

The raw data received.

Returns

true if processing should continue.

Definition at line 131 of file MultipartParser.cpp.

{
    TRACE("Handling chunk, size: %zu bytes\n", chunkData.size());
    const std::string boundaryPrefix = "--" + boundary;
    const std::string finalBoundary = boundaryPrefix + "--";
 
    while (!chunkData.empty() && currentState != COMPLETE)
    {
        switch (currentState)
        {
        case SEARCHING_FOR_BOUNDARY:
        {
            size_t boundaryPos = chunkData.find(boundaryPrefix);
            if (boundaryPos != std::string::npos)
            {
                size_t skip = boundaryPos + boundaryPrefix.length();
                if (chunkData.substr(skip, 2) == "\r\n")
                    skip += 2;
                chunkData = chunkData.substr(skip);
                currentState = FOUND_BOUNDARY;
                TRACE("Found initial boundary, buffer size now: %zu bytes\n", chunkData.size());
                continue;
            }
            return true; // Wait for more data
        }
 
        case FOUND_BOUNDARY:
        {
            size_t headersEnd = chunkData.find("\r\n\r\n");
            if (headersEnd == std::string::npos)
                return true; // wait for more data
 
            std::string headers = chunkData.substr(0, headersEnd);
            std::istringstream stream(headers);
            std::string line;
            bool gotFilename = false;
 
            while (std::getline(stream, line))
            {
                line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
                if (line.find("Content-Disposition:") != std::string::npos)
                {
                    gotFilename = extractFilename(line);
                    if (gotFilename)
                    {
                        TRACE("Filename extracted: %s\n", filename.c_str());
                    }
                }
            }
 
            if (!gotFilename)
            {
                sendHttpResponse(400, "Invalid upload: no filename or filename exists already");
                currentState = COMPLETE;
                return false;
            }
 
            chunkData = chunkData.substr(headersEnd + 4); // skip headers
            currentState = FOUND_DATA_START;
            continue;
        }
 
        case FOUND_DATA_START:
        {
            size_t finalPos = chunkData.find(finalBoundary);
            size_t nextBoundaryPos = chunkData.find(boundaryPrefix);
 
            size_t boundaryPos = std::string::npos;
            bool isFinal = false;
 
            if (finalPos != std::string::npos &&
                (nextBoundaryPos == std::string::npos || finalPos < nextBoundaryPos))
            {
                boundaryPos = finalPos;
                isFinal = true;
            }
            else if (nextBoundaryPos != std::string::npos)
            {
                boundaryPos = nextBoundaryPos;
            }
 
            if (boundaryPos == std::string::npos)
            {
                // No boundary, stream all data
                if (processFileData(chunkData))
                {
                    chunkData.clear();
                    return true;
                }
                return false; // Error processing data;
            }
 
            // Process data up to boundary
            size_t dataEnd = boundaryPos;
            if (dataEnd >= 2 && chunkData.substr(dataEnd - 2, 2) == "\r\n")
                dataEnd -= 2;
 
            std::string fileData = chunkData.substr(0, dataEnd);
            processFileData(fileData);
 
            // Advance past boundary
            size_t skip = boundaryPos + boundaryPrefix.length();
            isFinal = (chunkData.substr(skip, 2) == "--");
            if (isFinal)
                skip += 2;
 
            if (chunkData.substr(skip, 2) == "\r\n")
                skip += 2;
 
            chunkData = chunkData.substr(skip);
 
            TRACE("Final boundary reached — exiting multipart parser\n");
            currentState = COMPLETE; 
            break;
 
            TRACE("Final boundary reached — exiting multipart parser\n");
            break;
        }
 
        default:
            return false;
        }
    }
 
    return true;
}

References boundary, COMPLETE, currentState, extractFilename(), filename, FOUND_BOUNDARY, FOUND_DATA_START, processFileData(), SEARCHING_FOR_BOUNDARY, sendHttpResponse(), and TRACE.

Referenced by handleMultipart().

Here is the call graph for this function:

Here is the caller graph for this function:

handleFinalBoundary()

bool MultipartParser::handleFinalBoundary ( std::string &  fileData )

private

Detect and handle the final multipart boundary.

Parameters

fileData

The current chunk of file data.

Returns

true if final boundary was found and handled.

Parameters

fileData

The current chunk of file data.

Returns

true if final boundary was found and handled.

Definition at line 335 of file MultipartParser.cpp.

{
    std::size_t finalBoundaryPos = fileData.find(boundary + "--");
    if (finalBoundaryPos != std::string::npos)
    {
        fileData = fileData.substr(0, finalBoundaryPos);
        return true;
    }
    return false;
}

References boundary.

handleMultipart()

bool MultipartParser::handleMultipart	(	HttpRequest &	req,
		HttpResponse &	res
	)

This method reads from the client socket in chunks, processes headers and boundaries, and writes file contents to storage.

Returns

true if upload succeeds.

false on failure (mazlformed request, existing file, or write error).

Definition at line 69 of file MultipartParser.cpp.

{
    tcp = req.getTcp();  // extract here — don't store in ctor
 
    std::string contentType = req.getHeader("Content-Type");
    setBoundaryFromContentType(contentType);
 
    if (boundary.empty()) {
        res.status(400).send("Missing boundary");
        return false;
    }
 
    char buf[1460];
    int len;
 
    currentState = SEARCHING_FOR_BOUNDARY;
 
    // Handle any body data included with the initial request
    const std::string &initialBody = req.getBody();
    if (!initialBody.empty())
    {
        std::string chunk = initialBody;
        if (!handleChunk(chunk))
        {
            TRACE("Error handling chunk\n");
            return false;
        }
    }
 
    // Stream remaining data from socket
    while ((len = tcp->recv(buf, sizeof(buf) - 1, HTTP_RECEIVE_TIMEOUT)) > 0)
    {
        buf[len] = '\0';
        std::string chunk(buf, len);
 
        if (!handleChunk(chunk))
        {
            sendHttpResponse(400, "Upload incomplete or failed");
            TRACE("Error handling chunk\n");
            return false;
        }
 
        if (currentState == COMPLETE)
            break;
 
        vTaskDelay(pdMS_TO_TICKS(10)); // yield to allow other tasks to run
    }
 
    if (currentState != COMPLETE)
    {
        sendHttpResponse(400, "Upload incomplete or failed");
        return false;
    }
 
    // Only send 200 when we're truly done
    TRACE("Multipart: Successfully received file '%s'\n", filename.c_str());
    std::string filenameOnly = filename.substr(filename.find_last_of('/') + 1);
    sendHttpResponse(200, filenameOnly);
    return true;
}

References boundary, COMPLETE, currentState, filename, HttpRequest::getBody(), HttpRequest::getHeader(), HttpRequest::getTcp(), handleChunk(), HTTP_RECEIVE_TIMEOUT, Tcp::recv(), SEARCHING_FOR_BOUNDARY, HttpResponse::send(), sendHttpResponse(), setBoundaryFromContentType(), HttpResponse::status(), tcp, and TRACE.

Referenced by HttpRequest::handle_multipart().

Here is the call graph for this function:

Here is the caller graph for this function:

processFileData()

bool MultipartParser::processFileData ( const std::string &  fileData )

private

Append a chunk of file data to the output file.

Parameters

fileData

Data to append.

Returns

true on success.

Parameters

fileData

Data to append.

Returns

true on success.

Definition at line 298 of file MultipartParser.cpp.

{
    TRACE("Processing file data, size: %zu bytes\n", fileData.size());
    auto *storage = AppContext::get<StorageManager>();
    if (!storage->appendToFile(filename, (uint8_t *)fileData.c_str(), fileData.size()))
    {
        if (!storage->isMounted())
        {
            TRACE("SD card not mounted — cannot handle multipart upload\n");
            sendHttpResponse(500, "SD card not mounted");
        }
        else
        {
            TRACE("Failed to append file during multipart upload\n");
            sendHttpResponse(500, "Failed to write file data");
        }
        return false;
    }
    return true;
}

References filename, AppContext::getTypeKey(), sendHttpResponse(), and TRACE.

Referenced by handleChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

sendHttpResponse()

void MultipartParser::sendHttpResponse ( int  statusCode, const std::string &  messageOrFilename  )

private

Send a simple HTTP response to the client.

Parameters

statusCode	HTTP status code.
message	Message body to send.

Parameters

statusCode	HTTP status code.
message	Message body to send.

Definition at line 347 of file MultipartParser.cpp.

                                                                                         {
    std::ostringstream oss;
    std::string body;
 
    if (statusCode >= 200 && statusCode < 300) {
        // Success: treat message as filename
        body = R"({"success":true,"image":")" + messageOrFilename + R"("})";
    } else {
        std::string code = std::to_string(statusCode);
        body = R"({"success":false,"error":{"code":")" + code + R"(","message":")" + messageOrFilename + R"("}})";
    }
 
    oss << "HTTP/1.1 " << statusCode << (statusCode == 200 ? " OK" : " Bad Request") << "\r\n"
        << "Content-Type: application/json\r\n"
        << "Content-Length: " << body.length() << "\r\n"
        << "Connection: close\r\n\r\n"
        << body;
 
    std::string response = oss.str();
    if (!tcp || !tcp->isConnected()) {
        panic("Attempted to send on invalid socket");
    }
 
    tcp->send(response.c_str(), response.length());
    vTaskDelay(pdMS_TO_TICKS(50));
}

References Tcp::isConnected(), Tcp::send(), and tcp.

Referenced by extractFilename(), handleChunk(), handleMultipart(), and processFileData().

Here is the call graph for this function:

Here is the caller graph for this function:

setBoundaryFromContentType()

void MultipartParser::setBoundaryFromContentType

(

const std::string &

contentType

)

Parameters

contentType

The Content-Type header value.

Definition at line 55 of file MultipartParser.cpp.

                                                                            {
    size_t boundaryPos = contentType.find("boundary=");
    if (boundaryPos != std::string::npos) {
        boundary = contentType.substr(boundaryPos + 9); // 9 is the length of "boundary="
        // Remove any leading/trailing whitespace
        boundary.erase(0, boundary.find_first_not_of(" \t\r\n"));
        boundary.erase(boundary.find_last_not_of(" \t\r\n") + 1);
        TRACE("Boundary set to: '%s'\n", boundary.c_str());
    } else {
        boundary.clear();
        TRACE("No boundary found in Content-Type header\n");
    }
}

References boundary, and TRACE.

Referenced by handleMultipart().

Here is the caller graph for this function:

Member Data Documentation

boundary

std::string MultipartParser::boundary

private

Definition at line 73 of file MultipartParser.h.

Referenced by handleChunk(), handleFinalBoundary(), handleMultipart(), and setBoundaryFromContentType().

buffer

std::string MultipartParser::buffer

private

Definition at line 76 of file MultipartParser.h.

currentState

State MultipartParser::currentState = SEARCHING_FOR_BOUNDARY

staticprivate

Definition at line 79 of file MultipartParser.h.

Referenced by handleChunk(), and handleMultipart().

filename

std::string MultipartParser::filename

private

Definition at line 74 of file MultipartParser.h.

Referenced by extractFilename(), file_exists(), handleChunk(), handleMultipart(), and processFileData().

leftoverData

std::string MultipartParser::leftoverData

private

Definition at line 75 of file MultipartParser.h.

tcp

Tcp* MultipartParser::tcp

private

Definition at line 72 of file MultipartParser.h.

Referenced by handleMultipart(), and sendHttpResponse().

---

The documentation for this class was generated from the following files:

• MultipartParser.h
• MultipartParser.cpp