Utils.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2014 ZNC, see the NOTICE file for details.
 *
 * 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 _UTILS_H
#define _UTILS_H

#include <znc/zncconfig.h>
#include <znc/ZNCString.h>
#include <assert.h>
#include <cstdio>
#include <fcntl.h>
#include <map>
#include <sys/file.h>
#include <sys/time.h>
#include <unistd.h>
#include <vector>

static inline void SetFdCloseOnExec(int fd)
{
        int flags = fcntl(fd, F_GETFD, 0);
        if (flags < 0)
                return; // Ignore errors
        // When we execve() a new process this fd is now automatically closed.
        fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
}

static const char g_HexDigits[] = "0123456789abcdef";

class CUtils {
public:
        CUtils();
        ~CUtils();

        static CString GetIP(unsigned long addr);
        static unsigned long GetLongIP(const CString& sIP);

        static void PrintError(const CString& sMessage);
        static void PrintMessage(const CString& sMessage, bool bStrong = false);
        static void PrintPrompt(const CString& sMessage);
        static void PrintAction(const CString& sMessage);
        static void PrintStatus(bool bSuccess, const CString& sMessage = "");

#ifndef SWIGPERL
        // TODO refactor this
        static const CString sDefaultHash;
#endif

        static CString GetSaltedHashPass(CString& sSalt);
        static CString GetSalt();
        static CString SaltedMD5Hash(const CString& sPass, const CString& sSalt);
        static CString SaltedSHA256Hash(const CString& sPass, const CString& sSalt);
        static CString GetPass(const CString& sPrompt);
        static bool GetInput(const CString& sPrompt, CString& sRet, const CString& sDefault = "", const CString& sHint = "");
        static bool GetBoolInput(const CString& sPrompt, bool bDefault);
        static bool GetBoolInput(const CString& sPrompt, bool *pbDefault = NULL);
        static bool GetNumInput(const CString& sPrompt, unsigned int& uRet, unsigned int uMin = 0, unsigned int uMax = ~0, unsigned int uDefault = ~0);

        static unsigned long long GetMillTime() {
                struct timeval tv;
                unsigned long long iTime = 0;
                gettimeofday(&tv, NULL);
                iTime = (unsigned long long) tv.tv_sec * 1000;
                iTime += ((unsigned long long) tv.tv_usec / 1000);
                return iTime;
        }
#ifdef HAVE_LIBSSL
        static void GenerateCert(FILE *pOut, const CString& sHost = "");
#endif /* HAVE_LIBSSL */

        static CString CTime(time_t t, const CString& sTZ);
        static CString FormatTime(time_t t, const CString& sFormat, const CString& sTZ);
        static CString FormatServerTime(const timeval& tv);
        static SCString GetTimezones();

        static MCString GetMessageTags(const CString& sLine);
        static void SetMessageTags(CString& sLine, const MCString& mssTags);

private:
protected:
};

class CException {
public:
        typedef enum {
                EX_Shutdown,
                EX_Restart
        } EType;

        CException(EType e) {
                m_eType = e;
        }
        virtual ~CException() {}

        EType GetType() const { return m_eType; }
private:
protected:
        EType  m_eType;
};


class CTable : protected std::vector<std::vector<CString> > {
public:
        CTable() {}
        virtual ~CTable() {}

        bool AddColumn(const CString& sName);

        size_type AddRow();

        bool SetCell(const CString& sColumn, const CString& sValue, size_type uRowIdx = ~0);

        bool GetLine(unsigned int uIdx, CString& sLine) const;

        CString::size_type GetColumnWidth(unsigned int uIdx) const;

        void Clear();

        using std::vector<std::vector<CString> >::size;

        using std::vector<std::vector<CString> >::empty;
private:
        unsigned int GetColumnIndex(const CString& sName) const;

protected:
        std::vector<CString>            m_vsHeaders;
        std::map<CString, CString::size_type> m_msuWidths;  // Used to cache the width of a column
};


#ifdef HAVE_LIBSSL
#include <openssl/aes.h>
#include <openssl/blowfish.h>
#include <openssl/md5.h>
class CBlowfish {
public:
        CBlowfish(const CString & sPassword, int iEncrypt, const CString & sIvec = "");
        ~CBlowfish();

        static unsigned char *MD5(const unsigned char *input, u_int ilen);

        static CString MD5(const CString & sInput, bool bHexEncode = false);

        void Crypt(unsigned char *input, unsigned char *output, u_int ibytes);

        unsigned char * Crypt(unsigned char *input, u_int ibytes);
        CString Crypt(const CString & sData);

private:
        unsigned char  *m_ivec;
        BF_KEY          m_bkey;
        int             m_iEncrypt, m_num;
};

#endif /* HAVE_LIBSSL */

template<typename K, typename V = bool>
class TCacheMap {
public:
        TCacheMap(unsigned int uTTL = 5000) {
                m_uTTL = uTTL;
        }

        virtual ~TCacheMap() {}

