tris/recoll
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

binc: indent and cie

Browse Source
This commit is contained in:
Jean-Francois Dockes 2020-05-11 07:23:23 +01:00
parent 631532f100
commit 8a7e00a029
5 changed files with 191 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
src/bincimapmime/mime-inputsource.h
View File

@ -1,4 +1,3 @@
/* -*- mode:c++;c-basic-offset:2 -*- */
/* --------------------------------------------------------------------
* Filename:
* src/mime-inputsource.h
@ -25,7 +24,6 @@
*/
#ifndef mime_inputsource_h_included
#define mime_inputsource_h_included
#include "autoconfig.h"
// Data source for MIME parser
// Note about large files: we might want to change the unsigned int
@ -36,15 +34,15 @@
// stream input source (from a memory buffer, no file offsets). When
// parsing a raw message file, it's only one message.
#include <string.h>
#include <cstring>
#include "safeunistd.h"
#include <iostream>
namespace Binc {
class MimeInputSource {
public:
class MimeInputSource {
public:
// Note that we do NOT take ownership of fd, won't close it on delete
inline MimeInputSource(int fd, unsigned int start = 0);
virtual inline ~MimeInputSource(void);
@ -60,7 +58,7 @@ namespace Binc {
inline unsigned int getOffset(void) const;
private:
private:
int fd;
char data[16384];
unsigned int offset;
@ -68,10 +66,10 @@ namespace Binc {
unsigned int head;
unsigned int start;
char lastChar;
};
};
inline MimeInputSource::MimeInputSource(int fd, unsigned int start)
{
inline MimeInputSource::MimeInputSource(int fd, unsigned int start)
{
this->fd = fd;
this->start = start;
offset = 0;
@ -81,141 +79,141 @@ namespace Binc {
memset(data, '\0', sizeof(data));
seek(start);
}
}
inline MimeInputSource::~MimeInputSource(void)
{
}
inline MimeInputSource::~MimeInputSource(void)
{
}
inline ssize_t MimeInputSource::fillRaw(char *raw, size_t nbytes)
{
return read(fd, raw, nbytes);
}
inline ssize_t MimeInputSource::fillRaw(char *raw, size_t nbytes)
{
return read(fd, raw, nbytes);
}
inline bool MimeInputSource::fillInputBuffer(void)
{
inline bool MimeInputSource::fillInputBuffer(void)
{
char raw[4096];
ssize_t nbytes = fillRaw(raw, 4096);
if (nbytes <= 0) {
// FIXME: If ferror(crlffile) we should log this.
return false;
// FIXME: If ferror(crlffile) we should log this.
return false;
}
for (ssize_t i = 0; i < nbytes; ++i) {
const char c = raw[i];
if (c == '\r') {
if (lastChar == '\r') {
data[tail++ & (0x4000-1)] = '\r';
data[tail++ & (0x4000-1)] = '\n';
}
} else if (c == '\n') {
data[tail++ & (0x4000-1)] = '\r';
data[tail++ & (0x4000-1)] = '\n';
} else {
if (lastChar == '\r') {
data[tail++ & (0x4000-1)] = '\r';
data[tail++ & (0x4000-1)] = '\n';
}
const char c = raw[i];
if (c == '\r') {
if (lastChar == '\r') {
data[tail++ & (0x4000-1)] = '\r';
data[tail++ & (0x4000-1)] = '\n';
}
} else if (c == '\n') {
data[tail++ & (0x4000-1)] = '\r';
data[tail++ & (0x4000-1)] = '\n';
} else {
if (lastChar == '\r') {
data[tail++ & (0x4000-1)] = '\r';
data[tail++ & (0x4000-1)] = '\n';
}
data[tail++ & (0x4000-1)] = c;
}
data[tail++ & (0x4000-1)] = c;
}
lastChar = c;
lastChar = c;
}
return true;
}
}
inline void MimeInputSource::reset(void)
{
inline void MimeInputSource::reset(void)
{
offset = head = tail = 0;
lastChar = '\0';
if (fd != -1)
lseek(fd, 0, SEEK_SET);
}
lseek(fd, 0, SEEK_SET);
}
inline void MimeInputSource::seek(unsigned int seekToOffset)
{
inline void MimeInputSource::seek(unsigned int seekToOffset)
{
if (offset > seekToOffset)
reset();
reset();
char c;
int n = 0;
while (seekToOffset > offset) {
if (!getChar(&c))
break;
++n;
if (!getChar(&c))
break;
++n;
}
}
}
inline bool MimeInputSource::getChar(char *c)
{
inline bool MimeInputSource::getChar(char *c)
{
if (head == tail && !fillInputBuffer())
return false;
return false;
*c = data[head++ & (0x4000-1)];
++offset;
return true;
}
}
inline void MimeInputSource::ungetChar()
{
inline void MimeInputSource::ungetChar()
{
--head;
--offset;
}
}
inline int MimeInputSource::getFileDescriptor(void) const
{
inline int MimeInputSource::getFileDescriptor(void) const
{
return fd;
}
}
inline unsigned int MimeInputSource::getOffset(void) const
{
inline unsigned int MimeInputSource::getOffset(void) const
{
return offset;
}
}
///////////////////////////////////
class MimeInputSourceStream : public MimeInputSource {
public:
inline MimeInputSourceStream(istream& s, unsigned int start = 0);
///////////////////////////////////
class MimeInputSourceStream : public MimeInputSource {
public:
inline MimeInputSourceStream(std::istream& s, unsigned int start = 0);
virtual inline ssize_t fillRaw(char *raw, size_t nb);
virtual inline void reset(void);
private:
istream& s;
};
private:
std::istream& s;
};
inline MimeInputSourceStream::MimeInputSourceStream(istream& si,
unsigned int start)
: MimeInputSource(-1, start), s(si)
{
}
inline MimeInputSourceStream::MimeInputSourceStream(std::istream& si,
unsigned int start)
: MimeInputSource(-1, start), s(si)
{
}
inline ssize_t MimeInputSourceStream::fillRaw(char *raw, size_t nb)
{
inline ssize_t MimeInputSourceStream::fillRaw(char *raw, size_t nb)
{
// Why can't streams tell how many characters were actually read
// when hitting eof ?
std::streampos st = s.tellg();
s.seekg(0, ios::end);
s.seekg(0, std::ios::end);
std::streampos lst = s.tellg();
s.seekg(st);
size_t nbytes = size_t(lst - st);
if (nbytes > nb) {
nbytes = nb;
nbytes = nb;
}
if (nbytes <= 0) {
return (ssize_t)-1;
return (ssize_t)-1;
}
s.read(raw, nbytes);
return static_cast<ssize_t>(nbytes);
}
}
inline void MimeInputSourceStream::reset(void)
{
MimeInputSource::reset();
s.seekg(0);
}
inline void MimeInputSourceStream::reset(void)
{
MimeInputSource::reset();
s.seekg(0);
}
}

7
src/bincimapmime/mime-parsefull.cc
View File

@ -36,15 +36,14 @@
#include <exception>
#include <iostream>
#ifndef NO_NAMESPACES
using namespace ::std;
#endif /* NO_NAMESPACES */
#include "mime.h"
#include "mime-utils.h"
#include "mime-inputsource.h"
#include "convert.h"
using namespace std;
// #define MPF
#ifdef MPF
#define MPFDEB(X) fprintf X

4
src/bincimapmime/mime-parseonlyheader.cc
View File

@ -40,9 +40,7 @@
#include <stdio.h>
#include <errno.h>
#ifndef NO_NAMESPACES
using namespace ::std;
#endif /* NO_NAMESPACES */
using namespace std;
//------------------------------------------------------------------------
void Binc::MimeDocument::parseOnlyHeader(int fd)

6
src/bincimapmime/mime.cc
View File

@ -35,15 +35,13 @@
#include <map>
#include <exception>
#include <iostream>
#ifndef NO_NAMESPACES
using namespace ::std;
#endif /* NO_NAMESPACES */
#include "mime.h"
#include "convert.h"
#include "mime-inputsource.h"
using namespace std;
//------------------------------------------------------------------------
Binc::MimeDocument::MimeDocument(void)
{

200
src/bincimapmime/mime.h
View File

@ -1,4 +1,3 @@
/* -*- mode:c++;c-basic-offset:2 -*- */
/* --------------------------------------------------------------------
* Filename:
* src/parsers/mime/mime.h
@ -25,6 +24,7 @@
*/
#ifndef mime_h_included
#define mime_h_included
#include <string>
#include <vector>
#include <map>
@ -38,32 +38,33 @@ class MimeInputSource;
//----------------------------------------------------------------------
class HeaderItem {
private:
mutable std::string key;
mutable std::string value;
mutable std::string key;
mutable std::string value;
public:
inline const std::string &getKey(void) const { return key; }
inline const std::string &getValue(void) const { return value; }
inline const std::string &getKey(void) const { return key; }
inline const std::string &getValue(void) const { return value; }
//--
HeaderItem(void);
HeaderItem(const std::string &key, const std::string &value);
//--
HeaderItem(void);
HeaderItem(const std::string &key, const std::string &value);
};
//----------------------------------------------------------------------
class Header {
private:
mutable std::vector<HeaderItem> content;
mutable std::vector<HeaderItem> content;
public:
bool getFirstHeader(const std::string &key, HeaderItem &dest) const;
bool getAllHeaders(const std::string &key, std::vector<HeaderItem> &dest) const;
void add(const std::string &name, const std::string &content);
void clear(void);
bool getFirstHeader(const std::string &key, HeaderItem &dest) const;
bool getAllHeaders(const std::string &key, std::vector<HeaderItem> &dest)
const;
void add(const std::string &name, const std::string &content);
void clear(void);
//--
Header(void);
~Header(void);
//--
Header(void);
~Header(void);
};
//----------------------------------------------------------------------
@ -72,113 +73,114 @@ class MimeDocument;
class MimePart {
protected:
public:
mutable bool multipart;
mutable bool messagerfc822;
mutable std::string subtype;
mutable std::string boundary;
mutable bool multipart;
mutable bool messagerfc822;
mutable std::string subtype;
mutable std::string boundary;
mutable unsigned int headerstartoffsetcrlf;
mutable unsigned int headerlength;
mutable unsigned int headerstartoffsetcrlf;
mutable unsigned int headerlength;
mutable unsigned int bodystartoffsetcrlf;
mutable unsigned int bodylength;
mutable unsigned int nlines;
mutable unsigned int nbodylines;
mutable unsigned int size;
mutable unsigned int bodystartoffsetcrlf;
mutable unsigned int bodylength;
mutable unsigned int nlines;
mutable unsigned int nbodylines;
mutable unsigned int size;
public:
enum FetchType {
FetchBody,
FetchHeader,
FetchMime
};
enum FetchType {
FetchBody,
FetchHeader,
FetchMime
};
mutable Header h;
mutable Header h;
mutable std::vector<MimePart> members;
mutable std::vector<MimePart> members;
inline const std::string &getSubType(void) const { return subtype; }
inline bool isMultipart(void) const { return multipart; }
inline bool isMessageRFC822(void) const { return messagerfc822; }
inline unsigned int getSize(void) const { return bodylength; }
inline unsigned int getNofLines(void) const { return nlines; }
inline unsigned int getNofBodyLines(void) const { return nbodylines; }
inline unsigned int getBodyLength(void) const { return bodylength; }
inline unsigned int getBodyStartOffset(void) const { return bodystartoffsetcrlf; }
inline const std::string &getSubType(void) const { return subtype; }
inline bool isMultipart(void) const { return multipart; }
inline bool isMessageRFC822(void) const { return messagerfc822; }
inline unsigned int getSize(void) const { return bodylength; }
inline unsigned int getNofLines(void) const { return nlines; }
inline unsigned int getNofBodyLines(void) const { return nbodylines; }
inline unsigned int getBodyLength(void) const { return bodylength; }
inline unsigned int getBodyStartOffset(void) const {
return bodystartoffsetcrlf; }
void printBody(Binc::IODevice &output, unsigned int startoffset, unsigned int length) const;
void getBody(std::string& s, unsigned int startoffset, unsigned int length) const;
virtual void clear(void);
void printBody(Binc::IODevice &output, unsigned int startoffset,
unsigned int length) const;
void getBody(std::string& s, unsigned int startoffset, unsigned int length)
const;
virtual void clear(void);
virtual int doParseOnlyHeader(MimeInputSource *ms);
virtual int doParseFull(MimeInputSource *ms,
const std::string &toboundary, int &boundarysize);
virtual int doParseOnlyHeader(MimeInputSource *ms);
virtual int doParseFull(MimeInputSource *ms,
const std::string &toboundary, int &boundarysize);
MimePart(void);
virtual ~MimePart(void);
MimePart(void);
virtual ~MimePart(void);
private:
MimeInputSource *mimeSource;
MimeInputSource *mimeSource;
bool parseOneHeaderLine(Binc::Header *header, unsigned int *nlines);
bool parseOneHeaderLine(Binc::Header *header, unsigned int *nlines);
bool skipUntilBoundary(const std::string &delimiter,
unsigned int *nlines, bool *eof);
inline void postBoundaryProcessing(bool *eof,
unsigned int *nlines,
int *boundarysize,
bool *foundendofpart);
void parseMultipart(const std::string &boundary,
const std::string &toboundary,
bool *eof,
unsigned int *nlines,
int *boundarysize,
bool *foundendofpart,
unsigned int *bodylength,
std::vector<Binc::MimePart> *members);
void parseSinglePart(const std::string &toboundary,
int *boundarysize,
unsigned int *nbodylines,
unsigned int *nlines,
bool *eof, bool *foundendofpart,
unsigned int *bodylength);
void parseHeader(Binc::Header *header, unsigned int *nlines);
void analyzeHeader(Binc::Header *header, bool *multipart,
bool *messagerfc822, std::string *subtype,
std::string *boundary);
void parseMessageRFC822(std::vector<Binc::MimePart> *members,
bool *foundendofpart,
unsigned int *bodylength,
unsigned int *nbodylines,
const std::string &toboundary);
bool skipUntilBoundary(const std::string &delimiter,
unsigned int *nlines, bool *eof);
inline void postBoundaryProcessing(bool *eof,
unsigned int *nlines,
int *boundarysize,
bool *foundendofpart);
void parseMultipart(const std::string &boundary,
const std::string &toboundary,
bool *eof,
unsigned int *nlines,
int *boundarysize,
bool *foundendofpart,
unsigned int *bodylength,
std::vector<Binc::MimePart> *members);
void parseSinglePart(const std::string &toboundary,
int *boundarysize,
unsigned int *nbodylines,
unsigned int *nlines,
bool *eof, bool *foundendofpart,
unsigned int *bodylength);
void parseHeader(Binc::Header *header, unsigned int *nlines);
void analyzeHeader(Binc::Header *header, bool *multipart,
bool *messagerfc822, std::string *subtype,
std::string *boundary);
void parseMessageRFC822(std::vector<Binc::MimePart> *members,
bool *foundendofpart,
unsigned int *bodylength,
unsigned int *nbodylines,
const std::string &toboundary);
};
//----------------------------------------------------------------------
class MimeDocument : public MimePart {
public:
MimeDocument(void);
~MimeDocument(void);
MimeDocument(void);
~MimeDocument(void);
void parseOnlyHeader(int fd);
void parseFull(int fd);
void parseOnlyHeader(std::istream& s);
void parseFull(std::istream& s);
void parseOnlyHeader(int fd);
void parseFull(int fd);
void parseOnlyHeader(std::istream& s);
void parseFull(std::istream& s);
void clear(void);
void clear(void);
bool isHeaderParsed(void) const
{
return headerIsParsed;
}
bool isAllParsed(void) const
{
return allIsParsed;
}
bool isHeaderParsed(void) const {
return headerIsParsed;
}
bool isAllParsed(void) const {
return allIsParsed;
}
private:
bool headerIsParsed;
bool allIsParsed;
MimeInputSource *doc_mimeSource;
bool headerIsParsed;
bool allIsParsed;
MimeInputSource *doc_mimeSource;
};
};