diff options
Diffstat (limited to 'src')
103 files changed, 1291 insertions, 2046 deletions
diff --git a/src/address.cc b/src/address.cc index eff4ccd..33d216e 100644 --- a/src/address.cc +++ b/src/address.cc @@ -1,35 +1,38 @@ -/** ------------------------------------------------------------------- +/** * @file address.cc * @brief Implementation of the Address class * @author Andreas Aardal Hanssen * @date 2005 - * ---------------------------------------------------------------- **/ + */ + #include "address.h" #include "convert.h" #include <string> -using namespace ::std; using namespace Binc; +using std::string; -//------------------------------------------------------------------------ Address::Address(const string &name, const string &addr) { - string::size_type pos = addr.find('@'); + auto pos = addr.find('@'); + this->name = name; + if (pos != string::npos) { this->local = addr.substr(0, pos); this->host = addr.substr(pos + 1); - } else + } else { this->local = addr; + } } -//------------------------------------------------------------------------ Address::Address(const string &wholeaddress) { - string::size_type start = wholeaddress.find('<'); + auto start = wholeaddress.find('<'); string addr; + if (start != string::npos) addr = wholeaddress.substr(start + 1); else @@ -41,6 +44,7 @@ Address::Address(const string &wholeaddress) name = wholeaddress.substr(0, start); else name = ""; + trim(name); trim(name, "\""); @@ -53,7 +57,6 @@ Address::Address(const string &wholeaddress) trim(name); } -//------------------------------------------------------------------------ string Address::toParenList(void) const { string tmp = "("; diff --git a/src/argparser.cc b/src/argparser.cc index 1382610..d8e45ae 100644 --- a/src/argparser.cc +++ b/src/argparser.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file argparser.cc * @brief Implementation of the command line argument parser * @author Andreas Aardal Hanssen * @date 2005 - * ------------------------------------------------------------------ **/ + */ + #include "argparser.h" #include "convert.h" @@ -11,17 +12,15 @@ #include <map> #include <string> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- CommandLineArgs::CommandLineArgs() { errString = "Unknown error for args"; ac = 0; } -//---------------------------------------------------------------------- bool CommandLineArgs::parse(int argc, char *argv[]) { ac = -1; @@ -79,7 +78,7 @@ bool CommandLineArgs::parse(int argc, char *argv[]) // parse --argument string arg = s.substr(2); string val; - string::size_type epos = arg.find('='); + auto epos = arg.find('='); if (epos != string::npos) { val = arg.substr(epos + 1); arg = arg.substr(0, epos); @@ -128,12 +127,11 @@ bool CommandLineArgs::parse(int argc, char *argv[]) // parse -argument string arg = s.substr(1); if (arg.length() == 1) { - map<string, ArgOpts>::const_iterator it = reg.begin(); bool match = false; - for (; it != reg.end(); ++it) { - if (it->second.c.find(arg[0]) != string::npos) { - lastKey = it->first; - if (it->second.b) lastIsBoolean = true; + for (const auto &[first, second] : reg) { + if (second.c.find(arg[0]) != string::npos) { + lastKey = first; + if (second.b) lastIsBoolean = true; match = true; break; } @@ -145,23 +143,21 @@ bool CommandLineArgs::parse(int argc, char *argv[]) return false; } } else { - string::const_iterator its = arg.begin(); - for (; its != arg.end(); ++its) { - map<string, ArgOpts>::const_iterator it = reg.begin(); + for (auto its : arg) { bool match = false; - for (; it != reg.end(); ++it) { - if (it->second.c.find(*its) != string::npos) { - if (!it->second.b) { + for (const auto &[first, second] : reg) { + if (second.c.find(its) != string::npos) { + if (!second.b) { errString = "argument is not a boolean: "; - errString += "--" + it->first; + errString += "--" + first; errString += " / -"; - errString += it->second.c; + errString += second.c; return false; } match = true; - args[it->first] = "yes"; - passedArgs[it->first] = true; + args[first] = "yes"; + passedArgs[first] = true; lastKey = ""; lastIsBoolean = false; @@ -192,15 +188,14 @@ bool CommandLineArgs::parse(int argc, char *argv[]) } // assign default "no" values for arguments that were not passed. - map<string, ArgOpts>::const_iterator it = reg.begin(); - for (; it != reg.end(); ++it) { - if (args.find(it->first) == args.end()) { - if (!it->second.o) { + for (const auto &[first, second] : reg) { + if (args.find(first) == args.end()) { + if (!second.o) { errString = "missing argument: "; - errString += it->first; + errString += first; return false; } - if (it->second.b) args[it->first] = "no"; + if (second.b) args[first] = "no"; } } if (ac == -1) ac = argc; @@ -208,32 +203,27 @@ bool CommandLineArgs::parse(int argc, char *argv[]) return true; } -//---------------------------------------------------------------------- string CommandLineArgs::errorString(void) const { return errString; } -//---------------------------------------------------------------------- const string CommandLineArgs::operator[](const string &arg) const { if (args.find(arg) == args.end()) return ""; return args.find(arg)->second; } -//---------------------------------------------------------------------- void CommandLineArgs::addOptional(const string &arg, const string &desc, bool boolean) { registerArg(arg, desc, boolean, true); } -//---------------------------------------------------------------------- void CommandLineArgs::addRequired(const string &arg, const string &desc, bool boolean) { registerArg(arg, desc, boolean, false); } -//---------------------------------------------------------------------- void CommandLineArgs::registerArg(const string &arg, const string &desc, bool boolean, bool optional) { string name = arg; @@ -247,26 +237,22 @@ void CommandLineArgs::registerArg(const string &arg, const string &desc, bool bo reg.insert(make_pair(name, ArgOpts(shorts, boolean, optional, desc))); } -//---------------------------------------------------------------------- -bool CommandLineArgs::hasArg(const std::string &arg) const +bool CommandLineArgs::hasArg(const string &arg) const { string tmp = arg; lowercase(tmp); return passedArgs.find(tmp) != passedArgs.end(); } -//---------------------------------------------------------------------- string CommandLineArgs::usageString(void) const { string tmp = head; tmp += '\n'; - map<string, ArgOpts>::const_iterator it = reg.begin(); - for (; it != reg.end(); ++it) { - if (it->second.c != "") { - string::const_iterator sit = it->second.c.begin(); - for (; sit != it->second.c.end(); ++sit) { - if (sit != it->second.c.begin()) tmp += '\n'; + for (const auto &[first, second] : reg) { + if (!second.c.empty()) { + for (auto sit = second.c.cbegin(); sit != second.c.cend(); ++sit) { + if (sit != second.c.begin()) tmp += '\n'; tmp += " -"; tmp += *sit; } @@ -275,13 +261,12 @@ string CommandLineArgs::usageString(void) const tmp += " "; } - tmp += "--"; - tmp += it->first; - if (!it->second.b) tmp += "=<str>"; + tmp += "--" + first; + if (!second.b) tmp += "=<str>"; - if (!it->second.o) tmp += " (required)"; + if (!second.o) tmp += " (required)"; - string::size_type lineStart = tmp.rfind('\n'); + auto lineStart = tmp.rfind('\n'); if (lineStart == string::npos) lineStart = 0; int pad = 21 - (tmp.length() - lineStart); @@ -290,32 +275,25 @@ string CommandLineArgs::usageString(void) const pad = 20; } - tmp += string(pad, ' '); - tmp += it->second.desc; - tmp += '\n'; + tmp += string(pad, ' ') + second.desc + '\n'; } - tmp += '\n'; - tmp += tail; - tmp += '\n'; + tmp += '\n' + tail + '\n'; return tmp; } -//---------------------------------------------------------------------- int CommandLineArgs::argc(void) const { return ac; } -//---------------------------------------------------------------------- void CommandLineArgs::setTail(const string &str) { tail = str; } -//---------------------------------------------------------------------- -const vector<string> &CommandLineArgs::getUnqualifiedArgs() const +const std::vector<string> &CommandLineArgs::getUnqualifiedArgs() const { return unqualified; } diff --git a/src/authenticate.cc b/src/authenticate.cc index 88bfa63..63a8b3a 100644 --- a/src/authenticate.cc +++ b/src/authenticate.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file authenticate.cc * @brief Implementation of the common (C/R) authentication mechanism. * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #include <string> #include <vector> @@ -28,15 +29,16 @@ #include "iofactory.h" #include "session.h" -using namespace ::std; using namespace Binc; +using std::endl; +using std::string; // 0 = ok // 1 = internal error // 2 = failed // 3 = timeout // -1 = abort -//------------------------------------------------------------------------ + int Binc::authenticate(Depot &depot, const string &username, const string &password, @@ -46,7 +48,7 @@ int Binc::authenticate(Depot &depot, session.setUserID(username); // check if checkpassword is present - if (::access(session.unparsedArgs[0], X_OK) != 0) { // x is enough + if (access(session.unparsedArgs[0], X_OK) != 0) { // x is enough bincError << "unable to start authenticator " << session.unparsedArgs[0] << ": " << strerror(errno) << endl; return 1; @@ -84,15 +86,16 @@ int Binc::authenticate(Depot &depot, } string timestamp; - time_t t = time(0); + time_t t = time(nullptr); char *c; - if ((c = ctime(&t)) != 0) { + if ((c = ctime(&t)) != nullptr) { timestamp = c; trim(timestamp); - } else + } else { timestamp = "unknown timestamp"; + } - string pid = to_string(session.getPid()); + string pid = std::to_string(session.getPid()); // execute authentication module int result; @@ -128,7 +131,7 @@ int Binc::authenticate(Depot &depot, exit(111); } - if (session.unparsedArgs[0] != 0) { + if (session.unparsedArgs[0] != nullptr) { execvp(session.unparsedArgs[0], &session.unparsedArgs[0]); bincDebug << "bincimap-up: pid " << pid << " authenticate(), [auth module] invocation of " << session.unparsedArgs[0] << " failed: " << strerror(errno) << endl; @@ -212,7 +215,7 @@ int Binc::authenticate(Depot &depot, // EINTR. int n; do { - n = select(maxfd + 1, &rtmp, 0, 0, &timeout); + n = select(maxfd + 1, &rtmp, nullptr, nullptr, &timeout); } while (n < 0 && errno == EINTR); if (n < 0) { @@ -295,8 +298,7 @@ int Binc::authenticate(Depot &depot, return -1; } - // if the server died because we closed the sockets after a timeout, - // exit 3. + // if the server died because we closed the sockets after a timeout, exit 3. if (timedout) return 3; if (disconnected) return 0; diff --git a/src/base64.cc b/src/base64.cc index 5b182b2..1cbac91 100644 --- a/src/base64.cc +++ b/src/base64.cc @@ -1,22 +1,23 @@ -/** -------------------------------------------------------------------- +/** * @file base64.cc * @brief Implementation of base64 Utilities * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "base64.h" #include <iostream> #include <string> -using namespace ::std; +using std::string; -typedef unsigned char bbyte; /* Byte type */ +typedef unsigned char bbyte; // Byte type #define TRUE 1 #define FALSE 0 -#define LINELEN 72 /* Encoded line length (max 76) */ +#define LINELEN 72 // Encoded line length (max 76) static bbyte dtable[256]; @@ -25,15 +26,14 @@ string Binc::base64encode(const string &s_in) int i; string result; - /* Fill dtable with character encodings. */ + // Fill dtable with character encodings. for (i = 0; i < 26; i++) { dtable[i] = 'A' + i; dtable[26 + i] = 'a' + i; } - for (i = 0; i < 10; i++) { + for (i = 0; i < 10; i++) dtable[52 + i] = '0' + i; - } dtable[62] = '+'; dtable[63] = '/'; @@ -45,23 +45,22 @@ string Binc::base64encode(const string &s_in) igroup[0] = igroup[1] = igroup[2] = 0; for (n = 0; n < 3 && s_i != s_in.end(); n++) { c = *s_i++; - igroup[n] = (bbyte)c; + igroup[n] = static_cast<bbyte>(c); } + if (n > 0) { ogroup[0] = dtable[igroup[0] >> 2]; ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)]; ogroup[2] = dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)]; ogroup[3] = dtable[igroup[2] & 0x3F]; - /* Replace characters in output stream with "=" pad - characters if fewer than three characters were - read from the end of the input stream. */ + // Replace characters in output stream with "=" pad + // characters if fewer than three characters were + // read from the end of the input stream. if (n < 3) { ogroup[3] = '='; - if (n < 2) { - ogroup[2] = '='; - } + if (n < 2) ogroup[2] = '='; } for (i = 0; i < 4; i++) @@ -77,18 +76,14 @@ string Binc::base64decode(const string &s_in) string result; int i; - for (i = 0; i < 255; i++) { + for (i = 0; i < 255; i++) dtable[i] = 0x80; - } - for (i = 'A'; i <= 'Z'; i++) { + for (i = 'A'; i <= 'Z'; i++) dtable[i] = 0 + (i - 'A'); - } - for (i = 'a'; i <= 'z'; i++) { + for (i = 'a'; i <= 'z'; i++) dtable[i] = 26 + (i - 'a'); - } - for (i = '0'; i <= '9'; i++) { + for (i = '0'; i <= '9'; i++) dtable[i] = 52 + (i - '0'); - } dtable[(int)'+'] = 62; dtable[(int)'/'] = 63; dtable[(int)'='] = 0; diff --git a/src/bincimap-up.cc b/src/bincimap-up.cc index c74b98f..48615ad 100644 --- a/src/bincimap-up.cc +++ b/src/bincimap-up.cc @@ -1,15 +1,15 @@ -/** -------------------------------------------------------------------- +/** * @file bincimap-up.cc * @brief Implementation of the preauthenticated bincimap stub * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "imapserver.h" -//------------------------------------------------------------------------ int main(int argc, char *argv[]) { - Binc::IMAPServer imapServer(argc, argv); + auto imapServer = Binc::IMAPServer(argc, argv); int initResult = imapServer.initialize(); if (initResult != 0) return initResult; return imapServer.runStub(); diff --git a/src/bincimap-updatecache.cc b/src/bincimap-updatecache.cc index b89abdf..b1cf7b3 100644 --- a/src/bincimap-updatecache.cc +++ b/src/bincimap-updatecache.cc @@ -1,16 +1,16 @@ -/** -------------------------------------------------------------------- +/** * @file bincimap-updatecache.cc * @brief Implementation of the bincimap-updatecache tool. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "mailbox.h" #include "maildir.h" #include "session.h" -using namespace ::Binc; -using namespace ::std; +using namespace Binc; int main(int argc, char *argv[]) { @@ -27,11 +27,11 @@ int main(int argc, char *argv[]) depotfactory.assign(new IMAPdirDepot()); depotfactory.assign(new MaildirPPDepot()); - string depottype = session.getEnv("DEPOT"); + std::string depottype = session.getEnv("DEPOT"); if (depottype == "") depottype = "Maildir++"; Depot *depot; - if ((depot = depotfactory.get(depottype)) == 0) { + if ((depot = depotfactory.get(depottype)) == nullptr) { fprintf(stderr, "Found no Depot for \"%s\". Please check " " your configurations file under the Mailbox section.\n", diff --git a/src/bincimapd.cc b/src/bincimapd.cc index b8ba1cb..1ec89df 100644 --- a/src/bincimapd.cc +++ b/src/bincimapd.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file bincimapd.cc * @brief Implementation of the main bincimapd service * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "imapserver.h" namespace Binc { @@ -12,7 +13,7 @@ namespace Binc { int main(int argc, char *argv[]) { - Binc::IMAPServer imapServer(argc, argv); + auto imapServer = Binc::IMAPServer(argc, argv); int initResult = imapServer.initialize(); if (initResult != 0) return initResult; return imapServer.run(); diff --git a/src/broker.cc b/src/broker.cc index 4cb7787..507c8c4 100644 --- a/src/broker.cc +++ b/src/broker.cc @@ -1,9 +1,10 @@ -/** --------------------------------------------------------------------- +/** * @file broker.cc * @brief Implementation of the Broker class * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "broker.h" #include "convert.h" @@ -14,10 +15,9 @@ #include <map> #include <string> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- BrokerFactory::BrokerFactory(void) { brokers[Session::NONAUTHENTICATED] = new Broker(); @@ -25,86 +25,74 @@ BrokerFactory::BrokerFactory(void) brokers[Session::SELECTED] = new Broker(); } -//---------------------------------------------------------------------- BrokerFactory::~BrokerFactory(void) { - for (map<int, Broker *>::iterator i = brokers.begin(); i != brokers.end(); ++i) - delete i->second; + for (auto &[_, second] : brokers) + delete second; } -//---------------------------------------------------------------------- BrokerFactory &BrokerFactory::getInstance(void) { static BrokerFactory brokerfactory; return brokerfactory; } -//---------------------------------------------------------------------- void BrokerFactory::addCapability(const std::string &c) { - for (map<int, Broker *>::iterator i = brokers.begin(); i != brokers.end(); ++i) { - CapabilityOperator *o; - o = dynamic_cast<CapabilityOperator *>(i->second->get("CAPABILITY")); - if (o != 0) { + for (const auto &[_, second] : brokers) { + auto o = dynamic_cast<CapabilityOperator *>(second->get("CAPABILITY")); + if (o != nullptr) { o->addCapability(c); break; } } } -//---------------------------------------------------------------------- void BrokerFactory::assign(const string &fname, Operator *o) { int deletable = true; - for (map<int, Broker *>::iterator i = brokers.begin(); i != brokers.end(); ++i) - if (i->first & o->getState()) { - i->second->assign(fname, o, deletable); + for (const auto &[first, second] : brokers) { + if (first & o->getState()) { + second->assign(fname, o, deletable); deletable = false; } + } } -//---------------------------------------------------------------------- Operator *BrokerFactory::getOperator(int state, const string &name) const { if (brokers.find(state) == brokers.end()) - return 0; + return nullptr; else return brokers.find(state)->second->get(name); } -//---------------------------------------------------------------------- Broker *BrokerFactory::getBroker(int state) { if (brokers.find(state) == brokers.end()) { setLastError("No appropriate broker for state."); - return 0; + return nullptr; } return brokers[state]; } -//---------------------------------------------------------------------- Broker::Broker(void) {} -//---------------------------------------------------------------------- Broker::~Broker(void) {} -//---------------------------------------------------------------------- void Broker::assign(const string &fname, Operator *o, bool deletable) { deletables[fname] = deletable; operators[fname] = o; } -//---------------------------------------------------------------------- Operator *Broker::get(const string &name) const { - if (operators.find(name) == operators.end()) return 0; - + if (operators.find(name) == operators.end()) return nullptr; return operators.find(name)->second; } -//---------------------------------------------------------------------- Operator::ParseResult Broker::parseStub(Request &command) { Session &session = Session::getInstance(); @@ -117,6 +105,7 @@ Operator::ParseResult Broker::parseStub(Request &command) break; case Operator::REJECT: session.setLastError("Syntax error; first token must be a tag"); + [[fallthrough]]; case Operator::ERROR: return Operator::ERROR; case Operator::TIMEOUT: @@ -128,6 +117,7 @@ Operator::ParseResult Broker::parseStub(Request &command) break; case Operator::REJECT: session.setLastError("Syntax error; second token must be a SPACE"); + [[fallthrough]]; case Operator::ERROR: return Operator::ERROR; case Operator::TIMEOUT: @@ -139,6 +129,7 @@ Operator::ParseResult Broker::parseStub(Request &command) break; case Operator::REJECT: session.setLastError("Syntax error; third token must be a command"); + [[fallthrough]]; case Operator::ERROR: return Operator::ERROR; case Operator::TIMEOUT: @@ -154,8 +145,8 @@ Operator::ParseResult Broker::parseStub(Request &command) case Operator::ACCEPT: break; case Operator::REJECT: - session.setLastError("Syntax error; after UID there" - " must come a SPACE"); + session.setLastError("Syntax error; after UID there must come a SPACE"); + [[fallthrough]]; case Operator::ERROR: return Operator::ERROR; case Operator::TIMEOUT: @@ -166,8 +157,8 @@ Operator::ParseResult Broker::parseStub(Request &command) case Operator::ACCEPT: break; case Operator::REJECT: - session.setLastError("Syntax error; after UID " - "SPACE there must come a command"); + session.setLastError("Syntax error; after UID SPACE there must come a command"); + [[fallthrough]]; case Operator::ERROR: return Operator::ERROR; case Operator::TIMEOUT: diff --git a/src/convert.cc b/src/convert.cc index ac1c01b..5e77f97 100644 --- a/src/convert.cc +++ b/src/convert.cc @@ -1,26 +1,24 @@ -/** -------------------------------------------------------------------- +/** * @file convert.cc * @brief Implementation of miscellaneous convertion functions * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include <string> -using namespace ::std; using namespace Binc; +using std::string; -//------------------------------------------------------------------------ BincStream::BincStream(void) {} -//------------------------------------------------------------------------ BincStream::~BincStream(void) { clear(); } -//------------------------------------------------------------------------ string BincStream::popString(unsigned int size) { if (size > nstr.length()) size = nstr.length(); @@ -29,7 +27,6 @@ string BincStream::popString(unsigned int size) return tmp; } -//------------------------------------------------------------------------ char BincStream::popChar(void) { if (nstr.length() == 0) return '\0'; @@ -39,58 +36,49 @@ char BincStream::popChar(void) return c; } -//------------------------------------------------------------------------ void BincStream::unpopChar(char c) { nstr = c + nstr; } -//------------------------------------------------------------------------ void BincStream::unpopStr(const string &s) { nstr = s + nstr; } -//------------------------------------------------------------------------ const string &BincStream::str(void) const { return nstr; } -//------------------------------------------------------------------------ void BincStream::clear(void) { nstr = ""; } -//------------------------------------------------------------------------ unsigned int BincStream::getSize(void) const { return (unsigned int)nstr.length(); } -//------------------------------------------------------------------------ BincStream &BincStream::operator<<(std::ostream &(*)(std::ostream &)) { nstr += "\r\n"; return *this; } -//------------------------------------------------------------------------ BincStream &BincStream::operator<<(const string &t) { nstr += t; return *this; } -//------------------------------------------------------------------------ BincStream &BincStream::operator<<(int t) { nstr += toString(t); return *this; } -//------------------------------------------------------------------------ BincStream &BincStream::operator<<(unsigned long t) { nstr += toString(t); @@ -103,7 +91,6 @@ BincStream &BincStream::operator<<(unsigned int t) return *this; } -//------------------------------------------------------------------------ BincStream &BincStream::operator<<(char t) { nstr += t; diff --git a/src/depot.cc b/src/depot.cc index c31c04b..86ac5f4 100644 --- a/src/depot.cc +++ b/src/depot.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file depot.cc * @brief Implementation of the Depot class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "depot.h" #include "convert.h" @@ -12,6 +13,7 @@ #include "mailbox.h" #include "status.h" +#include <cstddef> #include <map> #include <string> @@ -19,224 +21,191 @@ #include <unistd.h> -using namespace ::std; using namespace Binc; +using std::endl; +using std::string; -//-------------------------------------------------------------------- DepotFactory::DepotFactory(void) {} -//-------------------------------------------------------------------- DepotFactory::~DepotFactory(void) { - for (vector<Depot *>::iterator i = depots.begin(); i != depots.end(); ++i) - delete *i; + for (auto i : depots) + delete i; } -//-------------------------------------------------------------------- Depot *DepotFactory::get(const string &name) const { - for (vector<Depot *>::const_iterator i = depots.begin(); i != depots.end(); ++i) - if ((*i)->getName() == name) return *i; + for (const auto i : depots) + if (i->getName() == name) return i; - return 0; + return nullptr; } -//-------------------------------------------------------------------- void DepotFactory::assign(Depot *depot) { depots.push_back(depot); } -//-------------------------------------------------------------------- DepotFactory &DepotFactory::getInstance(void) { static DepotFactory depotfactory; return depotfactory; } -//-------------------------------------------------------------------- -Depot::Depot(void) : enditerator(0, 0) -{ - defaultmailbox = 0; - selectedmailbox = 0; - - delimiter = '/'; -} - -//-------------------------------------------------------------------- -Depot::Depot(const string &name) : enditerator(0, 0) -{ - defaultmailbox = 0; - selectedmailbox = 0; - - delimiter = '/'; - - this->name = name; -} +Depot::Depot() : Depot("") {} -//-------------------------------------------------------------------- -Depot::~Depot(void) {} +Depot::Depot(const std::string &name) + : enditerator(nullptr, nullptr) + , defaultmailbox(nullptr) + , selectedmailbox(nullptr) + , name(name) + , delimiter('/') +{} -//-------------------------------------------------------------------- const string &Depot::getLastError(void) const { return lastError; } -//-------------------------------------------------------------------- void Depot::setLastError(const string &error) const { lastError = error; } -//-------------------------------------------------------------------- void Depot::assign(Mailbox *m) { - for (vector<Mailbox *>::const_iterator i = backends.begin(); i != backends.end(); ++i) - if (*i == m) break; + for (const auto i : backends) + if (i == m) break; backends.push_back(m); } -//-------------------------------------------------------------------- Mailbox *Depot::get(const string &s_in) const { - for (vector<Mailbox *>::const_iterator i = backends.begin(); i != backends.end(); ++i) - if ((*i)->isMailbox(mailboxToFilename(s_in))) return *i; + for (const auto i : backends) + if (i->isMailbox(mailboxToFilename(s_in))) return i; setLastError("No such mailbox " + toImapString(s_in)); - return 0; + return nullptr; } -//-------------------------------------------------------------------- bool Depot::setSelected(Mailbox *m) { - for (vector<Mailbox *>::const_iterator i = backends.begin(); i != backends.end(); ++i) - if (*i == m) { + for (const auto i : backends) { + if (i == m) { selectedmailbox = m; return true; } + } setLastError("Attempted to select unregistered Mailbox type in Depot"); return false; } -//-------------------------------------------------------------------- const string &Depot::getName(void) const { return name; } -//-------------------------------------------------------------------- const string &Depot::getPersonalNamespace(void) const { return personalNamespace; } -//-------------------------------------------------------------------- const string &Depot::getOthersNamespace(void) const { return othersNamespace; } -//-------------------------------------------------------------------- const string &Depot::getSharedNamespace(void) const { return sharedNamespace; } -//-------------------------------------------------------------------- void Depot::setDelimiter(char c) { delimiter = c; } -//-------------------------------------------------------------------- -const char Depot::getDelimiter(void) const +char Depot::getDelimiter(void) const { return delimiter; } -//-------------------------------------------------------------------- bool Depot::setDefaultType(const string &name) { - for (vector<Mailbox *>::const_iterator i = backends.begin(); i != backends.end(); ++i) - if ((*i)->getTypeName() == name) { - defaultmailbox = *i; + for (const auto i : backends) { + if (i->getTypeName() == name) { + defaultmailbox = i; return true; } + } setLastError("attempt to default to unregistered Mailbox type " + name); return false; } -//-------------------------------------------------------------------- Mailbox *Depot::getSelected(void) const { return selectedmailbox; } -//-------------------------------------------------------------------- void Depot::resetSelected(void) { - selectedmailbox = 0; + selectedmailbox = nullptr; } -//-------------------------------------------------------------------- Mailbox *Depot::getDefault(void) const { return defaultmailbox; } -//-------------------------------------------------------------------- bool Depot::createMailbox(const string &s_in) const { const string &mailboxname = mailboxToFilename(toCanonMailbox(s_in)); - if (mailboxname == "") { + if (mailboxname.empty()) { setLastError("invalid mailbox name"); return false; } Mailbox *mailbox = getDefault(); - if (mailbox == 0) { + if (mailbox == nullptr) { setLastError("no default mailbox defined"); return false; } bool result = mailbox->createMailbox(mailboxname, 0777); - if (result) + if (result) { return true; - else { + } else { setLastError(mailbox->getLastError()); return false; } } -//-------------------------------------------------------------------- bool Depot::deleteMailbox(const string &s_in) const { const string &mailboxname = mailboxToFilename(toCanonMailbox(s_in)); Mailbox *mailbox = get(s_in); - if (mailbox == 0) { + if (mailbox == nullptr) { setLastError(s_in + ": no such mailbox"); return false; } bool result = mailbox->deleteMailbox(mailboxname); - if (result) + if (result) { return true; - else { + } else { setLastError(mailbox->getLastError()); return false; } } -//-------------------------------------------------------------------- bool Depot::renameMailbox(const string &s_in, const string &t_in) const { - const string &source = mailboxToFilename(s_in).c_str(); - const string &dest = mailboxToFilename(t_in).c_str(); + const string &source = mailboxToFilename(s_in); + const string &dest = mailboxToFilename(t_in); int nrenamed = 0; const iterator e = end(); @@ -249,23 +218,24 @@ bool Depot::renameMailbox(const string &s_in, const string &t_in) const if (entry.length() == source.length()) { sourcename = source; destname = dest; - } else if (entry.length() > source.length() && entry[source.length()] == '.') { sourcename = entry; destname = dest + entry.substr(source.length()); - } else + } else { continue; + } if (rename(sourcename.c_str(), destname.c_str()) != 0) { bincWarning << "error renaming " << sourcename << " to " << destname << ": " << strerror(errno) << endl; - } else + } else { nrenamed++; + } Mailbox *mailbox; - if ((mailbox = get(filenameToMailbox(sourcename))) != 0) + if ((mailbox = get(filenameToMailbox(sourcename))) != nullptr) mailbox->bumpUidValidity(filenameToMailbox(sourcename)); - if ((mailbox = get(filenameToMailbox(destname))) != 0) + if ((mailbox = get(filenameToMailbox(destname))) != nullptr) mailbox->bumpUidValidity(filenameToMailbox(destname)); } } @@ -276,16 +246,16 @@ bool Depot::renameMailbox(const string &s_in, const string &t_in) const " then copy over all messages." " Finally, delete the original mailbox"); return false; - } else + } else { return true; + } } -//-------------------------------------------------------------------- bool Depot::getStatus(const std::string &s_in, Status &dest) const { const string mailbox = toCanonMailbox(s_in); Mailbox *m = get(mailbox); - if (m == 0) { + if (m == nullptr) { setLastError("Unrecognized mailbox: " + toImapString(s_in)); return false; } @@ -306,26 +276,22 @@ bool Depot::getStatus(const std::string &s_in, Status &dest) const return true; } -//---------------------------------------------------------------------- -vector<string> Depot::getSubscriptions(void) const +std::vector<string> Depot::getSubscriptions(void) const { return subscribed; } -//---------------------------------------------------------------------- -void Depot::subscribeTo(const std::string mailbox) +void Depot::subscribeTo(const string mailbox) { - for (vector<string>::iterator i = subscribed.begin(); i != subscribed.end(); ++i) { - if (*i == mailbox) return; - } + for (const auto &i : subscribed) + if (i == mailbox) return; subscribed.push_back(mailbox); } -//---------------------------------------------------------------------- -bool Depot::unsubscribeTo(const std::string mailbox) +bool Depot::unsubscribeTo(const string mailbox) { - for (vector<string>::iterator i = subscribed.begin(); i != subscribed.end(); ++i) { + for (auto i = subscribed.begin(); i != subscribed.end(); ++i) { if (*i == mailbox) { subscribed.erase(i); return true; @@ -335,7 +301,6 @@ bool Depot::unsubscribeTo(const std::string mailbox) return false; } -//---------------------------------------------------------------------- void Depot::loadSubscribes(void) { // drop all existing subscribed folders. @@ -344,7 +309,7 @@ void Depot::loadSubscribes(void) // try loading the .subscribed file bool ok = false; FILE *fp = fopen(".subscribed", "r"); - map<string, bool> addedEntries; + std::map<string, bool> addedEntries; if (fp) { int c; string current; @@ -361,8 +326,9 @@ void Depot::loadSubscribes(void) } current = ""; } - } else + } else { current += c; + } } fclose(fp); @@ -375,28 +341,24 @@ void Depot::loadSubscribes(void) } } -//---------------------------------------------------------------------- bool Depot::saveSubscribes(void) const { // create a safe file name - string tpl = ".subscribed-tmp-XXXXXX"; - char *ftemplate = new char[tpl.length() + 1]; + string ftemplate = ".subscribed-tmp-XXXXXX"; - strcpy(ftemplate, tpl.c_str()); - int fd = mkstemp(ftemplate); + int fd = mkstemp(ftemplate.data()); if (fd == -1) { - bincWarning << "unable to create temporary file \"" << tpl << "\"" << endl; - delete[] ftemplate; + bincWarning << "unable to create temporary file \"" << ftemplate << "\"" << endl; return false; } - map<string, bool> addedEntries; - for (vector<string>::const_iterator i = subscribed.begin(); i != subscribed.end(); ++i) { - if (addedEntries.find(*i) == addedEntries.end()) { - addedEntries[*i] = true; - string w = mailboxToFilename(*i) + "\n"; + std::map<string, bool> addedEntries; + for (const auto &i : subscribed) { + if (addedEntries.find(i) == addedEntries.end()) { + addedEntries[i] = true; + string w = mailboxToFilename(i) + "\n"; if (write(fd, w.c_str(), w.length()) != (ssize_t)w.length()) { - bincWarning << "failed to write to " << tpl << ": " << strerror(errno) << endl; + bincWarning << "failed to write to " << ftemplate << ": " << strerror(errno) << endl; break; } } @@ -404,29 +366,24 @@ bool Depot::saveSubscribes(void) const if ((fsync(fd) && (errno != EROFS || errno != EINVAL)) || close(fd)) { bincWarning << "failed to close " << ftemplate << ": " << strerror(errno) << endl; - delete[] ftemplate; return false; } - if (rename(ftemplate, ".subscribed") != 0) { + if (rename(ftemplate.c_str(), ".subscribed") != 0) { bincWarning << "failed to rename " << ftemplate << " to .subscribed: " << strerror(errno) << endl; - delete[] ftemplate; return false; } - delete[] ftemplate; return true; } -//-------------------------------------------------------------------- Depot::iterator::iterator(void) { - dirp = 0; + dirp = nullptr; ref = new int; *ref = 1; } -//-------------------------------------------------------------------- Depot::iterator::iterator(DIR *dp, struct dirent *sp) { dirp = dp; @@ -436,7 +393,6 @@ Depot::iterator::iterator(DIR *dp, struct dirent *sp) *ref = 1; } -//-------------------------------------------------------------------- Depot::iterator::iterator(const iterator ©) { if (*copy.ref != 0) ++(*copy.ref); @@ -446,13 +402,11 @@ Depot::iterator::iterator(const iterator ©) direntp = copy.direntp; } -//-------------------------------------------------------------------- Depot::iterator::~iterator(void) { deref(); } -//-------------------------------------------------------------------- Depot::iterator &Depot::iterator::operator=(const iterator ©) { if (*copy.ref != 0) ++(*copy.ref); @@ -466,53 +420,47 @@ Depot::iterator &Depot::iterator::operator=(const iterator ©) return *this; } -//-------------------------------------------------------------------- void Depot::iterator::deref(void) { // decrease existing copy ref if there is one if (*ref != 0 && --(*ref) == 0) { if (dirp) { closedir(dirp); - dirp = 0; + dirp = nullptr; } delete ref; - ref = 0; + ref = nullptr; } } -//-------------------------------------------------------------------- string Depot::iterator::operator*(void) const { - if (direntp == 0) return ""; + if (direntp == nullptr) return ""; return direntp->d_name; } -//-------------------------------------------------------------------- void Depot::iterator::operator++(void) { direntp = readdir(dirp); } -//-------------------------------------------------------------------- bool Depot::iterator::operator==(Depot::iterator i) const { return direntp == i.direntp; } -//-------------------------------------------------------------------- bool Depot::iterator::operator!=(Depot::iterator i) const { return direntp != i.direntp; } -//-------------------------------------------------------------------- Depot::iterator Depot::begin(const string &path) const { Depot::iterator i; - if ((i.dirp = opendir(path.c_str())) == 0) { + if ((i.dirp = opendir(path.c_str())) == nullptr) { bincWarning << "opendir on " << path << " failed" << endl; setLastError("opendir on " + path + " failed"); return end(); @@ -522,29 +470,24 @@ Depot::iterator Depot::begin(const string &path) const return i; } -//-------------------------------------------------------------------- const Depot::iterator &Depot::end(void) const { return enditerator; } -//-------------------------------------------------------------------- MaildirPPDepot::MaildirPPDepot(void) : Depot("Maildir++") { privateNamespace = "INBOX"; privateNamespace += getDelimiter(); } -//-------------------------------------------------------------------- MaildirPPDepot::~MaildirPPDepot(void) {} -//-------------------------------------------------------------------- const string &MaildirPPDepot::getPersonalNamespace(void) const { return privateNamespace; } -//-------------------------------------------------------------------- string MaildirPPDepot::mailboxToFilename(const string &m) const { string prefix = "INBOX"; @@ -566,9 +509,9 @@ string MaildirPPDepot::mailboxToFilename(const string &m) const twodelim += delimiter; twodelim += delimiter; - if (mm == "INBOX") + if (mm == "INBOX") { return "."; - else if (mm.length() <= 6) { + } else if (mm.length() <= 6) { setLastError("With a Maildir++ depot, you must create all" " mailboxes under INBOX."); return ""; @@ -584,37 +527,34 @@ string MaildirPPDepot::mailboxToFilename(const string &m) const return ""; } else { string tmp = mm.substr(6); - for (string::iterator i = tmp.begin(); i != tmp.end(); ++i) - if (*i == delimiter) *i = '.'; + for (auto &i : tmp) + if (i == delimiter) i = '.'; return "." + tmp; } } -//-------------------------------------------------------------------- string MaildirPPDepot::filenameToMailbox(const string &m) const { - if (m == ".") + if (m == ".") { return "INBOX"; - else if (delimiter != '.' && m.find(delimiter) != string::npos) + } else if (delimiter != '.' && m.find(delimiter) != string::npos) { return ""; - else if (m != "" && m[0] == '.') { + } else if (m != "" && m[0] == '.') { string tmp = m; - for (string::iterator i = tmp.begin(); i != tmp.end(); ++i) - if (*i == '.') *i = delimiter; + for (auto &i : tmp) + if (i == '.') i = delimiter; return "INBOX" + tmp; - } else + } else { return ""; + } } -//-------------------------------------------------------------------- IMAPdirDepot::IMAPdirDepot(void) : Depot("IMAPdir") {} -//-------------------------------------------------------------------- IMAPdirDepot::~IMAPdirDepot(void) {} -//-------------------------------------------------------------------- string IMAPdirDepot::mailboxToFilename(const string &m) const { string tmp; @@ -630,28 +570,23 @@ string IMAPdirDepot::mailboxToFilename(const string &m) const return ""; } - string::const_iterator i = mm.begin(); - while (i != mm.end()) { - if (*i == delimiter) { + for (auto i = mm.cbegin(); i != mm.cend(); ++i) { + if (*i == delimiter) tmp += '.'; - } else if (*i == '\\') { + else if (*i == '\\') tmp += "\\\\"; - } else if (*i == '.') { - if (i == mm.begin()) + else if (*i == '.') + if (i == mm.cbegin()) tmp += "."; else tmp += "\\."; - } else { + else tmp += *i; - } - - ++i; } return tmp; } -//-------------------------------------------------------------------- string IMAPdirDepot::filenameToMailbox(const string &m) const { string tmp; @@ -660,33 +595,28 @@ string IMAPdirDepot::filenameToMailbox(const string &m) const // hide the magic "." mailbox. if (m == "." || m == "..") return ""; - string::const_iterator i = m.begin(); - while (i != m.end()) { + for (auto i = m.cbegin(); i != m.cend(); ++i) { if (*i == '.') { - if (i != m.begin() && !escape) + if (i != m.cbegin() && !escape) tmp += delimiter; - else if (i == m.begin() || escape) + else if (i == m.cbegin() || escape) tmp += '.'; escape = false; } else if (*i == '\\') { - if (!escape) + if (!escape) { escape = true; - else { + } else { tmp += '\\'; escape = false; } } else if (*i == delimiter) { return ""; + } else if (escape) { + return ""; } else { - if (escape) - return ""; - else { - tmp += *i; - escape = false; - } + tmp += *i; + escape = false; } - - ++i; } return tmp; diff --git a/src/greeting.cc b/src/greeting.cc index 95e93c0..d96ab96 100644 --- a/src/greeting.cc +++ b/src/greeting.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file greeting.cc * @brief Implementation of the inital greeting. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "globals.h" #include "iodevice.h" #include "iofactory.h" @@ -11,7 +12,6 @@ #include <time.h> -using namespace ::std; using namespace Binc; static const unsigned int ISO8601SIZE = 32; @@ -20,12 +20,10 @@ namespace Binc { void showGreeting(void); }; -//------------------------------------------------------------------------ void Binc::showGreeting(void) { Session &session = Session::getInstance(); - - time_t t = time(0); + time_t t = time(nullptr); struct tm *mytm = localtime(&t); char mytime[ISO8601SIZE]; @@ -34,8 +32,8 @@ void Binc::showGreeting(void) if (session.hasEnv("VERBOSE_GREETING")) { bincClient << "* OK Welcome to Binc IMAP " << BINC_VERSION << " " << IMAP_VERSION - << " by Andreas Aardal Hanssen & Erwin Hoffmann at " << mytime << endl; + << " by Andreas Aardal Hanssen & Erwin Hoffmann at " << mytime << std::endl; } else { - bincClient << "* OK Welcome to Binc IMAP at " << mytime << endl; + bincClient << "* OK Welcome to Binc IMAP at " << mytime << std::endl; } } diff --git a/src/imapparser.cc b/src/imapparser.cc index fc2e071..d5e5f55 100644 --- a/src/imapparser.cc +++ b/src/imapparser.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file imapparser.cc * @brief Implementation of the common items for parsing IMAP input * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "imapparser.h" #include "convert.h" @@ -16,218 +17,181 @@ #include <stdio.h> -using namespace ::std; using namespace Binc; +using std::string; -//------------------------------------------------------------------------ -Request::Request(void) : extra(0), flags(), statuses(), bset(), searchkey(), fatt() -{ - uidmode = false; -} +Request::Request(void) : uidmode(false), extra(nullptr), flags(), statuses(), bset(), searchkey(), fatt() +{} Request::~Request(void) { - if (extra != 0) delete extra; + if (extra != nullptr) delete extra; } -//------------------------------------------------------------------------ void Request::setUidMode(void) { uidmode = true; } -//------------------------------------------------------------------------ bool Request::getUidMode(void) const { return uidmode; } -//------------------------------------------------------------------------ void Request::setTag(string &t_in) { tag = t_in; } -//------------------------------------------------------------------------ const string &Request::getTag(void) const { return tag; } -//------------------------------------------------------------------------ void Request::setMode(const string &m_in) { mode = m_in; } -//------------------------------------------------------------------------ const string &Request::getMode(void) const { return mode; } -//------------------------------------------------------------------------ void Request::setName(const string &s_in) { name = s_in; } -//------------------------------------------------------------------------ const string &Request::getName(void) const { return name; } -//------------------------------------------------------------------------ void Request::setAuthType(const string &s_in) { authtype = s_in; } -//------------------------------------------------------------------------ const string &Request::getAuthType(void) const { return authtype; } -//------------------------------------------------------------------------ void Request::setLiteral(const string &s_in) { literal = s_in; } -//------------------------------------------------------------------------ const string &Request::getLiteral(void) const { return literal; } -//------------------------------------------------------------------------ void Request::setDate(const string &s_in) { date = s_in; } -//------------------------------------------------------------------------ const string &Request::getDate(void) const { return date; } -//------------------------------------------------------------------------ void Request::setCharSet(const string &s_in) { charset = s_in; uppercase(charset); } -//------------------------------------------------------------------------ const string &Request::getCharSet(void) const { return charset; } -//------------------------------------------------------------------------ void Request::setUserID(const string &s_in) { userid = s_in; } -//------------------------------------------------------------------------ const string &Request::getUserID(void) const { return userid; } -//------------------------------------------------------------------------ void Request::setPassword(const string &s_in) { password = s_in; } -//------------------------------------------------------------------------ const string &Request::getPassword(void) const { return password; } -//------------------------------------------------------------------------ void Request::setMailbox(const string &s_in) { mailbox = s_in; } -//------------------------------------------------------------------------ const string &Request::getMailbox(void) const { return mailbox; } -//------------------------------------------------------------------------ void Request::setListMailbox(const string &s_in) { listmailbox = s_in; } -//------------------------------------------------------------------------ const string &Request::getListMailbox(void) const { return listmailbox; } -//------------------------------------------------------------------------ void Request::setContextInfo(const string &s_in) { contextInfo = s_in; } -//------------------------------------------------------------------------ const string &Request::getContextInfo(void) const { return contextInfo; } -//------------------------------------------------------------------------ void Request::setNewMailbox(const string &s_in) { newmailbox = s_in; } -//------------------------------------------------------------------------ const string &Request::getNewMailbox(void) const { return newmailbox; } -//------------------------------------------------------------------------ SequenceSet &Request::getSet(void) { return bset; } -//------------------------------------------------------------------------ -vector<string> &Request::getStatuses(void) +std::vector<string> &Request::getStatuses(void) { return statuses; } -//------------------------------------------------------------------------ -vector<string> &Request::getFlags(void) +std::vector<string> &Request::getFlags(void) { return flags; } -//------------------------------------------------------------------------ SequenceSet::SequenceSet(void) : limited(true), nullSet(false) {} -//------------------------------------------------------------------------ SequenceSet::SequenceSet(const SequenceSet ©) : limited(copy.limited) , nullSet(copy.nullSet) , internal(copy.internal) {} -//------------------------------------------------------------------------ SequenceSet &SequenceSet::operator=(const SequenceSet ©) { limited = copy.limited; @@ -237,10 +201,8 @@ SequenceSet &SequenceSet::operator=(const SequenceSet ©) return *this; } -//------------------------------------------------------------------------ SequenceSet::~SequenceSet(void) {} -//------------------------------------------------------------------------ SequenceSet &SequenceSet::null(void) { static SequenceSet nil; @@ -248,13 +210,11 @@ SequenceSet &SequenceSet::null(void) return nil; } -//------------------------------------------------------------------------ bool SequenceSet::isNull(void) const { return nullSet; } -//------------------------------------------------------------------------ SequenceSet &SequenceSet::all(void) { static bool initialized = false; @@ -268,7 +228,6 @@ SequenceSet &SequenceSet::all(void) return all; } -//------------------------------------------------------------------------ SequenceSet::Range::Range(unsigned int a, unsigned int b) { if (a > b) { @@ -280,40 +239,33 @@ SequenceSet::Range::Range(unsigned int a, unsigned int b) } } -//------------------------------------------------------------------------ void SequenceSet::addRange(unsigned int a, unsigned int b) { if (a == (unsigned int)-1 || b == (unsigned int)-1) limited = false; internal.push_back(Range(a, b)); } -//------------------------------------------------------------------------ void SequenceSet::addNumber(unsigned int a) { if (a == (unsigned int)-1) limited = false; internal.push_back(Range(a, a)); } -//------------------------------------------------------------------------ bool SequenceSet::isInSet(unsigned int n) const { unsigned int maxvalue = 0; - for (vector<Range>::const_iterator i = internal.begin(); i != internal.end(); ++i) { - const Range &r = *i; + for (const auto &r : internal) { if (r.from > maxvalue) maxvalue = r.from; else if (r.to > maxvalue) maxvalue = r.to; - if (n >= (*i).from && n <= (*i).to) { - return true; - } + if (n >= r.from && n <= r.to) return true; } return (n > maxvalue && !limited); } -//------------------------------------------------------------------------ BincImapParserFetchAtt::BincImapParserFetchAtt(const std::string &typeName) : type(typeName) { offsetstart = 0; @@ -321,7 +273,6 @@ BincImapParserFetchAtt::BincImapParserFetchAtt(const std::string &typeName) : ty hassection = false; } -//------------------------------------------------------------------------ string BincImapParserFetchAtt::toString(void) { string tmp; @@ -340,8 +291,8 @@ string BincImapParserFetchAtt::toString(void) if (headerlist.size() > 0) { tmp += " ("; - for (vector<string>::iterator i = headerlist.begin(); i != headerlist.end(); ++i) { - if (i != headerlist.begin()) tmp += " "; + for (auto i = headerlist.cbegin(); i != headerlist.cend(); ++i) { + if (i != headerlist.cbegin()) tmp += " "; tmp += Binc::toImapString(*i); } tmp += ")"; @@ -359,14 +310,12 @@ string BincImapParserFetchAtt::toString(void) return tmp; } -//------------------------------------------------------------------------ BincImapParserSearchKey::BincImapParserSearchKey(void) { type = 0; number = 0; } -//------------------------------------------------------------------------ const SequenceSet &BincImapParserSearchKey::getSet(void) const { return bset; diff --git a/src/imapserver.cc b/src/imapserver.cc index 4ec646d..b19bc90 100644 --- a/src/imapserver.cc +++ b/src/imapserver.cc @@ -1,10 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file imapserver.cc * @brief Implementation of the IMAPServer class. * @author Andreas Aardal Hanssen * @date 2005 - * -------------------------------------------------------------------- */ + #include "imapserver.h" #include "broker.h" @@ -14,8 +14,10 @@ #include "iofactory.h" #include "session.h" -using namespace ::Binc; -using namespace ::std; +#include <cstdint> + +using namespace Binc; +using std::endl; namespace Binc { void showGreeting(void); @@ -62,7 +64,7 @@ int IMAPServer::run(void) { Session &session = Session::getInstance(); bincLog.setOutputLevelLimit(IODevice::InfoLevel); - string pid = to_string(session.getPid()); + std::string pid = std::to_string(session.getPid()); bincDebug << "IMAPServer::run(), started server" << endl; @@ -106,7 +108,7 @@ int IMAPServer::run(void) Operator *o = broker->get(clientRequest.getName()); if (!o) { serverStatus = RequestRejected; - string err = "The command \""; + std::string err = "The command \""; if (clientRequest.getUidMode()) err += "UID "; err += clientRequest.getName(); err += "\" is unsupported in this state. "; @@ -166,9 +168,9 @@ int IMAPServer::run(void) if (skipToNextRequest) { if (!bincClient.skipTo('\n')) { - if (bincClient.getLastError() == IODevice::Timeout) { + if (bincClient.getLastError() == IODevice::Timeout) serverStatus = Timeout; - } else + else serverStatus = ClientDisconnected; break; } @@ -177,7 +179,7 @@ int IMAPServer::run(void) // Session finished - write some log information - string userID = this->stubMode ? session.getIP() : session.getEnv("USER"); + std::string userID = this->stubMode ? session.getIP() : session.getEnv("USER"); if (this->stubMode) { bincLog << "bincimap-up: pid " << pid << " (Read: " << session.getReadBytes() diff --git a/src/include/address.h b/src/include/address.h index a8aded9..6d0a6cd 100644 --- a/src/include/address.h +++ b/src/include/address.h @@ -1,26 +1,24 @@ -/** -------------------------------------------------------------------- +/** * @file address.h * @brief Declaration of the Address class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef address_h_included #define address_h_included + #include <string> namespace Binc { - //------------------------------------------------------------------------ - class Address { - public: + struct Address { std::string name; std::string local; std::string host; - //-- std::string toParenList(void) const; - //-- Address(const std::string &name, const std::string &addr); Address(const std::string &wholeaddr); }; diff --git a/src/include/argparser.h b/src/include/argparser.h index ba7838d..0e9b060 100644 --- a/src/include/argparser.h +++ b/src/include/argparser.h @@ -1,30 +1,31 @@ -/** -------------------------------------------------------------------- +/** * @file argparser.h * @brief Declaration of the argument parser class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef ARGPARSER_H_INCLUDED #define ARGPARSER_H_INCLUDED + #include <map> #include <string> #include <vector> namespace Binc { - class ArgOpts { - public: + + struct ArgOpts { std::string c; bool b; bool o; std::string desc; - inline ArgOpts(const std::string &chr, bool boolean, bool optional, const std::string &descr) - { - c = chr; - b = boolean; - o = optional; - desc = descr; - } + ArgOpts(const std::string &chr, bool boolean, bool optional, const std::string &descr) + : c(chr) + , b(boolean) + , o(optional) + , desc(descr) + {} }; class CommandLineArgs { @@ -46,7 +47,7 @@ namespace Binc { void setTail(const std::string &str); - const std::vector<std::string> &getUnqualifiedArgs() const; + const std::vector<std::string> &getUnqualifiedArgs(void) const; private: void registerArg(const std::string &arg, const std::string &desc, bool boolean, bool optional); diff --git a/src/include/authenticate.h b/src/include/authenticate.h index a3d63ce..b3f68e9 100644 --- a/src/include/authenticate.h +++ b/src/include/authenticate.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file authenticate.h * @brief Declaration of the common authentication mechanism. * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #ifndef authenticate_h_included #define authenticate_h_included #include "depot.h" diff --git a/src/include/base64.h b/src/include/base64.h index 25b0ff4..da219d2 100644 --- a/src/include/base64.h +++ b/src/include/base64.h @@ -1,18 +1,18 @@ -/** -------------------------------------------------------------------- +/** * @file base64.h * @brief Declaration of base64 Utilities * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef base64_h_included #define base64_h_included + #include <string> namespace Binc { - std::string base64decode(const std::string &s_in); std::string base64encode(const std::string &s_in); - } #endif diff --git a/src/include/broker.h b/src/include/broker.h index ac78041..eb28bd4 100644 --- a/src/include/broker.h +++ b/src/include/broker.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file broker.h * @brief Declaration of the Broker class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef broker_h_included #define broker_h_included + #include "depot.h" #include "operators.h" @@ -17,12 +19,10 @@ namespace Binc { class Request; class Broker; - //------------------------------------------------------------------ class BrokerFactory { private: std::map<int, Broker *> brokers; - //-- BrokerFactory(void); mutable std::string lastError; @@ -36,24 +36,20 @@ namespace Binc { inline const std::string &getLastError(void) const; inline void setLastError(const std::string &error) const; - //-- static BrokerFactory &getInstance(void); ~BrokerFactory(void); }; - //------------------------------------------------------------------ inline const std::string &BrokerFactory::getLastError(void) const { return lastError; } - //------------------------------------------------------------------ inline void BrokerFactory::setLastError(const std::string &error) const { lastError = error; } - //------------------------------------------------------------------ class Broker { private: std::map<std::string, Operator *> operators; @@ -64,11 +60,10 @@ namespace Binc { void assign(const std::string &fname, Operator *o, bool deletable = false); Operator::ParseResult parseStub(Request &cmd); - //-- inline Broker(Broker &); inline Broker(const Broker &); Broker(void); - ~Broker(void); + ~Broker(); }; inline Broker::Broker(Broker &) {} diff --git a/src/include/convert.h b/src/include/convert.h index 9e51027..2342a70 100644 --- a/src/include/convert.h +++ b/src/include/convert.h @@ -1,12 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file convert.h * @brief Declaration of miscellaneous convertion functions. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ #ifndef convert_h_included #define convert_h_included + #include "address.h" #include "depot.h" @@ -22,7 +23,6 @@ namespace Binc { - //---------------------------------------------------------------------- inline std::string toString(int i_in) { char intbuf[16]; @@ -30,7 +30,6 @@ namespace Binc { return std::string(intbuf); } - //---------------------------------------------------------------------- inline std::string toString(unsigned int i_in) { char intbuf[16]; @@ -38,7 +37,6 @@ namespace Binc { return std::string(intbuf); } - //---------------------------------------------------------------------- inline std::string toString(unsigned long i_in) { char longbuf[40]; @@ -46,25 +44,22 @@ namespace Binc { return std::string(longbuf); } - //---------------------------------------------------------------------- inline std::string toString(const char *i_in) { return std::string(i_in); } - //---------------------------------------------------------------------- inline int atoi(const std::string &s_in) { return ::atoi(s_in.c_str()); } - //---------------------------------------------------------------------- inline std::string toHex(const std::string &s) { const char hexchars[] = "0123456789abcdef"; std::string tmp; - for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) { - unsigned char c = (unsigned char)*i; + for (auto i : s) { + unsigned char c = static_cast<unsigned char>(i); tmp += hexchars[((c & 0xf0) >> 4)]; tmp += hexchars[c & 0x0f]; } @@ -72,22 +67,21 @@ namespace Binc { return tmp; } - //---------------------------------------------------------------------- inline std::string fromHex(const std::string &s) { // const char hexchars[] = "0123456789abcdef"; std::string tmp; - for (std::string::const_iterator i = s.begin(); i != s.end() && i + 1 != s.end(); i += 2) { + for (auto i = s.cbegin(); i != s.cend() && i + 1 != s.cend(); i += 2) { int n; unsigned char c = *i; unsigned char d = *(i + 1); char *t; - if ((t = strchr(hexchars, c)) == 0) return "out of range"; + if ((t = strchr(hexchars, c)) == nullptr) return "out of range"; n = (t - hexchars) << 4; - if ((t = strchr(hexchars, d)) == 0) return "out of range"; + if ((t = strchr(hexchars, d)) == nullptr) return "out of range"; n += (t - hexchars); if (n >= 0 && n <= 255) @@ -99,11 +93,10 @@ namespace Binc { return tmp; } - //---------------------------------------------------------------------- inline std::string toImapString(const std::string &s_in) { - for (std::string::const_iterator i = s_in.begin(); i != s_in.end(); ++i) { - unsigned char c = (unsigned char)*i; + for (const auto i : s_in) { + auto c = static_cast<unsigned char>(i); if (c <= 31 || c >= 127 || c == '\"' || c == '\\') return "{" + toString(s_in.length()) + "}\r\n" + s_in; } @@ -111,21 +104,18 @@ namespace Binc { return "\"" + s_in + "\""; } - //---------------------------------------------------------------------- inline void uppercase(std::string &input) { - for (std::string::iterator i = input.begin(); i != input.end(); ++i) - *i = toupper(*i); + for (auto &i : input) + i = toupper(i); } - //---------------------------------------------------------------------- inline void lowercase(std::string &input) { - for (std::string::iterator i = input.begin(); i != input.end(); ++i) - *i = tolower(*i); + for (char &i : input) + i = tolower(i); } - //---------------------------------------------------------------------- inline void chomp(std::string &s_in, const std::string &chars = " \t\r\n") { int n = s_in.length(); @@ -133,7 +123,6 @@ namespace Binc { s_in.resize(n-- - 1); } - //---------------------------------------------------------------------- inline void trim(std::string &s_in, const std::string &chars = " \t\r\n") { while (s_in != "" && chars.find(s_in[0]) != std::string::npos) @@ -141,14 +130,15 @@ namespace Binc { chomp(s_in, chars); } - //---------------------------------------------------------------------- inline const std::string unfold(const std::string &a, bool removecomment = true) { std::string tmp; + bool incomment = false; bool inquotes = false; - for (std::string::const_iterator i = a.begin(); i != a.end(); ++i) { - unsigned char c = (unsigned char)*i; + + for (const char i : a) { + unsigned char c = (unsigned char)i; if (!inquotes && removecomment) { if (c == '(') { incomment = true; @@ -156,14 +146,14 @@ namespace Binc { } else if (c == ')') { incomment = false; } else if (c != 0x0a && c != 0x0d) { - tmp += *i; + tmp += i; } } else if (c != 0x0a && c != 0x0d) { - tmp += *i; + tmp += i; } if (!incomment) { - if (*i == '\"') inquotes = !inquotes; + if (i == '\"') inquotes = !inquotes; } } @@ -171,46 +161,45 @@ namespace Binc { return tmp; } - //---------------------------------------------------------------------- inline void split(const std::string &s_in, const std::string &delim, std::vector<std::string> &dest, bool skipempty = true) { std::string token; - for (std::string::const_iterator i = s_in.begin(); i != s_in.end(); ++i) { - if (delim.find(*i) != std::string::npos) { + for (const char i : s_in) { + if (delim.find(i) != std::string::npos) { if (!skipempty || token != "") dest.push_back(token); token = ""; - } else - token += *i; + } else { + token += i; + } } if (token != "") dest.push_back(token); } - //---------------------------------------------------------------------- inline void splitAddr(const std::string &s_in, std::vector<std::string> &dest, bool skipempty = true) { static const std::string delim = ","; std::string token; bool inquote = false; - for (std::string::const_iterator i = s_in.begin(); i != s_in.end(); ++i) { - if (inquote && *i == '\"') + for (const char i : s_in) { + if (inquote && i == '\"') inquote = false; - else if (!inquote && *i == '\"') + else if (!inquote && i == '\"') inquote = true; - if (!inquote && delim.find(*i) != std::string::npos) { + if (!inquote && delim.find(i) != std::string::npos) { if (!skipempty || token != "") dest.push_back(token); token = ""; - } else - token += *i; + } else { + token += i; + } } if (token != "") dest.push_back(token); } - //---------------------------------------------------------------------- inline std::string toCanonMailbox(const std::string &s_in) { if (s_in.find("..") != std::string::npos) return ""; @@ -224,27 +213,27 @@ namespace Binc { return s_in; } - //------------------------------------------------------------------------ inline std::string toRegex(const std::string &s_in, char delimiter) { std::string regex = "^"; - for (std::string::const_iterator i = s_in.begin(); i != s_in.end(); ++i) { - if (*i == '.' || *i == '[' || *i == ']' || *i == '{' || *i == '}' || *i == '(' || *i == ')' - || *i == '^' || *i == '$' || *i == '?' || *i == '+' || *i == '\\') + for (const char i : s_in) { + if (i == '.' || i == '[' || i == ']' || i == '{' || i == '}' || i == '(' || i == ')' || i == '^' + || i == '$' || i == '?' || i == '+' || i == '\\') { regex += "\\"; - regex += *i; - } else if (*i == '*') + regex += i; + } else if (i == '*') { regex += ".*?"; - else if (*i == '%') { + } else if (i == '%') { regex += "(\\"; regex += delimiter; regex += "){0,1}"; regex += "[^\\"; regex += delimiter; regex += "]*?"; - } else - regex += *i; + } else { + regex += i; + } } if (regex[regex.length() - 1] == '?') @@ -255,13 +244,11 @@ namespace Binc { return regex; } - //------------------------------------------------------------------------ class BincStream { private: std::string nstr; public: - //-- BincStream &operator<<(std::ostream &(*)(std::ostream &)); BincStream &operator<<(const std::string &t); BincStream &operator<<(unsigned long t); @@ -269,24 +256,18 @@ namespace Binc { BincStream &operator<<(int t); BincStream &operator<<(char t); - //-- std::string popString(unsigned int size); - //-- char popChar(void); void unpopChar(char c); void unpopStr(const std::string &s); - //-- const std::string &str(void) const; - //-- unsigned int getSize(void) const; - //-- void clear(void); - //-- BincStream(void); ~BincStream(void); }; diff --git a/src/include/depot.h b/src/include/depot.h index bd4f743..3e65c8e 100644 --- a/src/include/depot.h +++ b/src/include/depot.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @filec depot.h * @file Declaration of the Depot class (the mail storage) * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef depot_h_included #define depot_h_included + #include <map> #include <string> #include <vector> @@ -18,7 +20,6 @@ namespace Binc { class Depot; class Status; - //------------------------------------------------------------------ class DepotFactory { private: std::vector<Depot *> depots; @@ -32,26 +33,24 @@ namespace Binc { ~DepotFactory(void); }; - //------------------------------------------------------------------ class Depot { public: - //-- class iterator { public: - std::string operator*(void) const; - void operator++(void); - bool operator!=(iterator) const; - bool operator==(iterator) const; - iterator(void); iterator(const iterator ©); iterator(DIR *, struct dirent *); ~iterator(void); - void deref(void); - iterator &operator=(const iterator ©); + std::string operator*(void) const; + void operator++(void); + bool operator!=(iterator) const; + bool operator==(iterator) const; + + void deref(void); + friend class Depot; private: @@ -77,11 +76,15 @@ namespace Binc { mutable std::map<std::string, Status> mailboxstatuses; public: + Depot(); + Depot(const std::string &name); + virtual ~Depot(void) = default; + virtual iterator begin(const std::string &) const; virtual const iterator &end(void) const; void setDelimiter(char); - const char getDelimiter(void) const; + char getDelimiter(void) const; virtual void assign(Mailbox *); @@ -116,14 +119,8 @@ namespace Binc { virtual bool unsubscribeTo(const std::string mailbox); virtual void loadSubscribes(void); virtual bool saveSubscribes(void) const; - - //-- - Depot(void); - Depot(const std::string &name); - virtual ~Depot(void); }; - //------------------------------------------------------------------ class MaildirPPDepot : public Depot { public: std::string mailboxToFilename(const std::string &m) const; @@ -131,7 +128,6 @@ namespace Binc { const std::string &getPersonalNamespace(void) const; - //-- MaildirPPDepot(); ~MaildirPPDepot(); @@ -139,13 +135,11 @@ namespace Binc { std::string privateNamespace; }; - //------------------------------------------------------------------ class IMAPdirDepot : public Depot { public: std::string mailboxToFilename(const std::string &m) const; std::string filenameToMailbox(const std::string &m) const; - //-- IMAPdirDepot(); ~IMAPdirDepot(); }; diff --git a/src/include/globals.h b/src/include/globals.h index d86ae4d..8d939b6 100644 --- a/src/include/globals.h +++ b/src/include/globals.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file globals.h * @brief Global constants. * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #ifndef GLOBAL_H_INCLUDED #define GLOBAL_H_INCLUDED @@ -20,6 +21,6 @@ namespace Binc { static const int TRANSFER_TIMEOUT = 20 * 60; static const int TRANSFER_BUFFER_SIZE = 1024; static const int INPUT_BUFFER_LIMIT = 8192; - }; + #endif diff --git a/src/include/imapparser.h b/src/include/imapparser.h index 5dfffb4..737d7c7 100644 --- a/src/include/imapparser.h +++ b/src/include/imapparser.h @@ -1,19 +1,18 @@ -/** -------------------------------------------------------------------- +/** * @file imapparser.h * @brief Declaration of the common items for parsing IMAP input * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef imapparser_h_included #define imapparser_h_included -/* stl includes */ #include <map> #include <string> #include <vector> namespace Binc { - //------------------------------------------------------------------------ class SequenceSet { public: void addRange(unsigned int a_in, unsigned int b_in); @@ -52,7 +51,6 @@ namespace Binc { std::vector<Range> internal; }; - //------------------------------------------------------------------------ class BincImapParserFetchAtt { public: std::string type; @@ -68,7 +66,6 @@ namespace Binc { std::string toString(void); }; - //------------------------------------------------------------------------ class BincImapParserSearchKey { public: std::string name; @@ -88,13 +85,11 @@ namespace Binc { BincImapParserSearchKey(void); }; - //------------------------------------------------------------------------ class BincImapParserData { public: virtual ~BincImapParserData(void) {} }; - //------------------------------------------------------------------------ class Request { private: std::string tag; diff --git a/src/include/imapserver.h b/src/include/imapserver.h index d3268ba..2afaadd 100644 --- a/src/include/imapserver.h +++ b/src/include/imapserver.h @@ -1,9 +1,9 @@ -/** -------------------------------------------------------------------- +/** * @file imapserver.h * @brief Declaration of the IMAPServer class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ namespace Binc { diff --git a/src/include/iodevice.h b/src/include/iodevice.h index 73dd2ab..1612d3a 100644 --- a/src/include/iodevice.h +++ b/src/include/iodevice.h @@ -1,14 +1,15 @@ -/** -------------------------------------------------------------------- +/** * @file iodevice.h * @brief Declaration of the IODevice class. * @author Andreas Aardal Hanssen * @date 2002, 2003 - * ----------------------------------------------------------------- **/ + */ + #ifndef iodevice_h_included #define iodevice_h_included #include "convert.h" // BincStream -// #include <iostream> + #include <string> #include <unistd.h> // ::write @@ -143,7 +144,7 @@ namespace Binc { For instance, if the output level is set to 0, then "Hello" is written, and the output level is set to 1, followed by writing - "Daisy", the output level limit value will decive wether only + "Daisy", the output level limit value will decide whether only "Hello" is written, or if also "Daisy" is written. A low value of the level gives higher priority, and a high level @@ -233,7 +234,7 @@ namespace Binc { \param dest The incoming byte is stored in this char. */ - bool readChar(char *dest = 0); + bool readChar(char *dest = nullptr); /*! FIXME: add docs @@ -347,7 +348,6 @@ namespace Binc { int dumpfd; }; - //---------------------------------------------------------------------- template<class T> IODevice &IODevice::operator<<(const T &source) { if ((flags & IsEnabled) && outputLevel <= outputLevelLimit) { @@ -359,8 +359,9 @@ namespace Binc { ::write(dumpfd, ss.str().c_str(), ss.getSize()); } - if (flags & HasInputLimit) + if (flags & HasInputLimit) { if (outputBuffer.getSize() > maxOutputBufferSize) flush(); + } } return *this; diff --git a/src/include/iofactory.h b/src/include/iofactory.h index 1a50e4e..70bd8f4 100644 --- a/src/include/iofactory.h +++ b/src/include/iofactory.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file iofactory.h * @brief Declaration of the IOFactory class. * @author Andreas Aardal Hanssen * @date 2002, 2003 - * ----------------------------------------------------------------- **/ + */ + #ifndef IOFACTORY_H_INCLUDED #define IOFACTORY_H_INCLUDED + #include "iodevice.h" #include <map> diff --git a/src/include/mailbox.h b/src/include/mailbox.h index 870a695..d8c9592 100644 --- a/src/include/mailbox.h +++ b/src/include/mailbox.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mailbox.h * @brief Declaration of the Mailbox class (Mailbox is logical container) * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef mailbox_h_included #define mailbox_h_included @@ -27,10 +28,8 @@ namespace Binc { class PendingUpdates; class File; - //------------------------------------------------------------------------ class Mailbox { public: - //---------------------------------------------------------------------- class BaseIterator { public: BaseIterator(int sqn = 0); @@ -46,7 +45,6 @@ namespace Binc { unsigned int sqnr; }; - //---------------------------------------------------------------------- class iterator { public: iterator(BaseIterator &i); @@ -117,6 +115,8 @@ namespace Binc { Mailbox(void); virtual ~Mailbox(void); + Mailbox &operator=(const Mailbox &m) = delete; + friend class Mailbox::iterator; protected: diff --git a/src/include/maildir.h b/src/include/maildir.h index dda88df..4a4c106 100644 --- a/src/include/maildir.h +++ b/src/include/maildir.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file maildir.h * @brief Declaration of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef maildir_h_included #define maildir_h_included + #include "mailbox.h" #include "maildirmessage.h" @@ -17,7 +19,6 @@ namespace Binc { static const std::string CACHEFILEVERSION = "1.0.5"; static const std::string UIDVALFILEVERSION = "1.0.5"; - //---------------------------------------------------------------------- class Lock { public: Lock(const std::string &path); @@ -27,14 +28,12 @@ namespace Binc { std::string lock; }; - //------------------------------------------------------------------------ class MaildirIndexItem { public: unsigned int uid; std::string fileName; }; - //------------------------------------------------------------------------ class MaildirIndex { private: std::map<std::string, MaildirIndexItem> idx; @@ -49,7 +48,6 @@ namespace Binc { MaildirIndexItem *find(const std::string &unique); }; - //------------------------------------------------------------------------ class Maildir : public Mailbox { public: typedef std::map<unsigned int, MaildirMessage> MessageMap; @@ -131,7 +129,6 @@ namespace Binc { bool fastCopy(Message &source, Mailbox &desttype, const std::string &destname); - //-- Maildir(void); ~Maildir(void); diff --git a/src/include/maildirmessage.h b/src/include/maildirmessage.h index 6bc2a20..96dcf73 100644 --- a/src/include/maildirmessage.h +++ b/src/include/maildirmessage.h @@ -1,15 +1,18 @@ -/** -------------------------------------------------------------------- +/** * @file maildirmessage.h * @brief Declaration of the MaildirMessage class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef maildirmessage_h_included #define maildirmessage_h_included + #include "address.h" #include "message.h" #include "mime.h" +#include <deque> #include <exception> #include <iostream> #include <map> @@ -278,7 +281,6 @@ namespace Binc { std::vector<std::string> *customFlags; }; - //------------------------------------------------------------------------ class MaildirMessageCache { public: ~MaildirMessageCache(); diff --git a/src/include/message.h b/src/include/message.h index e1bbf2b..130902e 100644 --- a/src/include/message.h +++ b/src/include/message.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file message.h * @brief Declaration of the Message class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef message_h_included #define message_h_included + #include <string> #include <vector> @@ -18,33 +20,30 @@ namespace Binc { /*! - \class Message - \brief The Message class provides an interface for - IMAP messages. - - Mailbox independent operations and properties are available - through this interface. - - This class is an abstract, and has no implementation. - - \sa MaildirMessage - */ + * \class Message + * \brief The Message class provides an interface for + * IMAP messages. + * + * Mailbox independent operations and properties are available + * through this interface. + * + * This class is an abstract, and has no implementation. + * + * \sa MaildirMessage + */ class Message { public: - /*! - Standard IMAP message flags. - - */ + //! Standard IMAP message flags. enum Flags { - F_NONE = 0x00, /*!< No flag is set */ - F_SEEN = 0x01, /*!< The message has been seen */ - F_ANSWERED = 0x02, /*!< The message has been answered */ - F_DELETED = 0x04, /*!< The message is marked as deleted */ - F_DRAFT = 0x08, /*!< The message is a draft */ - F_RECENT = 0x10, /*!< The message arrived recently */ - F_FLAGGED = 0x20, /*!< The message is flagged / important */ - F_EXPUNGED = 0x40, /*!< The message has been expunged */ - F_PASSED = 0x80 /*!< The message has been bounced */ + F_NONE = 0x00, //!< No flag is set + F_SEEN = 0x01, //!< The message has been seen + F_ANSWERED = 0x02, //!< The message has been answered + F_DELETED = 0x04, //!< The message is marked as deleted + F_DRAFT = 0x08, //!< The message is a draft + F_RECENT = 0x10, //!< The message arrived recently + F_FLAGGED = 0x20, //!< The message is flagged / important + F_EXPUNGED = 0x40, //!< The message has been expunged + F_PASSED = 0x80 //!< The message has been bounced }; virtual void setUID(unsigned int) = 0; @@ -68,7 +67,7 @@ namespace Binc { virtual void setInternalDate(time_t) = 0; virtual time_t getInternalDate(void) const = 0; - // virtual void rewind(void) = 0; + // virtual void rewind(void) = 0; virtual int readChunk(std::string &) = 0; virtual bool appendChunk(const std::string &) = 0; virtual void close(void) = 0; diff --git a/src/include/mime-inputsource.h b/src/include/mime-inputsource.h index 8ff97f4..011c4c3 100644 --- a/src/include/mime-inputsource.h +++ b/src/include/mime-inputsource.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-inputsource.h * @brief The base class of the MIME input source * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef mime_inputsource_h_included #define mime_inputsource_h_included diff --git a/src/include/mime-utils.h b/src/include/mime-utils.h index 8a59041..a8f62c7 100644 --- a/src/include/mime-utils.h +++ b/src/include/mime-utils.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef mime_utils_h_included #define mime_utils_h_included @@ -12,8 +13,6 @@ #include <stdio.h> #include <string.h> -using namespace ::std; - inline bool compareStringToQueue(const char *s_in, char *bqueue, int pos, int size) { for (int i = 0; i < size; ++i) diff --git a/src/include/mime.h b/src/include/mime.h index f35ebb2..a8050af 100644 --- a/src/include/mime.h +++ b/src/include/mime.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file mime.h * @brief Declaration of main mime parser components * @author Andreas Aardal Hanssen * @date Andreas Aardal Hanssen - * ----------------------------------------------------------------- **/ + */ + #ifndef mime_h_included #define mime_h_included + #include <map> #include <string> #include <vector> @@ -13,7 +15,6 @@ #include <stdio.h> namespace Binc { - //---------------------------------------------------------------------- class HeaderItem { private: mutable std::string key; @@ -30,12 +31,10 @@ namespace Binc { return value; } - //-- HeaderItem(void); HeaderItem(const std::string &key, const std::string &value); }; - //---------------------------------------------------------------------- class Header { private: mutable std::vector<HeaderItem> content; @@ -46,12 +45,10 @@ namespace Binc { void add(const std::string &name, const std::string &content); void clear(void) const; - //-- Header(void); ~Header(void); }; - //---------------------------------------------------------------------- class IODevice; class MimeDocument; @@ -140,7 +137,6 @@ namespace Binc { virtual ~MimePart(void); }; - //---------------------------------------------------------------------- class MimeDocument : public MimePart { private: mutable bool headerIsParsed; @@ -161,7 +157,6 @@ namespace Binc { return allIsParsed; } - //-- MimeDocument(void); ~MimeDocument(void); }; diff --git a/src/include/multilogdevice.h b/src/include/multilogdevice.h index a6f29f2..3ae4655 100644 --- a/src/include/multilogdevice.h +++ b/src/include/multilogdevice.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file multilogdevice.h * @brief Declaration of the MultilogDevice class. * @author Andreas Aardal Hanssen * @date Andreas Aardal Hanssen - * ----------------------------------------------------------------- **/ + */ + #ifndef multilogdevice_h_included #define multilogdevice_h_included diff --git a/src/include/operators.h b/src/include/operators.h index a4e0f74..66c7e2b 100644 --- a/src/include/operators.h +++ b/src/include/operators.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file operators.h * @brief Declaration of all operators. * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #ifndef operators_h_included #define operators_h_included + #include "depot.h" #include "imapparser.h" #include "message.h" @@ -15,7 +17,6 @@ namespace Binc { - //-------------------------------------------------------------------- class Operator { public: enum ProcessResult { OK, BAD, NO, NOTHING, ABORT }; @@ -27,11 +28,9 @@ namespace Binc { virtual int getState(void) const = 0; virtual const std::string getName(void) const = 0; - //-- virtual ~Operator(void){}; }; - //-------------------------------------------------------------------- class AppendOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -43,7 +42,6 @@ namespace Binc { ~AppendOperator(void); }; - //-------------------------------------------------------------------- class AuthenticateOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -60,7 +58,6 @@ namespace Binc { ~AuthenticateOperator(void); }; - //-------------------------------------------------------------------- class CapabilityOperator : public Operator { std::vector<std::string> capabilities; @@ -77,7 +74,6 @@ namespace Binc { ~CapabilityOperator(void); }; - //-------------------------------------------------------------------- class CheckOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -90,7 +86,6 @@ namespace Binc { ~CheckOperator(void); }; - //-------------------------------------------------------------------- class CreateOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -103,7 +98,6 @@ namespace Binc { ~CreateOperator(void); }; - //-------------------------------------------------------------------- class CloseOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -116,7 +110,6 @@ namespace Binc { ~CloseOperator(void); }; - //-------------------------------------------------------------------- class CopyOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -129,7 +122,6 @@ namespace Binc { ~CopyOperator(void); }; - //-------------------------------------------------------------------- class DeleteOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -142,7 +134,6 @@ namespace Binc { ~DeleteOperator(void); }; - //-------------------------------------------------------------------- class ExpungeOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -155,7 +146,6 @@ namespace Binc { ~ExpungeOperator(void); }; - //-------------------------------------------------------------------- class FetchOperator : public Operator { protected: ParseResult expectSectionText(BincImapParserFetchAtt &f_in) const; @@ -175,7 +165,6 @@ namespace Binc { ~FetchOperator(void); }; - //-------------------------------------------------------------------- class IdOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -188,7 +177,6 @@ namespace Binc { ~IdOperator(void); }; - //-------------------------------------------------------------------- class IdleOperator : public Operator { protected: ParseResult expectSectionText(BincImapParserFetchAtt &f_in) const; @@ -208,7 +196,6 @@ namespace Binc { ~IdleOperator(void); }; - //-------------------------------------------------------------------- class ListOperator : public Operator { protected: enum MailboxFlags { DIR_SELECT = 0x01, DIR_MARKED = 0x02, DIR_NOINFERIORS = 0x04, DIR_LEAF = 0x08 }; @@ -227,7 +214,6 @@ namespace Binc { ~ListOperator(void); }; - //-------------------------------------------------------------------- class LoginOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -240,7 +226,6 @@ namespace Binc { ~LoginOperator(void); }; - //-------------------------------------------------------------------- class LogoutOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -253,7 +238,6 @@ namespace Binc { ~LogoutOperator(void); }; - //-------------------------------------------------------------------- class LsubOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -266,7 +250,6 @@ namespace Binc { ~LsubOperator(void); }; - //-------------------------------------------------------------------- class NamespaceOperator : public Operator { public: virtual ProcessResult process(Depot &, Request &); @@ -279,7 +262,6 @@ namespace Binc { ~NamespaceOperator(void); }; - //-------------------------------------------------------------------- class NoopOperator : public Operator { public: virtual ProcessResult process(Depot &, Request &); @@ -292,7 +274,6 @@ namespace Binc { ~NoopOperator(void); }; - //-------------------------------------------------------------------- class NoopPendingOperator : public NoopOperator { public: ProcessResult process(Depot &, Request &); @@ -301,7 +282,6 @@ namespace Binc { ~NoopPendingOperator(void); }; - //-------------------------------------------------------------------- class RenameOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -314,12 +294,10 @@ namespace Binc { ~RenameOperator(void); }; - //-------------------------------------------------------------------- class SearchOperator : public Operator { protected: ParseResult expectSearchKey(BincImapParserSearchKey &s_in) const; - //------------------------------------------------------------------ class SearchNode { std::string date; std::string astring; @@ -390,7 +368,6 @@ namespace Binc { void init(const BincImapParserSearchKey &a); - //- static bool compareNodes(const SearchNode &a, const SearchNode &b) { return a.getWeight() < b.getWeight(); @@ -411,7 +388,6 @@ namespace Binc { ~SearchOperator(void); }; - //-------------------------------------------------------------------- class SelectOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -424,7 +400,6 @@ namespace Binc { ~SelectOperator(void); }; - //-------------------------------------------------------------------- class ExamineOperator : public SelectOperator { public: const std::string getName(void) const; @@ -432,7 +407,6 @@ namespace Binc { ~ExamineOperator(void); }; - //-------------------------------------------------------------------- class StarttlsOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -446,7 +420,6 @@ namespace Binc { ~StarttlsOperator(void); }; - //-------------------------------------------------------------------- class StatusOperator : public Operator { std::map<int, Status> statuses; @@ -461,7 +434,6 @@ namespace Binc { ~StatusOperator(void); }; - //-------------------------------------------------------------------- class StoreOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -474,7 +446,6 @@ namespace Binc { ~StoreOperator(void); }; - //-------------------------------------------------------------------- class SubscribeOperator : public Operator { public: ProcessResult process(Depot &, Request &); @@ -487,7 +458,6 @@ namespace Binc { ~SubscribeOperator(void); }; - //-------------------------------------------------------------------- class UnsubscribeOperator : public Operator { public: ProcessResult process(Depot &, Request &); diff --git a/src/include/pendingupdates.h b/src/include/pendingupdates.h index c1adda0..eddf8f9 100644 --- a/src/include/pendingupdates.h +++ b/src/include/pendingupdates.h @@ -1,24 +1,24 @@ -/** -------------------------------------------------------------------- +/** * @file pendingupdates.h * @brief <---> * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ -#include <map> -#include <vector> + */ #ifndef pendingupdates_h_included #define pendingupdates_h_included +#include <map> +#include <string> +#include <vector> + namespace Binc { class Mailbox; - //------------------------------------------------------------------------ class PendingUpdates { public: enum { EXPUNGE = 0x01, FLAGS = 0x02, EXISTS = 0x04, RECENT = 0x08 }; - //---------------------------------------------------------------------- class expunged_const_iterator { private: std::vector<unsigned int>::iterator internal; @@ -29,16 +29,13 @@ namespace Binc { bool operator!=(expunged_const_iterator) const; bool operator==(expunged_const_iterator) const; - //-- expunged_const_iterator(void); expunged_const_iterator(std::vector<unsigned int>::iterator i); }; - //-- expunged_const_iterator beginExpunged(void); expunged_const_iterator endExpunged(void); - //---------------------------------------------------------------------- class flagupdates_const_iterator { private: std::map<unsigned int, unsigned int>::iterator internal; @@ -54,18 +51,15 @@ namespace Binc { void operator++(void); bool operator!=(flagupdates_const_iterator) const; - //-- flagupdates_const_iterator(void); flagupdates_const_iterator(std::map<unsigned int, unsigned int>::iterator i, std::map<unsigned int, std::vector<std::string>> *, std::map<unsigned int, unsigned int> *); }; - //-- flagupdates_const_iterator beginFlagUpdates(void); flagupdates_const_iterator endFlagUpdates(void); - //-- void addExpunged(unsigned int uid); void addFlagUpdates(unsigned int sqnr, unsigned int uid, @@ -78,7 +72,6 @@ namespace Binc { bool newExists(void) const; bool newRecent(void) const; - //-- PendingUpdates(void); ~PendingUpdates(void); diff --git a/src/include/recursivedescent.h b/src/include/recursivedescent.h index 96c3a7e..26ad794 100644 --- a/src/include/recursivedescent.h +++ b/src/include/recursivedescent.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file recursivedescent.h * @brief Declaration of a recursive descent IMAP command parser. * @author Andreas Aardal Hanssen * @date Andreas Aardal Hanssen - * ----------------------------------------------------------------- **/ + */ + #ifndef expectcommand_h_inluded #define expectcommand_h_inluded + #include "imapparser.h" #include "operators.h" diff --git a/src/include/regmatch.h b/src/include/regmatch.h index 1471e90..5cc2274 100644 --- a/src/include/regmatch.h +++ b/src/include/regmatch.h @@ -1,16 +1,16 @@ -/** -------------------------------------------------------------------- +/** * @file regex.h * @brief Declaration of miscellaneous regexp functions. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef regex_h_included #define regex_h_included #include <string> namespace Binc { - int regexMatch(const std::string &data_in, const std::string &p_in); } diff --git a/src/include/session.h b/src/include/session.h index ee96613..a329183 100644 --- a/src/include/session.h +++ b/src/include/session.h @@ -1,11 +1,13 @@ -/** -------------------------------------------------------------------- +/** * @file session.h * @brief <---> * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef session_h_included #define session_h_included + #include "argparser.h" #include <map> @@ -18,7 +20,6 @@ namespace Binc { class Depot; - //-------------------------------------------------------------------- class Session { public: std::map<std::string, std::string> attrs; @@ -37,13 +38,13 @@ namespace Binc { CommandLineArgs args; - int timeout() const; + int timeout(void) const; bool hasEnv(const std::string &key) const; std::string getEnv(const std::string &key); void setEnv(const std::string &key, const std::string &value); - const int getState(void) const; + int getState(void) const; void setState(int n); bool parseCommandLine(int argc, char *argv[]); void assignCommandLineArgs(void); @@ -61,7 +62,7 @@ namespace Binc { const std::string &getLastError(void) const; const std::string &getResponseCode(void) const; const std::string &getIP(void) const; - const std::string &getUserID() const; + const std::string &getUserID(void) const; pid_t getPid(void); const std::string &getHostname(void); void setLastError(const std::string &error) const; @@ -72,13 +73,11 @@ namespace Binc { inline Depot *getDepot(void) const; - //-- static Session &getInstance(void); bool initialize(int argc, char *argv[]); private: - //-- int state; std::string userid; std::string ip; diff --git a/src/include/status.h b/src/include/status.h index 9248505..ae944c0 100644 --- a/src/include/status.h +++ b/src/include/status.h @@ -1,28 +1,25 @@ -/** -------------------------------------------------------------------- +/** * @file status.h * @brief Declaration of the Status class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #ifndef status_h_included #define status_h_included namespace Binc { - //------------------------------------------------------------------------ class Status { - //-- int recent; int messages; int unseen; int uidvalidity; int uidnext; - //-- int statusid; public: - //-- inline void setMessages(int i) { messages = i; @@ -53,7 +50,6 @@ namespace Binc { uidnext = i; } - //-- inline int getMessages(void) const { return messages; @@ -84,7 +80,6 @@ namespace Binc { return uidnext; } - //-- Status(void); ~Status(void); }; diff --git a/src/include/stdiodevice.h b/src/include/stdiodevice.h index 7b4f465..9dac4fd 100644 --- a/src/include/stdiodevice.h +++ b/src/include/stdiodevice.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file stdiodevice.h * @brief Declaration of the StdIODevice class. * @author Andreas Aardal Hanssen * @date 2002, 2003 - * ----------------------------------------------------------------- **/ + */ + #ifndef stdiodevice_h_included #define stdiodevice_h_included diff --git a/src/include/syslogdevice.h b/src/include/syslogdevice.h index 68d4112..78389d7 100644 --- a/src/include/syslogdevice.h +++ b/src/include/syslogdevice.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file Syslogdevice.h * @brief Declaration of the SyslogDevice class. * @author Andreas Aardal Hanssen * @date 2002, 2003 - * ----------------------------------------------------------------- **/ + */ + #ifndef syslogdevice_h_included #define syslogdevice_h_included diff --git a/src/include/tools.h b/src/include/tools.h index 67ed91e..70f5cf4 100644 --- a/src/include/tools.h +++ b/src/include/tools.h @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file tools.h * @brief Declaration of miscellaneous tools. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include <string> namespace Binc { @@ -16,7 +17,6 @@ namespace Binc { void setenv(const std::string &key, const std::string &value) const; std::string getenv(const std::string &key) const; - //-- static Tools &getInstance(void); }; diff --git a/src/iodevice.cc b/src/iodevice.cc index c2bc9ee..851bfb1 100644 --- a/src/iodevice.cc +++ b/src/iodevice.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file iodevice.cc * @brief Implementation of the IODevice class. * @author Andreas Aardal Hanssen * @date 2002, 2003 - * ----------------------------------------------------------------- **/ + */ + #include "iodevice.h" #include "convert.h" // BincStream @@ -13,10 +14,9 @@ #include <unistd.h> -using namespace ::std; -using namespace ::Binc; +using namespace Binc; +using std::ostream; -//------------------------------------------------------------------------ IODevice::IODevice(int f) : flags(f | IsEnabled) , maxInputBufferSize(0) @@ -31,15 +31,13 @@ IODevice::IODevice(int f) , dumpfd(0) {} -//------------------------------------------------------------------------ IODevice::~IODevice(void) {} -//------------------------------------------------------------------------ IODevice &IODevice::operator<<(ostream &(*source)(ostream &)) { if (!(flags & IsEnabled) || outputLevel > outputLevelLimit) return *this; - static std::ostream &(*endl_funcptr)(ostream &) = endl; + static ostream &(*endl_funcptr)(ostream &) = std::endl; if (source != endl_funcptr) return *this; @@ -47,21 +45,20 @@ IODevice &IODevice::operator<<(ostream &(*source)(ostream &)) if (dumpfd) ::write(dumpfd, "\r\n", 2); - if (flags & FlushesOnEndl) + if (flags & FlushesOnEndl) { flush(); - else if (flags & HasOutputLimit) + } else if (flags & HasOutputLimit) { if (outputBuffer.getSize() > maxOutputBufferSize) flush(); + } return *this; } -//------------------------------------------------------------------------ bool IODevice::canRead(void) const { return false; } -//------------------------------------------------------------------------ void IODevice::clear() { if (!(flags & IsEnabled)) return; @@ -70,7 +67,6 @@ void IODevice::clear() outputBuffer.clear(); } -//------------------------------------------------------------------------ bool IODevice::flush() { if (!(flags & IsEnabled)) return true; @@ -90,31 +86,26 @@ bool IODevice::flush() return true; } -//------------------------------------------------------------------------ void IODevice::setFlags(unsigned int f) { flags |= f; } -//------------------------------------------------------------------------ void IODevice::clearFlags(unsigned int f) { flags &= ~f; } -//------------------------------------------------------------------------ void IODevice::setMaxInputBufferSize(unsigned int max) { maxInputBufferSize = max; } -//------------------------------------------------------------------------ void IODevice::setMaxOutputBufferSize(unsigned int max) { maxOutputBufferSize = max; } -//------------------------------------------------------------------------ void IODevice::setTimeout(unsigned int t) { timeout = t; @@ -125,52 +116,43 @@ void IODevice::setTimeout(unsigned int t) flags &= ~HasTimeout; } -//------------------------------------------------------------------------ unsigned int IODevice::getTimeout(void) const { return timeout; } -//------------------------------------------------------------------------ void IODevice::setOutputLevel(LogLevel level) { outputLevel = level; } -//------------------------------------------------------------------------ IODevice::LogLevel IODevice::getOutputLevel(void) const { return outputLevel; } -//------------------------------------------------------------------------ void IODevice::setOutputLevelLimit(LogLevel level) { outputLevelLimit = level; } -//------------------------------------------------------------------------ IODevice::LogLevel IODevice::getOutputLevelLimit(void) const { return outputLevelLimit; } -//------------------------------------------------------------------------ -bool IODevice::readStr(string *dest, unsigned int max) +bool IODevice::readStr(std::string *dest, unsigned int max) { // If max is 0, fill the input buffer once only if it's empty. if (!max && inputBuffer.getSize() == 0 && !fillInputBuffer()) return false; // If max is != 0, wait until we have max. - while (max && inputBuffer.getSize() < max) { + while (max && inputBuffer.getSize() < max) if (!fillInputBuffer()) return false; - } unsigned int bytesToRead = max ? max : inputBuffer.getSize(); *dest += inputBuffer.str().substr(0, bytesToRead); - if (dumpfd) { - ::write(dumpfd, inputBuffer.str().substr(0, bytesToRead).c_str(), bytesToRead); - } + if (dumpfd) ::write(dumpfd, inputBuffer.str().substr(0, bytesToRead).c_str(), bytesToRead); inputBuffer.popString(bytesToRead); readCount += bytesToRead; @@ -178,7 +160,6 @@ bool IODevice::readStr(string *dest, unsigned int max) return true; } -//------------------------------------------------------------------------ bool IODevice::readChar(char *dest) { if (inputBuffer.getSize() == 0 && !fillInputBuffer()) return false; @@ -192,19 +173,16 @@ bool IODevice::readChar(char *dest) return true; } -//------------------------------------------------------------------------ void IODevice::unreadChar(char c) { inputBuffer.unpopChar(c); } -//------------------------------------------------------------------------ -void IODevice::unreadStr(const string &s) +void IODevice::unreadStr(const std::string &s) { inputBuffer.unpopStr(s); } -//------------------------------------------------------------------------ bool IODevice::skipTo(char c) { char dest = '\0'; @@ -216,67 +194,57 @@ bool IODevice::skipTo(char c) return true; } -//------------------------------------------------------------------------ -string IODevice::service(void) const +std::string IODevice::service(void) const { return "nul"; } -//------------------------------------------------------------------------ bool IODevice::waitForWrite(void) const { return false; } -//------------------------------------------------------------------------ bool IODevice::waitForRead(void) const { return false; } -//------------------------------------------------------------------------ IODevice::WriteResult IODevice::write(void) { return WriteError; } -//------------------------------------------------------------------------ bool IODevice::fillInputBuffer(void) { return false; } -//------------------------------------------------------------------------ IODevice::Error IODevice::getLastError(void) const { return error; } -//------------------------------------------------------------------------ -string IODevice::getLastErrorString(void) const +std::string IODevice::getLastErrorString(void) const { return errorString; } -//------------------------------------------------------------------------ unsigned int IODevice::getReadCount(void) const { return readCount; } -//------------------------------------------------------------------------ unsigned int IODevice::getWriteCount(void) const { return writeCount; } -//------------------------------------------------------------------------ void IODevice::enableProtocolDumping(void) { BincStream ss; - ss << "/tmp/bincimap-dump-" << (int)time(0) << "-" << Session::getInstance().getIP() << "-XXXXXX"; - char *safename = strdup(ss.str().c_str()); - dumpfd = mkstemp(safename); + ss << "/tmp/bincimap-dump-" << static_cast<int>(time(nullptr)) << "-" << Session::getInstance().getIP() + << "-XXXXXX"; + std::string safename = ss.str(); + dumpfd = mkstemp(safename.data()); if (dumpfd == -1) dumpfd = 0; - delete[] safename; } diff --git a/src/iofactory.cc b/src/iofactory.cc index abe71b4..e58efdb 100644 --- a/src/iofactory.cc +++ b/src/iofactory.cc @@ -1,30 +1,26 @@ -/* -------------------------------------------------------------------- - * @file iofactory.cc - * @brief Implementation of the IOFactory class. - * @author Andreas Aardal Hanssen - * @date 2002, 2003 - * ----------------------------------------------------------------- **/ +/** + * @file iofactory.cc + * @brief Implementation of the IOFactory class. + * @author Andreas Aardal Hanssen + * @date 2002, 2003 + */ + #include "iofactory.h" #include "iodevice.h" -using namespace ::Binc; -using namespace ::std; +using namespace Binc; -//------------------------------------------------------------------------ IOFactory::IOFactory(void) {} -//------------------------------------------------------------------------ IOFactory::~IOFactory(void) {} -//------------------------------------------------------------------------ IOFactory &IOFactory::getInstance(void) { static IOFactory ioFactory; return ioFactory; } -//------------------------------------------------------------------------ void IOFactory::addDevice(IODevice *dev) { IODevice *ioDevice = IOFactory::getInstance().devices[dev->service()]; @@ -36,7 +32,6 @@ void IOFactory::addDevice(IODevice *dev) IOFactory::getInstance().devices[dev->service()] = dev; } -//------------------------------------------------------------------------ IODevice &IOFactory::getClient(void) { static IODevice nulDevice; @@ -48,7 +43,6 @@ IODevice &IOFactory::getClient(void) return nulDevice; } -//------------------------------------------------------------------------ IODevice &IOFactory::getLogger(void) { static IODevice nulDevice; diff --git a/src/mailbox.cc b/src/mailbox.cc index fd83276..23ed2a5 100644 --- a/src/mailbox.cc +++ b/src/mailbox.cc @@ -1,104 +1,87 @@ -/** -------------------------------------------------------------------- +/** * @file mailbox.cc * @brief Implementation of the Mailbox class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "mailbox.h" #include "message.h" #include <string> -using namespace ::std; using namespace Binc; -//------------------------------------------------------------------------ Mailbox::BaseIterator::BaseIterator(int sqn) { sqnr = sqn; } -//------------------------------------------------------------------------ Mailbox::BaseIterator::~BaseIterator(void) {} -//------------------------------------------------------------------------ Mailbox::Mailbox(void) : readOnly(false) {} -//------------------------------------------------------------------------ Mailbox::~Mailbox(void) {} -//------------------------------------------------------------------------ bool Mailbox::isReadOnly(void) const { return readOnly; } -//------------------------------------------------------------------------ void Mailbox::setReadOnly(bool readOnly) { this->readOnly = readOnly; } -//------------------------------------------------------------------------ Mailbox::iterator::iterator(BaseIterator &i) : realIterator(i) {} -//------------------------------------------------------------------------ Message &Mailbox::iterator::operator*(void) { return *realIterator; } -//------------------------------------------------------------------------ void Mailbox::iterator::operator++(void) { ++realIterator; } -//------------------------------------------------------------------------ bool Mailbox::iterator::operator==(const iterator &i) const { return realIterator == i.realIterator; } -//------------------------------------------------------------------------ bool Mailbox::iterator::operator!=(const iterator &i) const { return realIterator != i.realIterator; } -//------------------------------------------------------------------------ void Mailbox::iterator::erase(void) { realIterator.erase(); } -//------------------------------------------------------------------------ unsigned int Mailbox::iterator::getSqnr(void) const { return realIterator.sqnr; } -//------------------------------------------------------------------------ -void Mailbox::setName(const string &name) +void Mailbox::setName(const std::string &name) { this->name = name; } -//------------------------------------------------------------------------ -const string Mailbox::getName(void) const +const std::string Mailbox::getName(void) const { return name; } -//------------------------------------------------------------------------ -const string &Mailbox::getLastError(void) const +const std::string &Mailbox::getLastError(void) const { return lastError; } -//------------------------------------------------------------------------ -void Mailbox::setLastError(const string &error) const +void Mailbox::setLastError(const std::string &error) const { lastError = error; } diff --git a/src/maildir-close.cc b/src/maildir-close.cc index c0e0dbd..81e526f 100644 --- a/src/maildir-close.cc +++ b/src/maildir-close.cc @@ -1,18 +1,17 @@ -/** -------------------------------------------------------------------- - * @file maildir-close.cc - * @brief Implementation of the Maildir class. - * @author Andreas Aardal Hanssen - * @date 2002-2005 - * ----------------------------------------------------------------- **/ +/** + * @file maildir-close.cc + * @brief Implementation of the Maildir class. + * @author Andreas Aardal Hanssen + * @date 2002-2005 + */ + #include "maildir.h" #include <fcntl.h> #include <unistd.h> -using namespace ::std; using namespace Binc; -//------------------------------------------------------------------------ void Binc::Maildir::closeMailbox(void) { if (!selected) return; diff --git a/src/maildir-create.cc b/src/maildir-create.cc index 6e08b61..89d9f40 100644 --- a/src/maildir-create.cc +++ b/src/maildir-create.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- - * @file maildir-create.cc - * @brief Implementation of the Maildir class. - * @author Andreas Aardal Hanssen - * @date 2002-2005 - * ----------------------------------------------------------------- **/ +/** + * @file maildir-create.cc + * @brief Implementation of the Maildir class. + * @author Andreas Aardal Hanssen + * @date 2002-2005 + */ + #include "maildir.h" #include <errno.h> @@ -13,10 +14,9 @@ #include <sys/types.h> #include <unistd.h> -using namespace ::std; using namespace Binc; +using std::string; -//------------------------------------------------------------------------ bool Binc::Maildir::createMailbox(const string &s_in, mode_t mode, uid_t owner, gid_t group, bool root) { if (s_in != "." && mkdir(s_in.c_str(), mode) == -1) { diff --git a/src/maildir-delete.cc b/src/maildir-delete.cc index b0abb2a..356128b 100644 --- a/src/maildir-delete.cc +++ b/src/maildir-delete.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-delete.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "maildir.h" #include <errno.h> @@ -14,18 +15,18 @@ #include <sys/types.h> #include <unistd.h> -using namespace ::std; using namespace Binc; +using std::string; namespace { bool recursiveDelete(const string &path) { DIR *mydir = opendir(path.c_str()); - if (mydir == 0) return false; + if (mydir == nullptr) return false; struct dirent *mydirent; - while ((mydirent = readdir(mydir)) != 0) { + while ((mydirent = readdir(mydir)) != nullptr) { string d = mydirent->d_name; if (d == "." || d == "..") continue; @@ -46,11 +47,9 @@ namespace { closedir(mydir); return false; } - } else { - if (unlink(f.c_str()) != 0 && errno != ENOENT) { - closedir(mydir); - return false; - } + } else if (unlink(f.c_str()) != 0 && errno != ENOENT) { + closedir(mydir); + return false; } } @@ -59,7 +58,6 @@ namespace { } } -//------------------------------------------------------------------------ bool Binc::Maildir::deleteMailbox(const string &s_in) { if (s_in == ".") { diff --git a/src/maildir-expunge.cc b/src/maildir-expunge.cc index 75c8f3d..a63f354 100644 --- a/src/maildir-expunge.cc +++ b/src/maildir-expunge.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-expunge.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "iodevice.h" #include "iofactory.h" #include "maildir.h" @@ -13,35 +14,32 @@ #include <unistd.h> -using namespace ::std; using namespace Binc; -//------------------------------------------------------------------------ void Maildir::expungeMailbox(void) { if (readOnly) return; Mailbox::iterator i = begin(SequenceSet::all(), SQNR_MODE | INCLUDE_EXPUNGED); - bool success = true; - for (; success && i != end(); ++i) { + for (bool success = true; success && i != end(); ++i) { MaildirMessage &message = reinterpret_cast<MaildirMessage &>(*i); if ((message.getStdFlags() & Message::F_DELETED) == 0) continue; message.setExpunged(); - const string &id = message.getUnique(); + const std::string &id = message.getUnique(); // The message might be gone already MaildirIndexItem *item = index.find(id); if (!item) continue; - string fpath = path + "/cur/" + item->fileName; + std::string fpath = path + "/cur/" + item->fileName; while (unlink(fpath.c_str()) != 0) { if (errno != ENOENT) { - bincWarning << "unable to remove " << fpath << ": " << strerror(errno) << endl; + bincWarning << "unable to remove " << fpath << ": " << strerror(errno) << std::endl; break; } diff --git a/src/maildir-readcache.cc b/src/maildir-readcache.cc index dbbf4ef..5864ff6 100644 --- a/src/maildir-readcache.cc +++ b/src/maildir-readcache.cc @@ -1,19 +1,20 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-readcache.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "globals.h" #include "maildir.h" #include <algorithm> -using namespace ::std; using namespace Binc; +using std::string; +using std::vector; -//------------------------------------------------------------------------ Maildir::ReadCacheResult Maildir::readCache(void) { index.clearUids(); @@ -21,7 +22,7 @@ Maildir::ReadCacheResult Maildir::readCache(void) const string cachefilename = path + "/bincimap-cache"; FILE *fp = fopen(cachefilename.c_str(), "r"); if (!fp) { - uidvalidity = time(0); + uidvalidity = time(nullptr); uidnext = 1; messages.clear(); index.clear(); @@ -32,7 +33,7 @@ Maildir::ReadCacheResult Maildir::readCache(void) char inputBuffer[512]; if (!fgets(inputBuffer, sizeof(inputBuffer), fp)) { fclose(fp); - uidvalidity = time(0); + uidvalidity = time(nullptr); uidnext = 1; messages.clear(); index.clear(); @@ -52,7 +53,7 @@ Maildir::ReadCacheResult Maildir::readCache(void) { // bump cache fclose(fp); - uidvalidity = time(0); + uidvalidity = time(nullptr); uidnext = 1; messages.clear(); index.clear(); @@ -73,7 +74,7 @@ Maildir::ReadCacheResult Maildir::readCache(void) if (sscanf(inputBuffer, "%u %u %u %s", &readUID, &readInternalDate, &readSize, readUnique) != 4) { // error in input fclose(fp); - uidvalidity = time(0); + uidvalidity = time(nullptr); uidnext = 1; messages.clear(); index.clear(); @@ -84,7 +85,7 @@ Maildir::ReadCacheResult Maildir::readCache(void) vector<string> customFlags; char *flagStart = inputBuffer; - for (int i = 0; flagStart != 0 && *flagStart != '\0' && i < 4; ++i) { + for (int i = 0; flagStart != nullptr && *flagStart != '\0' && i < 4; ++i) { flagStart = strchr(flagStart, ' '); // skip consecutive white space @@ -112,9 +113,8 @@ Maildir::ReadCacheResult Maildir::readCache(void) m.setUnique(readUnique); m.setInternalDate(readInternalDate); - if (index.find(readUnique) == 0) { - for (vector<string>::const_iterator it = customFlags.begin(); it != customFlags.end(); ++it) { - string tmpFlag = *it; + if (index.find(readUnique) == nullptr) { + for (auto tmpFlag : customFlags) { trim(tmpFlag, " \n"); m.setCustomFlag(tmpFlag); } @@ -134,8 +134,7 @@ Maildir::ReadCacheResult Maildir::readCache(void) sort(customFlags.begin(), customFlags.end()); if (oldCustomFlags != customFlags) { existingMessage.resetCustomFlags(); - for (vector<string>::const_iterator it = customFlags.begin(); it != customFlags.end(); ++it) { - string tmpFlag = *it; + for (auto tmpFlag : customFlags) { trim(tmpFlag, " \n"); existingMessage.setCustomFlag(tmpFlag); } diff --git a/src/maildir-scan.cc b/src/maildir-scan.cc index 2f3a9b4..65548f7 100644 --- a/src/maildir-scan.cc +++ b/src/maildir-scan.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-scan.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "iodevice.h" #include "iofactory.h" #include "maildir.h" @@ -16,7 +17,8 @@ #include <unistd.h> using namespace Binc; -using namespace ::std; +using std::endl; +using std::string; Lock::Lock(const string &path) { @@ -32,19 +34,18 @@ Lock::Lock(const string &path) struct stat mystat; bincWarning << "waiting for mailbox lock " << lock << "." << endl; if (lstat(lock.c_str(), &mystat) == 0) { - if ((time(0) - mystat.st_ctime) > 300) { - if (unlink(lock.c_str()) == 0) + if ((time(nullptr) - mystat.st_ctime) > 300) { + if (unlink(lock.c_str()) == 0) { continue; - else + } else { bincWarning << "failed to force mailbox lock: " << lock << ", " << string(strerror(errno)) << endl; + } } - } else { - if (errno != ENOENT) { - string err = "invalid lock " + lock + ": " + strerror(errno); - bincWarning << err << endl; - return; - } + } else if (errno != ENOENT) { + string err = "invalid lock " + lock + ": " + strerror(errno); + bincWarning << err << endl; + return; } // sleep one second. @@ -57,15 +58,14 @@ Lock::Lock(const string &path) Lock::~Lock() { // remove the lock - if (unlink(lock.c_str()) != 0) + if (unlink(lock.c_str()) != 0) { bincWarning << "failed to unlock mailbox: " << lock << ", " << strerror(errno) << endl; + } } -//------------------------------------------------------------------------ // scan the maildir. update flags, find messages in new/ and move them // to cur, setting the recent flag in memory only. check for expunged // messages. give newly arrived messages uids. -//------------------------------------------------------------------------ Maildir::ScanResult Maildir::scan(bool forceScan) { const string newpath = path + "/new/"; @@ -95,8 +95,8 @@ Maildir::ScanResult Maildir::scan(bool forceScan) old_bincimap_cache_st_mtime = oldstat.st_mtime; old_bincimap_cache_st_ctime = oldstat.st_ctime; } else { - old_bincimap_cache_st_mtime = 0; - old_bincimap_cache_st_ctime = 0; + old_bincimap_cache_st_mtime = {}; + old_bincimap_cache_st_ctime = {}; } } else { struct stat oldcurstat; @@ -147,10 +147,10 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // An error with reading the cache files when it's not the first // time we scan the depot is treated as an error. if (!firstscan && !readOnly) { - old_cur_st_mtime = (time_t)0; - old_cur_st_ctime = (time_t)0; - old_new_st_mtime = (time_t)0; - old_new_st_ctime = (time_t)0; + old_cur_st_mtime = {}; + old_cur_st_ctime = {}; + old_new_st_mtime = {}; + old_new_st_ctime = {}; return TemporaryError; } mailboxchanged = true; @@ -161,7 +161,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // open new/ directory DIR *pdir = opendir(newpath.c_str()); - if (pdir == 0) { + if (pdir == nullptr) { string reason = "failed to open \"" + newpath + "\" ("; reason += strerror(errno); reason += ")"; @@ -172,7 +172,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // scan all entries struct dirent *pdirent; - while ((pdirent = readdir(pdir)) != 0) { + while ((pdirent = readdir(pdir)) != nullptr) { // "Unless you're writing messages to a maildir, the format of a // unique name is none of your business. A unique name can be // anything that doesn't contain a colon (or slash) and doesn't @@ -201,15 +201,16 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // a rare race between readdir and stat force us to restart the scan. closedir(pdir); - if ((pdir = opendir(newpath.c_str())) == 0) { + if ((pdir = opendir(newpath.c_str())) == nullptr) { string reason = "Warning: opendir(\"" + newpath + "\") == 0 ("; reason += strerror(errno); reason += ")"; setLastError(reason); return PermanentError; } - } else + } else { bincWarning << "junk in Maildir: \"" << fullfilename << "\": " << strerror(errno); + } continue; } @@ -220,22 +221,19 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // and st_mtime. the next time the mailbox is scanned, it must not // simply be skipped. :-) - vector<MaildirMessage>::const_iterator newIt = newMessages.begin(); bool ours = false; - for (; newIt != newMessages.end(); ++newIt) { - if ((filename == (*newIt).getUnique()) - && ((*newIt).getInternalFlags() & MaildirMessage::Committed)) - { + for (const auto &newIt : newMessages) { + if ((filename == newIt.getUnique()) && (newIt.getInternalFlags() & MaildirMessage::Committed)) { ours = true; break; } } - if (!ours && ::time(0) <= mystat.st_mtime) { - old_cur_st_mtime = (time_t)0; - old_cur_st_ctime = (time_t)0; - old_new_st_mtime = (time_t)0; - old_new_st_ctime = (time_t)0; + if (!ours && ::time(nullptr) <= mystat.st_mtime) { + old_cur_st_mtime = {}; + old_cur_st_ctime = {}; + old_new_st_mtime = {}; + old_new_st_ctime = {}; continue; } @@ -261,7 +259,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // Then, scan cur // open directory - if ((pdir = opendir(curpath.c_str())) == 0) { + if ((pdir = opendir(curpath.c_str())) == nullptr) { string reason = "Maildir::scan::opendir(\"" + curpath + "\") == 0 ("; reason += strerror(errno); reason += ")"; @@ -275,10 +273,10 @@ Maildir::ScanResult Maildir::scan(bool forceScan) index.clearFileNames(); // this is to sort recent messages by internaldate - multimap<unsigned int, MaildirMessage> tempMessageMap; + std::multimap<unsigned int, MaildirMessage> tempMessageMap; // scan all entries - while ((pdirent = readdir(pdir)) != 0) { + while ((pdirent = readdir(pdir)) != nullptr) { string filename = pdirent->d_name; if (filename[0] == '.') continue; @@ -289,12 +287,13 @@ Maildir::ScanResult Maildir::scan(bool forceScan) uniquename = filename.substr(0, pos); string tmp = filename.substr(pos); if ((pos = tmp.find("2,")) != string::npos) standard = tmp.substr(pos + 2); - } else + } else { uniquename = filename; + } unsigned char mflags = Message::F_NONE; - for (string::const_iterator i = standard.begin(); i != standard.end(); ++i) { - switch (*i) { + for (char i : standard) { + switch (i) { case 'R': mflags |= Message::F_ANSWERED; break; @@ -335,7 +334,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) closedir(pdir); - if ((pdir = opendir(newpath.c_str())) == 0) { + if ((pdir = opendir(newpath.c_str())) == nullptr) { string reason = "Warning: opendir(\"" + newpath + "\") == 0 ("; reason += strerror(errno); reason += ")"; @@ -354,7 +353,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // If we have this message in memory already.. if (message) { - if (message->getInternalDate() == 0) { + if (message->getInternalDate() == time_t{}) { mailboxchanged = true; message->setInternalDate(mystat.st_mtime); } @@ -382,7 +381,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) m.setInternalDate(mystat.st_mtime); m.setStdFlag((mflags | Message::F_RECENT) & ~Message::F_EXPUNGED); m.setUnique(uniquename); - tempMessageMap.insert(make_pair((unsigned int)mystat.st_mtime, m)); + tempMessageMap.insert(std::make_pair((unsigned int)mystat.st_mtime, m)); mailboxchanged = true; } @@ -392,14 +391,11 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // Recent messages are added, ordered by internaldate. { int readonlyuidnext = uidnext; - multimap<unsigned int, MaildirMessage>::iterator i = tempMessageMap.begin(); - while (i != tempMessageMap.end()) { + + for (auto i = tempMessageMap.begin(); i != tempMessageMap.end(); ++i) { i->second.setUID(readOnly ? readonlyuidnext++ : uidnext++); - multimap<unsigned int, MaildirMessage>::iterator itmp = i; - ++itmp; add(i->second); tempMessageMap.erase(i); - i = itmp; mailboxchanged = true; } } @@ -410,7 +406,7 @@ Maildir::ScanResult Maildir::scan(bool forceScan) // exist in the Maildir, are removed from the messages list. Mailbox::iterator jj = begin(SequenceSet::all(), INCLUDE_EXPUNGED | SQNR_MODE); while (jj != end()) { - MaildirMessage &message = (MaildirMessage &)*jj; + auto &message = dynamic_cast<MaildirMessage &>(*jj); if (message.isExpunged()) { mailboxchanged = true; @@ -434,12 +430,12 @@ Maildir::ScanResult Maildir::scan(bool forceScan) Mailbox::iterator ii = begin(SequenceSet::all(), INCLUDE_EXPUNGED | SQNR_MODE); for (; ii != end(); ++ii) { - MaildirMessage &message = (MaildirMessage &)*ii; + MaildirMessage &message = dynamic_cast<MaildirMessage &>(*ii); message.clearInternalFlag(MaildirMessage::JustArrived); - if (lastuid < message.getUID()) + if (lastuid < message.getUID()) { lastuid = message.getUID(); - else { + } else { bincWarning << "UID values are not strictly ascending in this" " mailbox: " << path << ". This is usually caused by " @@ -450,10 +446,10 @@ Maildir::ScanResult Maildir::scan(bool forceScan) if (!readOnly) { bumpUidValidity(path); - old_cur_st_mtime = (time_t)0; - old_cur_st_ctime = (time_t)0; - old_new_st_mtime = (time_t)0; - old_new_st_ctime = (time_t)0; + old_cur_st_mtime = {}; + old_cur_st_ctime = {}; + old_new_st_mtime = {}; + old_new_st_ctime = {}; return TemporaryError; } else { return PermanentError; diff --git a/src/maildir-scanfilesnames.cc b/src/maildir-scanfilesnames.cc index 0bde999..ff5c2d4 100644 --- a/src/maildir-scanfilesnames.cc +++ b/src/maildir-scanfilesnames.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-scanfilesnames.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "iodevice.h" #include "iofactory.h" #include "maildir.h" @@ -16,23 +17,22 @@ #include <dirent.h> #include <unistd.h> -using namespace ::std; +using std::string; -//------------------------------------------------------------------------ bool Binc::Maildir::scanFileNames(void) const { string curpath = path + "/cur/"; DIR *pdir = opendir(curpath.c_str()); - if (pdir == 0) { + if (pdir == nullptr) { setLastError("when scanning mailbox \"" + path + "\": " + string(strerror(errno))); - bincWarning << getLastError() << endl; + bincWarning << getLastError() << std::endl; return false; } index.clearFileNames(); struct dirent *pdirent; - while ((pdirent = readdir(pdir)) != 0) { + while ((pdirent = readdir(pdir)) != nullptr) { if (!isdigit(pdirent->d_name[0])) continue; string filename = pdirent->d_name; diff --git a/src/maildir-select.cc b/src/maildir-select.cc index a779a4a..470dbbc 100644 --- a/src/maildir-select.cc +++ b/src/maildir-select.cc @@ -1,18 +1,17 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-select.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date Andreas Aardal Hanssen - * ----------------------------------------------------------------- **/ + */ + #include "maildir.h" #include <fcntl.h> #include <unistd.h> -using namespace ::std; using namespace Binc; -//------------------------------------------------------------------------ bool Binc::Maildir::selectMailbox(const std::string &name, const std::string &s_in) { setName(name); @@ -34,6 +33,7 @@ bool Binc::Maildir::selectMailbox(const std::string &name, const std::string &s_ break; case TemporaryError: if (scan() == Success) break; + [[fallthrough]]; case PermanentError: return false; } diff --git a/src/maildir-updateflags.cc b/src/maildir-updateflags.cc index a3d2ab7..ba18f82 100644 --- a/src/maildir-updateflags.cc +++ b/src/maildir-updateflags.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-updateflags.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "iodevice.h" #include "iofactory.h" #include "maildir.h" @@ -13,9 +14,8 @@ #include <dirent.h> #include <unistd.h> -using namespace ::std; +using std::string; -//------------------------------------------------------------------------ void Binc::Maildir::updateFlags(void) { // don't update a read-only mailbox. @@ -24,15 +24,15 @@ void Binc::Maildir::updateFlags(void) // open the cur/ directory string curpath = path + "/cur/"; DIR *pdir = opendir(curpath.c_str()); - if (pdir == 0) { - bincError << "failed to open " << curpath << ": " << strerror(errno) << endl; + if (pdir == nullptr) { + bincError << "failed to open " << curpath << ": " << strerror(errno) << std::endl; return; } // read all entries in the directory - vector<string> entries; + std::vector<string> entries; struct dirent *pdirent; - while ((pdirent = readdir(pdir)) != 0) { + while ((pdirent = readdir(pdir)) != nullptr) { string filename = pdirent->d_name; if (filename[0] == '.') continue; entries.push_back(filename); @@ -41,11 +41,8 @@ void Binc::Maildir::updateFlags(void) bool customFlagsChanged = false; - // loop through all messages in cur/, and update the flags that have - // changed. - for (vector<string>::const_iterator it = entries.begin(); it != entries.end(); ++it) { - string filename = *it; - + // loop through all messages in cur/, and update the flags that have changed. + for (const auto &filename : entries) { // separate the unique name from the flags. accept messages that do not // contain the flags section. string uniquename; @@ -83,8 +80,8 @@ void Binc::Maildir::updateFlags(void) if (rename(srcname.c_str(), destname.c_str()) != 0) { if (errno == ENOENT) { closedir(pdir); - if ((pdir = opendir(curpath.c_str())) == 0) { - bincError << "failed to open " << curpath << ": " << strerror(errno) << endl; + if ((pdir = opendir(curpath.c_str())) == nullptr) { + bincError << "failed to open " << curpath << ": " << strerror(errno) << std::endl; return; } @@ -94,7 +91,7 @@ void Binc::Maildir::updateFlags(void) } bincError << "failed to rename " << srcname << " to " << destname << ": " << strerror(errno) - << endl; + << std::endl; } else { index.insert(uniquename, 0, uniquename + ":2," + flags); } diff --git a/src/maildir-writecache.cc b/src/maildir-writecache.cc index 2a51b49..ceb2f81 100644 --- a/src/maildir-writecache.cc +++ b/src/maildir-writecache.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir-writecache.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "globals.h" #include "maildir.h" @@ -11,9 +12,6 @@ #include <fcntl.h> #include <unistd.h> -using namespace ::std; - -//------------------------------------------------------------------------ bool Binc::Maildir::writeCache(void) { if (readOnly) return true; @@ -25,7 +23,7 @@ bool Binc::Maildir::writeCache(void) return false; } - string safeName = safename; + std::string safeName = safename; free(safename); FILE *fp = fdopen(fd, "w"); @@ -35,7 +33,7 @@ bool Binc::Maildir::writeCache(void) } if (uidvalidity == 0 || uidnext == 0) { - uidvalidity = time(0); + uidvalidity = time(nullptr); uidnext = messages.size() + 1; } @@ -49,10 +47,9 @@ bool Binc::Maildir::writeCache(void) (unsigned int)message.getInternalDate(), message.getSize(), message.getUnique().c_str()); - vector<string> cflags = message.getCustomFlags(); - for (vector<string>::const_iterator it = cflags.begin(); it != cflags.end(); ++it) { + std::vector<std::string> cflags = message.getCustomFlags(); + for (std::vector<std::string>::const_iterator it = cflags.begin(); it != cflags.end(); ++it) fprintf(fp, " %s", (*it).c_str()); - } fprintf(fp, "\n"); } @@ -67,9 +64,7 @@ bool Binc::Maildir::writeCache(void) } int dfd = open(path.c_str(), O_RDONLY); - if (dfd == -1 || (fsync(fd) && (errno != EROFS || errno != EINVAL)) || close(dfd)) { - return false; - } + if (dfd == -1 || (fsync(fd) && (errno != EROFS || errno != EINVAL)) || close(dfd)) return false; return true; } diff --git a/src/maildir.cc b/src/maildir.cc index 5071a1a..dc7e45a 100644 --- a/src/maildir.cc +++ b/src/maildir.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildir.cc * @brief Implementation of the Maildir class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "maildir.h" #include "convert.h" @@ -30,16 +31,16 @@ #include <sys/types.h> #include <unistd.h> -using namespace ::std; using namespace Binc; +using std::endl; +using std::map; +using std::string; // Used to generate the unique names for Maildir delivery static int numDeliveries = 0; -//------------------------------------------------------------------------ Maildir::iterator::iterator(void) {} -//------------------------------------------------------------------------ Maildir::iterator::iterator(Maildir *home, MessageMap::iterator it, const SequenceSet &_bset, @@ -54,7 +55,6 @@ Maildir::iterator::iterator(Maildir *home, sqnrmax = home->getMaxSqnr(); } -//------------------------------------------------------------------------ Maildir::iterator::iterator(const iterator ©) : BaseIterator(copy.sqnr) , mailbox(copy.mailbox) @@ -65,7 +65,6 @@ Maildir::iterator::iterator(const iterator ©) , sqnrmax(copy.sqnrmax) {} -//------------------------------------------------------------------------ Maildir::iterator &Maildir::iterator::operator=(const iterator ©) { sqnr = copy.sqnr; @@ -78,22 +77,18 @@ Maildir::iterator &Maildir::iterator::operator=(const iterator ©) return *this; } -//------------------------------------------------------------------------ Maildir::iterator::~iterator(void) {} -//------------------------------------------------------------------------ MaildirMessage &Maildir::iterator::curMessage(void) { return i->second; } -//------------------------------------------------------------------------ Message &Maildir::iterator::operator*(void) { return curMessage(); } -//------------------------------------------------------------------------ void Maildir::iterator::operator++(void) { ++i; @@ -101,20 +96,17 @@ void Maildir::iterator::operator++(void) reposition(); } -//------------------------------------------------------------------------ bool Maildir::iterator::operator==(const BaseIterator &a) const { const iterator *b = dynamic_cast<const iterator *>(&a); return b ? (i == b->i) : false; } -//------------------------------------------------------------------------ bool Maildir::iterator::operator!=(const BaseIterator &a) const { return !((*this) == a); } -//------------------------------------------------------------------------ void Maildir::iterator::reposition(void) { for (;;) { @@ -144,23 +136,20 @@ void Maildir::iterator::reposition(void) } } -//------------------------------------------------------------------------ Mailbox::iterator Maildir::begin(const SequenceSet &bset, unsigned int mod) const { - beginIterator = iterator((Maildir *)this, messages.begin(), bset, mod); + beginIterator = iterator(const_cast<Maildir *>(this), messages.begin(), bset, mod); beginIterator.reposition(); return Mailbox::iterator(beginIterator); } -//------------------------------------------------------------------------ Mailbox::iterator Maildir::end(void) const { - endIterator = iterator((Maildir *)this, messages.end(), endIterator.bset, endIterator.mod); + endIterator = iterator(const_cast<Maildir *>(this), messages.end(), endIterator.bset, endIterator.mod); return Mailbox::iterator(endIterator); } -//------------------------------------------------------------------------ void Maildir::iterator::erase(void) { MessageMap::iterator iter = i; @@ -174,7 +163,6 @@ void Maildir::iterator::erase(void) reposition(); } -//------------------------------------------------------------------------ Maildir::Maildir(void) : Mailbox() { firstscan = true; @@ -186,16 +174,13 @@ Maildir::Maildir(void) : Mailbox() oldexists = 0; } -//------------------------------------------------------------------------ Maildir::~Maildir(void) {} -//------------------------------------------------------------------------ void Maildir::setPath(const string &path_in) { path = path_in; } -//------------------------------------------------------------------------ bool Maildir::getUpdates(bool doscan, unsigned int type, PendingUpdates &updates, bool forceScan) { if (doscan && scan(forceScan) != Success) return false; @@ -216,8 +201,9 @@ bool Maildir::getUpdates(bool doscan, unsigned int type, PendingUpdates &updates i.erase(); mailboxchanged = true; displayExists = true; - } else + } else { ++i; + } } } @@ -250,7 +236,6 @@ bool Maildir::getUpdates(bool doscan, unsigned int type, PendingUpdates &updates return true; } -//------------------------------------------------------------------------ bool Maildir::isMailbox(const std::string &s_in) const { struct stat mystat; @@ -260,27 +245,24 @@ bool Maildir::isMailbox(const std::string &s_in) const && (stat((s_in + "/tmp").c_str(), &mystat) == 0 && S_ISDIR(mystat.st_mode))); } -//------------------------------------------------------------------------ const std::string Maildir::getTypeName(void) const { return "Maildir"; } -//------------------------------------------------------------------------ void Maildir::bumpUidValidity(const string &s_in) const { unlink((s_in + "/bincimap-uidvalidity").c_str()); unlink((s_in + "/bincimap-cache").c_str()); } -//------------------------------------------------------------------------ bool Maildir::isMarked(const std::string &s_in) const { DIR *dirp = opendir((s_in + "/new").c_str()); - if (dirp == 0) return false; + if (dirp == nullptr) return false; struct dirent *direntp; - while ((direntp = readdir(dirp)) != 0) { + while ((direntp = readdir(dirp)) != nullptr) { string s = direntp->d_name; if (s[0] != '.' && s.find('/') == string::npos && s.find(':') == string::npos) { closedir(dirp); @@ -292,7 +274,6 @@ bool Maildir::isMarked(const std::string &s_in) const return false; } -//------------------------------------------------------------------------ unsigned int Maildir::getStatusID(const string &path) const { unsigned int statusid = 0; @@ -306,7 +287,6 @@ unsigned int Maildir::getStatusID(const string &path) const return statusid; } -//------------------------------------------------------------------------ bool Maildir::getStatus(const string &path, Status &s) const { unsigned int messages = 0; @@ -319,8 +299,8 @@ bool Maildir::getStatus(const string &path, Status &s) const const string cachefilename = path + "/bincimap-cache"; FILE *fp = fopen(cachefilename.c_str(), "r"); - if (fp) do - { + if (fp) { + do { char inputBuffer[512]; if (!fgets(inputBuffer, sizeof(inputBuffer), fp)) { fclose(fp); @@ -362,18 +342,18 @@ bool Maildir::getStatus(const string &path, Status &s) const fclose(fp); - s.setUidValidity(readUidValidity < 1 ? time(0) : readUidValidity); + s.setUidValidity(readUidValidity < 1 ? time(nullptr) : readUidValidity); } while (0); - else { - s.setUidValidity(time(0)); + } else { + s.setUidValidity(time(nullptr)); } // Scan new DIR *dirp = opendir((path + "/new").c_str()); - if (dirp == 0) return false; + if (dirp == nullptr) return false; struct dirent *direntp; - while ((direntp = readdir(dirp)) != 0) { + while ((direntp = readdir(dirp)) != nullptr) { const string filename = direntp->d_name; if (filename[0] == '.' || filename.find(':') != string::npos || filename.find('/') != string::npos) continue; @@ -387,9 +367,9 @@ bool Maildir::getStatus(const string &path, Status &s) const closedir(dirp); // Scan cur - if ((dirp = opendir((path + "/cur").c_str())) == 0) return false; + if ((dirp = opendir((path + "/cur").c_str())) == nullptr) return false; - while ((direntp = readdir(dirp)) != 0) { + while ((direntp = readdir(dirp)) != nullptr) { const string dname = direntp->d_name; if (dname[0] == '.') continue; @@ -425,7 +405,6 @@ bool Maildir::getStatus(const string &path, Status &s) const return true; } -//------------------------------------------------------------------------ unsigned int Maildir::getMaxUid(void) const { MessageMap::const_iterator i = messages.end(); @@ -445,7 +424,6 @@ unsigned int Maildir::getMaxUid(void) const return 0; } -//------------------------------------------------------------------------ unsigned int Maildir::getMaxSqnr(void) const { int sqnr = messages.size(); @@ -467,51 +445,41 @@ unsigned int Maildir::getMaxSqnr(void) const return 0; } -//------------------------------------------------------------------------ unsigned int Maildir::getUidValidity(void) const { return uidvalidity; } -//------------------------------------------------------------------------ unsigned int Maildir::getUidNext(void) const { return uidnext; } -//------------------------------------------------------------------------ Message *Maildir::createMessage(const string &mbox, time_t idate) { string sname = mbox + "/tmp/bincimap-XXXXXX"; - char *safename = strdup(sname.c_str()); - int fd = mkstemp(safename); + int fd = mkstemp(sname.data()); if (fd == -1) { setLastError("Unable to create safe name."); - return 0; + return nullptr; } - string safenameStr = safename; - delete[] safename; - MaildirMessage message(*this); message.setFile(fd); - message.setSafeName(safenameStr); + message.setSafeName(sname); message.setInternalDate(idate); newMessages.push_back(message); - vector<MaildirMessage>::iterator i = newMessages.end(); - --i; - return &(*i); + return &newMessages.back(); } -//------------------------------------------------------------------------ bool Maildir::commitNewMessages(const string &mbox) { Session &session = Session::getInstance(); - vector<MaildirMessage>::iterator i = newMessages.begin(); + std::vector<MaildirMessage>::iterator i = newMessages.begin(); map<MaildirMessage *, string> committedMessages; struct timeval youngestFile = {0, 0}; @@ -531,13 +499,13 @@ bool Maildir::commitNewMessages(const string &mbox) for (int attempt = 0; !abort && attempt < 1000; ++attempt) { struct timeval tv; - gettimeofday(&tv, 0); + gettimeofday(&tv, nullptr); youngestFile = tv; // Generate Maildir conformant file name BincStream ssid; ssid << (int)tv.tv_sec << "." - << "R" << (int)rand() << "M" << (int)tv.tv_usec << "P" << (int)session.getPid() << "Q" + << "R" << rand() << "M" << (int)tv.tv_usec << "P" << session.getPid() << "Q" << numDeliveries++ << "." << session.getEnv("TCPLOCALHOST"); BincStream ss; @@ -568,33 +536,29 @@ bool Maildir::commitNewMessages(const string &mbox) ++i; } - // abort means to make an attempt to restore the mailbox to - // its original state. + // abort means to make an attempt to restore the mailbox to its original state. if (abort) { // Fixme: Messages that are in committedMessages should be skipped // here. - for (i = newMessages.begin(); i != newMessages.end(); ++i) - unlink((*i).getSafeName().c_str()); + for (const auto &i : newMessages) + unlink(i.getSafeName().c_str()); - map<MaildirMessage *, string>::const_iterator j = committedMessages.begin(); - while (j != committedMessages.end()) { - if (unlink(j->second.c_str()) != 0) { + for (const auto &[_, second] : committedMessages) { + if (unlink(second.c_str()) != 0) { if (errno == ENOENT) { // FIXME: The message was probably moves away from new/ by // another IMAP session. bincWarning << "error rollbacking after failed commit to " << toImapString(mbox) - << ", failed to unlink " << toImapString(j->second) << ": " << strerror(errno) + << ", failed to unlink " << toImapString(second) << ": " << strerror(errno) << endl; } else { bincWarning << "error rollbacking after failed commit to " << toImapString(mbox) - << ", failed to unlink " << toImapString(j->second) << ": " << strerror(errno) + << ", failed to unlink " << toImapString(second) << ": " << strerror(errno) << endl; newMessages.clear(); return false; } } - - ++j; } newMessages.clear(); @@ -606,16 +570,14 @@ bool Maildir::commitNewMessages(const string &mbox) // random number by spinning until the timestamp has changed before // moving the message into cur. struct timeval tv; - gettimeofday(&tv, 0); - while (tv.tv_sec == youngestFile.tv_sec && tv.tv_usec == youngestFile.tv_usec) { - gettimeofday(&tv, 0); - } + gettimeofday(&tv, nullptr); + while (tv.tv_sec == youngestFile.tv_sec && tv.tv_usec == youngestFile.tv_usec) + gettimeofday(&tv, nullptr); - map<MaildirMessage *, string>::const_iterator j = committedMessages.begin(); - for (; j != committedMessages.end(); ++j) { - string basename = j->second.substr(j->second.rfind('/') + 1); + for (auto &j : committedMessages) { + string basename = j.second.substr(j.second.rfind('/') + 1); - int flags = j->first->getStdFlags(); + int flags = j.first->getStdFlags(); string flagStr; if (flags & Message::F_DRAFT) flagStr += "D"; if (flags & Message::F_FLAGGED) flagStr += "F"; @@ -624,30 +586,27 @@ bool Maildir::commitNewMessages(const string &mbox) if (flags & Message::F_DELETED) flagStr += "T"; string dest = mbox + "/cur/" + basename + ":2," + flagStr; - if (rename(j->second.c_str(), dest.c_str()) == 0) continue; + if (rename(j.second.c_str(), dest.c_str()) == 0) continue; - if (errno != ENOENT) - bincWarning << "when setting flags on: " << j->second << ": " << strerror(errno) << endl; + if (errno != ENOENT) { + bincWarning << "when setting flags on: " << j.second << ": " << strerror(errno) << endl; + } } committedMessages.clear(); return true; } -//------------------------------------------------------------------------ bool Maildir::rollBackNewMessages(void) { - vector<MaildirMessage>::const_iterator i = newMessages.begin(); - // Fixme: Messages that are in committedMessages should be skipped - // here. - for (; i != newMessages.end(); ++i) - unlink((*i).getSafeName().c_str()); + // Fixme: Messages that are in committedMessages should be skipped here. + for (const auto &i : newMessages) + unlink(i.getSafeName().c_str()); newMessages.clear(); return true; } -//------------------------------------------------------------------------ bool Maildir::fastCopy(Message &m, Mailbox &desttype, const std::string &destname) { // At this point, fastCopy is broken because the creation time is @@ -669,7 +628,7 @@ bool Maildir::fastCopy(Message &m, Mailbox &desttype, const std::string &destnam for (int attempt = 0; attempt < 1000; ++attempt) { struct timeval tv; - gettimeofday(&tv, 0); + gettimeofday(&tv, nullptr); // Generate Maildir conformant file name BincStream ssid; @@ -686,7 +645,7 @@ bool Maildir::fastCopy(Message &m, Mailbox &desttype, const std::string &destnam MaildirMessage newmess = *message; newmess.setSafeName(fileName); newmess.setUnique(ssid.str()); - newmess.setInternalDate((time_t)tv.tv_sec); + newmess.setInternalDate(tv.tv_sec); newmess.setUID(0); newMessages.push_back(newmess); break; @@ -705,34 +664,30 @@ bool Maildir::fastCopy(Message &m, Mailbox &desttype, const std::string &destnam return true; } -//------------------------------------------------------------------------ MaildirMessage *Maildir::get(const std::string &id) { MaildirIndexItem *item = index.find(id); - if (!item) return 0; + if (!item) return nullptr; unsigned int uid = item->uid; - if (messages.find(uid) == messages.end()) return 0; + if (messages.find(uid) == messages.end()) return nullptr; return &messages.find(uid)->second; } -//------------------------------------------------------------------------ void Maildir::add(MaildirMessage &m) { MessageMap::iterator it = messages.find(m.getUID()); if (it != messages.end()) messages.erase(it); - messages.insert(make_pair(m.getUID(), m)); + messages.insert(std::make_pair(m.getUID(), m)); index.insert(m.getUnique(), m.getUID()); } -//------------------------------------------------------------------------ unsigned int MaildirIndex::getSize(void) const { return idx.size(); } -//------------------------------------------------------------------------ void MaildirIndex::insert(const string &unique, unsigned int uid, const string &fileName) { if (idx.find(unique) == idx.end()) { @@ -747,40 +702,33 @@ void MaildirIndex::insert(const string &unique, unsigned int uid, const string & } } -//------------------------------------------------------------------------ void MaildirIndex::remove(const string &unique) { map<string, MaildirIndexItem>::iterator it = idx.find(unique); if (it != idx.end()) idx.erase(it); } -//------------------------------------------------------------------------ MaildirIndexItem *MaildirIndex::find(const string &unique) { map<string, MaildirIndexItem>::iterator it = idx.find(unique); if (it != idx.end()) return &it->second; - return 0; + return nullptr; } -//------------------------------------------------------------------------ void MaildirIndex::clear(void) { idx.clear(); } -//------------------------------------------------------------------------ void MaildirIndex::clearUids(void) { - map<string, MaildirIndexItem>::iterator it = idx.begin(); - for (; it != idx.end(); ++it) - it->second.uid = 0; + for (auto &it : idx) + it.second.uid = 0; } -//------------------------------------------------------------------------ void MaildirIndex::clearFileNames(void) { - map<string, MaildirIndexItem>::iterator it = idx.begin(); - for (; it != idx.end(); ++it) - it->second.fileName = ""; + for (auto &it : idx) + it.second.fileName = ""; } diff --git a/src/maildirmessage.cc b/src/maildirmessage.cc index ee1d889..56a75c4 100644 --- a/src/maildirmessage.cc +++ b/src/maildirmessage.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file maildirmessage.cc * @brief Implementation of the MaildirMessage class. * @author Andreas Aardal Hanssen * @date Copyright 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "maildirmessage.h" #include "convert.h" @@ -25,14 +26,14 @@ #include <unistd.h> #include <utime.h> -using namespace ::std; using namespace Binc; +using std::string; +using std::vector; string Message::lastError; string MaildirMessage::storage; namespace { - //---------------------------------------------------------------------- void printOneHeader(IODevice &io, const MimePart *message, const string &s_in, @@ -44,11 +45,11 @@ namespace { if (message->h.getFirstHeader(s_in, hitem)) { tmp = hitem.getValue(); io << toImapString(unfold(tmp, removecomments)); - } else + } else { io << "NIL"; + } } - //---------------------------------------------------------------------- void printOneAddressList(IODevice &io, const MimePart *message, const string &s_in, @@ -63,17 +64,17 @@ namespace { splitAddr(unfold(tmp, removecomments), addr); if (addr.size() != 0) { io << "("; - for (vector<string>::const_iterator i = addr.begin(); i != addr.end(); ++i) - - io << Address(*i).toParenList(); + for (const auto &i : addr) + io << Address(i).toParenList(); io << ")"; - } else + } else { io << "NIL"; - } else + } + } else { io << "NIL"; + } } - //---------------------------------------------------------------------- void envelope(IODevice &io, const MimePart *message) { HeaderItem hitem; @@ -106,16 +107,14 @@ namespace { io << ")"; } - //---------------------------------------------------------------------- void bodyStructure(IODevice &io, const MimePart *message, bool extended) { HeaderItem hitem; if (message->isMultipart() && message->members.size() > 0) { io << "("; - for (vector<MimePart>::const_iterator i = message->members.begin(); i != message->members.end(); - ++i) - bodyStructure(io, &(*i), extended); + for (const auto &i : message->members) + bodyStructure(io, &i, extended); io << " "; io << toImapString(message->getSubType()); @@ -137,8 +136,7 @@ namespace { vector<string> v; split(tmp, ";", v); - for (vector<string>::const_iterator i = v.begin(); i != v.end(); ++i) { - string element = *i; + for (string element : v) { trim(element); if (element.find('=') != string::npos) { string::size_type pos = element.find('='); @@ -153,15 +151,17 @@ namespace { if (parameters.size() != 0) { io << "("; - for (vector<string>::const_iterator i = parameters.begin(); i != parameters.end(); ++i) { - if (i != parameters.begin()) io << " "; + for (auto i = parameters.cbegin(); i != parameters.cend(); ++i) { + if (i != parameters.cbegin()) io << " "; io << toImapString(*i); } io << ")"; - } else + } else { io << "NIL"; - } else + } + } else { io << "NIL"; + } // CONTENT-DISPOSITION io << " "; @@ -207,13 +207,16 @@ namespace { ++i; } io << ")"; - } else + } else { io << "NIL"; + } io << ")"; - } else + } else { io << "NIL"; - } else + } + } else { io << "NIL"; + } // CONTENT-LANGUAGE io << " "; @@ -251,8 +254,8 @@ namespace { subtype = "plain"; } - for (vector<string>::const_iterator i = v.begin(); i != v.end(); ++i) { - if (i == v.begin()) continue; + for (auto i = v.cbegin(); i != v.cend(); ++i) { + if (i == v.cbegin()) continue; string element = *i; trim(element); if (element.find('=') != string::npos) { @@ -278,13 +281,14 @@ namespace { io << " "; if (parameters.size() != 0) { io << "("; - for (vector<string>::const_iterator i = parameters.begin(); i != parameters.end(); ++i) { - if (i != parameters.begin()) io << " "; + for (auto i = parameters.cbegin(); i != parameters.cend(); ++i) { + if (i != parameters.cbegin()) io << " "; io << toImapString(*i); } io << ")"; - } else + } else { io << "NIL"; + } // CONTENT-ID io << " "; @@ -301,8 +305,9 @@ namespace { tmp = hitem.getValue(); trim(tmp); io << toImapString(tmp); - } else + } else { io << "\"7bit\""; + } io << " "; // Size of body in octets @@ -366,13 +371,16 @@ namespace { ++i; } io << ")"; - } else + } else { io << "NIL"; + } io << ")"; - } else + } else { io << "NIL"; - } else + } + } else { io << "NIL"; + } // CONTENT-LANGUAGE io << " "; @@ -388,10 +396,9 @@ namespace { } } -//------------------------------------------------------------------------ MaildirMessage::MaildirMessage(Maildir &hom) : fd(-1) - , doc(0) + , doc(nullptr) , internalFlags(None) , stdflags(F_NONE) , uid(0) @@ -400,10 +407,9 @@ MaildirMessage::MaildirMessage(Maildir &hom) , safeName("") , internaldate(0) , home(hom) - , customFlags(0) + , customFlags(nullptr) {} -//------------------------------------------------------------------------ MaildirMessage::MaildirMessage(const MaildirMessage ©) : fd(copy.fd) , doc(copy.doc) @@ -424,43 +430,16 @@ MaildirMessage::MaildirMessage(const MaildirMessage ©) } } -//------------------------------------------------------------------------ MaildirMessage::~MaildirMessage(void) { delete customFlags; } -//------------------------------------------------------------------------ -MaildirMessage &MaildirMessage::operator=(const MaildirMessage ©) -{ - fd = copy.fd; - doc = copy.doc; - internalFlags = copy.internalFlags; - stdflags = copy.stdflags; - uid = copy.uid; - size = copy.size; - unique = copy.unique; - safeName = copy.safeName; - internaldate = copy.internaldate; - home = copy.home; - - if (copy.customFlags) { - customFlags = new vector<string>; - *customFlags = *copy.customFlags; - } else { - customFlags = 0; - } - - return *this; -} - -//------------------------------------------------------------------------ bool MaildirMessage::operator<(const MaildirMessage &a) const { return uid < a.uid; } -//------------------------------------------------------------------------ void MaildirMessage::close(void) { if (fd != -1) { @@ -482,7 +461,7 @@ void MaildirMessage::close(void) struct utimbuf tim = {internaldate, internaldate}; utime(safeName.c_str(), &tim); } else { - time_t t = time(0); + time_t t = time(nullptr); struct utimbuf tim = {t, t}; utime(safeName.c_str(), &tim); } @@ -490,57 +469,48 @@ void MaildirMessage::close(void) internalFlags &= ~WasWrittenTo; } - if (doc) { doc->clear(); delete doc; - doc = 0; + doc = nullptr; } } -//------------------------------------------------------------------------ void MaildirMessage::setExpunged(void) { internalFlags |= Expunged; } -//------------------------------------------------------------------------ void MaildirMessage::setUnExpunged(void) { internalFlags &= ~Expunged; } -//------------------------------------------------------------------------ void MaildirMessage::setFlagsUnchanged(void) { internalFlags &= ~FlagsChanged; } -//------------------------------------------------------------------------ bool MaildirMessage::hasFlagsChanged(void) const { return (internalFlags & FlagsChanged) != 0; } -//------------------------------------------------------------------------ unsigned char MaildirMessage::getStdFlags(void) const { return stdflags; } -//------------------------------------------------------------------------ bool MaildirMessage::isExpunged(void) const { return (internalFlags & Expunged) != 0; } -//------------------------------------------------------------------------ unsigned int MaildirMessage::getUID(void) const { return uid; } -//------------------------------------------------------------------------ unsigned int MaildirMessage::getSize(bool render) const { if (size == 0 && render) { @@ -551,57 +521,48 @@ unsigned int MaildirMessage::getSize(bool render) const return size; } -//------------------------------------------------------------------------ const string &MaildirMessage::getUnique(void) const { return unique; } -//------------------------------------------------------------------------ time_t MaildirMessage::getInternalDate(void) const { return internaldate; } -//------------------------------------------------------------------------ void MaildirMessage::setInternalDate(time_t t) { internaldate = t; } -//------------------------------------------------------------------------ void MaildirMessage::setStdFlag(unsigned char f_in) { internalFlags |= FlagsChanged; stdflags |= f_in; } -//------------------------------------------------------------------------ void MaildirMessage::resetStdFlags(void) { internalFlags |= FlagsChanged; stdflags = F_NONE; } -//------------------------------------------------------------------------ void MaildirMessage::setUID(unsigned int i_in) { uid = i_in; } -//------------------------------------------------------------------------ void MaildirMessage::setSize(unsigned int i_in) { size = i_in; } -//------------------------------------------------------------------------ void MaildirMessage::setUnique(const string &s_in) { unique = s_in; } -//------------------------------------------------------------------------ int MaildirMessage::getFile(void) const { if (fd != -1) return fd; @@ -619,16 +580,16 @@ int MaildirMessage::getFile(void) const if (errno == ENOENT) { struct stat st; if (lstat(fpath.c_str(), &st) != -1) { - bincWarning << "dangling symlink: " << fpath << endl; + bincWarning << "dangling symlink: " << fpath << std::endl; return -1; } } else { - bincWarning << "unable to open " << fpath << ": " << strerror(errno) << endl; + bincWarning << "unable to open " << fpath << ": " << strerror(errno) << std::endl; return -1; } home.scanFileNames(); - if ((item = home.index.find(id)) == 0) + if ((item = home.index.find(id)) == nullptr) break; else fpath = home.path + "/cur/" + item->fileName; @@ -643,38 +604,33 @@ int MaildirMessage::getFile(void) const return -1; } -//------------------------------------------------------------------------ void MaildirMessage::setFile(int fd) { this->fd = fd; } -//------------------------------------------------------------------------ void MaildirMessage::setSafeName(const string &name) { safeName = name; } -//------------------------------------------------------------------------ const string &MaildirMessage::getSafeName(void) const { return safeName; } -//------------------------------------------------------------------------ string MaildirMessage::getFileName(void) const { MaildirIndexItem *item = home.index.find(getUnique()); if (!item) { home.scanFileNames(); - if ((item = home.index.find(getUnique())) == 0) return ""; + if ((item = home.index.find(getUnique())) == nullptr) return ""; } return item->fileName; } -//------------------------------------------------------------------------ int MaildirMessage::readChunk(string &chunk) { if (fd == -1) { @@ -692,7 +648,6 @@ int MaildirMessage::readChunk(string &chunk) return readBytes; } -//------------------------------------------------------------------------ bool MaildirMessage::appendChunk(const string &chunk) { if (fd == -1) { @@ -725,7 +680,6 @@ bool MaildirMessage::appendChunk(const string &chunk) return false; } -//------------------------------------------------------------------------ bool MaildirMessage::parseFull(void) const { MaildirMessageCache &cache = MaildirMessageCache::getInstance(); @@ -744,7 +698,6 @@ bool MaildirMessage::parseFull(void) const return true; } -//------------------------------------------------------------------------ bool MaildirMessage::parseHeaders(void) const { MaildirMessageCache &cache = MaildirMessageCache::getInstance(); @@ -764,7 +717,6 @@ bool MaildirMessage::parseHeaders(void) const return true; } -//------------------------------------------------------------------------ bool MaildirMessage::printBodyStructure(bool extended) const { if (!parseFull()) return false; @@ -773,7 +725,6 @@ bool MaildirMessage::printBodyStructure(bool extended) const return true; } -//------------------------------------------------------------------------ bool MaildirMessage::printEnvelope(void) const { if (!parseFull()) return false; @@ -782,7 +733,6 @@ bool MaildirMessage::printEnvelope(void) const return true; } -//------------------------------------------------------------------------ bool MaildirMessage::printHeader(const std::string §ion, std::vector<std::string> headers, bool includeHeaders, @@ -795,7 +745,6 @@ bool MaildirMessage::printHeader(const std::string §ion, return true; } -//------------------------------------------------------------------------ unsigned int MaildirMessage::getHeaderSize(const std::string §ion, std::vector<std::string> headers, bool includeHeaders, @@ -805,8 +754,9 @@ unsigned int MaildirMessage::getHeaderSize(const std::string §ion, { if (section == "") { if (!parseHeaders()) return 0; - } else if (!parseFull()) + } else if (!parseFull()) { return 0; + } const MimePart *part = doc->getPart(section, "", mime ? MimePart::FetchMime : MimePart::FetchHeader); if (!part) { @@ -823,7 +773,6 @@ unsigned int MaildirMessage::getHeaderSize(const std::string §ion, return storage.size(); } -//------------------------------------------------------------------------ bool MaildirMessage::printBody(const std::string §ion, unsigned int startOffset, unsigned int length) const @@ -833,7 +782,7 @@ bool MaildirMessage::printBody(const std::string §ion, const MimePart *part = doc->getPart(section, ""); if (!part) { storage = ""; - return 0; + return false; } int fd = getFile(); @@ -844,7 +793,6 @@ bool MaildirMessage::printBody(const std::string §ion, return true; } -//------------------------------------------------------------------------ unsigned int MaildirMessage::getBodySize(const std::string §ion, unsigned int startOffset, unsigned int length) const @@ -863,7 +811,6 @@ unsigned int MaildirMessage::getBodySize(const std::string §ion, return s < length ? s : length; } -//------------------------------------------------------------------------ bool MaildirMessage::printDoc(unsigned int startOffset, unsigned int length, bool onlyText) const { if (!parseFull()) return false; @@ -878,7 +825,6 @@ bool MaildirMessage::printDoc(unsigned int startOffset, unsigned int length, boo return true; } -//------------------------------------------------------------------------ unsigned int MaildirMessage::getDocSize(unsigned int startOffset, unsigned int length, bool onlyText) const @@ -894,7 +840,6 @@ unsigned int MaildirMessage::getDocSize(unsigned int startOffset, return s < length ? s : length; } -//------------------------------------------------------------------------ bool MaildirMessage::headerContains(const std::string &header, const std::string &text) { if (!parseHeaders()) return false; @@ -909,7 +854,6 @@ bool MaildirMessage::headerContains(const std::string &header, const std::string return (tmp.find(tmp2) != string::npos); } -//------------------------------------------------------------------------ bool MaildirMessage::bodyContains(const std::string &text) { if (!parseFull()) return false; @@ -944,7 +888,6 @@ bool MaildirMessage::bodyContains(const std::string &text) return false; } -//------------------------------------------------------------------------ bool MaildirMessage::textContains(const std::string &text) { // search the body part of the message.. @@ -973,7 +916,6 @@ bool MaildirMessage::textContains(const std::string &text) return false; } -//------------------------------------------------------------------------ const std::string &MaildirMessage::getHeader(const std::string &header) { static string NIL = ""; @@ -986,23 +928,19 @@ const std::string &MaildirMessage::getHeader(const std::string &header) return hitem.getValue(); } -//------------------------------------------------------------------------ MaildirMessageCache::MaildirMessageCache(void) {} -//------------------------------------------------------------------------ MaildirMessageCache::~MaildirMessageCache(void) { clear(); } -//------------------------------------------------------------------------ MaildirMessageCache &MaildirMessageCache::getInstance(void) { static MaildirMessageCache cache; return cache; } -//------------------------------------------------------------------------ void MaildirMessageCache::addStatus(const MaildirMessage *m, ParseStatus s) { if (statuses.find(m) == statuses.end()) { @@ -1019,7 +957,6 @@ void MaildirMessageCache::addStatus(const MaildirMessage *m, ParseStatus s) statuses[m] = s; } -//------------------------------------------------------------------------ MaildirMessageCache::ParseStatus MaildirMessageCache::getStatus(const MaildirMessage *m) const { if (statuses.find(m) == statuses.end()) return NotParsed; @@ -1027,24 +964,19 @@ MaildirMessageCache::ParseStatus MaildirMessageCache::getStatus(const MaildirMes return statuses[m]; } -//------------------------------------------------------------------------ void MaildirMessageCache::clear(void) { - for (deque<const MaildirMessage *>::iterator i = parsed.begin(); i != parsed.end(); ++i) - const_cast<MaildirMessage *>(*i)->close(); - + for (std::deque<const MaildirMessage *>::iterator i = parsed.begin(); i != parsed.end(); ++i) parsed.clear(); - statuses.clear(); } -//------------------------------------------------------------------------ void MaildirMessageCache::removeStatus(const MaildirMessage *m) { if (statuses.find(m) == statuses.end()) return; statuses.erase(statuses.find(m)); - for (deque<const MaildirMessage *>::iterator i = parsed.begin(); i != parsed.end(); ++i) { + for (std::deque<const MaildirMessage *>::iterator i = parsed.begin(); i != parsed.end(); ++i) { if (*i == m) { const_cast<MaildirMessage *>(*i)->close(); parsed.erase(i); @@ -1053,25 +985,21 @@ void MaildirMessageCache::removeStatus(const MaildirMessage *m) } } -//------------------------------------------------------------------------ void MaildirMessage::setInternalFlag(unsigned char f) { internalFlags |= f; } -//------------------------------------------------------------------------ unsigned char MaildirMessage::getInternalFlags(void) const { return internalFlags; } -//------------------------------------------------------------------------ void MaildirMessage::clearInternalFlag(unsigned char f) { internalFlags &= ~f; } -//------------------------------------------------------------------------ void MaildirMessage::setCustomFlag(const string &flag) { if (!customFlags) { @@ -1079,15 +1007,13 @@ void MaildirMessage::setCustomFlag(const string &flag) customFlags = new vector<string>; } - for (vector<string>::const_iterator it = customFlags->begin(); it != customFlags->end(); ++it) { - if (*it == flag) return; - } + for (const auto &it : *customFlags) + if (it == flag) return; internalFlags |= FlagsChanged | CustomFlagsChanged; customFlags->push_back(flag); } -//------------------------------------------------------------------------ void MaildirMessage::removeCustomFlag(const string &flag) { internalFlags |= FlagsChanged | CustomFlagsChanged; @@ -1102,16 +1028,14 @@ void MaildirMessage::removeCustomFlag(const string &flag) } } -//------------------------------------------------------------------------ void MaildirMessage::resetCustomFlags(void) { internalFlags |= FlagsChanged | CustomFlagsChanged; delete customFlags; - customFlags = 0; + customFlags = nullptr; } -//------------------------------------------------------------------------ vector<string> MaildirMessage::getCustomFlags(void) const { if (!customFlags) return vector<string>(); diff --git a/src/mime-getpart.cc b/src/mime-getpart.cc index 02a1ec5..42f6c60 100644 --- a/src/mime-getpart.cc +++ b/src/mime-getpart.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-getpart.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "mime.h" @@ -18,32 +19,27 @@ #include <stdio.h> #include <string.h> -using namespace ::std; - -//------------------------------------------------------------------------ -const Binc::MimePart *Binc::MimePart::getPart(const string &findpart, - string genpart, +const Binc::MimePart *Binc::MimePart::getPart(const std::string &findpart, + std::string genpart, FetchType fetchType) const { if (findpart == genpart) return this; if (isMultipart()) { if (members.size() != 0) { - vector<MimePart>::const_iterator i = members.begin(); int part = 1; - while (i != members.end()) { + for (const auto &i : members) { BincStream ss; ss << genpart; if (genpart != "") ss << "."; ss << part; const MimePart *m; - if ((m = (*i).getPart(findpart, ss.str())) != 0) { + if ((m = i.getPart(findpart, ss.str())) != nullptr) { if (fetchType == FetchHeader && m->isMessageRFC822()) m = &m->members[0]; return m; } - ++i; ++part; } } @@ -52,7 +48,7 @@ const Binc::MimePart *Binc::MimePart::getPart(const string &findpart, const MimePart *m = members[0].getPart(findpart, genpart); return m; } else { - return 0; + return nullptr; } } else { // Singlepart @@ -62,5 +58,5 @@ const Binc::MimePart *Binc::MimePart::getPart(const string &findpart, if (findpart == genpart) return this; } - return 0; + return nullptr; } diff --git a/src/mime-parsefull.cc b/src/mime-parsefull.cc index 50d3157..5d5d836 100644 --- a/src/mime-parsefull.cc +++ b/src/mime-parsefull.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-parsefull.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "mime-inputsource.h" #include "mime-utils.h" @@ -20,11 +21,11 @@ #include <stdio.h> #include <string.h> -Binc::MimeInputSource *mimeSource = 0; +Binc::MimeInputSource *mimeSource = nullptr; -using namespace ::std; +using std::string; +using std::vector; -//------------------------------------------------------------------------ void Binc::MimeDocument::parseFull(int fd) const { if (allIsParsed) return; @@ -58,7 +59,6 @@ void Binc::MimeDocument::parseFull(int fd) const size = mimeSource->getOffset(); } -//------------------------------------------------------------------------ static bool parseOneHeaderLine(Binc::Header *header, unsigned int *nlines) { using namespace ::Binc; @@ -139,14 +139,12 @@ static bool parseOneHeaderLine(Binc::Header *header, unsigned int *nlines) return !(eof || endOfHeaders); } -//------------------------------------------------------------------------ static void parseHeader(Binc::Header *header, unsigned int *nlines) { while (parseOneHeaderLine(header, nlines)) { } } -//------------------------------------------------------------------------ static void analyzeHeader(Binc::Header *header, bool *multipart, bool *messagerfc822, @@ -211,7 +209,7 @@ static void parseMessageRFC822(vector<Binc::MimePart> *members, unsigned int *nbodylines, const string &toboundary) { - using namespace ::Binc; + using namespace Binc; // message rfc822 means a completely enclosed mime document. we // call the parser recursively, and pass on the boundary string @@ -230,11 +228,10 @@ static void parseMessageRFC822(vector<Binc::MimePart> *members, *bodylength = mimeSource->getOffset(); if (*bodylength >= bodystartoffsetcrlf) { *bodylength -= bodystartoffsetcrlf; - if (*bodylength >= (unsigned int)bsize) { + if (*bodylength >= (unsigned int)bsize) *bodylength -= (unsigned int)bsize; - } else { + else *bodylength = 0; - } } else { *bodylength = 0; } @@ -247,7 +244,7 @@ static void parseMessageRFC822(vector<Binc::MimePart> *members, static bool skipUntilBoundary(const string &delimiter, unsigned int *nlines, bool *eof) { int endpos = delimiter.length(); - char *delimiterqueue = 0; + char *delimiterqueue = nullptr; int delimiterpos = 0; const char *delimiterStr = delimiter.c_str(); if (delimiter != "") { @@ -282,7 +279,7 @@ static bool skipUntilBoundary(const string &delimiter, unsigned int *nlines, boo } delete[] delimiterqueue; - delimiterqueue = 0; + delimiterqueue = nullptr; return foundBoundary; } @@ -338,9 +335,9 @@ static void parseMultipart(const string &boundary, // This exception is to handle a special case where the // delimiter of one part is not followed by CRLF, but // immediately followed by a CRLF prefixed delimiter. - if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b)) + if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b)) { *eof = true; - else if (a == '-' && b == '-') { + } else if (a == '-' && b == '-') { mimeSource->ungetChar(); mimeSource->ungetChar(); mimeSource->ungetChar(); @@ -415,9 +412,9 @@ static void parseMultipart(const string &boundary, // This exception is to handle a special case where the // delimiter of one part is not followed by CRLF, but // immediately followed by a CRLF prefixed delimiter. - if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b)) + if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b)) { *eof = true; - else if (a == '-' && b == '-') { + } else if (a == '-' && b == '-') { mimeSource->ungetChar(); mimeSource->ungetChar(); mimeSource->ungetChar(); @@ -439,11 +436,10 @@ static void parseMultipart(const string &boundary, *bodylength = mimeSource->getOffset(); if (*bodylength >= bodystartoffsetcrlf) { *bodylength -= bodystartoffsetcrlf; - if (*bodylength >= (unsigned int)*boundarysize) { + if (*bodylength >= (unsigned int)*boundarysize) *bodylength -= (unsigned int)*boundarysize; - } else { + else *bodylength = 0; - } } else { *bodylength = 0; } @@ -471,7 +467,7 @@ static void parseSinglePart(const string &toboundary, // if (skipUntilBoundary(_toboundary, nlines, eof)) // *boundarysize = _toboundary.length(); - char *boundaryqueue = 0; + char *boundaryqueue = nullptr; int endpos = _toboundary.length(); if (toboundary != "") { boundaryqueue = new char[endpos]; @@ -525,9 +521,9 @@ static void parseSinglePart(const string &toboundary, // This exception is to handle a special case where the // delimiter of one part is not followed by CRLF, but // immediately followed by a CRLF prefixed delimiter. - if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b)) + if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b)) { *eof = true; - else if (a == '-' && b == '-') { + } else if (a == '-' && b == '-') { mimeSource->ungetChar(); mimeSource->ungetChar(); mimeSource->ungetChar(); @@ -548,17 +544,15 @@ static void parseSinglePart(const string &toboundary, *bodylength = mimeSource->getOffset(); if (*bodylength >= bodystartoffsetcrlf) { *bodylength -= bodystartoffsetcrlf; - if (*bodylength >= (unsigned int)*boundarysize) { + if (*bodylength >= (unsigned int)*boundarysize) *bodylength -= (unsigned int)*boundarysize; - } else { + else *bodylength = 0; - } } else { *bodylength = 0; } } -//------------------------------------------------------------------------ int Binc::MimePart::parseFull(const string &toboundary, int &boundarysize) const { headerstartoffsetcrlf = mimeSource->getOffset(); diff --git a/src/mime-parseonlyheader.cc b/src/mime-parseonlyheader.cc index 5245aa5..36679b2 100644 --- a/src/mime-parseonlyheader.cc +++ b/src/mime-parseonlyheader.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-parseonlyheader.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "mime-inputsource.h" #include "mime-utils.h" @@ -20,9 +21,6 @@ #include <stdio.h> #include <string.h> -using namespace ::std; - -//------------------------------------------------------------------------ void Binc::MimeDocument::parseOnlyHeader(int fd) const { if (allIsParsed || headerIsParsed) return; @@ -36,7 +34,6 @@ void Binc::MimeDocument::parseOnlyHeader(int fd) const mimeSource->reset(); } - headerstartoffsetcrlf = 0; headerlength = 0; bodystartoffsetcrlf = 0; @@ -50,11 +47,10 @@ void Binc::MimeDocument::parseOnlyHeader(int fd) const MimePart::parseOnlyHeader(""); } -//------------------------------------------------------------------------ -int Binc::MimePart::parseOnlyHeader(const string &toboundary) const +int Binc::MimePart::parseOnlyHeader(const std::string &toboundary) const { - string name; - string content; + std::string name; + std::string content; char cqueue[4]; memset(cqueue, 0, sizeof(cqueue)); diff --git a/src/mime-printbody.cc b/src/mime-printbody.cc index 0c9e0b8..0159e61 100644 --- a/src/mime-printbody.cc +++ b/src/mime-printbody.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-printbody.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "iodevice.h" #include "iofactory.h" @@ -22,9 +23,6 @@ #include <stdio.h> #include <string.h> -using namespace ::std; - -//------------------------------------------------------------------------ void Binc::MimePart::printBody(int fd, IODevice &output, unsigned int startoffset, diff --git a/src/mime-printdoc.cc b/src/mime-printdoc.cc index 37ec356..f9f86dc 100644 --- a/src/mime-printdoc.cc +++ b/src/mime-printdoc.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-printdoc.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "iodevice.h" #include "iofactory.h" @@ -22,9 +23,6 @@ #include <stdio.h> #include <string.h> -using namespace ::std; - -//------------------------------------------------------------------------ void Binc::MimePart::printDoc(int fd, IODevice &output, unsigned int startoffset, diff --git a/src/mime-printheader.cc b/src/mime-printheader.cc index 9fb168e..34f1b99 100644 --- a/src/mime-printheader.cc +++ b/src/mime-printheader.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime-printheader.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "iodevice.h" #include "iofactory.h" @@ -22,9 +23,9 @@ #include <stdio.h> #include <string.h> -using namespace ::std; +using std::string; +using std::vector; -//------------------------------------------------------------------------ void Binc::MimePart::printHeader(int fd, IODevice &output, vector<string> headers, @@ -116,8 +117,7 @@ void Binc::MimePart::printHeader(int fd, trim(lowername, ": \t"); bool foundMatch = false; - for (vector<string>::const_iterator i = headers.begin(); i != headers.end(); ++i) { - string nametmp = *i; + for (auto nametmp : headers) { lowercase(nametmp); if (nametmp == lowername) { foundMatch = true; @@ -127,14 +127,16 @@ void Binc::MimePart::printHeader(int fd, if (foundMatch == includeheaders || headers.size() == 0) { string out = name + content; - for (string::const_iterator i = out.begin(); i != out.end(); ++i) + for (char i : out) { if (processedbytes >= startoffset && wrotebytes < length) { if (processedbytes >= startoffset) { - store += *i; + store += i; ++wrotebytes; } - } else + } else { ++processedbytes; + } + } } // move on to the next header @@ -151,8 +153,7 @@ void Binc::MimePart::printHeader(int fd, lowercase(lowername); trim(lowername, ": \t"); bool foundMatch = false; - for (vector<string>::const_iterator i = headers.begin(); i != headers.end(); ++i) { - string nametmp = *i; + for (auto nametmp : headers) { lowercase(nametmp); if (nametmp == lowername) { foundMatch = true; @@ -162,12 +163,14 @@ void Binc::MimePart::printHeader(int fd, if (hasHeaderSeparator || foundMatch == includeheaders || headers.size() == 0) { string out = name + content; - for (string::const_iterator i = out.begin(); i != out.end(); ++i) + for (char i : out) { if (processedbytes >= startoffset && wrotebytes < length) { - store += *i; + store += i; ++wrotebytes; - } else + } else { ++processedbytes; + } + } } } } diff --git a/src/mime.cc b/src/mime.cc index fa2e2ea..6a4817e 100644 --- a/src/mime.cc +++ b/src/mime.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file mime.cc * @brief Implementation of main mime parser components * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "mime.h" #include "convert.h" @@ -19,19 +20,16 @@ #include <stdio.h> #include <string.h> -using namespace ::std; +using std::string; -//------------------------------------------------------------------------ Binc::MimeDocument::MimeDocument(void) : MimePart() { allIsParsed = false; headerIsParsed = false; } -//------------------------------------------------------------------------ Binc::MimeDocument::~MimeDocument(void) {} -//------------------------------------------------------------------------ void Binc::MimeDocument::clear(void) const { members.clear(); @@ -40,14 +38,12 @@ void Binc::MimeDocument::clear(void) const allIsParsed = false; } -//------------------------------------------------------------------------ void Binc::MimePart::clear(void) const { members.clear(); h.clear(); } -//------------------------------------------------------------------------ Binc::MimePart::MimePart(void) { size = 0; @@ -58,50 +54,43 @@ Binc::MimePart::MimePart(void) nbodylines = 0; } -//------------------------------------------------------------------------ Binc::MimePart::~MimePart(void) {} -//------------------------------------------------------------------------ Binc::HeaderItem::HeaderItem(void) {} -//------------------------------------------------------------------------ Binc::HeaderItem::HeaderItem(const string &key, const string &value) { this->key = key; this->value = value; } -//------------------------------------------------------------------------ Binc::Header::Header(void) {} -//------------------------------------------------------------------------ Binc::Header::~Header(void) {} -//------------------------------------------------------------------------ bool Binc::Header::getFirstHeader(const string &key, HeaderItem &dest) const { string k = key; lowercase(k); - for (vector<HeaderItem>::const_iterator i = content.begin(); i != content.end(); ++i) { - string tmp = (*i).getKey(); + for (const auto &i : content) { + string tmp = i.getKey(); lowercase(tmp); if (tmp == k) { - dest = *i; + dest = i; return true; } } return false; } -//------------------------------------------------------------------------ -bool Binc::Header::getAllHeaders(const string &key, vector<HeaderItem> &dest) const +bool Binc::Header::getAllHeaders(const string &key, std::vector<HeaderItem> &dest) const { string k = key; lowercase(k); - for (vector<HeaderItem>::const_iterator i = content.begin(); i != content.end(); ++i) { + for (std::vector<HeaderItem>::const_iterator i = content.begin(); i != content.end(); ++i) { string tmp = (*i).getKey(); lowercase(tmp); if (tmp == k) dest.push_back(*i); @@ -110,13 +99,11 @@ bool Binc::Header::getAllHeaders(const string &key, vector<HeaderItem> &dest) co return (dest.size() != 0); } -//------------------------------------------------------------------------ void Binc::Header::clear(void) const { content.clear(); } -//------------------------------------------------------------------------ void Binc::Header::add(const string &key, const string &value) { content.push_back(HeaderItem(key, value)); diff --git a/src/multilogdevice.cc b/src/multilogdevice.cc index 7452432..cf7c412 100644 --- a/src/multilogdevice.cc +++ b/src/multilogdevice.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file multilogdevice.cc * @brief Implementation of the MultilogDevice class * @author Andreas Aardal Hanssen * @date 2003/2023 - * --------------------------------------------------------------- **/ + */ + #include "multilogdevice.h" #include <string> @@ -15,22 +16,17 @@ #include <sys/types.h> #include <unistd.h> -using namespace ::std; -using namespace ::Binc; +using namespace Binc; -//------------------------------------------------------------------------ MultilogDevice::MultilogDevice(int f) : IODevice(f) {} -//------------------------------------------------------------------------ MultilogDevice::~MultilogDevice(void) {} -//------------------------------------------------------------------------ -string MultilogDevice::service(void) const +std::string MultilogDevice::service(void) const { return "log"; } -//------------------------------------------------------------------------ bool MultilogDevice::waitForWrite(void) const { fd_set writeMask; @@ -41,18 +37,16 @@ bool MultilogDevice::waitForWrite(void) const tv.tv_sec = getTimeout(); tv.tv_usec = 0; - int result = select(fileno(stderr) + 1, 0, &writeMask, 0, tv.tv_sec ? &tv : 0); + int result = select(fileno(stderr) + 1, nullptr, &writeMask, nullptr, tv.tv_sec ? &tv : nullptr); return result > 0; } -//------------------------------------------------------------------------ bool MultilogDevice::waitForRead(void) const { return false; } -//------------------------------------------------------------------------ IODevice::WriteResult MultilogDevice::write(void) { for (;;) { @@ -75,7 +69,6 @@ IODevice::WriteResult MultilogDevice::write(void) } } -//------------------------------------------------------------------------ bool MultilogDevice::fillInputBuffer(void) { return false; diff --git a/src/operator-append.cc b/src/operator-append.cc index f4eaaa9..cf40fdf 100644 --- a/src/operator-append.cc +++ b/src/operator-append.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-append.cc * @brief Implementation of the APPEND command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "iodevice.h" #include "iofactory.h" @@ -18,37 +19,32 @@ #include <fcntl.h> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- AppendOperator::AppendOperator(void) {} -//---------------------------------------------------------------------- AppendOperator::~AppendOperator(void) {} -//---------------------------------------------------------------------- const string AppendOperator::getName(void) const { return "APPEND"; } -//---------------------------------------------------------------------- int AppendOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult AppendOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); const string &srcmailbox = command.getMailbox(); const string &canonmailbox = toCanonMailbox(srcmailbox); - Mailbox *mailbox = 0; + Mailbox *mailbox = nullptr; - if ((mailbox = depot.get(canonmailbox)) == 0) { + if ((mailbox = depot.get(canonmailbox)) == nullptr) { session.setResponseCode("TRYCREATE"); session.setLastError("invalid destination mailbox " + toImapString(srcmailbox)); return NO; @@ -56,7 +52,7 @@ Operator::ProcessResult AppendOperator::process(Depot &depot, Request &command) // mask all passed flags together unsigned int newflags = (unsigned int)Message::F_NONE; - vector<string>::const_iterator f_i = command.flags.begin(); + std::vector<string>::const_iterator f_i = command.flags.begin(); while (f_i != command.flags.end()) { if (*f_i == "\\Deleted") newflags |= Message::F_DELETED; if (*f_i == "\\Answered") newflags |= Message::F_ANSWERED; @@ -150,7 +146,7 @@ Operator::ProcessResult AppendOperator::process(Depot &depot, Request &command) return BAD; } - nr += (char)c; + nr += c; } int nchars = atoi(nr.c_str()); @@ -173,8 +169,8 @@ Operator::ProcessResult AppendOperator::process(Depot &depot, Request &command) return BAD; } - time_t newtime = (command.getDate() != "") ? mktime(&mytm) : time(0); - if (newtime == -1) newtime = time(0); + time_t newtime = (command.getDate() != "") ? mktime(&mytm) : time(nullptr); + if (newtime == -1) newtime = time(nullptr); Message *dest = mailbox->createMessage(depot.mailboxToFilename(canonmailbox), newtime); if (!dest) { session.setLastError(mailbox->getLastError()); @@ -182,7 +178,7 @@ Operator::ProcessResult AppendOperator::process(Depot &depot, Request &command) } if (!literalPlus) { - bincClient << "+ go ahead with " << nchars << " characters" << endl; + bincClient << "+ go ahead with " << nchars << " characters" << std::endl; bincClient.flush(); } @@ -248,7 +244,6 @@ Operator::ProcessResult AppendOperator::process(Depot &depot, Request &command) return OK; } -//---------------------------------------------------------------------- Operator::ParseResult AppendOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -275,7 +270,7 @@ Operator::ParseResult AppendOperator::parse(Request &c_in) const } if ((res = expectThisString("(")) == ACCEPT) { - if ((res = expectFlag(c_in.getFlags())) == ACCEPT) + if ((res = expectFlag(c_in.getFlags())) == ACCEPT) { while (1) { if ((res = expectSPACE()) != ACCEPT) break; if ((res = expectFlag(c_in.getFlags())) != ACCEPT) { @@ -283,6 +278,7 @@ Operator::ParseResult AppendOperator::parse(Request &c_in) const return res; } } + } if ((res = expectThisString(")")) != ACCEPT) { session.setLastError("expected a ')'"); @@ -296,11 +292,12 @@ Operator::ParseResult AppendOperator::parse(Request &c_in) const } string date; - if ((res = expectDateTime(date)) == ACCEPT) + if ((res = expectDateTime(date)) == ACCEPT) { if ((res = expectSPACE()) != ACCEPT) { session.setLastError("expected a SPACE after date_time"); return res; } + } c_in.setDate(date); c_in.setName("APPEND"); diff --git a/src/operator-authenticate.cc b/src/operator-authenticate.cc index 7802c47..2cb9ced 100644 --- a/src/operator-authenticate.cc +++ b/src/operator-authenticate.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-authenticate.cc * @brief Implementation of the AUTHENTICATE command, incl. CRAM-MD5. * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #include "authenticate.h" #include "base64.h" #include "convert.h" @@ -18,28 +19,24 @@ #include <cstring> #include <string> -using namespace ::std; using namespace Binc; +using std::endl; +using std::string; -//---------------------------------------------------------------------- AuthenticateOperator::AuthenticateOperator(void) {} -//---------------------------------------------------------------------- AuthenticateOperator::~AuthenticateOperator(void) {} -//---------------------------------------------------------------------- const string AuthenticateOperator::getName(void) const { return "AUTHENTICATE"; } -//---------------------------------------------------------------------- int AuthenticateOperator::getState(void) const { return Session::NONAUTHENTICATED; } -//------------------------------------------------------------------------ Operator::ProcessResult AuthenticateOperator::Login(string &username, string &password) { Session &session = Session::getInstance(); @@ -90,7 +87,6 @@ Operator::ProcessResult AuthenticateOperator::Login(string &username, string &pa return OK; } -//------------------------------------------------------------------------ Operator::ProcessResult AuthenticateOperator::Plain(string &username, string &password) { Session &session = Session::getInstance(); @@ -139,14 +135,13 @@ Operator::ProcessResult AuthenticateOperator::Plain(string &username, string &pa return OK; } -//------------------------------------------------------------------------ Operator::ProcessResult AuthenticateOperator::Cram(string &username, string &password, string &challenge) { Session &session = Session::getInstance(); // generate challenge first: <pid.time@fqdn> and deploy it to authenticator time_t timer; - struct tm y2k = {0}; + struct tm y2k = {}; int timestamp; y2k.tm_hour = 0; y2k.tm_min = 0; @@ -159,9 +154,9 @@ Operator::ProcessResult AuthenticateOperator::Cram(string &username, string &pas timestamp = difftime(timer, mktime(&y2k)); challenge += "<"; - challenge += to_string(session.getPid()); + challenge += std::to_string(session.getPid()); challenge += "."; - challenge += to_string(timestamp); + challenge += std::to_string(timestamp); challenge += "@"; challenge += session.getEnv("TCPLOCALHOST"); challenge += ">"; @@ -195,7 +190,6 @@ Operator::ProcessResult AuthenticateOperator::Cram(string &username, string &pas return OK; } -//------------------------------------------------------------------------ Operator::ProcessResult AuthenticateOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -231,7 +225,6 @@ Operator::ProcessResult AuthenticateOperator::process(Depot &depot, Request &com // this type can be used even over unencrypted connections if ((r = Cram(username, password, challenge)) != OK) return r; - } else { // Any other disallowed session.setLastError("The authentication method " + toImapString(authtype) + " is not supported. " @@ -281,7 +274,6 @@ Operator::ProcessResult AuthenticateOperator::process(Depot &depot, Request &com return NOTHING; } -//---------------------------------------------------------------------- Operator::ParseResult AuthenticateOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-capability.cc b/src/operator-capability.cc index 73f5a26..6be3e79 100644 --- a/src/operator-capability.cc +++ b/src/operator-capability.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file bincimapd-capability.cc * @brief Implementation of the CAPABILITY command * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "globals.h" #include "iodevice.h" @@ -14,34 +15,28 @@ #include <string> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- CapabilityOperator::CapabilityOperator(void) {} -//---------------------------------------------------------------------- CapabilityOperator::~CapabilityOperator(void) {} -//---------------------------------------------------------------------- const string CapabilityOperator::getName(void) const { return "CAPABILITY"; } -//---------------------------------------------------------------------- int CapabilityOperator::getState(void) const { return Session::NONAUTHENTICATED | Session::AUTHENTICATED | Session::SELECTED; } -//---------------------------------------------------------------------- void CapabilityOperator::addCapability(const string &cap) { capabilities.push_back(cap); } -//---------------------------------------------------------------------- Operator::ProcessResult CapabilityOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -49,34 +44,34 @@ Operator::ProcessResult CapabilityOperator::process(Depot &depot, Request &comma bincClient << "* CAPABILITY " << IMAP_VERSION; if (session.getState() == Session::NONAUTHENTICATED) { - if (getenv("UCSPITLS")) + if (getenv("UCSPITLS")) { if (!session.command.ssl) bincClient << " STARTTLS"; + } const string authmethods = session.getEnv("BINCIMAP_LOGIN"); auto cram = authmethods.find("+CRAM-MD5"); - if (session.command.ssl || session.hasEnv("ALLOW_NONSSL_PLAINTEXT_LOGINS")) { + if (session.command.ssl || session.hasEnv("ALLOW_NONSSL_PLAINTEXT_LOGINS")) if (cram != string::npos) bincClient << " AUTH=LOGIN AUTH=PLAIN AUTH=CRAM-MD5"; else bincClient << " AUTH=LOGIN AUTH=PLAIN"; - } else + else bincClient << " LOGINDISABLED"; } bincClient << " IDLE LITERAL+ NAMESPACE CHILDREN"; - vector<string>::const_iterator i = capabilities.begin(); + std::vector<string>::const_iterator i = capabilities.begin(); while (i != capabilities.end()) { bincClient << " " << *i; ++i; } - bincClient << endl; + bincClient << std::endl; return OK; } -//---------------------------------------------------------------------- Operator::ParseResult CapabilityOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-check.cc b/src/operator-check.cc index 045f8b0..110ce9c 100644 --- a/src/operator-check.cc +++ b/src/operator-check.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-check.cc * @author Implementation of the CHECK command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "mailbox.h" #include "operators.h" @@ -13,40 +14,34 @@ #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- CheckOperator::CheckOperator(void) {} -//---------------------------------------------------------------------- CheckOperator::~CheckOperator(void) {} -//---------------------------------------------------------------------- -const string CheckOperator::getName(void) const +const std::string CheckOperator::getName(void) const { return "CHECK"; } -//---------------------------------------------------------------------- int CheckOperator::getState(void) const { return Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult CheckOperator::process(Depot &depot, Request &command) { Mailbox *mailbox = depot.getSelected(); - if (mailbox != 0) + if (mailbox != nullptr) { pendingUpdates(mailbox, PendingUpdates::FLAGS | PendingUpdates::EXISTS | PendingUpdates::RECENT, true); + } return OK; } -//---------------------------------------------------------------------- Operator::ParseResult CheckOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-close.cc b/src/operator-close.cc index 686f668..2727e25 100644 --- a/src/operator-close.cc +++ b/src/operator-close.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-close.cc * @brief Implementation of the CLOSE command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "mailbox.h" #include "operators.h" @@ -12,28 +13,22 @@ #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- CloseOperator::CloseOperator(void) {} -//---------------------------------------------------------------------- CloseOperator::~CloseOperator(void) {} -//------------------------------------------------------------------------ -const string CloseOperator::getName(void) const +const std::string CloseOperator::getName(void) const { return "CLOSE"; } -//------------------------------------------------------------------------ int CloseOperator::getState(void) const { return Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult CloseOperator::process(Depot &depot, Request &command) { Mailbox *mailbox = depot.getSelected(); @@ -47,7 +42,6 @@ Operator::ProcessResult CloseOperator::process(Depot &depot, Request &command) return OK; } -//---------------------------------------------------------------------- Operator::ParseResult CloseOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-copy.cc b/src/operator-copy.cc index 50afe77..77e1b9d 100644 --- a/src/operator-copy.cc +++ b/src/operator-copy.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-copy.cc * @brief Implementation of the COPY command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "iodevice.h" @@ -15,28 +16,23 @@ #include <string> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- CopyOperator::CopyOperator(void) {} -//---------------------------------------------------------------------- CopyOperator::~CopyOperator(void) {} -//---------------------------------------------------------------------- const string CopyOperator::getName(void) const { return "COPY"; } -//---------------------------------------------------------------------- int CopyOperator::getState(void) const { return Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult CopyOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -47,7 +43,7 @@ Operator::ProcessResult CopyOperator::process(Depot &depot, Request &command) // Get the destination mailbox string dmailbox = command.getMailbox(); Mailbox *destMailbox = depot.get(toCanonMailbox(dmailbox)); - if (destMailbox == 0) { + if (destMailbox == nullptr) { session.setResponseCode("TRYCREATE"); session.setLastError("invalid mailbox " + toImapString(dmailbox)); return NO; @@ -84,14 +80,14 @@ Operator::ProcessResult CopyOperator::process(Depot &depot, Request &command) do { int readSize = source.readChunk(chunk); - if (readSize == 0) + if (readSize == 0) { break; - else if (readSize == -1) { + } else if (readSize == -1) { bincWarning << "when reading from message " << i.getSqnr() << "/" << source.getUID() << " in \"" - << srcMailbox->getName() << "\": " << source.getLastError() << endl; + << srcMailbox->getName() << "\": " << source.getLastError() << std::endl; success = false; } else if (!dest->appendChunk(chunk)) { - bincWarning << "when writing to \"" << dmailbox << "\": " << dest->getLastError() << endl; + bincWarning << "when writing to \"" << dmailbox << "\": " << dest->getLastError() << std::endl; success = false; } } while (success); @@ -104,21 +100,22 @@ Operator::ProcessResult CopyOperator::process(Depot &depot, Request &command) return NO; } - if (success) + if (success) { if (!destMailbox->commitNewMessages(depot.mailboxToFilename(toCanonMailbox(dmailbox)))) { session.setLastError("Failed to commit after successful copy: " + destMailbox->getLastError()); return NO; } + } - if (!success) + if (!success) { session.setLastError("The transaction was unrolled. Please " "contant your system administrator for " "more information."); + } return success ? OK : NO; } -//------------------------------------------------------------------------ Operator::ParseResult CopyOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-create.cc b/src/operator-create.cc index 83c5e1d..22fd37e 100644 --- a/src/operator-create.cc +++ b/src/operator-create.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file bincimapd-create.cc * @brief Implementation of the CREATE command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "imapparser.h" @@ -14,40 +15,33 @@ #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- CreateOperator::CreateOperator(void) {} -//---------------------------------------------------------------------- CreateOperator::~CreateOperator(void) {} -//---------------------------------------------------------------------- -const string CreateOperator::getName(void) const +const std::string CreateOperator::getName(void) const { return "CREATE"; } -//---------------------------------------------------------------------- int CreateOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult CreateOperator::process(Depot &depot, Request &command) { - if (depot.createMailbox(command.getMailbox())) + if (depot.createMailbox(command.getMailbox())) { return OK; - else { + } else { Session &session = Session::getInstance(); session.setLastError(depot.getLastError()); return NO; } } -//---------------------------------------------------------------------- Operator::ParseResult CreateOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -60,7 +54,7 @@ Operator::ParseResult CreateOperator::parse(Request &c_in) const return res; } - string mailbox; + std::string mailbox; if ((res = expectMailbox(mailbox)) != ACCEPT) { session.setLastError("Expected mailbox after CREATE SPACE"); return res; diff --git a/src/operator-delete.cc b/src/operator-delete.cc index 350e572..00d7ecb 100644 --- a/src/operator-delete.cc +++ b/src/operator-delete.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-delete.cc * @briefe Implementation of the DELETE command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "imapparser.h" @@ -14,40 +15,33 @@ #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- DeleteOperator::DeleteOperator(void) {} -//---------------------------------------------------------------------- DeleteOperator::~DeleteOperator(void) {} -//---------------------------------------------------------------------- -const string DeleteOperator::getName(void) const +const std::string DeleteOperator::getName(void) const { return "DELETE"; } -//---------------------------------------------------------------------- int DeleteOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult DeleteOperator::process(Depot &depot, Request &command) { - if (depot.deleteMailbox(command.getMailbox())) + if (depot.deleteMailbox(command.getMailbox())) { return OK; - else { + } else { Session &session = Session::getInstance(); session.setLastError(depot.getLastError()); return NO; } } -//---------------------------------------------------------------------- Operator::ParseResult DeleteOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -60,7 +54,7 @@ Operator::ParseResult DeleteOperator::parse(Request &c_in) const return res; } - string mailbox; + std::string mailbox; if ((res = expectMailbox(mailbox)) != ACCEPT) { session.setLastError("Expected mailbox after DELETE SPACE"); return res; diff --git a/src/operator-examine.cc b/src/operator-examine.cc index 9f64ce6..ceb1ec6 100644 --- a/src/operator-examine.cc +++ b/src/operator-examine.cc @@ -1,22 +1,19 @@ -/** -------------------------------------------------------------------- +/** * @file operator-examine.cc * @brief Implementation of the EXAMINE command * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "operators.h" -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- const std::string ExamineOperator::getName(void) const { return "EXAMINE"; } -//---------------------------------------------------------------------- ExamineOperator::ExamineOperator(void) {} -//---------------------------------------------------------------------- ExamineOperator::~ExamineOperator(void) {} diff --git a/src/operator-expunge.cc b/src/operator-expunge.cc index 03fd655..2416417 100644 --- a/src/operator-expunge.cc +++ b/src/operator-expunge.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-expunge.cc * @brief Implementation of the EXPUNGE command * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "imapparser.h" #include "mailbox.h" @@ -14,28 +15,22 @@ #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- ExpungeOperator::ExpungeOperator(void) {} -//---------------------------------------------------------------------- ExpungeOperator::~ExpungeOperator(void) {} -//---------------------------------------------------------------------- -const string ExpungeOperator::getName(void) const +const std::string ExpungeOperator::getName(void) const { return "EXPUNGE"; } -//---------------------------------------------------------------------- int ExpungeOperator::getState(void) const { return Session::SELECTED; } -//---------------------------------------------------------------------- Operator::ProcessResult ExpungeOperator::process(Depot &depot, Request &command) { Mailbox *mailbox = depot.getSelected(); @@ -49,7 +44,6 @@ Operator::ProcessResult ExpungeOperator::process(Depot &depot, Request &command) return OK; } -//---------------------------------------------------------------------- Operator::ParseResult ExpungeOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-fetch.cc b/src/operator-fetch.cc index 8b33d79..4fcdf1a 100644 --- a/src/operator-fetch.cc +++ b/src/operator-fetch.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-fetch.cc * @brief Implementation of the FETCH command * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "imapparser.h" @@ -17,8 +18,9 @@ #include <string> -using namespace ::std; using namespace Binc; +using std::string; +using std::vector; namespace { void outputFlags(const Message &message) @@ -35,13 +37,13 @@ namespace { if (flags & Message::F_RECENT) flagv.push_back("\\Recent"); if (flags & Message::F_FLAGGED) flagv.push_back("\\Flagged"); - for (vector<string>::const_iterator k = flagv.begin(); k != flagv.end(); ++k) { + for (auto k = flagv.begin(); k != flagv.end(); ++k) { if (k != flagv.begin()) bincClient << " "; bincClient << *k; } vector<string> customFlags = message.getCustomFlags(); - for (vector<string>::const_iterator it = customFlags.begin(); it != customFlags.end(); ++it) { + for (auto it = customFlags.begin(); it != customFlags.end(); ++it) { if (flagv.size() > 0 || it != customFlags.begin()) bincClient << " "; bincClient << *it; } @@ -51,25 +53,20 @@ namespace { } -//---------------------------------------------------------------------- FetchOperator::FetchOperator(void) {} -//---------------------------------------------------------------------- FetchOperator::~FetchOperator(void) {} -//---------------------------------------------------------------------- const string FetchOperator::getName(void) const { return "FETCH"; } -//---------------------------------------------------------------------- int FetchOperator::getState(void) const { return Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) { Session &session = Session::getInstance(); @@ -130,9 +127,10 @@ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) else mode = Mailbox::SQNR_MODE; - Mailbox::iterator i = mailbox->begin(req.bset, Mailbox::SKIP_EXPUNGED | mode); - - for (; i != mailbox->end(); ++i) { + for (Mailbox::iterator i = mailbox->begin(req.bset, Mailbox::SKIP_EXPUNGED | mode); + i != mailbox->end(); + ++i) + { Message &message = *i; bincClient << "* " << i.getSqnr() << " FETCH ("; @@ -186,8 +184,9 @@ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) if (strftime(internal, sizeof(internal), "%d-%b-%Y %H:%M:%S %z", _tm) != 0) { if (internal[0] == '0') internal[0] = ' '; iDateStr = internal; - } else + } else { iDateStr = "NIL"; + } bincClient << toImapString(iDateStr); } else if (fatt.type == "BODY" || fatt.type == "BODY.PEEK") { @@ -220,8 +219,9 @@ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) v.push_back("content-transfer-encoding"); v.push_back("content-disposition"); v.push_back("content-description"); - } else + } else { v = fatt.headerlist; + } string dummy; unsigned int size = fullheader ? message.getHeaderSize(fatt.section, @@ -270,8 +270,9 @@ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) } // set the \Seen flag if .PEEK is not used. - if (!peek) + if (!peek) { if ((message.getStdFlags() & Message::F_SEEN) == 0) message.setStdFlag(Message::F_SEEN); + } } else if (fatt.type == "RFC822") { bincClient << prefix; hasprinted = true; @@ -330,13 +331,13 @@ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) // FIXME: how are parse error passed back? - bincClient << ")" << endl; + bincClient << ")" << std::endl; if (message.hasFlagsChanged()) { updateFlags = true; bincClient << "* " << i.getSqnr() << " FETCH ("; outputFlags(message); - bincClient << ")" << endl; + bincClient << ")" << std::endl; message.setFlagsUnchanged(); } } @@ -351,7 +352,6 @@ Operator::ProcessResult FetchOperator::process(Depot &depot, Request &request) return OK; } -//---------------------------------------------------------------------- Operator::ParseResult FetchOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -419,7 +419,6 @@ Operator::ParseResult FetchOperator::parse(Request &c_in) const return ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult FetchOperator::expectSectionText(BincImapParserFetchAtt &f_in) const { Session &session = Session::getInstance(); @@ -443,15 +442,15 @@ Operator::ParseResult FetchOperator::expectSectionText(BincImapParserFetchAtt &f return res; } } - } else if ((res = expectThisString("TEXT")) == ACCEPT) + } else if ((res = expectThisString("TEXT")) == ACCEPT) { f_in.sectiontext = "TEXT"; - else + } else { return REJECT; + } return ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult FetchOperator::expectSection(BincImapParserFetchAtt &f_in) const { Session &session = Session::getInstance(); @@ -500,7 +499,6 @@ Operator::ParseResult FetchOperator::expectSection(BincImapParserFetchAtt &f_in) return ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult FetchOperator::expectHeaderList(BincImapParserFetchAtt &f_in) const { Session &session = Session::getInstance(); @@ -531,7 +529,6 @@ Operator::ParseResult FetchOperator::expectHeaderList(BincImapParserFetchAtt &f_ return ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult FetchOperator::expectOffset(BincImapParserFetchAtt &f_in) const { Session &session = Session::getInstance(); @@ -566,30 +563,29 @@ Operator::ParseResult FetchOperator::expectOffset(BincImapParserFetchAtt &f_in) return ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult FetchOperator::expectFetchAtt(BincImapParserFetchAtt &f_in) const { Operator::ParseResult res; Session &session = Session::getInstance(); - if ((res = expectThisString("ENVELOPE")) == ACCEPT) + if ((res = expectThisString("ENVELOPE")) == ACCEPT) { f_in.type = "ENVELOPE"; - else if ((res = expectThisString("FLAGS")) == ACCEPT) + } else if ((res = expectThisString("FLAGS")) == ACCEPT) { f_in.type = "FLAGS"; - else if ((res = expectThisString("INTERNALDATE")) == ACCEPT) + } else if ((res = expectThisString("INTERNALDATE")) == ACCEPT) { f_in.type = "INTERNALDATE"; - else if ((res = expectThisString("UID")) == ACCEPT) + } else if ((res = expectThisString("UID")) == ACCEPT) { f_in.type = "UID"; - else if ((res = expectThisString("RFC822")) == ACCEPT) { + } else if ((res = expectThisString("RFC822")) == ACCEPT) { f_in.type = "RFC822"; - if ((res = expectThisString(".HEADER")) == ACCEPT) + if ((res = expectThisString(".HEADER")) == ACCEPT) { f_in.type += ".HEADER"; - else if ((res = expectThisString(".SIZE")) == ACCEPT) + } else if ((res = expectThisString(".SIZE")) == ACCEPT) { f_in.type += ".SIZE"; - else if ((res = expectThisString(".TEXT")) == ACCEPT) + } else if ((res = expectThisString(".TEXT")) == ACCEPT) { f_in.type += ".TEXT"; - else if ((res = expectThisString(".")) == ACCEPT) { + } else if ((res = expectThisString(".")) == ACCEPT) { session.setLastError("Expected RFC822, RFC822.HEADER," " RFC822.SIZE or RFC822.TEXT"); return ERROR; @@ -603,14 +599,15 @@ Operator::ParseResult FetchOperator::expectFetchAtt(BincImapParserFetchAtt &f_in else if ((res = expectThisString(".PEEK")) == ACCEPT) f_in.type += ".PEEK"; - if ((res = expectSection(f_in)) != ACCEPT) + if ((res = expectSection(f_in)) != ACCEPT) { f_in.hassection = false; - else { + } else { f_in.hassection = true; if ((res = expectOffset(f_in)) == ERROR) return ERROR; } - } else + } else { return REJECT; + } return ACCEPT; } diff --git a/src/operator-id.cc b/src/operator-id.cc index de74909..3a6fd49 100644 --- a/src/operator-id.cc +++ b/src/operator-id.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-id.cc * @brief Operator for the ID extension. Described in RFC2971 Oct 2000. * @author Erwin Hoffmann * @date 22.09.2023 - * ------------------------------------------------------------------ **/ + */ + #include "depot.h" #include "globals.h" #include "iodevice.h" @@ -15,37 +16,30 @@ #include <iostream> #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- IdOperator::IdOperator(void) {} -//---------------------------------------------------------------------- IdOperator::~IdOperator(void) {} -//---------------------------------------------------------------------- -const string IdOperator::getName(void) const +const std::string IdOperator::getName(void) const { return "ID"; } -//---------------------------------------------------------------------- int IdOperator::getState(void) const { return Session::NONAUTHENTICATED | Session::AUTHENTICATED | Session::SELECTED; } -//---------------------------------------------------------------------- Operator::ProcessResult IdOperator::process(Depot &depot, Request &command) { bincClient << "* ID (\"name\" \"Binc IMAP\"" - << " \"version\" \"" << BINC_VERSION "\")" << endl; + << " \"version\" \"" << BINC_VERSION "\")" << std::endl; return OK; } -//---------------------------------------------------------------------- Operator::ParseResult IdOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-idle.cc b/src/operator-idle.cc index 369bcd9..ff95dbf 100644 --- a/src/operator-idle.cc +++ b/src/operator-idle.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-idle.cc * @brief Operator for the IDLE command. Described in RFC2177 / June 1997. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "convert.h" #include "depot.h" #include "globals.h" @@ -36,8 +37,8 @@ void fnotifyEventHandler(int sig) } #endif -using namespace ::std; using namespace Binc; +using std::endl; // Seconds between each poll. With FNOTIFY support, we can idle for 30 // minutes before timing out. @@ -47,29 +48,24 @@ static const int POLLTIMEOUT = 30 * 60; static const int POLLTIMEOUT = 30; #endif -//---------------------------------------------------------------------- IdleOperator::IdleOperator(void) {} -//---------------------------------------------------------------------- IdleOperator::~IdleOperator(void) {} -//---------------------------------------------------------------------- -const string IdleOperator::getName(void) const +const std::string IdleOperator::getName(void) const { return "IDLE"; } -//---------------------------------------------------------------------- int IdleOperator::getState(void) const { return Session::SELECTED; } -//---------------------------------------------------------------------- Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) { Mailbox *mailbox = depot.getSelected(); - string mailboxDir = depot.mailboxToFilename(mailbox->getName()); + std::string mailboxDir = depot.mailboxToFilename(mailbox->getName()); #ifdef HAVE_FNOTIFY // Check for FNOTIFY support. @@ -93,7 +89,7 @@ Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) #endif // when not using FNOTIFY, we need to check the session timeout. - time_t startTime = time(0); + time_t startTime = time(nullptr); #ifdef HAVE_FNOTIFY (void)startTime; // removes a compile warning #endif @@ -110,9 +106,9 @@ Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) // check for data from stdin. with FNOTIFY enabled, this select // will be interrupted by the notification signal. - string input; + std::string input; struct timeval tv = {POLLTIMEOUT, 0}; - int ret = select(maxfd + 1, &readfds, 0, 0, &tv); + int ret = select(maxfd + 1, &readfds, nullptr, nullptr, &tv); // check if the select timed out. if (ret == 0) { @@ -126,7 +122,7 @@ Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) return NOTHING; } else #endif - if (time(0) > startTime + IDLE_TIMEOUT) + if (time(nullptr) > startTime + IDLE_TIMEOUT) { bincClient << "* BYE Timeout after " << IDLE_TIMEOUT << " seconds of inactivity." << endl; session.setState(Session::LOGOUT); @@ -136,7 +132,7 @@ Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) // unless the select failed, attempt to read client input. if (ret > 0 && FD_ISSET(0, &readfds)) { - if (bincClient.readStr(&input) == 0) { + if (bincClient.readStr(&input) == false) { break; } else { uppercase(input); @@ -170,11 +166,10 @@ Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) } // scan for changes in the mailbox and report to the client. - if (pendingUpdates(mailbox, - PendingUpdates::EXPUNGE | PendingUpdates::EXISTS | PendingUpdates::RECENT - | PendingUpdates::FLAGS, - true) - == false) + if (!pendingUpdates(mailbox, + PendingUpdates::EXPUNGE | PendingUpdates::EXISTS | PendingUpdates::RECENT + | PendingUpdates::FLAGS, + true)) { Session &session = Session::getInstance(); bincClient << "* NO " << session.getLastError() << endl; @@ -217,7 +212,6 @@ Operator::ProcessResult IdleOperator::process(Depot &depot, Request &command) return OK; } -//---------------------------------------------------------------------- Operator::ParseResult IdleOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-list.cc b/src/operator-list.cc index 7ee66f3..b304e08 100644 --- a/src/operator-list.cc +++ b/src/operator-list.cc @@ -1,7 +1,8 @@ -/** -------------------------------------------------------------------- +/** * @file operator-list.cc * @brief Implementation of the LIST command. - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "iodevice.h" @@ -19,35 +20,30 @@ #include <sys/stat.h> #include <sys/types.h> -using namespace ::std; using namespace Binc; +using std::string; namespace { const time_t LIST_CACHE_TIMEOUT = 10; } -//---------------------------------------------------------------------- ListOperator::ListOperator(void) { cacheTimeout = 0; } -//---------------------------------------------------------------------- ListOperator::~ListOperator(void) {} -//---------------------------------------------------------------------- const string ListOperator::getName(void) const { return "LIST"; } -//---------------------------------------------------------------------- int ListOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult ListOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -57,7 +53,7 @@ Operator::ProcessResult ListOperator::process(Depot &depot, Request &command) // hard coded reply. string wildcard; if ((wildcard = command.getListMailbox()) == "") { - bincClient << "* LIST (\\Noselect) \"" << delim << "\" \"\"" << endl; + bincClient << "* LIST (\\Noselect) \"" << delim << "\" \"\"" << std::endl; return OK; } @@ -78,30 +74,32 @@ Operator::ProcessResult ListOperator::process(Depot &depot, Request &command) if (wildcardLower.substr(0, 6) == "^inbox") ref = "^[iI][nN][bB][oO][xX]" + ref.substr(6); if (wildcardLower.substr(0, 5) == "inbox" && (wildcardLower.length() == 5 || wildcardLower[5] == delim)) + { ref = "INBOX" + ref.substr(5); + } // a map from mailbox name to flags - map<string, unsigned int> mailboxes; + std::map<string, unsigned int> mailboxes; - if (cacheTimeout == 0 || cacheTimeout < time(0) - LIST_CACHE_TIMEOUT || session.mailboxchanges) { + if (cacheTimeout == 0 || cacheTimeout < time(nullptr) - LIST_CACHE_TIMEOUT || session.mailboxchanges) { session.mailboxchanges = false; // read through all entries in depository. for (Depot::iterator i = depot.begin("."); i != depot.end(); ++i) { const string path = *i; const string mpath = depot.filenameToMailbox(path); - Mailbox *m = 0; + Mailbox *m = nullptr; // skip entries that are not identified as mailboxes - if ((m = depot.get(mpath)) == 0) continue; + if ((m = depot.get(mpath)) == nullptr) continue; // convert file name to mailbox name. skip it if there is no // corresponding mailbox name. string tmp = toCanonMailbox(depot.filenameToMailbox(path)); trim(tmp, string(&delim, 1)); - if (tmp == "") + if (tmp == "") { continue; - else { + } else { // inherit flags that were already set for this mailbox. int flags = DIR_SELECT; if (m->isMarked(path)) flags |= DIR_MARKED; @@ -123,14 +121,13 @@ Operator::ProcessResult ListOperator::process(Depot &depot, Request &command) } // find leaf nodes O(N^2) - map<string, unsigned int>::iterator i; - for (i = mailboxes.begin(); i != mailboxes.end(); ++i) { + for (auto i = mailboxes.begin(); i != mailboxes.end(); ++i) { string mailbox = i->first; mailbox += delim; bool leaf = true; - map<string, unsigned int>::const_iterator j = mailboxes.begin(); - for (; j != mailboxes.end(); ++j) { + + for (auto j = mailboxes.begin(); j != mailboxes.end(); ++j) { string::size_type pos = j->first.rfind(delim); if (pos == string::npos) continue; @@ -150,17 +147,15 @@ Operator::ProcessResult ListOperator::process(Depot &depot, Request &command) } cache = mailboxes; - cacheTimeout = time(0); + cacheTimeout = time(nullptr); } else { mailboxes = cache; - cacheTimeout = time(0); + cacheTimeout = time(nullptr); } // finally, print all mailbox entries with flags. - map<string, unsigned int>::iterator i = mailboxes.begin(); - - for (; i != mailboxes.end(); ++i) { - if (ref == "" || (ref.length() <= i->first.length() && ref == i->first.substr(0, ref.length()))) + for (auto i = mailboxes.begin(); i != mailboxes.end(); ++i) { + if (ref == "" || (ref.length() <= i->first.length() && ref == i->first.substr(0, ref.length()))) { if (regexMatch(i->first.substr(ref.length()), regex) == 0) { bincClient << "* LIST ("; string sep = ""; @@ -190,14 +185,14 @@ Operator::ProcessResult ListOperator::process(Depot &depot, Request &command) if (flags & DIR_NOINFERIORS) bincClient << sep << "\\Noinferiors"; - bincClient << ") \"" << depot.getDelimiter() << "\" " << toImapString(i->first) << endl; + bincClient << ") \"" << depot.getDelimiter() << "\" " << toImapString(i->first) << std::endl; } + } } return OK; } -//---------------------------------------------------------------------- Operator::ParseResult ListOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-login.cc b/src/operator-login.cc index 7b7ffc2..cacafbb 100644 --- a/src/operator-login.cc +++ b/src/operator-login.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-login.cc * @brief Implementation of the rapid LOGIN command * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #include "authenticate.h" #include "depot.h" #include "globals.h" @@ -22,28 +23,22 @@ #include <sys/types.h> #include <unistd.h> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- LoginOperator::LoginOperator(void) {} -//---------------------------------------------------------------------- LoginOperator::~LoginOperator(void) {} -//---------------------------------------------------------------------- -const string LoginOperator::getName(void) const +const std::string LoginOperator::getName(void) const { return "LOGIN"; } -//---------------------------------------------------------------------- int LoginOperator::getState(void) const { return Session::NONAUTHENTICATED; } -//------------------------------------------------------------------------ Operator::ProcessResult LoginOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -55,7 +50,7 @@ Operator::ProcessResult LoginOperator::process(Depot &depot, Request &command) } session.setEnv("BINCIMAP_LOGIN", "LOGIN+" + command.getTag()); - string challenge; + std::string challenge; switch (authenticate(depot, command.getUserID(), command.getPassword(), challenge)) { case 1: @@ -70,12 +65,12 @@ Operator::ProcessResult LoginOperator::process(Depot &depot, Request &command) "your system administrator."); return NO; case 3: - bincClient << "* BYE Timeout after " << IDLE_TIMEOUT << " seconds of inactivity." << endl; + bincClient << "* BYE Timeout after " << IDLE_TIMEOUT << " seconds of inactivity." << std::endl; break; case -1: bincClient << "* BYE The server died unexpectedly. Please contact " "your system administrator for more information." - << endl; + << std::endl; break; } @@ -85,7 +80,6 @@ Operator::ProcessResult LoginOperator::process(Depot &depot, Request &command) return NOTHING; } -//---------------------------------------------------------------------- Operator::ParseResult LoginOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -98,7 +92,7 @@ Operator::ParseResult LoginOperator::parse(Request &c_in) const return res; } - string userid; + std::string userid; if ((res = expectAstring(userid)) != ACCEPT) { session.setLastError("Expected userid after LOGIN SPACE"); return res; @@ -110,7 +104,7 @@ Operator::ParseResult LoginOperator::parse(Request &c_in) const return res; } - string password; + std::string password; if ((res = expectAstring(password)) != ACCEPT) { session.setLastError("Expected password after LOGIN " "SPACE userid SPACE"); diff --git a/src/operator-logout.cc b/src/operator-logout.cc index aabffdf..67458f3 100644 --- a/src/operator-logout.cc +++ b/src/operator-logout.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-logout.cc * @brief Implementation of the LOGOUT command * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "iodevice.h" @@ -16,32 +17,26 @@ #include <iostream> #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- LogoutOperator::LogoutOperator(void) {} -//---------------------------------------------------------------------- LogoutOperator::~LogoutOperator(void) {} -//---------------------------------------------------------------------- -const string LogoutOperator::getName(void) const +const std::string LogoutOperator::getName(void) const { return "LOGOUT"; } -//---------------------------------------------------------------------- int LogoutOperator::getState(void) const { return Session::NONAUTHENTICATED | Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult LogoutOperator::process(Depot &depot, Request &command) { - bincClient << "* BYE Binc IMAP shutting down" << endl; - bincClient << command.getTag() << " OK LOGOUT completed" << endl; + bincClient << "* BYE Binc IMAP shutting down" << std::endl; + bincClient << command.getTag() << " OK LOGOUT completed" << std::endl; bincClient.flush(); #ifdef BINCIMAPD @@ -58,7 +53,6 @@ Operator::ProcessResult LogoutOperator::process(Depot &depot, Request &command) return NOTHING; } -//---------------------------------------------------------------------- Operator::ParseResult LogoutOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-lsub.cc b/src/operator-lsub.cc index e2bd07d..35c4d7d 100644 --- a/src/operator-lsub.cc +++ b/src/operator-lsub.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-lsub.cc * @brief Implementation of the LSUB command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "iodevice.h" @@ -26,28 +27,24 @@ namespace { const int DIR_LEAF = 0x08; } -using namespace ::std; using namespace Binc; +using std::multimap; +using std::string; -//---------------------------------------------------------------------- LsubOperator::LsubOperator(void) {} -//---------------------------------------------------------------------- LsubOperator::~LsubOperator(void) {} -//---------------------------------------------------------------------- const string LsubOperator::getName(void) const { return "LSUB"; } -//---------------------------------------------------------------------- int LsubOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult LsubOperator::process(Depot &depot, Request &command) { const char delim = depot.getDelimiter(); @@ -69,27 +66,29 @@ Operator::ProcessResult LsubOperator::process(Depot &depot, Request &command) lowercase(wildcardLower); if (wildcardLower.substr(0, 5) == "inbox" && (wildcardLower.length() == 5 || wildcardLower[5] == delim)) + { ref = "INBOX" + ref.substr(5); + } // a multimap from mailbox name to flags multimap<string, int> mailboxes; // read through all entries in depository. - for (Depot::iterator i = depot.begin("."); i != depot.end(); ++i) { + for (auto i = depot.begin("."); i != depot.end(); ++i) { const string path = *i; const string mpath = depot.filenameToMailbox(path); - Mailbox *m = 0; + Mailbox *m = nullptr; // skip entries that are not identified as mailboxes - if ((m = depot.get(mpath)) == 0) continue; + if ((m = depot.get(mpath)) == nullptr) continue; // convert file name to mailbox name. skip it if there is no // corresponding mailbox name. string tmp = toCanonMailbox(depot.filenameToMailbox(path)); trim(tmp, string(&delim, 1)); - if (tmp == "") + if (tmp == "") { continue; - else { + } else { int flags = DIR_SELECT; multimap<string, int>::iterator mi = mailboxes.find(tmp); if (mi != mailboxes.end()) { @@ -139,16 +138,16 @@ Operator::ProcessResult LsubOperator::process(Depot &depot, Request &command) depot.loadSubscribes(); - vector<string> subscribed = depot.getSubscriptions(); + std::vector<string> subscribed = depot.getSubscriptions(); sort(subscribed.begin(), subscribed.end()); // finally, print all mailbox entries with flags. - for (vector<string>::const_iterator j = subscribed.begin(); j != subscribed.end(); ++j) { - if (ref == "" || (ref.length() <= (*j).length() && ref == (*j).substr(0, ref.length()))) - if (regexMatch((*j).substr(ref.length()), regex) == 0) { + for (const auto &j : subscribed) { + if (ref == "" || (ref.length() <= j.length() && ref == j.substr(0, ref.length()))) { + if (regexMatch(j.substr(ref.length()), regex) == 0) { int flags = 0; for (i = mailboxes.begin(); i != mailboxes.end(); ++i) { - if (i->first == *j) { + if (i->first == j) { flags = i->second; break; } @@ -174,14 +173,14 @@ Operator::ProcessResult LsubOperator::process(Depot &depot, Request &command) bincClient << sep << "\\HasChildren"; sep = " "; if (flags & DIR_NOINFERIORS) bincClient << sep << "\\Noinferiors"; - bincClient << ") \"" << depot.getDelimiter() << "\" " << toImapString(*j) << endl; + bincClient << ") \"" << depot.getDelimiter() << "\" " << toImapString(j) << std::endl; } + } } return OK; } -//---------------------------------------------------------------------- Operator::ParseResult LsubOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-namespace.cc b/src/operator-namespace.cc index f03f0c7..96a3ee8 100644 --- a/src/operator-namespace.cc +++ b/src/operator-namespace.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-namespace.cc * @brief Operator for the NAMESPACE command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "iodevice.h" #include "iofactory.h" @@ -14,28 +15,22 @@ #include <iostream> #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- NamespaceOperator::NamespaceOperator(void) {} -//---------------------------------------------------------------------- NamespaceOperator::~NamespaceOperator(void) {} -//---------------------------------------------------------------------- -const string NamespaceOperator::getName(void) const +const std::string NamespaceOperator::getName(void) const { return "NAMESPACE"; } -//---------------------------------------------------------------------- int NamespaceOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//---------------------------------------------------------------------- Operator::ProcessResult NamespaceOperator::process(Depot &depot, Request &command) { bincClient << "* NAMESPACE "; @@ -44,17 +39,16 @@ Operator::ProcessResult NamespaceOperator::process(Depot &depot, Request &comman bincClient << toImapString(depot.getPersonalNamespace()); bincClient << " "; char c = depot.getDelimiter(); - bincClient << toImapString(string(&c, 1)); + bincClient << toImapString(std::string(&c, 1)); bincClient << "))"; bincClient << " NIL"; // others' namespaces bincClient << " NIL"; // shared namespaces - bincClient << endl; + bincClient << std::endl; return OK; } -//---------------------------------------------------------------------- Operator::ParseResult NamespaceOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-noop-pending.cc b/src/operator-noop-pending.cc index 96b255a..b13fdc1 100644 --- a/src/operator-noop-pending.cc +++ b/src/operator-noop-pending.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-noop-pending.cc * @brief Operator for the NOOP command, with pending extension * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "mailbox.h" #include "operators.h" @@ -14,16 +15,12 @@ #include <iostream> #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- NoopPendingOperator::NoopPendingOperator(void) : NoopOperator() {} -//---------------------------------------------------------------------- NoopPendingOperator::~NoopPendingOperator(void) {} -//---------------------------------------------------------------------- Operator::ProcessResult NoopPendingOperator::process(Depot &depot, Request &command) { Mailbox *mailbox = depot.getSelected(); diff --git a/src/operator-noop.cc b/src/operator-noop.cc index a32214f..bc73a10 100644 --- a/src/operator-noop.cc +++ b/src/operator-noop.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-noop.cc * @brief Operator for the NOOP command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "depot.h" #include "operators.h" #include "recursivedescent.h" @@ -12,34 +13,27 @@ #include <iostream> #include <string> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- NoopOperator::NoopOperator(void) {} -//---------------------------------------------------------------------- NoopOperator::~NoopOperator(void) {} -//---------------------------------------------------------------------- -const string NoopOperator::getName(void) const +const std::string NoopOperator::getName(void) const { return "NOOP"; } -//---------------------------------------------------------------------- int NoopOperator::getState(void) const { return Session::NONAUTHENTICATED | Session::AUTHENTICATED | Session::SELECTED; } -//---------------------------------------------------------------------- Operator::ProcessResult NoopOperator::process(Depot &depot, Request &command) { return OK; } -//---------------------------------------------------------------------- Operator::ParseResult NoopOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-rename.cc b/src/operator-rename.cc index bfbe226..1d3a69a 100644 --- a/src/operator-rename.cc +++ b/src/operator-rename.cc @@ -1,7 +1,8 @@ -/** -------------------------------------------------------------------- +/** * @file operator-rename.cc * @brief Implementation of the RENAME command. - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "mailbox.h" @@ -16,28 +17,23 @@ #include <sys/stat.h> #include <sys/types.h> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- RenameOperator::RenameOperator(void) {} -//---------------------------------------------------------------------- RenameOperator::~RenameOperator(void) {} -//---------------------------------------------------------------------- const string RenameOperator::getName(void) const { return "RENAME"; } -//---------------------------------------------------------------------- int RenameOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult RenameOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -66,7 +62,6 @@ Operator::ProcessResult RenameOperator::process(Depot &depot, Request &command) return NO; } -//---------------------------------------------------------------------- Operator::ParseResult RenameOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-search.cc b/src/operator-search.cc index 08f51c1..aca9f1f 100644 --- a/src/operator-search.cc +++ b/src/operator-search.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-search.cc * @brief Implementation of the SEARCH command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "imapparser.h" @@ -21,10 +22,11 @@ #include <ctype.h> -using namespace ::std; using namespace Binc; +using std::endl; +using std::string; +using std::vector; -//---------------------------------------------------------------------- bool SearchOperator::SearchNode::convertDate(const string &date, time_t &t, const string &delim) { vector<string> parts; @@ -32,7 +34,7 @@ bool SearchOperator::SearchNode::convertDate(const string &date, time_t &t, cons if (parts.size() < 3) return false; struct tm mold; - memset((char *)&mold, 0, sizeof(struct tm)); + memset(&mold, 0, sizeof(struct tm)); mold.tm_mday = atoi(parts[0].c_str()); mold.tm_year = atoi(parts[2].c_str()) - 1900; @@ -70,7 +72,6 @@ bool SearchOperator::SearchNode::convertDate(const string &date, time_t &t, cons return true; } -//---------------------------------------------------------------------- bool SearchOperator::SearchNode::convertDateHeader(const string &d_in, time_t &t) { string date = d_in; @@ -82,22 +83,18 @@ bool SearchOperator::SearchNode::convertDateHeader(const string &d_in, time_t &t return result; } -//---------------------------------------------------------------------- SearchOperator::SearchNode::SearchNode(void) {} -//---------------------------------------------------------------------- SearchOperator::SearchNode::SearchNode(const BincImapParserSearchKey &a) { init(a); } -//---------------------------------------------------------------------- int SearchOperator::SearchNode::getType(void) const { return type; } -//---------------------------------------------------------------------- bool SearchOperator::SearchNode::match(Mailbox *mailbox, Message *m, unsigned int seqnr, @@ -108,16 +105,12 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, string tmp; switch (type) { - //-------------------------------------------------------------------- case S_ALL: return true; - //-------------------------------------------------------------------- case S_ANSWERED: return (m->getStdFlags() & Message::F_ANSWERED); - //-------------------------------------------------------------------- case S_BCC: return m->headerContains("bcc", astring); - //-------------------------------------------------------------------- case S_BEFORE: { time_t mtime = m->getInternalDate(); struct tm *mtime_ = localtime(&mtime); @@ -136,32 +129,24 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, } return mtime < atime; - } //-------------------------------------------------------------------- + } case S_BODY: return m->bodyContains(astring); - //-------------------------------------------------------------------- case S_CC: return m->headerContains("cc", astring); - //-------------------------------------------------------------------- case S_DELETED: return (m->getStdFlags() & Message::F_DELETED); - //-------------------------------------------------------------------- case S_FLAGGED: return (m->getStdFlags() & Message::F_FLAGGED); - //-------------------------------------------------------------------- case S_FROM: return m->headerContains("from", astring); - //-------------------------------------------------------------------- case S_KEYWORD: // the server does not support keywords return false; - //-------------------------------------------------------------------- case S_NEW: return (m->getStdFlags() & Message::F_RECENT) && !(m->getStdFlags() & Message::F_SEEN); - //-------------------------------------------------------------------- case S_OLD: return !(m->getStdFlags() & Message::F_RECENT); - //-------------------------------------------------------------------- case S_ON: { time_t mtime = m->getInternalDate(); struct tm *mtime_ = localtime(&mtime); @@ -180,13 +165,11 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, } return mtime == atime; - } //-------------------------------------------------------------------- + } case S_RECENT: return (m->getStdFlags() & Message::F_RECENT); - //-------------------------------------------------------------------- case S_SEEN: return (m->getStdFlags() & Message::F_SEEN); - //-------------------------------------------------------------------- case S_SINCE: { time_t mtime = m->getInternalDate(); struct tm *mtime_ = localtime(&mtime); @@ -205,52 +188,39 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, } return mtime >= atime; - } //-------------------------------------------------------------------- + } case S_SUBJECT: return m->headerContains("subject", astring); - //-------------------------------------------------------------------- case S_TEXT: return m->textContains(astring); - //-------------------------------------------------------------------- case S_TO: return m->headerContains("to", astring); - //-------------------------------------------------------------------- case S_UNANSWERED: return !(m->getStdFlags() & Message::F_ANSWERED); - //-------------------------------------------------------------------- case S_UNDELETED: return !(m->getStdFlags() & Message::F_DELETED); - //-------------------------------------------------------------------- case S_UNFLAGGED: return !(m->getStdFlags() & Message::F_FLAGGED); - //-------------------------------------------------------------------- case S_UNKEYWORD: // the server does not support keywords return true; - //-------------------------------------------------------------------- case S_UNSEEN: return !(m->getStdFlags() & Message::F_SEEN); - //-------------------------------------------------------------------- case S_DRAFT: return (m->getStdFlags() & Message::F_DRAFT); - //-------------------------------------------------------------------- case S_HEADER: return m->headerContains(astring, bstring); - //-------------------------------------------------------------------- case S_LARGER: { return (m->getSize(true) > number); } - //-------------------------------------------------------------------- case S_NOT: - for (vector<SearchNode>::const_iterator i = children.begin(); i != children.end(); ++i) - if ((*i).match(mailbox, m, seqnr, lastmessage, lastuid)) return false; + for (const auto &i : children) + if (i.match(mailbox, m, seqnr, lastmessage, lastuid)) return false; return true; - //-------------------------------------------------------------------- case S_OR: - for (vector<SearchNode>::const_iterator i = children.begin(); i != children.end(); ++i) - if ((*i).match(mailbox, m, seqnr, lastmessage, lastuid)) return true; + for (const auto &i : children) + if (i.match(mailbox, m, seqnr, lastmessage, lastuid)) return true; return false; - //-------------------------------------------------------------------- case S_SENTBEFORE: { string tmp = m->getHeader("date"); if (tmp == "") return false; @@ -269,7 +239,7 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, } return mtime < atime; - } //-------------------------------------------------------------------- + } case S_SENTON: { string tmp = m->getHeader("date"); if (tmp == "") return false; @@ -288,7 +258,7 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, } return mtime == atime; - } //-------------------------------------------------------------------- + } case S_SENTSINCE: { string tmp = m->getHeader("date"); if (tmp == "") return false; @@ -307,33 +277,30 @@ bool SearchOperator::SearchNode::match(Mailbox *mailbox, } return mtime >= atime; - } //-------------------------------------------------------------------- + } case S_SMALLER: return (m->getSize(true) < number); - //-------------------------------------------------------------------- case S_UID: - if (!bset->isInSet(m->getUID())) + if (!bset->isInSet(m->getUID())) { if (!(m->getUID() == lastuid && !bset->isLimited())) return false; + } return true; - //-------------------------------------------------------------------- case S_UNDRAFT: return !(m->getStdFlags() & Message::F_DRAFT); - //-------------------------------------------------------------------- case S_SET: - if (!bset->isInSet(seqnr)) + if (!bset->isInSet(seqnr)) { if (!(seqnr == lastmessage && !bset->isLimited())) return false; + } return true; - //-------------------------------------------------------------------- case S_AND: - for (vector<SearchNode>::const_iterator i = children.begin(); i != children.end(); ++i) - if (!(*i).match(mailbox, m, seqnr, lastmessage, lastuid)) return false; + for (const auto &i : children) + if (!i.match(mailbox, m, seqnr, lastmessage, lastuid)) return false; return true; } return false; } -//---------------------------------------------------------------------- void SearchOperator::SearchNode::init(const BincImapParserSearchKey &a) { astring = a.astring; @@ -490,45 +457,37 @@ void SearchOperator::SearchNode::init(const BincImapParserSearchKey &a) } } -//---------------------------------------------------------------------- int SearchOperator::SearchNode::getWeight(void) const { return weight; } -//---------------------------------------------------------------------- void SearchOperator::SearchNode::setWeight(int i) { weight = i; } -//---------------------------------------------------------------------- void SearchOperator::SearchNode::order(void) { - for (vector<SearchNode>::iterator i = children.begin(); i != children.end(); ++i) - (*i).order(); - ::stable_sort(children.begin(), children.end(), compareNodes); + for (auto &i : children) + i.order(); + stable_sort(children.begin(), children.end(), compareNodes); } -//---------------------------------------------------------------------- SearchOperator::SearchOperator(void) {} -//---------------------------------------------------------------------- SearchOperator::~SearchOperator(void) {} -//---------------------------------------------------------------------- const string SearchOperator::getName(void) const { return "SEARCH"; } -//---------------------------------------------------------------------- int SearchOperator::getState(void) const { return Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult SearchOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -566,7 +525,6 @@ Operator::ProcessResult SearchOperator::process(Depot &depot, Request &command) return OK; } -//------------------------------------------------------------------------ Operator::ParseResult SearchOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -627,18 +585,17 @@ Operator::ParseResult SearchOperator::parse(Request &c_in) const return ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s_in) const { Session &session = Session::getInstance(); Operator::ParseResult res; s_in.type = BincImapParserSearchKey::KEY_OTHER; - if ((res = expectThisString("ALL")) == ACCEPT) + if ((res = expectThisString("ALL")) == ACCEPT) { s_in.name = "ALL"; - else if ((res = expectThisString("ANSWERED")) == ACCEPT) + } else if ((res = expectThisString("ANSWERED")) == ACCEPT) { s_in.name = "ANSWERED"; - else if ((res = expectThisString("BCC")) == ACCEPT) { + } else if ((res = expectThisString("BCC")) == ACCEPT) { s_in.name = "BCC"; if ((res = expectSPACE()) != ACCEPT) { session.setLastError("Expected SPACE"); @@ -683,11 +640,11 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected astring"); return res; } - } else if ((res = expectThisString("DELETED")) == ACCEPT) + } else if ((res = expectThisString("DELETED")) == ACCEPT) { s_in.name = "DELETED"; - else if ((res = expectThisString("FLAGGED")) == ACCEPT) + } else if ((res = expectThisString("FLAGGED")) == ACCEPT) { s_in.name = "FLAGGED"; - else if ((res = expectThisString("FROM")) == ACCEPT) { + } else if ((res = expectThisString("FROM")) == ACCEPT) { s_in.name = "FROM"; if ((res = expectSPACE()) != ACCEPT) { session.setLastError("Expected SPACE"); @@ -709,11 +666,11 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected flag_keyword"); return res; } - } else if ((res = expectThisString("NEW")) == ACCEPT) + } else if ((res = expectThisString("NEW")) == ACCEPT) { s_in.name = "NEW"; - else if ((res = expectThisString("OLD")) == ACCEPT) + } else if ((res = expectThisString("OLD")) == ACCEPT) { s_in.name = "OLD"; - else if ((res = expectThisString("ON")) == ACCEPT) { + } else if ((res = expectThisString("ON")) == ACCEPT) { s_in.name = "ON"; if ((res = expectSPACE()) != ACCEPT) { @@ -725,11 +682,11 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected date"); return res; } - } else if ((res = expectThisString("RECENT")) == ACCEPT) + } else if ((res = expectThisString("RECENT")) == ACCEPT) { s_in.name = "RECENT"; - else if ((res = expectThisString("SEEN")) == ACCEPT) + } else if ((res = expectThisString("SEEN")) == ACCEPT) { s_in.name = "SEEN"; - else if ((res = expectThisString("SINCE")) == ACCEPT) { + } else if ((res = expectThisString("SINCE")) == ACCEPT) { s_in.name = "SINCE"; if ((res = expectSPACE()) != ACCEPT) { @@ -774,13 +731,13 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected astring"); return res; } - } else if ((res = expectThisString("UNANSWERED")) == ACCEPT) + } else if ((res = expectThisString("UNANSWERED")) == ACCEPT) { s_in.name = "UNANSWERED"; - else if ((res = expectThisString("UNDELETED")) == ACCEPT) + } else if ((res = expectThisString("UNDELETED")) == ACCEPT) { s_in.name = "UNDELETED"; - else if ((res = expectThisString("UNFLAGGED")) == ACCEPT) + } else if ((res = expectThisString("UNFLAGGED")) == ACCEPT) { s_in.name = "UNFLAGGED"; - else if ((res = expectThisString("UNKEYWORD")) == ACCEPT) { + } else if ((res = expectThisString("UNKEYWORD")) == ACCEPT) { s_in.name = "UNKEYWORD"; if ((res = expectSPACE()) != ACCEPT) { session.setLastError("Expected SPACE"); @@ -791,11 +748,11 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected flag_keyword"); return res; } - } else if ((res = expectThisString("UNSEEN")) == ACCEPT) + } else if ((res = expectThisString("UNSEEN")) == ACCEPT) { s_in.name = "UNSEEN"; - else if ((res = expectThisString("DRAFT")) == ACCEPT) + } else if ((res = expectThisString("DRAFT")) == ACCEPT) { s_in.name = "DRAFT"; - else if ((res = expectThisString("HEADER")) == ACCEPT) { + } else if ((res = expectThisString("HEADER")) == ACCEPT) { s_in.name = "HEADER"; if ((res = expectSPACE()) != ACCEPT) { @@ -929,9 +886,9 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected number"); return res; } - } else if ((res = expectThisString("UNDRAFT")) == ACCEPT) + } else if ((res = expectThisString("UNDRAFT")) == ACCEPT) { s_in.name = "UNDRAFT"; - else if ((res = expectSet(s_in.bset)) == ACCEPT) { + } else if ((res = expectSet(s_in.bset)) == ACCEPT) { s_in.name = ""; s_in.type = BincImapParserSearchKey::KEY_SET; } else if ((res = expectThisString("(")) == ACCEPT) { @@ -953,8 +910,9 @@ Operator::ParseResult SearchOperator::expectSearchKey(BincImapParserSearchKey &s session.setLastError("Expected )"); return res; } - } else + } else { return REJECT; + } return ACCEPT; } diff --git a/src/operator-select.cc b/src/operator-select.cc index 64c4be6..1b0f5a4 100644 --- a/src/operator-select.cc +++ b/src/operator-select.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-select.cc * @brief Implementation of the SELECT command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "iodevice.h" @@ -16,28 +17,24 @@ #include <string> -using namespace ::std; using namespace Binc; +using std::endl; +using std::string; -//---------------------------------------------------------------------- SelectOperator::SelectOperator(void) {} -//---------------------------------------------------------------------- SelectOperator::~SelectOperator(void) {} -//---------------------------------------------------------------------- const string SelectOperator::getName(void) const { return "SELECT"; } -//---------------------------------------------------------------------- int SelectOperator::getState(void) const { return Session::NONAUTHENTICATED | Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult SelectOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -47,14 +44,14 @@ Operator::ProcessResult SelectOperator::process(Depot &depot, Request &command) const string &canonmailbox = toCanonMailbox(srcmailbox); Mailbox *mailbox = depot.getSelected(); - if (mailbox != 0) { + if (mailbox != nullptr) { mailbox->closeMailbox(); depot.resetSelected(); - mailbox = 0; + mailbox = nullptr; } mailbox = depot.get(canonmailbox); - if (mailbox == 0) { + if (mailbox == nullptr) { session.setLastError(depot.getLastError()); return NO; } @@ -84,9 +81,10 @@ Operator::ProcessResult SelectOperator::process(Depot &depot, Request &command) pendingUpdates(mailbox, PendingUpdates::EXISTS | PendingUpdates::RECENT, false, true); // unseen - if (unseen != -1) + if (unseen != -1) { bincClient << "*" << " OK [UNSEEN " << unseen << "] Message " << unseen << " is first unseen" << endl; + } // uidvalidity bincClient << "*" @@ -113,7 +111,6 @@ Operator::ProcessResult SelectOperator::process(Depot &depot, Request &command) return OK; } -//---------------------------------------------------------------------- Operator::ParseResult SelectOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-starttls.cc b/src/operator-starttls.cc index 3ba5dd0..c127e1a 100644 --- a/src/operator-starttls.cc +++ b/src/operator-starttls.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-starttls.cc * @brief Implementation of the STARTTLS command - based on sslserver * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #include "depot.h" #include "iodevice.h" #include "iofactory.h" @@ -17,34 +18,28 @@ #include <fcntl.h> #include <unistd.h> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- StarttlsOperator::StarttlsOperator(void) {} -//---------------------------------------------------------------------- StarttlsOperator::~StarttlsOperator(void) {} -//---------------------------------------------------------------------- -const string StarttlsOperator::getName(void) const +const std::string StarttlsOperator::getName(void) const { return "STARTTLS"; } -//---------------------------------------------------------------------- int StarttlsOperator::getState(void) const { return Session::NONAUTHENTICATED | Session::AUTHENTICATED | Session::SELECTED; } -//---------------------------------------------------------------------- int StarttlsOperator::goStartTLS(void) const { Session &session = Session::getInstance(); if (getenv("UCSPITLS")) { - string fdstr; + std::string fdstr; int fd; fdstr = session.getEnv("SSLCTLFD"); @@ -70,7 +65,6 @@ int StarttlsOperator::goStartTLS(void) const return ACCEPT; } -//------------------------------------------------------------------------ Operator::ProcessResult StarttlsOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -79,8 +73,8 @@ Operator::ProcessResult StarttlsOperator::process(Depot &depot, Request &command return BAD; } - bincClient << "* ENABLED StartTLS - begin negotiation now" << endl; - bincClient << command.getTag() << " OK STARTTLS completed" << endl; + bincClient << "* ENABLED StartTLS - begin negotiation now" << std::endl; + bincClient << command.getTag() << " OK STARTTLS completed" << std::endl; if (goStartTLS() == ACCEPT) session.command.ssl = true; @@ -90,7 +84,6 @@ Operator::ProcessResult StarttlsOperator::process(Depot &depot, Request &command return NOTHING; } -//---------------------------------------------------------------------- Operator::ParseResult StarttlsOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-status.cc b/src/operator-status.cc index 82c3bcf..2422747 100644 --- a/src/operator-status.cc +++ b/src/operator-status.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-status.cc * @brief Implementation of the STATUS command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "iodevice.h" @@ -21,28 +22,22 @@ #include <sys/stat.h> #include <sys/types.h> -using namespace ::std; using namespace Binc; -//---------------------------------------------------------------------- StatusOperator::StatusOperator(void) {} -//---------------------------------------------------------------------- StatusOperator::~StatusOperator(void) {} -//---------------------------------------------------------------------- -const string StatusOperator::getName(void) const +const std::string StatusOperator::getName(void) const { return "STATUS"; } -//---------------------------------------------------------------------- int StatusOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult StatusOperator::process(Depot &depot, Request &command) { Session &session = Session::getInstance(); @@ -55,9 +50,8 @@ Operator::ProcessResult StatusOperator::process(Depot &depot, Request &command) bincClient << "* STATUS " << toImapString(command.getMailbox()) << " ("; - string prefix; - for (vector<string>::const_iterator i = command.statuses.begin(); i != command.statuses.end(); ++i) { - string tmp = *i; + std::string prefix; + for (auto tmp : command.statuses) { uppercase(tmp); if (tmp == "UIDNEXT") { bincClient << prefix << "UIDNEXT " << status.getUidNext(); @@ -76,12 +70,11 @@ Operator::ProcessResult StatusOperator::process(Depot &depot, Request &command) prefix = " "; } } - bincClient << ")" << endl; + bincClient << ")" << std::endl; return OK; } -//---------------------------------------------------------------------- Operator::ParseResult StatusOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -94,7 +87,7 @@ Operator::ParseResult StatusOperator::parse(Request &c_in) const return res; } - string mailbox; + std::string mailbox; if ((res = expectMailbox(mailbox)) != ACCEPT) { session.setLastError("Expected mailbox"); return res; @@ -113,17 +106,17 @@ Operator::ParseResult StatusOperator::parse(Request &c_in) const } while (1) { - if ((res = expectThisString("MESSAGES")) == ACCEPT) + if ((res = expectThisString("MESSAGES")) == ACCEPT) { c_in.getStatuses().push_back("MESSAGES"); - else if ((res = expectThisString("RECENT")) == ACCEPT) + } else if ((res = expectThisString("RECENT")) == ACCEPT) { c_in.getStatuses().push_back("RECENT"); - else if ((res = expectThisString("UIDNEXT")) == ACCEPT) + } else if ((res = expectThisString("UIDNEXT")) == ACCEPT) { c_in.getStatuses().push_back("UIDNEXT"); - else if ((res = expectThisString("UIDVALIDITY")) == ACCEPT) + } else if ((res = expectThisString("UIDVALIDITY")) == ACCEPT) { c_in.getStatuses().push_back("UIDVALIDITY"); - else if ((res = expectThisString("UNSEEN")) == ACCEPT) + } else if ((res = expectThisString("UNSEEN")) == ACCEPT) { c_in.getStatuses().push_back("UNSEEN"); - else { + } else { session.setLastError("Expected status_att"); return res; } diff --git a/src/operator-store.cc b/src/operator-store.cc index b6e1b99..160002a 100644 --- a/src/operator-store.cc +++ b/src/operator-store.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-store.cc * @brief Implementation of the STORE command * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "depot.h" #include "imapparser.h" #include "mailbox.h" @@ -15,28 +16,24 @@ #include <iostream> #include <string> -using namespace ::std; using namespace Binc; +using std::string; +using std::vector; -//---------------------------------------------------------------------- StoreOperator::StoreOperator(void) {} -//---------------------------------------------------------------------- StoreOperator::~StoreOperator(void) {} -//---------------------------------------------------------------------- const string StoreOperator::getName(void) const { return "STORE"; } -//---------------------------------------------------------------------- int StoreOperator::getState(void) const { return Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult StoreOperator::process(Depot &depot, Request &command) { Mailbox *mailbox = depot.getSelected(); @@ -44,22 +41,19 @@ Operator::ProcessResult StoreOperator::process(Depot &depot, Request &command) // mask all passed flags together unsigned int newflags = (unsigned int)Message::F_NONE; vector<string> newCustomFlags; - vector<string>::const_iterator f_i = command.flags.begin(); - while (f_i != command.flags.end()) { - if (*f_i == "\\Deleted") + for (const auto &f_i : command.flags) { + if (f_i == "\\Deleted") newflags |= Message::F_DELETED; - else if (*f_i == "\\Answered") + else if (f_i == "\\Answered") newflags |= Message::F_ANSWERED; - else if (*f_i == "\\Seen") + else if (f_i == "\\Seen") newflags |= Message::F_SEEN; - else if (*f_i == "\\Draft") + else if (f_i == "\\Draft") newflags |= Message::F_DRAFT; - else if (*f_i == "\\Flagged") + else if (f_i == "\\Flagged") newflags |= Message::F_FLAGGED; else - newCustomFlags.push_back(*f_i); - - ++f_i; + newCustomFlags.push_back(f_i); } // pass through all messages @@ -80,19 +74,19 @@ Operator::ProcessResult StoreOperator::process(Depot &depot, Request &command) switch (command.getMode()[0]) { case '+': flags |= newflags; - for (vector<string>::const_iterator it = newCustomFlags.begin(); it != newCustomFlags.end(); ++it) - message.setCustomFlag(*it); + for (const auto &it : newCustomFlags) + message.setCustomFlag(it); break; case '-': flags &= ~newflags; - for (vector<string>::const_iterator it = newCustomFlags.begin(); it != newCustomFlags.end(); ++it) - message.removeCustomFlag(*it); + for (const auto &it : newCustomFlags) + message.removeCustomFlag(it); break; default: flags = newflags; message.resetCustomFlags(); - for (vector<string>::const_iterator it = newCustomFlags.begin(); it != newCustomFlags.end(); ++it) - message.setCustomFlag(*it); + for (const auto &it : newCustomFlags) + message.setCustomFlag(it); break; }; @@ -106,14 +100,14 @@ Operator::ProcessResult StoreOperator::process(Depot &depot, Request &command) mailbox->updateFlags(); // check mailbox for updates, and report them - if (command.getMode().find(".SILENT") != string::npos) + if (command.getMode().find(".SILENT") != string::npos) { pendingUpdates(mailbox, PendingUpdates::EXISTS | PendingUpdates::RECENT, false, false, false, command.getUidMode()); - else + } else { pendingUpdates(mailbox, PendingUpdates::EXISTS | PendingUpdates::RECENT | PendingUpdates::EXPUNGE | PendingUpdates::FLAGS, @@ -121,11 +115,11 @@ Operator::ProcessResult StoreOperator::process(Depot &depot, Request &command) false, false, command.getUidMode()); + } return OK; } -//---------------------------------------------------------------------- Operator::ParseResult StoreOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); @@ -155,8 +149,9 @@ Operator::ParseResult StoreOperator::parse(Request &c_in) const if ((res = expectThisString("FLAGS")) != ACCEPT) { session.setLastError("Expected FLAGS"); return res; - } else + } else { mode += "FLAGS"; + } if ((res = expectThisString(".SILENT")) == ACCEPT) mode += ".SILENT"; @@ -170,7 +165,7 @@ Operator::ParseResult StoreOperator::parse(Request &c_in) const bool paren = false; if ((res = expectThisString("(")) == ACCEPT) paren = true; - if ((res = expectFlag(c_in.getFlags())) == ACCEPT) + if ((res = expectFlag(c_in.getFlags())) == ACCEPT) { while (1) { if ((res = expectSPACE()) != ACCEPT) break; @@ -179,12 +174,14 @@ Operator::ParseResult StoreOperator::parse(Request &c_in) const return res; } } + } - if (paren) + if (paren) { if ((res = expectThisString(")")) != ACCEPT) { session.setLastError("Expected )"); return res; } + } if ((res = expectCRLF()) != ACCEPT) { session.setLastError("Expected CRLF"); diff --git a/src/operator-subscribe.cc b/src/operator-subscribe.cc index 7626844..2a7ca51 100644 --- a/src/operator-subscribe.cc +++ b/src/operator-subscribe.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-subscribe.cc * @brief Implementation of the SUBSCRIBE command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "operators.h" @@ -15,28 +16,23 @@ #include <sys/stat.h> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- SubscribeOperator::SubscribeOperator(void) {} -//---------------------------------------------------------------------- SubscribeOperator::~SubscribeOperator(void) {} -//---------------------------------------------------------------------- const string SubscribeOperator::getName(void) const { return "SUBSCRIBE"; } -//---------------------------------------------------------------------- int SubscribeOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult SubscribeOperator::process(Depot &depot, Request &command) { const string &srcmailbox = command.getMailbox(); @@ -49,7 +45,6 @@ Operator::ProcessResult SubscribeOperator::process(Depot &depot, Request &comman return OK; } -//---------------------------------------------------------------------- Operator::ParseResult SubscribeOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/operator-unsubscribe.cc b/src/operator-unsubscribe.cc index ae900a8..b4a197e 100644 --- a/src/operator-unsubscribe.cc +++ b/src/operator-unsubscribe.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file operator-unsubscribe.cc * @brief Implementation of the UNSUBSCRIBE command. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "convert.h" #include "depot.h" #include "operators.h" @@ -16,28 +17,23 @@ #include <sys/stat.h> -using namespace ::std; using namespace Binc; +using std::string; -//---------------------------------------------------------------------- UnsubscribeOperator::UnsubscribeOperator(void) {} -//---------------------------------------------------------------------- UnsubscribeOperator::~UnsubscribeOperator(void) {} -//---------------------------------------------------------------------- const string UnsubscribeOperator::getName(void) const { return "UNSUBSCRIBE"; } -//---------------------------------------------------------------------- int UnsubscribeOperator::getState(void) const { return Session::AUTHENTICATED | Session::SELECTED; } -//------------------------------------------------------------------------ Operator::ProcessResult UnsubscribeOperator::process(Depot &depot, Request &command) { const string &mailbox = command.getMailbox(); @@ -55,7 +51,6 @@ Operator::ProcessResult UnsubscribeOperator::process(Depot &depot, Request &comm return OK; } -//---------------------------------------------------------------------- Operator::ParseResult UnsubscribeOperator::parse(Request &c_in) const { Session &session = Session::getInstance(); diff --git a/src/pendingupdates.cc b/src/pendingupdates.cc index 1e4af8d..bf4e0f2 100644 --- a/src/pendingupdates.cc +++ b/src/pendingupdates.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file pendingupdates.cc * @brief <---> * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "pendingupdates.h" #include "iodevice.h" @@ -16,10 +17,9 @@ #include <string> #include <vector> -using namespace ::std; +using namespace std; using namespace Binc; -//------------------------------------------------------------------------ PendingUpdates::PendingUpdates(void) : expunges(), flagupdates() { recent = 0; @@ -29,16 +29,13 @@ PendingUpdates::PendingUpdates(void) : expunges(), flagupdates() newexists = false; } -//------------------------------------------------------------------------ PendingUpdates::~PendingUpdates(void) {} -//------------------------------------------------------------------------ void PendingUpdates::addExpunged(unsigned int uid) { expunges.push_back(uid); } -//------------------------------------------------------------------------ void PendingUpdates::addFlagUpdates(unsigned int sqnr, unsigned int uid, unsigned int flags, @@ -49,92 +46,76 @@ void PendingUpdates::addFlagUpdates(unsigned int sqnr, sqnrtocflags[sqnr] = cflags; } -//------------------------------------------------------------------------ void PendingUpdates::setExists(unsigned int n) { exists = n; newexists = true; } -//------------------------------------------------------------------------ void PendingUpdates::setRecent(unsigned int n) { recent = n; newrecent = true; } -//------------------------------------------------------------------------ unsigned int PendingUpdates::getExists(void) const { return exists; } -//------------------------------------------------------------------------ unsigned int PendingUpdates::getRecent(void) const { return recent; } -//------------------------------------------------------------------------ bool PendingUpdates::newExists(void) const { return newexists; } -//------------------------------------------------------------------------ bool PendingUpdates::newRecent(void) const { return newrecent; } -//------------------------------------------------------------------------ PendingUpdates::expunged_const_iterator::expunged_const_iterator(void) {} -//------------------------------------------------------------------------ PendingUpdates::expunged_const_iterator::expunged_const_iterator(vector<unsigned int>::iterator i) : internal(i) {} -//------------------------------------------------------------------------ unsigned int PendingUpdates::expunged_const_iterator::operator*(void) const { return *internal; } -//------------------------------------------------------------------------ void PendingUpdates::expunged_const_iterator::operator++(void) { ++internal; } -//------------------------------------------------------------------------ bool PendingUpdates::expunged_const_iterator::operator==(expunged_const_iterator i) const { return internal == i.internal; } -//------------------------------------------------------------------------ bool PendingUpdates::expunged_const_iterator::operator!=(expunged_const_iterator i) const { return internal != i.internal; } -//------------------------------------------------------------------------ PendingUpdates::expunged_const_iterator PendingUpdates::beginExpunged(void) { return expunged_const_iterator(expunges.begin()); } -//------------------------------------------------------------------------ PendingUpdates::expunged_const_iterator PendingUpdates::endExpunged(void) { return expunged_const_iterator(expunges.end()); } -//------------------------------------------------------------------------ PendingUpdates::flagupdates_const_iterator::flagupdates_const_iterator(void) {} -//------------------------------------------------------------------------ PendingUpdates::flagupdates_const_iterator::flagupdates_const_iterator( map<unsigned int, unsigned int>::iterator i, map<unsigned int, vector<string>> *j, @@ -145,55 +126,46 @@ PendingUpdates::flagupdates_const_iterator::flagupdates_const_iterator( sqnrtouid = sqnrmap; } -//------------------------------------------------------------------------ void PendingUpdates::flagupdates_const_iterator::operator++(void) { ++internal; } -//------------------------------------------------------------------------ bool PendingUpdates::flagupdates_const_iterator::operator!=(flagupdates_const_iterator i) const { return internal != i.internal; } -//------------------------------------------------------------------------ PendingUpdates::flagupdates_const_iterator PendingUpdates::beginFlagUpdates(void) { return flagupdates_const_iterator(flagupdates.begin(), &sqnrtocflags, &sqnrtouid); } -//------------------------------------------------------------------------ PendingUpdates::flagupdates_const_iterator PendingUpdates::endFlagUpdates(void) { return flagupdates_const_iterator(flagupdates.end(), &sqnrtocflags, &sqnrtouid); } -//------------------------------------------------------------------------ unsigned int PendingUpdates::flagupdates_const_iterator::first(void) const { return internal->first; } -//------------------------------------------------------------------------ unsigned int PendingUpdates::flagupdates_const_iterator::second(void) const { return internal->second; } -//------------------------------------------------------------------------ vector<string> PendingUpdates::flagupdates_const_iterator::getCustomFlags(void) const { return (*sqnrtocflags)[internal->first]; } -//------------------------------------------------------------------------ unsigned int PendingUpdates::flagupdates_const_iterator::getUID(void) const { return (*sqnrtouid)[internal->first]; } -//-------------------------------------------------------------------- bool Binc::pendingUpdates(Mailbox *mailbox, int type, bool rescan, @@ -203,7 +175,7 @@ bool Binc::pendingUpdates(Mailbox *mailbox, { Session &session = Session::getInstance(); - if (mailbox == 0) return true; + if (mailbox == nullptr) return true; PendingUpdates p; if (!mailbox->getUpdates(rescan, type, p, forceScan)) { diff --git a/src/recursivedescent.cc b/src/recursivedescent.cc index 0f0cf8d..e490865 100644 --- a/src/recursivedescent.cc +++ b/src/recursivedescent.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file recursivedescent.cc * @brief Implementation of a recursive descent IMAP command parser. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "recursivedescent.h" #include "convert.h" @@ -19,13 +20,12 @@ #include <ctype.h> #include <stdio.h> -using namespace ::std; using namespace Binc; +using std::string; -stack<int> Binc::inputBuffer; +std::stack<int> Binc::inputBuffer; int Binc::charnr = 0; -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectThisString(const string &s_in) { Session &session = Session::getInstance(); @@ -53,11 +53,11 @@ Operator::ParseResult Binc::expectThisString(const string &s_in) if (!match) { bincClient.unreadStr(tmp); return Operator::REJECT; - } else + } else { return Operator::ACCEPT; + } } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectDateTime(string &s_in) { Session &session = Session::getInstance(); @@ -102,31 +102,31 @@ Operator::ParseResult Binc::expectDateTime(string &s_in) s_in += "-"; /* month */ - if ((res = expectThisString("Jan")) == Operator::ACCEPT) + if ((res = expectThisString("Jan")) == Operator::ACCEPT) { s_in += "Jan"; - else if ((res = expectThisString("Feb")) == Operator::ACCEPT) + } else if ((res = expectThisString("Feb")) == Operator::ACCEPT) { s_in += "Feb"; - else if ((res = expectThisString("Mar")) == Operator::ACCEPT) + } else if ((res = expectThisString("Mar")) == Operator::ACCEPT) { s_in += "Mar"; - else if ((res = expectThisString("Apr")) == Operator::ACCEPT) + } else if ((res = expectThisString("Apr")) == Operator::ACCEPT) { s_in += "Apr"; - else if ((res = expectThisString("May")) == Operator::ACCEPT) + } else if ((res = expectThisString("May")) == Operator::ACCEPT) { s_in += "May"; - else if ((res = expectThisString("Jun")) == Operator::ACCEPT) + } else if ((res = expectThisString("Jun")) == Operator::ACCEPT) { s_in += "Jun"; - else if ((res = expectThisString("Jul")) == Operator::ACCEPT) + } else if ((res = expectThisString("Jul")) == Operator::ACCEPT) { s_in += "Jul"; - else if ((res = expectThisString("Aug")) == Operator::ACCEPT) + } else if ((res = expectThisString("Aug")) == Operator::ACCEPT) { s_in += "Aug"; - else if ((res = expectThisString("Sep")) == Operator::ACCEPT) + } else if ((res = expectThisString("Sep")) == Operator::ACCEPT) { s_in += "Sep"; - else if ((res = expectThisString("Oct")) == Operator::ACCEPT) + } else if ((res = expectThisString("Oct")) == Operator::ACCEPT) { s_in += "Oct"; - else if ((res = expectThisString("Nov")) == Operator::ACCEPT) + } else if ((res = expectThisString("Nov")) == Operator::ACCEPT) { s_in += "Nov"; - else if ((res = expectThisString("Dec")) == Operator::ACCEPT) + } else if ((res = expectThisString("Dec")) == Operator::ACCEPT) { s_in += "Dec"; - else { + } else { session.setLastError("expected month"); return res; } @@ -204,7 +204,6 @@ Operator::ParseResult Binc::expectDateTime(string &s_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectTime(string &s_in) { Session &session = Session::getInstance(); @@ -279,7 +278,6 @@ Operator::ParseResult Binc::expectTime(string &s_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectZone(string &s_in) { Session &session = Session::getInstance(); @@ -328,7 +326,6 @@ Operator::ParseResult Binc::expectZone(string &s_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectListWildcards(int &c_in) { Operator::ParseResult res; @@ -338,11 +335,11 @@ Operator::ParseResult Binc::expectListWildcards(int &c_in) } else if ((res = expectThisString("*")) == Operator::ACCEPT) { c_in = '*'; return Operator::ACCEPT; - } else + } else { return res; + } } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectListMailbox(string &s_in) { Operator::ParseResult res; @@ -357,7 +354,9 @@ Operator::ParseResult Binc::expectListMailbox(string &s_in) if ((res = expectAtomChar(c)) != Operator::ACCEPT && (res = expectListWildcards(c)) != Operator::ACCEPT && (res = expectThisString("]")) != Operator::ACCEPT) + { return Operator::ACCEPT; + } } while (1); } @@ -366,44 +365,41 @@ Operator::ParseResult Binc::expectListMailbox(string &s_in) return res; } -//---------------------------------------------------------------------- -Operator::ParseResult Binc::expectFlag(vector<string> &v_in) +Operator::ParseResult Binc::expectFlag(std::vector<string> &v_in) { Session &session = Session::getInstance(); Operator::ParseResult res; string flag; - if ((res = expectThisString("\\Answered")) == Operator::ACCEPT) + if ((res = expectThisString("\\Answered")) == Operator::ACCEPT) { v_in.push_back("\\Answered"); - else if ((res = expectThisString("\\Flagged")) == Operator::ACCEPT) + } else if ((res = expectThisString("\\Flagged")) == Operator::ACCEPT) { v_in.push_back("\\Flagged"); - else if ((res = expectThisString("\\Deleted")) == Operator::ACCEPT) + } else if ((res = expectThisString("\\Deleted")) == Operator::ACCEPT) { v_in.push_back("\\Deleted"); - else if ((res = expectThisString("\\Seen")) == Operator::ACCEPT) + } else if ((res = expectThisString("\\Seen")) == Operator::ACCEPT) { v_in.push_back("\\Seen"); - else if ((res = expectThisString("\\Draft")) == Operator::ACCEPT) + } else if ((res = expectThisString("\\Draft")) == Operator::ACCEPT) { v_in.push_back("\\Draft"); - else if ((res = expectThisString("\\Answered")) == Operator::ACCEPT) + } else if ((res = expectThisString("\\Answered")) == Operator::ACCEPT) { v_in.push_back("\\Answered"); - else { - if ((res = expectThisString("\\")) == Operator::ACCEPT) { - if ((res = expectAtom(flag)) == Operator::ACCEPT) - v_in.push_back("\\" + flag); - else { - session.setLastError("expected atom"); - return res; - } - - } else if (expectAtom(flag) == Operator::ACCEPT) { - v_in.push_back(flag); - } else + } else if ((res = expectThisString("\\")) == Operator::ACCEPT) { + if ((res = expectAtom(flag)) == Operator::ACCEPT) { + v_in.push_back("\\" + flag); + } else { + session.setLastError("expected atom"); return res; + } + + } else if (expectAtom(flag) == Operator::ACCEPT) { + v_in.push_back(flag); + } else { + return res; } return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectDate(string &s_in) { Session &session = Session::getInstance(); @@ -437,31 +433,31 @@ Operator::ParseResult Binc::expectDate(string &s_in) s_in += '-'; /* month */ - if ((res = expectThisString("Jan")) == Operator::ACCEPT) + if ((res = expectThisString("Jan")) == Operator::ACCEPT) { s_in += "Jan"; - else if ((res = expectThisString("Feb")) == Operator::ACCEPT) + } else if ((res = expectThisString("Feb")) == Operator::ACCEPT) { s_in += "Feb"; - else if ((res = expectThisString("Mar")) == Operator::ACCEPT) + } else if ((res = expectThisString("Mar")) == Operator::ACCEPT) { s_in += "Mar"; - else if ((res = expectThisString("Apr")) == Operator::ACCEPT) + } else if ((res = expectThisString("Apr")) == Operator::ACCEPT) { s_in += "Apr"; - else if ((res = expectThisString("May")) == Operator::ACCEPT) + } else if ((res = expectThisString("May")) == Operator::ACCEPT) { s_in += "May"; - else if ((res = expectThisString("Jun")) == Operator::ACCEPT) + } else if ((res = expectThisString("Jun")) == Operator::ACCEPT) { s_in += "Jun"; - else if ((res = expectThisString("Jul")) == Operator::ACCEPT) + } else if ((res = expectThisString("Jul")) == Operator::ACCEPT) { s_in += "Jul"; - else if ((res = expectThisString("Aug")) == Operator::ACCEPT) + } else if ((res = expectThisString("Aug")) == Operator::ACCEPT) { s_in += "Aug"; - else if ((res = expectThisString("Sep")) == Operator::ACCEPT) + } else if ((res = expectThisString("Sep")) == Operator::ACCEPT) { s_in += "Sep"; - else if ((res = expectThisString("Oct")) == Operator::ACCEPT) + } else if ((res = expectThisString("Oct")) == Operator::ACCEPT) { s_in += "Oct"; - else if ((res = expectThisString("Nov")) == Operator::ACCEPT) + } else if ((res = expectThisString("Nov")) == Operator::ACCEPT) { s_in += "Nov"; - else if ((res = expectThisString("Dec")) == Operator::ACCEPT) + } else if ((res = expectThisString("Dec")) == Operator::ACCEPT) { s_in += "Dec"; - else { + } else { session.setLastError("expected month"); return res; } @@ -508,16 +504,16 @@ Operator::ParseResult Binc::expectDate(string &s_in) s_in += yearstr.str(); - if (quoted) + if (quoted) { if ((res = expectThisString("\"")) != Operator::ACCEPT) { session.setLastError("expected \""); return res; } + } return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectCRLF(void) { Operator::ParseResult res; @@ -527,7 +523,6 @@ Operator::ParseResult Binc::expectCRLF(void) return res; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectCR(void) { Session &session = Session::getInstance(); @@ -540,15 +535,14 @@ Operator::ParseResult Binc::expectCR(void) return Operator::ERROR; } - if (c == 0x0d) + if (c == 0x0d) { return Operator::ACCEPT; - else { + } else { bincClient.unreadChar(c); return Operator::REJECT; } } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectLF(void) { Session &session = Session::getInstance(); @@ -561,15 +555,14 @@ Operator::ParseResult Binc::expectLF(void) return Operator::ERROR; } - if (c == 0x0a) + if (c == 0x0a) { return Operator::ACCEPT; - else { + } else { bincClient.unreadChar(c); return Operator::REJECT; } } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectTagChar(int &c_in) { Session &session = Session::getInstance(); @@ -680,20 +673,19 @@ Operator::ParseResult Binc::expectTagChar(int &c_in) return Operator::REJECT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectTag(string &s_in) { string tag; int tagchar; int eres = expectTagChar(tagchar); - if (eres == Operator::REJECT) + if (eres == Operator::REJECT) { return Operator::REJECT; - else if (eres == Operator::ERROR) + } else if (eres == Operator::ERROR) { return Operator::ERROR; - else if (eres == Operator::TIMEOUT) + } else if (eres == Operator::TIMEOUT) { return Operator::TIMEOUT; - else { + } else { tag += tagchar; bool done = false; @@ -719,7 +711,6 @@ Operator::ParseResult Binc::expectTag(string &s_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectSPACE(void) { Session &session = Session::getInstance(); @@ -732,21 +723,19 @@ Operator::ParseResult Binc::expectSPACE(void) return Operator::ERROR; } - if (c == ' ') + if (c == ' ') { return Operator::ACCEPT; - else { + } else { bincClient.unreadChar(c); return Operator::REJECT; } } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectMailbox(string &s_in) { return expectAstring(s_in); } -//---------------------------------------------------------------------- // FIXME: This rule is wrong. Operator::ParseResult Binc::expectAstring(string &s_in) { @@ -758,7 +747,6 @@ Operator::ParseResult Binc::expectAstring(string &s_in) return res; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectAtomChar(int &c_in) { Session &session = Session::getInstance(); @@ -869,7 +857,6 @@ Operator::ParseResult Binc::expectAtomChar(int &c_in) return Operator::REJECT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectAtom(string &s_in) { string atom; @@ -882,13 +869,13 @@ Operator::ParseResult Binc::expectAtom(string &s_in) if (atom == "") { bincClient.unreadStr(atom); return res; - } else + } else { s_in = atom; + } return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectString(string &s_in) { Operator::ParseResult res; @@ -899,7 +886,6 @@ Operator::ParseResult Binc::expectString(string &s_in) return res; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectQuoted(string &s_in) { string quoted; @@ -920,7 +906,6 @@ Operator::ParseResult Binc::expectQuoted(string &s_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectQuotedChar(int &c_in) { Session &session = Session::getInstance(); @@ -1085,7 +1070,6 @@ Operator::ParseResult Binc::expectQuotedChar(int &c_in) return Operator::REJECT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectLiteral(string &s_in) { Session &session = Session::getInstance(); @@ -1121,7 +1105,7 @@ Operator::ParseResult Binc::expectLiteral(string &s_in) // Only send the reply if the client did not send a LITERAL+ // request. if (!literalPlus) { - bincClient << "+ ok, send " << nchar << " bytes of data." << endl; + bincClient << "+ ok, send " << nchar << " bytes of data." << std::endl; bincClient.flush(); } @@ -1141,26 +1125,23 @@ Operator::ParseResult Binc::expectLiteral(string &s_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectNumber(unsigned int &i_in) { i_in = 0; unsigned int n; Operator::ParseResult res; - while ((res = expectDigit(n)) == Operator::ACCEPT) { + while ((res = expectDigit(n)) == Operator::ACCEPT) if (i_in == 0) i_in = n; else i_in = (i_in * 10) + n; - } if (res == Operator::TIMEOUT) return res; return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectDigit(unsigned int &i_in) { Session &session = Session::getInstance(); @@ -1176,15 +1157,15 @@ Operator::ParseResult Binc::expectDigit(unsigned int &i_in) if (c == '0') { i_in = 0; return Operator::ACCEPT; - } else + } else { bincClient.unreadChar(c); + } if (expectDigitNZ(i_in) != Operator::ACCEPT) return Operator::REJECT; return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectDigitNZ(unsigned int &i_in) { Session &session = Session::getInstance(); @@ -1238,7 +1219,6 @@ Operator::ParseResult Binc::expectDigitNZ(unsigned int &i_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectSet(SequenceSet &s_in) { Session &session = Session::getInstance(); @@ -1268,16 +1248,16 @@ Operator::ParseResult Binc::expectSet(SequenceSet &s_in) /* if _after_ a set there is a ',', then there will always be * a set after the comma. if not, it's a syntax error. */ - if ((res = expectThisString(",")) == Operator::ACCEPT) + if ((res = expectThisString(",")) == Operator::ACCEPT) { if ((res = expectSet(s_in)) != Operator::ACCEPT) { session.setLastError("expected set"); return res; } + } return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectSequenceNum(unsigned int &i_in) { Session &session = Session::getInstance(); @@ -1293,8 +1273,9 @@ Operator::ParseResult Binc::expectSequenceNum(unsigned int &i_in) if (c == '*') { i_in = (unsigned int)-1; return Operator::ACCEPT; - } else + } else { bincClient.unreadChar(c); + } if (expectNZNumber(i_in) != Operator::ACCEPT) return Operator::REJECT; @@ -1302,7 +1283,6 @@ Operator::ParseResult Binc::expectSequenceNum(unsigned int &i_in) return Operator::ACCEPT; } -//---------------------------------------------------------------------- Operator::ParseResult Binc::expectNZNumber(unsigned int &i_in) { unsigned int c; diff --git a/src/regmatch.cc b/src/regmatch.cc index 6e4b261..0942ad9 100644 --- a/src/regmatch.cc +++ b/src/regmatch.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file regex.cc * @brief Implementation of miscellaneous regexp functions * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "regmatch.h" #include <string> @@ -13,10 +14,7 @@ #include <regex.h> #include <sys/types.h> -using namespace ::std; - -//------------------------------------------------------------------------ -int Binc::regexMatch(const string &data_in, const string &p_in) +int Binc::regexMatch(const std::string &data_in, const std::string &p_in) { regex_t r; regmatch_t rm[2]; diff --git a/src/session-initialize-bincimap-up.cc b/src/session-initialize-bincimap-up.cc index 12c099c..c18ef26 100644 --- a/src/session-initialize-bincimap-up.cc +++ b/src/session-initialize-bincimap-up.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file session-initialize-bincimap-up.cc * @brief bincimap-up requires sslserver * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * ----------------------------------------------------------------- **/ + */ + #include "broker.h" #include "convert.h" #include "globals.h" @@ -23,12 +24,11 @@ #include <fcntl.h> #include <syslog.h> -using namespace ::std; using namespace Binc; +using std::string; extern char **environ; -//---------------------------------------------------------------------- bool Session::initialize(int argc, char *argv[]) { IOFactory &ioFactory = IOFactory::getInstance(); @@ -76,30 +76,28 @@ bool Session::initialize(int argc, char *argv[]) const string f = session.getEnv("SYSLOG_FACILITY"); int facility; - if (isdigit(f[0])) { + if (isdigit(f[0])) facility = atoi(f); - } else { - if (f == "LOG_USER") - facility = LOG_USER; - else if (f == "LOG_LOCAL0") - facility = LOG_LOCAL0; - else if (f == "LOG_LOCAL1") - facility = LOG_LOCAL1; - else if (f == "LOG_LOCAL2") - facility = LOG_LOCAL2; - else if (f == "LOG_LOCAL3") - facility = LOG_LOCAL3; - else if (f == "LOG_LOCAL4") - facility = LOG_LOCAL4; - else if (f == "LOG_LOCAL5") - facility = LOG_LOCAL5; - else if (f == "LOG_LOCAL6") - facility = LOG_LOCAL6; - else if (f == "LOG_LOCAL7") - facility = LOG_LOCAL7; - else - facility = LOG_DAEMON; - } + else if (f == "LOG_USER") + facility = LOG_USER; + else if (f == "LOG_LOCAL0") + facility = LOG_LOCAL0; + else if (f == "LOG_LOCAL1") + facility = LOG_LOCAL1; + else if (f == "LOG_LOCAL2") + facility = LOG_LOCAL2; + else if (f == "LOG_LOCAL3") + facility = LOG_LOCAL3; + else if (f == "LOG_LOCAL4") + facility = LOG_LOCAL4; + else if (f == "LOG_LOCAL5") + facility = LOG_LOCAL5; + else if (f == "LOG_LOCAL6") + facility = LOG_LOCAL6; + else if (f == "LOG_LOCAL7") + facility = LOG_LOCAL7; + else + facility = LOG_DAEMON; SyslogDevice *device = new SyslogDevice(IODevice::IsEnabled | IODevice::FlushesOnEndl, "bincimap-up", @@ -112,7 +110,6 @@ bool Session::initialize(int argc, char *argv[]) IOFactory::getLogger().setFlags(IODevice::FlushesOnEndl); IOFactory::getLogger().setOutputLevelLimit(IODevice::InfoLevel); - // imaps (port 993) -- requires sslserver with option -e int stls = 0; diff --git a/src/session-initialize-bincimapd.cc b/src/session-initialize-bincimapd.cc index 057accd..a574363 100644 --- a/src/session-initialize-bincimapd.cc +++ b/src/session-initialize-bincimapd.cc @@ -1,10 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file session-initialize-bincimapd.cc * @brief <---> * @author Andreas Aardal Hanssen, Erwin Hoffmann * @date 2002-2005, 2023 - * -------------------------------------------------------------------- */ + #include "broker.h" #include "convert.h" #include "depot.h" @@ -28,12 +28,12 @@ #include <syslog.h> #include <unistd.h> -using namespace ::std; using namespace Binc; +using std::endl; +using std::string; extern char **environ; -//---------------------------------------------------------------------- bool Session::initialize(int argc, char *argv[]) { IOFactory &ioFactory = IOFactory::getInstance(); @@ -82,28 +82,26 @@ bool Session::initialize(int argc, char *argv[]) if (isdigit(f[0])) facility = atoi(f); - else { - if (f == "LOG_USER") - facility = LOG_USER; - else if (f == "LOG_LOCAL0") - facility = LOG_LOCAL0; - else if (f == "LOG_LOCAL1") - facility = LOG_LOCAL1; - else if (f == "LOG_LOCAL2") - facility = LOG_LOCAL2; - else if (f == "LOG_LOCAL3") - facility = LOG_LOCAL3; - else if (f == "LOG_LOCAL4") - facility = LOG_LOCAL4; - else if (f == "LOG_LOCAL5") - facility = LOG_LOCAL5; - else if (f == "LOG_LOCAL6") - facility = LOG_LOCAL6; - else if (f == "LOG_LOCAL7") - facility = LOG_LOCAL7; - else - facility = LOG_DAEMON; - } + else if (f == "LOG_USER") + facility = LOG_USER; + else if (f == "LOG_LOCAL0") + facility = LOG_LOCAL0; + else if (f == "LOG_LOCAL1") + facility = LOG_LOCAL1; + else if (f == "LOG_LOCAL2") + facility = LOG_LOCAL2; + else if (f == "LOG_LOCAL3") + facility = LOG_LOCAL3; + else if (f == "LOG_LOCAL4") + facility = LOG_LOCAL4; + else if (f == "LOG_LOCAL5") + facility = LOG_LOCAL5; + else if (f == "LOG_LOCAL6") + facility = LOG_LOCAL6; + else if (f == "LOG_LOCAL7") + facility = LOG_LOCAL7; + else + facility = LOG_DAEMON; session.setEnv("SYSLOG_FACILITY", toString(facility)); @@ -116,10 +114,10 @@ bool Session::initialize(int argc, char *argv[]) IOFactory::getLogger().setFlags(IODevice::FlushesOnEndl); IOFactory::getLogger().setOutputLevelLimit(IODevice::InfoLevel); - string pid = to_string(session.getPid()); + string pid = std::to_string(session.getPid()); char *logindetails = getenv("BINCIMAP_LOGIN"); - if (logindetails == 0) { + if (logindetails == nullptr) { bincLog << "bincimapd: pid " << pid << " BINCIMAP_LOGIN missing from environment (are you sure you invoked " << argv[0] << " properly?)\n"; @@ -133,7 +131,7 @@ bool Session::initialize(int argc, char *argv[]) string depottype = session.getEnv("DEPOT"); if (depottype == "") depottype = "Maildir++"; - if ((depot = depotfactory.get(depottype)) == 0) { + if ((depot = depotfactory.get(depottype)) == nullptr) { bincLog << "bincimapd: pid " << pid << " Found no Depot for: " << depottype << ". Please check your configurations file under the Mailbox section\n"; bincLog.flush(); @@ -177,9 +175,9 @@ bool Session::initialize(int argc, char *argv[]) // automatically create depot directory if it's not there already string path; if (session.args.getUnqualifiedArgs().size() > 0) path = session.args.getUnqualifiedArgs()[0]; - if (path == "") + if (path == "") { path = "."; - else if (chdir(path.c_str()) != 0) { + } else if (chdir(path.c_str()) != 0) { mkdir(path.c_str(), 0777); if (chdir(path.c_str()) != 0) { bincLog << "bincimapd: pid" << pid << " Error entering depot " + toImapString(path) + ": " diff --git a/src/session.cc b/src/session.cc index b6a0834..41192cb 100644 --- a/src/session.cc +++ b/src/session.cc @@ -1,7 +1,8 @@ -/** -------------------------------------------------------------------- +/** * @file session.cc * @brief Implementation of the Session class. - * ------------------------------------------------------------------ **/ + */ + #include "session.h" #include "argparser.h" @@ -15,12 +16,11 @@ #include <syslog.h> #include <unistd.h> -using namespace ::std; using namespace Binc; +using std::string; extern char **environ; -//---------------------------------------------------------------------- Session::Session(void) { readbytes = 0; @@ -31,110 +31,92 @@ Session::Session(void) logfacility = LOG_DAEMON; } -//---------------------------------------------------------------------- Session &Session::getInstance(void) { static Session session; return session; } -//---------------------------------------------------------------------- -const int Session::getState(void) const +int Session::getState(void) const { return state; } -//---------------------------------------------------------------------- void Session::setState(int n) { state = n; } -//---------------------------------------------------------------------- const string &Session::getUserID(void) const { return userid; } -//---------------------------------------------------------------------- void Session::setUserID(const string &s) { userid = s; } -//---------------------------------------------------------------------- const string &Session::getIP(void) const { return ip; } -//---------------------------------------------------------------------- void Session::setIP(const string &s) { ip = s; } -//---------------------------------------------------------------------- void Session::setLogFacility(int facility) { logfacility = facility; } -//---------------------------------------------------------------------- int Session::getLogFacility(void) const { return logfacility; } -//---------------------------------------------------------------------- void Session::addBody(void) { ++bodies; } -//---------------------------------------------------------------------- void Session::addStatement(void) { ++statements; } -//---------------------------------------------------------------------- void Session::addReadBytes(int i) { readbytes += i; } -//---------------------------------------------------------------------- void Session::addWriteBytes(int i) { writebytes += i; } -//---------------------------------------------------------------------- int Session::getBodies(void) const { return bodies; } -//---------------------------------------------------------------------- int Session::getStatements(void) const { return statements; } -//---------------------------------------------------------------------- int Session::getWriteBytes(void) const { return writebytes; } -//---------------------------------------------------------------------- int Session::getReadBytes(void) const { return readbytes; } -//---------------------------------------------------------------------- bool Session::parseCommandLine(int argc, char *argv[]) { args.addOptional("h|help", "Display this help screen", true); @@ -158,7 +140,6 @@ bool Session::parseCommandLine(int argc, char *argv[]) return true; } -//---------------------------------------------------------------------- void Session::assignCommandLineArgs(void) { if (args.hasArg("allow-plain")) setEnv("ALLOW_NONSSL_PLAINTEXT_LOGINS", "yes"); @@ -172,37 +153,31 @@ void Session::assignCommandLineArgs(void) if (args.hasArg("delimiter")) setEnv("DELIMITER", args["delimiter"]); } -//---------------------------------------------------------------------- const string &Session::getLastError(void) const { return lastError; } -//---------------------------------------------------------------------- void Session::setLastError(const string &error) const { lastError = error; } -//---------------------------------------------------------------------- const string &Session::getResponseCode(void) const { return responseCode; } -//---------------------------------------------------------------------- void Session::setResponseCode(const string &code) const { responseCode = "[" + code + "] "; } -//---------------------------------------------------------------------- void Session::clearResponseCode(void) const { responseCode = ""; } -//---------------------------------------------------------------------- pid_t Session::getPid(void) { if (pid == 0) pid = getpid(); @@ -210,26 +185,22 @@ pid_t Session::getPid(void) return pid; } -//---------------------------------------------------------------------- int Session::timeout() const { return state == NONAUTHENTICATED ? AUTH_TIMEOUT : IDLE_TIMEOUT; } -//---------------------------------------------------------------------- bool Session::hasEnv(const string &key) const { - return getenv(key.c_str()) != 0; + return getenv(key.c_str()) != nullptr; } -//---------------------------------------------------------------------- string Session::getEnv(const string &key) { char *c = getenv(key.c_str()); return c ? c : ""; } -//---------------------------------------------------------------------- void Session::setEnv(const string &key, const string &value) { string env = key + "=" + value; diff --git a/src/status.cc b/src/status.cc index 8b481ef..341c04f 100644 --- a/src/status.cc +++ b/src/status.cc @@ -1,16 +1,14 @@ -/** -------------------------------------------------------------------- +/** * @file status.cc * @brief Implementation of the Status class. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ----------------------------------------------------------------- **/ + */ + #include "status.h" -using namespace ::std; using namespace Binc; -//------------------------------------------------------------------------ Status::Status(void) {} -//------------------------------------------------------------------------ Status::~Status(void) {} diff --git a/src/stdiodevice.cc b/src/stdiodevice.cc index a9cce91..b078c7a 100644 --- a/src/stdiodevice.cc +++ b/src/stdiodevice.cc @@ -1,9 +1,10 @@ -/** -------------------------------------------------------------------- +/** * @file stdiodevice.cc * @brief Implementation of the StdIODevice class * @author Andreas Aardal Hanssen * @date 2003/2023 - * ---------------------------------------------------------------- **/ + */ + #include "stdiodevice.h" #include <string> @@ -16,29 +17,23 @@ #include <sys/types.h> #include <unistd.h> -using namespace ::std; -using namespace ::Binc; +using namespace Binc; -//------------------------------------------------------------------------ StdIODevice::StdIODevice(int f) : IODevice(f) {} -//------------------------------------------------------------------------ StdIODevice::~StdIODevice(void) {} -//------------------------------------------------------------------------ -string StdIODevice::service(void) const +std::string StdIODevice::service(void) const { return "client"; } -//------------------------------------------------------------------------ bool StdIODevice::canRead(void) const { size_t bytes; return ioctl(fileno(stdin), FIONREAD, (char *)&bytes) > 0; } -//------------------------------------------------------------------------ bool StdIODevice::waitForWrite(void) const { fd_set writeMask; @@ -49,12 +44,11 @@ bool StdIODevice::waitForWrite(void) const tv.tv_sec = timeout; tv.tv_usec = 0; - int result = select(fileno(stdout) + 1, 0, &writeMask, 0, timeout ? &tv : 0); + int result = select(fileno(stdout) + 1, nullptr, &writeMask, nullptr, timeout ? &tv : nullptr); if (result == 0) error = Timeout; return result > 0; } -//------------------------------------------------------------------------ bool StdIODevice::waitForRead(void) const { fd_set readMask; @@ -65,12 +59,11 @@ bool StdIODevice::waitForRead(void) const tv.tv_sec = timeout; tv.tv_usec = 0; - int result = select(fileno(stdin) + 1, &readMask, 0, 0, timeout ? &tv : 0); + int result = select(fileno(stdin) + 1, &readMask, nullptr, nullptr, timeout ? &tv : nullptr); if (result == 0) error = Timeout; return result > 0; } -//------------------------------------------------------------------------ IODevice::WriteResult StdIODevice::write(void) { for (;;) { @@ -90,7 +83,6 @@ IODevice::WriteResult StdIODevice::write(void) } } -//------------------------------------------------------------------------ bool StdIODevice::fillInputBuffer(void) { if (!waitForRead()) return false; diff --git a/src/syslogdevice.cc b/src/syslogdevice.cc index f694835..49162a4 100644 --- a/src/syslogdevice.cc +++ b/src/syslogdevice.cc @@ -1,22 +1,21 @@ -/** -------------------------------------------------------------------- +/** * @file syslogdevice.cc * @brief Implementation of the SyslogDevice class. * @author Andreas Aardal Hanssen * @date 2002, 2003 - * ----------------------------------------------------------------- **/ + */ + #include "syslogdevice.h" #include <string> #include <syslog.h> -using namespace ::std; -using namespace ::Binc; +using namespace Binc; +using std::string; -//------------------------------------------------------------------------ string SyslogDevice::ident; -//------------------------------------------------------------------------ SyslogDevice::SyslogDevice(int f, const char *i, int o, int fa) : IODevice(f) , option(o) @@ -27,31 +26,26 @@ SyslogDevice::SyslogDevice(int f, const char *i, int o, int fa) openlog(ident.c_str(), option, facility); } -//------------------------------------------------------------------------ SyslogDevice::~SyslogDevice(void) { closelog(); } -//------------------------------------------------------------------------ string SyslogDevice::service(void) const { return "log"; } -//------------------------------------------------------------------------ bool SyslogDevice::waitForWrite(void) const { return true; } -//------------------------------------------------------------------------ bool SyslogDevice::waitForRead(void) const { return false; } -//------------------------------------------------------------------------ IODevice::WriteResult SyslogDevice::write(void) { string out; @@ -62,8 +56,9 @@ IODevice::WriteResult SyslogDevice::write(void) if (*i == '\n') { syslog(priority, out.c_str(), out.size()); out = ""; - } else if (*i != '\r') + } else if (*i != '\r') { out += *i; + } } if (out != "") syslog(priority, out.c_str(), out.size()); @@ -72,7 +67,6 @@ IODevice::WriteResult SyslogDevice::write(void) return WriteDone; } -//------------------------------------------------------------------------ bool SyslogDevice::fillInputBuffer(void) { return false; diff --git a/src/tools.cc b/src/tools.cc index 95c28d6..1b6e28a 100644 --- a/src/tools.cc +++ b/src/tools.cc @@ -1,42 +1,39 @@ -/** -------------------------------------------------------------------- +/** * @file tools.cc * @brief Implementation of miscellaneous tools. * @author Andreas Aardal Hanssen * @date 2002-2005 - * ------------------------------------------------------------------ **/ + */ + #include "tools.h" #include <cstring> #include <errno.h> -using namespace ::std; using namespace Binc; +using std::string; -//------------------------------------------------------------------------ Tools::Tools(void) {} -//------------------------------------------------------------------------ Tools &Tools::getInstance(void) { static Tools tools; return tools; } -//------------------------------------------------------------------------ void Tools::setenv(const string &key, const string &value) const { char *c = strdup((key + "=" + value).c_str()); putenv(c); } -//------------------------------------------------------------------------ string Tools::getenv(const string &key) const { static const string NIL = ""; const char *c = ::getenv((char *)key.c_str()); - if (c == 0) + if (c == nullptr) return NIL; else return string(c); |