        void AddItem(const K& Item) {
                AddItem(Item, m_uTTL);
        }

        void AddItem(const K& Item, unsigned int uTTL) {
                AddItem(Item, V(), uTTL);
        }

        void AddItem(const K& Item, const V& Val) {
                AddItem(Item, Val, m_uTTL);
        }

        void AddItem(const K& Item, const V& Val, unsigned int uTTL) {
                if (!uTTL) {             // If time-to-live is zero we don't want to waste our time adding it
                        RemItem(Item);   // Remove the item incase it already exists
                        return;
                }

                m_mItems[Item] = value(CUtils::GetMillTime() + uTTL, Val);
        }

        bool HasItem(const K& Item) {
                Cleanup();
                return (m_mItems.find(Item) != m_mItems.end());
        }

        V* GetItem(const K& Item) {
                Cleanup();
                iterator it = m_mItems.find(Item);
                if (it == m_mItems.end())
                        return NULL;
                return &it->second.second;
        }

        bool RemItem(const K& Item) {
                return (m_mItems.erase(Item) != 0);
        }

        void Cleanup() {
                iterator it = m_mItems.begin();

                while (it != m_mItems.end()) {
                        if (CUtils::GetMillTime() > (it->second.first)) {
                                m_mItems.erase(it++);
                        } else {
                                ++it;
                        }
                }
        }

        void Clear() {
                m_mItems.clear();
        }

        // Setters
        void SetTTL(unsigned int u) { m_uTTL = u; }
        // !Setters
        // Getters
        unsigned int GetTTL() const { return m_uTTL; }
        // !Getters
protected:
        typedef std::pair<unsigned long long, V> value;
        typedef typename std::map<K, value>::iterator iterator;
        std::map<K, value>   m_mItems;   
        unsigned int         m_uTTL;     
};

template<typename T>
class CSmartPtr {
public:
        CSmartPtr() {
                m_pType = NULL;
                m_puCount = NULL;
        }

        CSmartPtr(T* pRawPtr) {
                m_pType = NULL;
                m_puCount = NULL;

                Attach(pRawPtr);
        }

        CSmartPtr(const CSmartPtr<T>& CopyFrom) {
                m_pType = NULL;
                m_puCount = NULL;

                *this = CopyFrom;
        }

        ~CSmartPtr() {
                Release();
        }

        // Overloaded operators
        T& operator *() const { assert(m_pType); return *m_pType; }
        T* operator ->() const { assert(m_pType); return m_pType; }

        CSmartPtr<T>& operator =(T* pRawPtr) { Attach(pRawPtr); return *this; }

        CSmartPtr<T>& operator =(const CSmartPtr<T>& CopyFrom) {
                if (&CopyFrom != this) {              // Check for assignment to self
                        Release();                    // Release the current pointer

                        if (CopyFrom.IsNull()) {      // If the source raw pointer is null
                                return *this;         // Then just bail out
                        }

                        m_pType = CopyFrom.m_pType;   // Make our pointers reference the same raw pointer and counter
                        m_puCount = CopyFrom.m_puCount;

                        assert(m_puCount);            // We now point to something valid, so increment the counter
                        (*m_puCount)++;
                }

                return *this;
        }
        // !Overloaded operators

        operator bool() const {
                return !IsNull();
        }

        bool IsNull() const {
                return (m_pType == NULL);
        }

        CSmartPtr<T>& Attach(T* pRawPtr) {
                if (pRawPtr != m_pType) {                        // Check for assignment to self
                        Release();                               // Release the current pointer
                        m_pType = pRawPtr;                       // Point to the passed raw pointer

                        if (m_pType) {                           // If the passed pointer was valid
                                m_puCount = new unsigned int(1); // Create a new counter starting at 1 (us)
                        }
                }

                return *this;
        }

        void Release() {
                if (m_pType) {              // Only release if there is something to be released
                        assert(m_puCount);
                        (*m_puCount)--;     // Decrement our counter

                        if (!*m_puCount) {  // If we were the last reference to this pointer, then clean up
                                delete m_puCount;
                                delete m_pType;
                        }

                        m_pType = NULL;     // Get rid of our references
                        m_puCount = NULL;
                }
        }

        // Getters
        T* GetPtr() const { return m_pType; }
        unsigned int GetCount() const { return (m_puCount) ? *m_puCount : 0; }
        // !Getters
private:
        T*            m_pType;      
        unsigned int* m_puCount;    
};

template<typename T>
bool operator ==(T* lhs, const CSmartPtr<T>& rhs) { return (lhs == rhs.GetPtr()); }

template<typename T>
bool operator ==(const CSmartPtr<T>& lhs, T* rhs) { return (lhs.GetPtr() == rhs); }

template<typename T>
bool operator ==(const CSmartPtr<T>& lhs, const CSmartPtr<T>& rhs) { return (lhs.GetPtr() == rhs.GetPtr()); }

#endif // !_UTILS_H