Utils.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2017 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 ZNC_UTILS_H
#define ZNC_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 = nullptr);
    static bool GetNumInput(const CString& sPrompt, unsigned int& uRet,
                            unsigned int uMin = 0, unsigned int uMax = ~0,
                            unsigned int uDefault = ~0);

    static timeval GetTime();
    static unsigned long long GetMillTime();
#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 timeval ParseServerTime(const CString& sTime);
    static SCString GetTimezones();
    static SCString GetEncodings();
    static bool CheckCIDR(const CString& sIP, const CString& sRange);

    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;
    // Used to cache the width of a column
    std::map<CString, CString::size_type> m_msuWidths;
};

#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();

    CBlowfish(const CBlowfish&) = default;
    CBlowfish& operator=(const CBlowfish&) = default;

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

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

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

    unsigned char* Crypt(unsigned char* input, unsigned 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_mItems(), 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 nullptr;
        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(); }

    std::map<K, V> GetItems() {
        Cleanup();
        std::map<K, V> mItems;
        for (const auto& it : m_mItems) {
            mItems[it.first] = it.second.second;
        }
        return mItems;
    }

    // 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;  
};

#endif  // !ZNC_UTILS_H