EMailImapService.h

Go to the documentation of this file.

/*
 * EMailImapService.h
 *
 * Copyright (C) 2013 IBR, TU Braunschweig
 *
 * Written-by: Björn Gernert <mail@bjoern-gernert.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#ifndef EMAILIMAPSERVICE_H_
#define EMAILIMAPSERVICE_H_

#include "Configuration.h"
#include "net/EMailSmtpService.h"

#include <ibrcommon/thread/Thread.h>
#include <vmime/vmime.hpp>

namespace dtn
{
        namespace net
        {
                class EMailImapService : public ibrcommon::JoinableThread
                {
                public:

                        static EMailImapService& getInstance();

                        void run() throw ();

                        void __cancellation() throw ();

                        void storeProcessedTask(EMailSmtpService::Task *task);

                        void fetchMails();

                private:
                        class TimeoutHandler : public vmime::net::timeoutHandler
                        {
                                public:
                                        bool isTimeOut();
                                        void resetTimeOut();
                                        bool handleTimeOut();
                                private:
                                        unsigned int getTime()
                                        {
                                                return vmime::platform::getHandler()->getUnixTime();
                                        }
                                        unsigned int last;
                        };

                        class TimeoutHandlerFactory : public vmime::net::timeoutHandlerFactory
                        {
                        public:
                                vmime::ref<vmime::net::timeoutHandler> create()
                                {
                                        return vmime::create<TimeoutHandler>();
                                }
                        };

                        EMailImapService();

                        virtual ~EMailImapService();

                        void connect();

                        bool isConnected();

                        void disconnect();

                        void queryServer();

                        void loadCerificates();

                        void generateBundle(vmime::ref<vmime::net::message> &msg);

                        void returningMailCheck(vmime::ref<vmime::net::message> &msg);

                        dtn::data::BundleID extractBID(const std::string &message);

                        std::string searchString(const std::string &search, const std::string &s);

                        void setProcFlags(dtn::data::Block &block, size_t &flags);

                        vmime::ref<vmime::security::cert::X509Certificate> loadCertificateFromFile(const std::string &path);

                        const dtn::daemon::Configuration::EMail& _config;

                        static bool _run;

                        vmime::ref<vmime::net::store> _store;

                        ibrcommon::Mutex _threadMutex;

                        vmime::ref<vmime::security::cert::defaultCertificateVerifier> _certificateVerifier;

                        vmime::net::folder::path _path;

                        vmime::ref<vmime::net::folder> _folder;

                        std::list<EMailSmtpService::Task*> _processedTasks;

                        ibrcommon::Mutex _processedTasksMutex;

                        int toInt(std::string s);

                        std::string toString(int i);

                        void addEIDList(dtn::data::Block &block,
                                        vmime::utility::ref<const vmime::attachment> &attachment);

                        class InvalidCertificate : public ibrcommon::Exception {
                        public:
                                InvalidCertificate() {}
                                InvalidCertificate(std::string msg) : Exception(msg) {}
                        };

                        class InvalidConversion : public ibrcommon::Exception {
                        public:
                                InvalidConversion() {}
                                InvalidConversion(std::string msg) : Exception(msg) {}
                        };

                        class StringNotFound : public ibrcommon::Exception {
                        public:
                                StringNotFound() {}
                                StringNotFound(std::string msg) : Exception(msg) {}
                        };

                        class BidNotFound : public ibrcommon::Exception {
                        public:
                                BidNotFound() {}
                                BidNotFound(std::string msg) : Exception(msg) {}
                        };

                        class IMAPException : public ibrcommon::Exception {
                        public:
                                IMAPException() {}
                                IMAPException(std::string msg) : Exception(msg) {}
                        };
                };
        }
}

#endif /* EMAILIMAPSERVICE_H_ */