You can use parser which based on Formidable
https://github.com/FooBarWidget/multipart-parser/tree/master
"multipart_parser.h"
// multipart_parser.h
#ifndef _MULTIPART_PARSER_H_
#define _MULTIPART_PARSER_H_
#include <sys/types.h>
#include <string>
#include <stdexcept>
#include <cstring>
class MultipartParser {
public:
typedef void (*Callback)(const char* buffer, size_t start, size_t end, void* userData);
private:
static const char CR = 13;
static const char LF = 10;
static const char SPACE = 32;
static const char HYPHEN = 45;
static const char COLON = 58;
static const size_t UNMARKED = (size_t)-1;
enum State {
ERROR,
START,
START_BOUNDARY,
HEADER_FIELD_START,
HEADER_FIELD,
HEADER_VALUE_START,
HEADER_VALUE,
HEADER_VALUE_ALMOST_DONE,
HEADERS_ALMOST_DONE,
PART_DATA_START,
PART_DATA,
PART_END,
END
};
enum Flags {
PART_BOUNDARY = 1,
LAST_BOUNDARY = 2
};
std::string boundary;
const char* boundaryData;
size_t boundarySize;
bool boundaryIndex[256];
char* lookbehind;
size_t lookbehindSize;
State state;
int flags;
size_t index;
size_t headerFieldMark;
size_t headerValueMark;
size_t partDataMark;
const char* errorReason;
void resetCallbacks() {
onPartBegin = NULL;
onHeaderField = NULL;
onHeaderValue = NULL;
onHeaderEnd = NULL;
onHeadersEnd = NULL;
onPartData = NULL;
onPartEnd = NULL;
onEnd = NULL;
userData = NULL;
}
void indexBoundary() {
const char* current;
const char* end = boundaryData + boundarySize;
memset(boundaryIndex, 0, sizeof(boundaryIndex));
for (current = boundaryData; current < end; current++) {
boundaryIndex[(unsigned char)*current] = true;
}
}
void callback(Callback cb, const char* buffer = NULL, size_t start = UNMARKED,
size_t end = UNMARKED, bool allowEmpty = false)
{
if (start != UNMARKED && start == end && !allowEmpty) {
return;
}
if (cb != NULL) {
cb(buffer, start, end, userData);
}
}
void dataCallback(Callback cb, size_t& mark, const char* buffer, size_t i, size_t bufferLen,
bool clear, bool allowEmpty = false)
{
if (mark == UNMARKED) {
return;
}
if (!clear) {
callback(cb, buffer, mark, bufferLen, allowEmpty);
mark = 0;
}
else {
callback(cb, buffer, mark, i, allowEmpty);
mark = UNMARKED;
}
}
char lower(char c) const {
return c | 0x20;
}
inline bool isBoundaryChar(char c) const {
return boundaryIndex[(unsigned char)c];
}
bool isHeaderFieldCharacter(char c) const {
return (c >= 'a' && c <= 'z')
|| (c >= 'A' && c <= 'Z')
|| c == HYPHEN;
}
void setError(const char* message) {
state = ERROR;
errorReason = message;
}
void processPartData(size_t& prevIndex, size_t& index, const char* buffer,
size_t len, size_t boundaryEnd, size_t& i, char c, State& state, int& flags)
{
prevIndex = index;
if (index == 0) {
// boyer-moore derived algorithm to safely skip non-boundary data
while (i + boundarySize <= len) {
if (isBoundaryChar(buffer[i + boundaryEnd])) {
break;
}
i += boundarySize;
}
if (i == len) {
return;
}
c = buffer[i];
}
if (index < boundarySize) {
if (boundary[index] == c) {
if (index == 0) {
dataCallback(onPartData, partDataMark, buffer, i, len, true);
}
index++;
}
else {
index = 0;
}
}
else if (index == boundarySize) {
index++;
if (c == CR) {
// CR = part boundary
flags |= PART_BOUNDARY;
}
else if (c == HYPHEN) {
// HYPHEN = end boundary
flags |= LAST_BOUNDARY;
}
else {
index = 0;
}
}
else if (index - 1 == boundarySize) {
if (flags & PART_BOUNDARY) {
index = 0;
if (c == LF) {
// unset the PART_BOUNDARY flag
flags &= ~PART_BOUNDARY;
callback(onPartEnd);
callback(onPartBegin);
state = HEADER_FIELD_START;
return;
}
}
else if (flags & LAST_BOUNDARY) {
if (c == HYPHEN) {
callback(onPartEnd);
callback(onEnd);
state = END;
}
else {
index = 0;
}
}
else {
index = 0;
}
}
else if (index - 2 == boundarySize) {
if (c == CR) {
index++;
}
else {
index = 0;
}
}
else if (index - boundarySize == 3) {
index = 0;
if (c == LF) {
callback(onPartEnd);
callback(onEnd);
state = END;
return;
}
}
if (index > 0) {
// when matching a possible boundary, keep a lookbehind reference
// in case it turns out to be a false lead
if (index - 1 >= lookbehindSize) {
setError("Parser bug: index overflows lookbehind buffer. "
"Please send bug report with input file attached.");
throw std::out_of_range("index overflows lookbehind buffer");
}
else if (index - 1 < 0) {
setError("Parser bug: index underflows lookbehind buffer. "
"Please send bug report with input file attached.");
throw std::out_of_range("index underflows lookbehind buffer");
}
lookbehind[index - 1] = c;
}
else if (prevIndex > 0) {
// if our boundary turned out to be rubbish, the captured lookbehind
// belongs to partData
callback(onPartData, lookbehind, 0, prevIndex);
prevIndex = 0;
partDataMark = i;
// reconsider the current character even so it interrupted the sequence
// it could be the beginning of a new sequence
i--;
}
}
public:
Callback onPartBegin;
Callback onHeaderField;
Callback onHeaderValue;
Callback onHeaderEnd;
Callback onHeadersEnd;
Callback onPartData;
Callback onPartEnd;
Callback onEnd;
void* userData;
MultipartParser() {
lookbehind = NULL;
resetCallbacks();
reset();
}
MultipartParser(const std::string& boundary) {
lookbehind = NULL;
resetCallbacks();
setBoundary(boundary);
}
~MultipartParser() {
delete[] lookbehind;
}
void reset() {
delete[] lookbehind;
state = ERROR;
boundary.clear();
boundaryData = boundary.c_str();
boundarySize = 0;
lookbehind = NULL;
lookbehindSize = 0;
flags = 0;
index = 0;
headerFieldMark = UNMARKED;
headerValueMark = UNMARKED;
partDataMark = UNMARKED;
errorReason = "Parser uninitialized.";
}
void setBoundary(const std::string& boundary) {
reset();
this->boundary = "\r\n--" + boundary;
boundaryData = this->boundary.c_str();
boundarySize = this->boundary.size();
indexBoundary();
lookbehind = new char[boundarySize + 8];
lookbehindSize = boundarySize + 8;
state = START;
errorReason = "No error.";
}
size_t feed(const char* buffer, size_t len) {
if (state == ERROR || len == 0) {
return 0;
}
State state = this->state;
int flags = this->flags;
size_t prevIndex = this->index;
size_t index = this->index;
size_t boundaryEnd = boundarySize - 1;
size_t i;
char c, cl;
for (i = 0; i < len; i++) {
c = buffer[i];
switch (state) {
case ERROR:
return i;
case START:
index = 0;
state = START_BOUNDARY;
case START_BOUNDARY:
if (index == boundarySize - 2) {
if (c != CR) {
setError("Malformed. Expected CR after boundary.");
return i;
}
index++;
break;
}
else if (index - 1 == boundarySize - 2) {
if (c != LF) {
setError("Malformed. Expected LF after boundary CR.");
return i;
}
index = 0;
callback(onPartBegin);
state = HEADER_FIELD_START;
break;
}
if (c != boundary[index + 2]) {
setError("Malformed. Found different boundary data than the given one.");
return i;
}
index++;
break;
case HEADER_FIELD_START:
state = HEADER_FIELD;
headerFieldMark = i;
index = 0;
case HEADER_FIELD:
if (c == CR) {
headerFieldMark = UNMARKED;
state = HEADERS_ALMOST_DONE;
break;
}
index++;
if (c == HYPHEN) {
break;
}
if (c == COLON) {
if (index == 1) {
// empty header field
setError("Malformed first header name character.");
return i;
}
dataCallback(onHeaderField, headerFieldMark, buffer, i, len, true);
state = HEADER_VALUE_START;
break;
}
cl = lower(c);
if (cl < 'a' || cl > 'z') {
setError("Malformed header name.");
return i;
}
break;
case HEADER_VALUE_START:
if (c == SPACE) {
break;
}
headerValueMark = i;
state = HEADER_VALUE;
case HEADER_VALUE:
if (c == CR) {
dataCallback(onHeaderValue, headerValueMark, buffer, i, len, true, true);
callback(onHeaderEnd);
state = HEADER_VALUE_ALMOST_DONE;
}
break;
case HEADER_VALUE_ALMOST_DONE:
if (c != LF) {
setError("Malformed header value: LF expected after CR");
return i;
}
state = HEADER_FIELD_START;
break;
case HEADERS_ALMOST_DONE:
if (c != LF) {
setError("Malformed header ending: LF expected after CR");
return i;
}
callback(onHeadersEnd);
state = PART_DATA_START;
break;
case PART_DATA_START:
state = PART_DATA;
partDataMark = i;
case PART_DATA:
processPartData(prevIndex, index, buffer, len, boundaryEnd, i, c, state, flags);
break;
default:
return i;
}
}
dataCallback(onHeaderField, headerFieldMark, buffer, i, len, false);
dataCallback(onHeaderValue, headerValueMark, buffer, i, len, false);
dataCallback(onPartData, partDataMark, buffer, i, len, false);
this->index = index;
this->state = state;
this->flags = flags;
return len;
}
bool succeeded() const {
return state == END;
}
bool hasError() const {
return state == ERROR;
}
bool stopped() const {
return state == ERROR || state == END;
}
const char* getErrorMessage() const {
return errorReason;
}
};
#endif /* _MULTIPART_PARSER_H_ */
// main.cpp
#include "multipart_parser.h"
#include <string>
using namespace std;
static void
onPartBegin(const char* buffer, size_t start, size_t end, void* userData) {
printf("onPartBegin\n");
}
static void
onHeaderField(const char* buffer, size_t start, size_t end, void* userData) {
printf("onHeaderField: (%s)\n", string(buffer + start, end - start).c_str());
}
static void
onHeaderValue(const char* buffer, size_t start, size_t end, void* userData) {
printf("onHeaderValue: (%s)\n", string(buffer + start, end - start).c_str());
}
static void
onPartData(const char* buffer, size_t start, size_t end, void* userData) {
printf("onPartData: (%s)\n", string(buffer + start, end - start).c_str());
}
static void
onPartEnd(const char* buffer, size_t start, size_t end, void* userData) {
printf("onPartEnd\n");
}
static void
onEnd(const char* buffer, size_t start, size_t end, void* userData) {
printf("onEnd\n");
}
"main.cpp"
#include "multipart_parser2.h"
#include <string>
using namespace std;
static void
onPartBegin(const char* buffer, size_t start, size_t end, void* userData) {
printf("onPartBegin\n");
}
static void
onHeaderField(const char* buffer, size_t start, size_t end, void* userData) {
printf("onHeaderField: (%s)\n", string(buffer + start, end - start).c_str());
}
static void
onHeaderValue(const char* buffer, size_t start, size_t end, void* userData) {
printf("onHeaderValue: (%s)\n", string(buffer + start, end - start).c_str());
}
static void
onPartData(const char* buffer, size_t start, size_t end, void* userData) {
printf("onPartData: (%s)\n", string(buffer + start, end - start).c_str());
}
static void
onPartEnd(const char* buffer, size_t start, size_t end, void* userData) {
printf("onPartEnd\n");
}
static void
onEnd(const char* buffer, size_t start, size_t end, void* userData) {
printf("onEnd\n");
}
int main()
{
// Sample multipart/form-data request body
std::string boundary = "----WebKitFormBoundary7MA4YWxkTrZu0gW";
std::string body =
"------WebKitFormBoundary7MA4YWxkTrZu0gW\r\n"
"Content-Disposition: form-data; name=\"username\"\r\n"
"\r\n"
"test_user\r\n"
"------WebKitFormBoundary7MA4YWxkTrZu0gW\r\n"
"Content-Disposition: form-data; name=\"file1\"; filename=\"example.txt\"\r\n"
"Content-Type: text/plain\r\n"
"\r\n"
"This is the content of the file.\r\n"
"------WebKitFormBoundary7MA4YWxkTrZu0gW--";
MultipartParser parser;
parser.onPartBegin = onPartBegin;
parser.onHeaderField = onHeaderField;
parser.onHeaderValue = onHeaderValue;
parser.onPartData = onPartData;
parser.onPartEnd = onPartEnd;
parser.onEnd = onEnd;
parser.userData = &parser;
parser.setBoundary(boundary);
const char* buf = body.c_str();
size_t bufsize = body.size();
size_t fed = 0;
do {
size_t ret = parser.feed(buf + fed, bufsize - fed);
fed += ret;
} while (fed < bufsize && !parser.stopped());
return 0;
}
