static size_t getHeadersLen(StringBuffer &s, StringBuffer &newline)
{
// detect the newline used in headers
size_t pos1 = s.find("\n");
if(pos1 == StringBuffer::npos){
LOG.error("MailMessage: no newlines in message?");
return pos1;
}
size_t pos2 = pos1 + 1 ;
while (s[pos1-1] == '\r'){
pos1--;
}
newline = s.substr(pos1, pos2-pos1);
StringBuffer emptyline = newline + newline ;
// Split headers and body
size_t hdrlen = s.find(emptyline);
if(hdrlen == StringBuffer::npos) {
// Empty body, get the message anyway.
hdrlen = s.length();
}
return hdrlen;
}
int MailMessage::parseBodyParts(StringBuffer &rfcBody) {
BodyPart part;
// The boundary is the one defined in the headers preceded by
// a newline and two hypens
StringBuffer bound("\n--");
bound += boundary;
LOG.debug("parseBodyParts START");
size_t nextBoundary = rfcBody.find(bound);
getBodyPart(rfcBody, bound, body, nextBoundary, false);
if (contentType.ifind("multipart/alternative") == StringBuffer::npos) {
// If it's not multipart/alternative, get the other parts
while( getBodyPart(rfcBody, bound, part, nextBoundary, true) ) {
// some problem in the attachment?
if( part.getContent() ) {
attachments.add(part);
}
else LOG.error("Empty content in attachment.");
part = BodyPart();
}
}
LOG.debug("parseBodyParts END");
return 0;
}
void testFillSyncItem(){
StringBuffer inFile = getTestFileFullPath(TEST_INPUT_DIR, TEST_FILE_NAME1);
SyncItem* si = fmss->fakeFillSyncItem(&inFile, true);
StringBuffer* data = new StringBuffer((char*)si->getData());
CPPUNIT_ASSERT(si != NULL);
CPPUNIT_ASSERT(data != NULL);
CPPUNIT_ASSERT(data->find("body") == StringBuffer::npos);
CPPUNIT_ASSERT(data->find("size") != StringBuffer::npos);
}
void HttpConnection::readResponseHeaders()
{
WCHAR *wbuffer = new WCHAR[1024];
DWORD ddsize = 1024;
StringBuffer headerString;
responseHeaders.clear();
BOOL reqDone = HttpQueryInfo(req, HTTP_QUERY_RAW_HEADERS_CRLF ,(LPVOID)wbuffer, &ddsize, NULL);
if (reqDone == false) {
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
// Allocate the necessary buffer.
delete [] wbuffer;
wbuffer = new WCHAR[ddsize];
reqDone = HttpQueryInfo(req, HTTP_QUERY_RAW_HEADERS_CRLF ,(LPVOID)wbuffer, &ddsize, NULL);
}
}
if (reqDone) {
headerString.convert(wbuffer);
LOG.debug("Response Headers:", headerString.c_str());
ArrayList headers;
headerString.split(headers, "\r\n");
StringBuffer *prop;
for(ArrayElement* e=headers.front(); e; e=headers.next()) {
prop = dynamic_cast<StringBuffer *>(e);
if(prop->empty()) continue;
size_t colon = prop->find(":");
if (colon != StringBuffer::npos) {
StringBuffer key = prop->substr(0, colon);
StringBuffer value = prop->substr(colon+1);
responseHeaders.put(key.trim(),value.trim());
if (canBeLogged(key)) {
LOG.debug("\t%s : %s", key.c_str(), value.c_str());
} else {
LOG.debug("\t%s : *****", key.c_str());
}
}
else {
LOG.debug("\t%s", prop->c_str());
}
}
} else {
DWORD err = GetLastError();
const char* msg = createHttpErrorMessage(err);
LOG.error("[HttpConnection] Error reading response headers - code %d: %s", err, msg);
delete [] msg;
}
}
StringBuffer getCompleteName(const char* dir, const StringBuffer& name) {
if (name.find(dir) == 0) {
// Filename contains the path from the first char -> it's already the complete name
return name;
}
else {
StringBuffer pathName(dir);
pathName += "/";
pathName += name;
return pathName;
}
}
/**
* Get the next bodypart from the message body string.
*
* @param rfcBody (in) - message content
* @param boundary (in) - mime boundary string
* @param ret (out) - parsed BodyPart
* @param next (i/o) - offset of the new boundary
* @param isAttach (in) - says if the current body part is an attachment or not
*/
static bool getBodyPart(StringBuffer &rfcBody, StringBuffer &boundary,
BodyPart &ret, size_t &next, bool isAttach)
{
LOG.debug("getBodyPart START");
StringBuffer newline;
// The part starts on the next line
size_t begin = findNewLine(rfcBody, next);
if (begin == StringBuffer::npos)
return false;
// find the end of the part
next = rfcBody.find(boundary, begin);
if (next == StringBuffer::npos)
return false;
// get the part
StringBuffer part = rfcBody.substr(begin, next-begin);
// If it is a multipart alternative part, get the text part only.
// check only until the first new line not on all the message (it could be
// a message inside another message)
size_t headers_len = getHeadersLen(part, newline);
StringBuffer headers_part = part.substr(0, headers_len);
if (headers_part.ifind("Content-Type: multipart/alternative") != StringBuffer::npos) {
if(part.ifind("Content-Type: multipart/alternative") != StringBuffer::npos) {
size_t b_pos = part.ifind("boundary=");
if( b_pos != StringBuffer::npos ) {
size_t begin = part.find("=\"", b_pos) + 2 ;
size_t end = part.find("\"", begin) ;
StringBuffer inner_boundary("\n--");
inner_boundary += part.substr( begin, end-begin );
begin = part.find(inner_boundary, end);
begin += inner_boundary.length();
end = part.find(inner_boundary, begin);
if (begin != StringBuffer::npos && end != StringBuffer::npos) {
part = part.substr(begin, end-begin);
LOG.debug("Bodypart is multipart/alternative: "
"getting first alternative only: \n%s\n", part.c_str() );
}
}
}
}
// Split headers and body
size_t hdrlen = getHeadersLen(part, newline);
// Get headers
StringBuffer headers = part.substr(0, hdrlen);
// Join header parts using \t or 8 blank
StringBuffer joinlinetab("\t");
headers.replaceAll(joinlinetab, " ");
StringBuffer joinlinespaces(newline);
joinlinespaces+=" "; // 8 blanks
headers.replaceAll(joinlinespaces, " ");
ArrayList lines;
const StringBuffer *line;
// parse the bodypart headers
headers.split(lines, newline);
for ( line=(StringBuffer *)lines.front();
line;
line=(StringBuffer *)lines.next() ) {
if( *line == "\r" )
continue;
// The first empty line marks the end of the header section
//if( line->empty() ){
// break;
//}
// Process the headers
if( line->ifind(MIMETYPE) == 0 ) { // it must at the beginning
ret.setMimeType(getTokenValue(line, MIMETYPE));
if (line->ifind(CT_NAME) != StringBuffer::npos) {
ret.setName(MailMessage::decodeHeader(getTokenValue(line, CT_NAME,false)));
}
if (line->ifind(CT_CHARSET) != StringBuffer::npos ) {
ret.setCharset(getTokenValue(line, CT_CHARSET));
}
}
else if( line->ifind(DISPOSITION) == 0 ) {
ret.setDisposition( getTokenValue(line, DISPOSITION));
if (line->ifind(CD_FILENAME) != StringBuffer::npos ) {
ret.setFilename( MailMessage::decodeHeader( getTokenValue(line, CD_FILENAME, false) ) );
}
}
else if( line->ifind(ENCODING) == 0 ) {
ret.setEncoding( getTokenValue(line, ENCODING));
}
}
// move to the beginning of the content
hdrlen += strlen(newline) + strlen(newline); // added 2 new line that separate the bodyparts
// get bodypart content
if( isAttach == false) { // || !ret.getFilename() ) {
// this is not an attachment
if(ret.getEncoding() && strcmp(ret.getEncoding(), "quoted-printable") == 0 ) {
char *decoded = qp_decode( part.substr(hdrlen) );
ret.setContent ( decoded );
delete [] decoded;
}
else if (ret.getEncoding() && strcmp(ret.getEncoding(), "base64") == 0 ) {
char *decoded = "";
size_t len = 0;
if( uudecode( part.substr(hdrlen), &decoded, &len ) ) {
LOG.error("Error decoding content");
}
ret.setContent ( decoded );
delete [] decoded;
}
else {
bool found = true;
if (part.substr(hdrlen).length() < 6) {
StringBuffer s(part.substr(hdrlen));
for (unsigned int i = 0; i < s.length(); i++) {
if (s.c_str()[i] != '\r' && s.c_str()[i] != '\n') {
found = true;
break;
} else {
found = false;
}
}
}
if (found) {
ret.setContent ( part.substr(hdrlen) );
}
}
}
else {
LOG.debug("Attachment");
ret.setContent( mkTempFileName( ret.getFilename() ) );
LOG.debug("%s", ret.getContent());
StringBuffer p = part.substr(hdrlen);
if (p.length()) {
LOG.debug("Saving...");
if( convertAndSave(ret.getContent(), p.c_str(), ret.getEncoding()) ) {
LOG.error("Error in convertAndSave");
}
else {
LOG.debug("convertAndSave success");
}
}
}
LOG.debug("getBodyPart END");
// return true if there are more parts
return (next != StringBuffer::npos);
}
StringBuffer MailMessage::decodeHeader(StringBuffer line) {
if (!line || line.empty()) {
return line;
}
size_t startPos = 0;
StringBuffer ret;
StringBuffer charset;
while( (startPos = line.find("=?", startPos)) != StringBuffer::npos) {
// Skip the '=?'
startPos += 2;
// Find the first '?'
size_t firstMark = line.find("?", startPos);
if (firstMark == StringBuffer::npos) {
LOG.error("Invalid encoded header");
return line;
}
// Find the second '?'
size_t secondMark = line.find("?", firstMark+1);
if (secondMark == StringBuffer::npos) {
LOG.error("Invalid encoded header");
return line;
}
// Find the final '?='
size_t endPos = line.find("?=", secondMark+1);
if (endPos == StringBuffer::npos) {
LOG.error("Invalid encoded header");
return line;
}
charset = line.substr(startPos, firstMark - startPos);
StringBuffer encoding = line.substr(firstMark+1, secondMark - (firstMark + 1));
StringBuffer text = line.substr(secondMark+1, endPos - (secondMark + 1));
if (encoding.icmp("Q")) {
// quoted-printable
text.replaceAll("_", " ");
char* dec = qp_decode(text);
if (startPos >= 2 && ret.length() == 0) {
ret += line.substr(0, startPos - 2);
}
ret += dec;
delete [] dec;
}
else if (encoding.icmp("B")){
// base64
char* dec = new char[text.length()];
int len = b64_decode((void *)dec, text);
dec[len]=0;
if (startPos >= 2 && ret.length() == 0) {
ret += line.substr(0, startPos - 2);
}
ret += dec;
delete [] dec;
}
startPos = endPos;
}
if (ret.length() == 0) {
ret += line;
}
WCHAR* wret = toWideChar(ret, charset);
ret.set(NULL);
char* t = toMultibyte(wret);
ret.set(t);
if (wret) {delete [] wret;}
if (t) {delete [] t;}
return ret;
}
inline static size_t findNewLine(StringBuffer &str, size_t offset) {
size_t nl = str.find("\n", offset)+1;
if(nl == StringBuffer::npos)
return nl;
return (str[nl] == '\r') ? nl+1 : nl ;
}
int FolderData::parse(const char *syncmlData, size_t len)
{
int ret = 0;
unsigned int start, end;
StringBuffer msg(syncmlData);
msg.replaceAll("<", "<");
msg.replaceAll("&", "&");
// Get attributes
if( XMLProcessor::getElementContent (msg, FOLDER_HIDDEN, NULL, &start, &end) ) {
hidden = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isHiddenPresent = true;
}
else hidden = false;
if( XMLProcessor::getElementContent (msg, FOLDER_SYSTEM, NULL, &start, &end) ) {
system = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isSystemPresent = true;
}
else system = false;
if( XMLProcessor::getElementContent (msg, FOLDER_ARCHIVED, NULL, &start, &end) ) {
archived = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isArchivedPresent = true;
}
else archived = false;
if( XMLProcessor::getElementContent (msg, FOLDER_DELETE, NULL, &start, &end) ) {
deleted = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isDeletedPresent = true;
}
else deleted = false;
if( XMLProcessor::getElementContent (msg, FOLDER_WRITABLE, NULL, &start, &end) ) {
writable = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isWritablePresent = true;
}
else writable = false;
if( XMLProcessor::getElementContent (msg, FOLDER_READABLE, NULL, &start, &end) ) {
readable = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isReadablePresent = true;
}
else readable = false;
if( XMLProcessor::getElementContent (msg, FOLDER_EXECUTABLE, NULL, &start, &end) ) {
executable = ( strncmp(msg.c_str()+start, "true", end-start) == 0 ) ;
isExecutablePresent = true;
}
else executable = false;
if( XMLProcessor::getElementContent (msg, FOLDER_ACCESSED, NULL, &start, &end) ) {
accessed = msg.substr(start, end-start);
}
else accessed = "";
if( XMLProcessor::getElementContent (msg, FOLDER_MODIFIED, NULL, &start, &end) ) {
modified = msg.substr(start, end-start);
}
else modified = "";
if( XMLProcessor::getElementContent (msg, FOLDER_CREATED, NULL, &start, &end) ) {
created = msg.substr(start, end-start);
}
else created = "";
if( XMLProcessor::getElementContent (msg, FOLDER_ROLE, NULL, &start, &end) ) {
role = msg.substr(start, end-start);
}
else role = "";
if( XMLProcessor::getElementContent (msg, FOLDER_NAME, NULL, &start, &end) ) {
name = msg.substr(start, end-start);
}
else{
name = "";
ret = -1;
}
if( XMLProcessor::getElementContent (msg, FOLDER_EXT, NULL, &start, &end) ) {
StringBuffer extmsg = msg;
while( XMLProcessor::getElementContent (extmsg, FOLDER_EXT, NULL, &start, &end) ) {
FolderExt ext;
ext.parse(extmsg.substr(start, end-start));
extended.add(ext);
extmsg = extmsg.substr( extmsg.find("</Ext>") + strlen("</Ext>"));
}
}
return ret;
}