base.H

Go to the documentation of this file.

/*
 *  This file is part of the Home2L project.
 *
 *  (C) 2015-2024 Gundolf Kiefer
 *
 *  Home2L is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Home2L is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Home2L. If not, see <https://www.gnu.org/licenses/>.
 *
 */
 
 
#ifndef _BASE_
#define _BASE_
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <limits.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <regex.h>
#include <stdarg.h>
 
#include <config.H>
 
 
 
 
 
// *************************** Configuration ***********************************
 
 
#ifdef __ANDROID__
#define ANDROID 1   
#else
#define ANDROID 0
#endif
 
 
 
 
 
// ***************** Basic definitions and functions ***************************
 
 
#define MIN(A, B) ((A) < (B) ? (A) : (B))   
#define MAX(A, B) ((A) > (B) ? (A) : (B))   
 
#define STR(X) #X
 
#define OFFSET(type, field) ((unsigned) &(((type *) 0)->field))
 
#define ENTRIES(ARRAY) ((int) (sizeof (ARRAY) / sizeof (ARRAY[0])))
 
#define CLEAR(X) bzero (&(X), sizeof (X))
 
 
#define ATOMIC_READ(OBJ)        __atomic_load_n (&(OBJ), __ATOMIC_RELAXED)
#define ATOMIC_WRITE(OBJ, VAL)  __atomic_store_n (&(OBJ), VAL, __ATOMIC_RELAXED)
#define ATOMIC_INC(OBJ, N)      __atomic_exchange_n (&(OBJ), (OBJ) + (N), __ATOMIC_RELAXED)
 
 
size_t Write (int fd, const void *buf, size_t count);
 
size_t Read (int fd, void *buf, size_t count);
 
bool MakeDir (const char *relOrAbsPath, bool setHome2lGroup = true);
 
bool UnlinkTree (const char *relOrAbsPath, const char *skipPattern = NULL);
 
bool ReadDir (const char *relOrAbsPath, class CKeySet *ret);
 
 
 
 
 
 
 
 
// ********************** Logging and Debugging ********************************
 
 
#if WITH_DEBUG == 1
extern int envDebug;            
#else
#define envDebug 0
#endif
 
 
typedef void FLogCbMessage (const char *title, const char *msg);
typedef void FLogCbToast (const char *msg, bool showLonger);
 
 
#if !ANDROID
void LogToSyslog (const char *instanceName = NULL);      
void LogClose ();
bool LoggingToSyslog ();
void LogStack ();         
static inline void LogSetCbMessage (FLogCbMessage *_cbMessage) {}
static inline void LogSetCallbacks (FLogCbMessage *_cbMessage, FLogCbToast *_cbToast) {}
#else
static inline void LogToSyslog () {}
static inline void LogClose () {}
static inline bool LoggingToSyslog () { return true; }
static inline void LogStack () {}
void LogSetCallbacks (FLogCbMessage *_cbMessage, FLogCbToast *_cbToast);
#endif
 
void LogPara (const char *_logHead, const char* _logFile, int _logLine);    // Helper only; use the following macros instead
void LogPrintf (const char *format, ...);     // Helper only; use the following macros instead
 
 
#if WITH_DEBUG == 1
#define DEBUG(LEVEL, MSG) do { if (envDebug >= LEVEL) { LogPara ("DEBUG-" #LEVEL, __FILE__, __LINE__); LogPrintf (MSG); } } while (0)
#define DEBUGF(LEVEL, FMT) do { if (envDebug >= LEVEL) { LogPara ("DEBUG-" #LEVEL, __FILE__, __LINE__); LogPrintf FMT; } } while (0)
#else
#define DEBUG(LEVEL, MSG) do {} while (0)
#define DEBUGF(LEVEL, FMT) do {} while (0)
#endif
 
#define INFO(MSG) do { LogPara ("INFO", __FILE__, __LINE__); LogPrintf (MSG); } while (0)
#define INFOF(FMT) do { LogPara ("INFO", __FILE__, __LINE__); LogPrintf FMT; } while (0)
 
#define WARNING(MSG) do { LogPara ("WARNING", __FILE__, __LINE__); LogPrintf (MSG); } while (0)
#define WARNINGF(FMT) do { LogPara ("WARNING", __FILE__, __LINE__); LogPrintf FMT; } while (0)
 
#define SECURITY(MSG) do { LogPara ("SECURITY", __FILE__, __LINE__); LogPrintf (MSG); } while (0)
#define SECURITYF(FMT) do { LogPara ("SECURITY", __FILE__, __LINE__); LogPrintf FMT; } while (0)
 
#define ERROR(MSG) do { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf (MSG); _exit (3); } while (0)
#define ERRORF(FMT) do { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf FMT; _exit (3); } while (0)
 
#define ABORT(MSG) do { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf (MSG); abort (); } while (0)
#define ABORTF(FMT) do { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf FMT; abort (); } while (0)
 
#define ASSERT(COND) do { if (!(COND)) { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf ("Assertion failed"); LogStack (); abort (); } } while (0)
#define ASSERTM(COND,MSG) do { if (!(COND)) { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf ("Assertion failed: %s", MSG); LogStack (); abort (); } } while (0)
#define ASSERTF(COND,FMT) do { if (!(COND)) { LogPara ("ERROR", __FILE__, __LINE__); LogPrintf ("Assertion failed - explanation follows."); LogPrintf FMT; abort (); LogStack (); abort (); } } while (0)
 
#define ASSERT_WARN(COND) do { if (!(COND)) WARNING("Weak assertion failed"); } while (0)
 
 
 
 
// ***** Compile-time assertion *****
 
 
#if __cplusplus >= 201103L
#define STATIC_ASSERT(COND) static_assert (COND, "please check!")
#else
#define STATIC_ASSERT(COND) static inline void build_assert_##__LINE__() { (void) sizeof(char[(COND) - 1]); }
#endif
 
 
 
 
 
 
 
// *************************** Safe heap operations ****************************
 
 
#define MALLOC(T, N) (T*) malloc (sizeof (T) * (N))
#define REALLOC(T, P, N) (T*) realloc (P, sizeof (T) * (N))
#define SETP(P, X) { if (P) free (P); P = (X); }
#define FREEP(P) SETP(P, NULL)
 
 
#define SETO(O, X) { if (O) delete O; O = (X); }
#define FREEO(O) SETO(O, NULL)
 
#define SETA(A, X) { if (A) delete [] A; A = (X); }
#define FREEA(A) SETA(A, NULL)
 
 
 
 
 
 
 
// *************************** Version Helpers *********************************
 
 
static inline uint32_t VersionCompose (uint8_t major, uint8_t minor, uint16_t revision, bool dirty = false) {
  return (((uint32_t) major) << 24) + (((uint32_t) minor) << 16) + (((uint32_t) revision) << 1) + ((uint32_t) dirty);
}
static inline int VersionMajor (uint32_t ver) { return (int) (ver >> 24); }
static inline int VersionMinor (uint32_t ver) { return (int) ((ver >> 16) & 0xff); }
static inline int VersionRevision (uint32_t ver) { return (int) ((ver >> 1) & 0x7fff); }
static inline bool VersionDirty (uint32_t ver) { return (ver & 1) == 1; }
 
uint32_t VersionFromStr (const char *str);
const char *VersionToStr (class CString *ret, uint32_t ver);
 
static inline const char *VersionGetOwnAsStr () { return buildVersion; }
uint32_t VersionGetOwn ();
 
 
 
 
 
 
 
// ********************** Localization and language ****************************
 
 
// Select the 'gettext' implementation (GNU vs. internal)...
#if ANDROID
#define USE_GNU_GETTEXT 0   // Android does not have GNU gettext => use internal implementation
#else
#define USE_GNU_GETTEXT 0   // can be set to 1, presently set to 0 for debugging purposes
#endif
 
 
// Basic definitions...
#if USE_GNU_GETTEXT   // GNU gettext implementation ...
 
#include <libintl.h>
 
#else                 // Internal implementation ...
 
const char *LangGetText (const char *msgId);
 
#define gettext(STR) LangGetText (STR)
 
#endif
 
 
// Init/done...
void LangInit (const char *localeDir, const char *locale);
  // locale = "" or NULL: use environment setting LC_MESSAGES
  // 'localeDir' is expected to be '$HOME2L_ROOT/locale'. The domain will be automatically set to "home2l",
  // so that the translations for the complete Home2L suite are contained in a single file:
  // '$HOME2L_ROOT/locale/<locale>/LC_MESSAGES/home2l.mo'
void LangDone ();
 
 
// Marking macros...
#define _(STR) gettext(STR)       
#define gettext_noop(STR) STR
#define N_(STR) gettext_noop(STR) 
 
 
// More helpers...
void LangTranslateNumber (char *str);
 
 
 
 
 
 
 
// *************************** Strings *****************************************
 
 
#define WHITESPACE " \t\n\r\v"    
 
 
// ***** Misc. helpers *****
 
 
class CString *GetThreadTempString ();
 
#define TTS (GetThreadTempString ())
 
const char *StringF (class CString *ret, const char *fmt, ...);
 
bool BoolFromString (const char *str, bool *ret);
bool ValidBoolFromString (const char *str, bool defaultVal);
bool IntFromString (const char *str, int *ret, int radix = 0);
int ValidIntFromString (const char *str, int defaultVal, int radix = 0);
bool UnsignedFromString (const char *str, unsigned *ret, int radix = 0);
unsigned ValidUnsignedFromString (const char *str, unsigned defaultVal, int radix = 0);
bool FloatFromString (const char *str, float *ret);
float ValidFloatFromString (const char *str, float defaultVal);
 
void StringStrip (char *str, const char *sepChars = WHITESPACE);
void StringTruncate (char *str, const char *sepChars = WHITESPACE, bool after = false);
void StringSplit (const char *str, int *retArgc, char ***retArgv, int maxArgc = INT_MAX, const char *sepChars = NULL, char **retRef = NULL);
void StringSplitFree (char ***argv);
 
bool CharIsWhiteSpace (char c);
 
 
void PathNormalize (char *str);             
void PathRemoveTrailingSlashes (char *str); 
const char *PathLeaf (const char *str);     
 
const char *GetAbsPath (class CString *ret, const char *relOrAbsPath, const char *defaultPath);
 
 
const char *ToUtf8 (class CString *ret, const char *iso8859str);
const char *ToIso8859 (class CString *ret, const char *str);
 
 
 
// ***** CString *****
 
 
class CString {
  public:
    CString () { size = 0; ptr = (char *) emptyStr; }
    CString (const CString& str) { size = 0; Set (str.Get ()); }    
    CString (const char *str, int maxLen = INT_MAX) { size = 0; Set (str, maxLen); }
    ~CString () { if (size) free (ptr); }
 
    void Clear () { SetC (emptyStr); }
    void Set (char c) { Clear (); Insert (0, c); }
    void Set (const char *str, int maxLen = INT_MAX);
    void SetF (const char *fmt, ...);
    void SetFV (const char *fmt, va_list ap);
 
    void SetC (const char *_ptr);
 
    void SetO (const char *_ptr);
    char *Disown ();
 
    static const char * const emptyStr;       
 
    void SetFromIso8859 (const char *iso8859str);   
    bool SetAsIso8859 (const char *str);            
 
    char *Get () const { return ptr; }    
    int Len () { return strlen (ptr); }   
    bool IsEmpty () { return ptr[0] == '\0'; }  
 
    void Del (int n0, int dn = INT_MAX);
 
    void Insert (int n0, int dn, int *retInsPos = NULL);
    void Insert (int n0, char c);
    void Insert (int n0, const char *str, int maxLen = INT_MAX);
    void InsertF (int n0, const char *fmt, ...);
    void InsertFV (int n0, const char *fmt, va_list ap);
 
    void Append (char c) { Insert (INT_MAX, c); }
    void Append (const char *str, int maxLen = INT_MAX) { Insert (INT_MAX, str, maxLen); }
    void AppendF (const char *fmt, ...);
    void AppendFV (const char *fmt, va_list ap) { InsertFV (INT_MAX, fmt, ap); }
 
    int Compare (const char *str2);
 
    void Strip (const char *sepChars = WHITESPACE);
    void Truncate (const char *sepChars = WHITESPACE, bool after = false);
 
    void Split (class CSplitString *args, int maxArgc = INT_MAX, const char *sepChars = WHITESPACE);
    void Split (int *retArgc, char ***retArgv, int maxArgc = INT_MAX, const char *sepChars = WHITESPACE) { StringSplit (ptr, retArgc, retArgv, maxArgc, sepChars); }
 
    void AppendFByLine (const char *fmt, const char *text);
    void SetFByLine (const char *fmt, const char *text) { Clear (); AppendFByLine (fmt, text); }
 
    void AppendEscaped (const char *s, const char *dontEscape = NULL);
    void SetEscaped (const char *s, const char *dontEscape = NULL) { Clear (); AppendEscaped (s, dontEscape); }
 
    bool AppendUnescaped (const char *s);
    bool SetUnescaped (const char *s) { Clear (); return AppendUnescaped (s); }
 
    void PathNormalize ();
    void PathRemoveTrailingSlashes ();
    const char *PathLeaf () { return ::PathLeaf (ptr); }
    void PathGo (const char *where);
    void PathGoUp ();
 
    bool ReadFile (const char *relOrAbsPath);
    bool AppendFromFile (int fd, const char *name = NULL);
    bool ReadLine (CString *ret);
 
    operator char * () { return ptr; }
 
    CString& operator = (const CString &str) { Set (str.Get ()); return *this; }
    CString& operator = (const char *str) { Set (str); return *this; }
    char& operator [] (int n) { return n >= 0 ? ptr [n] : ptr [strlen (ptr) + n]; }
    CString operator + (const char *str);
    CString& operator += (char c) { Append (c); return *this; }
    CString& operator += (const char *str) { Append (str); return *this; }
 
    bool operator < (const char *str) { return Compare (str) < 0; }
    bool operator > (const char *str) { return Compare (str) > 0; }
    bool operator <= (const char *str) { return Compare (str) <= 0; }
    bool operator >= (const char *str) { return Compare (str) >= 0; }
    bool operator == (const char *str) { return Compare (str) == 0; }
    bool operator != (const char *str) { return Compare (str) != 0; }
 
    // Interfaces ...
    const char *ToStr (CString *) { return Get (); }   // (internal, for 'CDict')
 
  protected:
    void SetSize (int _size);
    void MakeWriteable () { if (!size) SetSize (strlen (ptr) + 1); }    // '+1' is just for the case that string was empty
 
    char *ptr;
    int size;   // number of allocated bytes (including '\0`);
                //'size' == 0: nothing allocated in heap ('ptr' may still point to some constant string
 
};
 
 
 
// ***** CSplitString *****
 
 
class CSplitString {
  public:
    CSplitString () { argc = 0; argv = NULL; ref = NULL; }
    CSplitString (const char *str, int maxArgc = INT_MAX, const char *sepChars = NULL) { StringSplit (str, &argc, &argv, maxArgc, sepChars, &ref); }
    ~CSplitString () { Clear (); }
 
    void Clear ();
 
    void Set (const char *str, int maxArgc = INT_MAX, const char *sepChars = NULL) { Clear (); StringSplit (str, &argc, &argv, maxArgc, sepChars, &ref); }
 
    int Entries () const { return argc; }     
    const char *Get (int idx) const { return argv[idx]; }       
    const char *operator [] (int n) const { return Get (n); }   
 
    int GetOffset (int argNo) { return (argv && ref) ? argv[argNo] - ref : 0; }
    int GetOffset (const char *p) { return ref ? (p - ref) : 0; }
    int GetIdx (int pos);
 
  protected:
    int argc;
    char **argv, *ref;
};
 
 
 
// ***** Regexp *****
 
 
class CRegex {
  public:
    CRegex () { reValid = false; lastError = 0; }
    ~CRegex () { if (reValid) regfree (&re); }
 
    bool SetPattern (const char *pattern, int cflags = REG_EXTENDED);
    bool Match (const char *s, int eflags = 0, size_t maxMatches = 0, regmatch_t *retMatchList = NULL);
 
    bool IsValid () { return reValid; }
    const char *ErrorStr ();
 
  private:
    CString errorStr;
    bool reValid;
    int lastError;
    regex_t re;
};
 
 
 
 
 
 
 
// ********************** Container Classes ************************************
 
 
#define CONT_ALIGNMENT 4
#define CONT_ALIGN(X) (((X) + CONT_ALIGNMENT - 1) & ~(CONT_ALIGNMENT - 1))
 
 
 
// ***** Stringification of container values ****
 
 
// Template for all classes, which must have a 'ToStr()' method ...
template <typename T> const char *ToStr (CString *ret, T *obj) { return obj->ToStr (ret); }
 
// Specializations for non-class types (more specializations may be added here as required) ...
template <> const char *ToStr<int> (CString *ret, int *obj);
 
 
 
// ***** CList... *****
 
 
class CListRaw {
  public:
    CListRaw (int _recSize);
    virtual ~CListRaw () { Clear (); }
 
    int Entries () const { return entries; }
 
    void Clear () { SetEntries (0); }
    void Del (int idx);
 
    virtual void Dump (const char *name);   
 
  protected:
 
    // Methods to be overloaded by derived classes ...
    virtual void RecInit (void *p);
      // Initialize record in previously uninitialized memory.
      // This method is also used to wipe entries that have been copied and are no longer owned.
    virtual void RecClear (void *p);
      // Clear (initialized) record such that no destructor call is necessary anymore.
 
    virtual void ValueInit (void *p) {}
      // Initialize value data in previously uninitialized memory
    virtual void ValueClear (void *p) {}
      // Clear (initialized) record such that no destructor call is necessary anymore
    virtual void ValueSet (void *p, void *orig) {}
      // Copy or move 'orig' to 'p' properly. Both are initialized objects.
      // The derived class must specify whether 'orig' is copied or moved (= disowned) by this
      // and document the behavior for
    virtual const char *ValueToStr (CString *ret, void *p);
                                          // return readable string for the 'Dump' method
 
    // Helpers for derived classes ...
    void SetEntries (int _entries);
 
    uint8_t *GetRecAdr (int idx) const { return idx < 0 ? NULL : data + recSize * idx; }
      // Get memory address of whole record (including eventual tag)
    uint8_t *GetValueAdr (int idx) const { return idx < 0 ? NULL : data + recSize * idx + tagSize; }
      // Get memory address of the value part of the record (for '...Compact' classes)
    void *GetValuePtr (int idx) const { return idx < 0 ? NULL : * (void **) (GetValueAdr (idx)); }
      // (for non-compact classes) Take the value part inside the record as a pointer to the real value and dereference it
 
    void Copy (int idxDst, int idxSrc);   // byte-copy entry
    void Swap (void *rec0, void *rec1);   // byte-swap two entries (potentially from different objects)
 
    void SetRaw (int idx, void *value);
      // Set a new entry. The entry must exist and 'idx' be valid.
      // 'value' may either be copied or moved, see comment to 'ValueSet()'.
    void InsertRaw (int idx, void *value);
      // Insert a new entry in position 'idx'.
      // 'value' may either be copied or moved, see comment to 'ValueSet()'.
    void *DisownRaw (int idx);
      // (for non-compact classes) Take the value part inside the record as a pointer to the real value,
      // return it and set it to NULL in the record.
 
    // Data ...
    uint8_t *data;
    int recSize, tagSize, entries, allocEntries;
      // 'tagSize' is an offset inside a record. It can be used by derived classes,
      //  e.g. by 'CDictRaw' to reserve space for keys.
};
 
 
template <typename T> class CList: public CListRaw {
  public:
    CList (): CListRaw (sizeof (T *)) {}
 
    T *Get (int idx) { return (T *) GetValuePtr (idx); }
    T *operator [] (int idx) { return Get (idx); }
 
    void Set (int idx, T *value) { SetRaw (idx, value); }
    void Insert (int idx, T *value) { InsertRaw (idx, value); }
    void Append (T *value) { InsertRaw (INT_MAX, value); }
    T *Disown (int idx) { return (T *) DisownRaw (idx); }
 
  protected:
    virtual void ValueInit (void *p) { * (T **) p = NULL; }
    virtual void ValueClear (void *p) { if (* (T**) p) { delete * (T **) p; * (T **) p = NULL; } }
    virtual void ValueSet (void *p, void *orig) { ValueClear (p); * (T**) p = (T*) orig; }
    virtual const char *ValueToStr (CString *ret, void *p) { return ::ToStr<T> (ret, * (T**) p); }
};
 
 
template <typename T> class CListCompact: public CListRaw {
  public:
    CListCompact (): CListRaw (sizeof (T)) {}
    virtual ~CListCompact () { Clear (); }
 
    T *Get (int idx) { return (T *) GetValueAdr (idx); }
    T *operator [] (int idx) { return Get (idx); }
 
    void Set (int idx, T *value) { SetRaw (idx, value); }
    void Insert (int idx, T *value) { InsertRaw (idx, value); }
    void Append (T *value) { InsertRaw (INT_MAX, value); }
 
  protected:
    virtual void ValueInit (void *p) { memcpy (p, &emptyObj, sizeof (emptyObj)); }
    virtual void ValueClear (void *p) { ValueSet (p, &emptyObj); }
    virtual void ValueSet (void *p, void *orig) { * (T *) p = * (T *) orig; }
    virtual const char *ValueToStr (CString *ret, void *p) { return ::ToStr<T> (ret, (T*) p); }
 
    T emptyObj;   // Template for an initialized object
};
 
 
template <typename T> class CListRef: public CList<T> {
  protected:
    virtual void ValueClear (void *p) { * (T **) p = NULL; }
    virtual void ValueSet (void *p, void *orig) { * (T**) p = (T*) orig; }
};
 
 
 
// ***** CDict... *****
 
 
#define DICT_KEYSIZE CONT_ALIGN((int) sizeof (CString))
 
 
class CDictRaw: public CListRaw {
  public:
    CDictRaw (int _valueSize): CListRaw (_valueSize + DICT_KEYSIZE) { tagSize = DICT_KEYSIZE; }
 
    void Del (int idx) { CListRaw::Del (idx); }
    void Del (const char *key) { Del (Find (key)); }
 
    const char *GetKey (int idx) const { return ((CString *) GetRecAdr (idx))->Get (); }
    int Find (const char *key, int *retInsIdx = NULL);
    void PrefixSearch (const char *key, int *retIdx0, int *retIdx1);
 
    virtual void Dump (const char *name);
 
  protected:
    virtual void RecInit (void *p);
    virtual void RecClear (void *p);
 
    void SetRaw (int idx, void *value) { CListRaw::SetRaw (idx, value); }
    int SetRaw (const char *key, void *value);     // add or replace the keyed entry; returns new index
 
    void MergeRaw (CDictRaw *dict2);               // merge 'dict2' into this one and clear 'dict2'
};
 
 
template <typename T> class CDict: public CDictRaw {
  public:
    CDict (): CDictRaw (sizeof (T *)) {}
 
    T *Get (int idx) { return (T *) GetValuePtr (idx); }
    T *Get (const char *key) { return Get (Find (key)); }
    T *operator [] (int idx) { return Get (idx); }
    T *operator [] (const char *key) { return Get (key); }
 
    int Set (const char *key, T *value) { return SetRaw (key, value); }
    void SetValue (int idx, T *value) { SetRaw (idx, value); }
    T *DisownValue (int idx) { return (T *) DisownRaw (idx); }
    T *DisownValue (const char *key) { return (T *) DisownRaw (Find (key)); }
 
    void Merge (CDict<T> *dict2) { MergeRaw (dict2); }
 
  protected:
    virtual void ValueInit (void *p) { * (T **) p = NULL; }
    virtual void ValueClear (void *p) { if (* (T**) p) { delete * (T **) p; * (T **) p = NULL; } }
    virtual void ValueSet (void *p, void *orig) { ValueClear (p); * (T**) p = (T*) orig; }
    virtual const char *ValueToStr (CString *ret, void *p) { return ::ToStr<T> (ret, * (T**) p); }
};
 
 
template <typename T> class CDictCompact: public CDictRaw {
  public:
    CDictCompact (): CDictRaw (sizeof (T)) {}
 
    T *Get (int idx) { return (T *) GetValueAdr (idx); }
    T *Get (const char *key) { return Get (Find (key)); }
    T *operator [] (int idx) { return Get (idx); }
    T *operator [] (const char *key) { return Get (key); }
 
    int Set (const char *key, T *value) { return SetRaw (key, value); }
    void SetValue (int idx, T *value) { SetRaw (idx, value); }
    void Merge (CDictCompact<T> *dict2) { MergeRaw (dict2); }
 
  protected:
    virtual void ValueInit (void *p) { memcpy (p, (void *) &emptyObj, sizeof (emptyObj)); }
    virtual void ValueClear (void *p) { ValueSet (p, (void *) &emptyObj); }
    virtual void ValueSet (void *p, void *orig) { * (T *) p = * (T *) orig; }
    virtual const char *ValueToStr (CString *ret, void *p) { return ::ToStr<T> (ret, (T*) p); }
 
    T emptyObj;   // Template for an initialized object
};
 
 
template <typename T> class CDictRef: public CDict<T> {
  protected:
    virtual void ValueClear (void *p) { * (T **) p = NULL; }
    virtual void ValueSet (void *p, void *orig) { * (T**) p = (T*) orig; }
};
 
 
 
// ***** CKeySet *****
 
class CKeySet: public CDictRaw {
  public:
    CKeySet (): CDictRaw (0) {}
 
    const char *operator [] (int idx) { return GetKey (idx); }
 
    int Set (const char *key) { return SetRaw (key, NULL); }
    void Merge (CKeySet *set2) { MergeRaw (set2); }
 
    virtual void Dump (const char *name);
};
 
 
 
 
 
 
 
// *************************** Date & Time *************************************
 
 
 
typedef int64_t TTicks;
 
#define ASAP   ((TTicks) 0)
#define NEVER  ((TTicks) INT64_MIN)
 
 
TTicks TicksNow ();
TTicks TicksNowMonotonic ();
 
TTicks TicksAbsFromMonotic (TTicks tm);
TTicks TicksMonotonicFromAbs (TTicks ta);
 
const char *TicksAbsToString (CString *ret, TTicks ticks, int fracDigits = INT_MAX, bool precise = false);
const char *TicksRelToString (CString *ret, TTicks ticks);
 
bool TicksFromString (const char *str, TTicks *ret, bool absolute);
static inline bool TicksAbsFromString (const char *str, TTicks *ret) { return TicksFromString (str, ret, true); }
static inline bool TicksRelFromString (const char *str, TTicks *ret) { return TicksFromString (str, ret, false); }
 
void TicksToStructTimeval (TTicks t, struct timeval *retTv);
 
#define TICKS_FROM_SECONDS(S) (((TTicks) (S)) * 1000)         
#define SECONDS_FROM_TICKS(T) (((TTicks) (T) + 500) / 1000)   
#define TICKS_FROM_MILLIS(MS) ((TTicks) (MS))                 
#define MILLIS_FROM_TICKS(T)  ((int) (T))                     
 
 
 
 
typedef int TDate;      // Date encoded as bit fields
 
#define DATE_OF(Y,M,D) ((TDate) (((Y) << 9) | ((M) << 5) | (D)))
#define YEAR_OF(DT) ((int) (DT) >> 9)
#define MONTH_OF(DT) (((int) (DT) >> 5) & 0xf)    // range is 1..12 (different from 'struct tm' in <time.h>)
#define DAY_OF(DT) ((int) (DT) & 0x1f)            // range is 1..31
 
 
typedef int TTime;      // Time in seconds since midnight
 
#define TIME_OF(H,M,S) ((TTime) ((H) * 3600 + (M) * 60 + (S)))
#define HOURS_OF(T) ((int) (T) / 3600)
#define MINUTES_OF(T) ((int) (T) / 60)
#define HOUR_OF(T) HOURS_OF(T)
#define MINUTE_OF(T) (MINUTES_OF(T) % 60)
#define SECOND_OF(T) ((int) (T) % 60)
 
 
 
TTicks TicksOfDate (int dy, int dm, int dd);      // range of 'dm' is 1..12
TTicks TicksOfDate (TDate d);
TTicks TicksOfTime (int th, int tm, int ts);
TTicks TicksOfTime (TTime t);
 
TDate DateOfTicks (TTicks t);
TTime TimeOfTicks (TTicks t);
 
TTicks DateTimeToTicks (TDate d, TTime t, struct tm *retTm = NULL);
#if !ANDROID
TTicks DateTimeToTicksUTC (TDate d, TTime t, struct tm *retTm = NULL);
#endif
void TicksToDateTime (TTicks t, TDate *retDate, TTime *retTime, struct tm *retTm = NULL);
void TicksToDateTimeUTC (TTicks t, TDate *retDate, TTime *retTime, struct tm *retTm = NULL);
 
 
static inline void DateTimeNow (TDate *d, TTime *t) { TicksToDateTime (TicksNow (), d, t, NULL); }
TDate Today ();
TTicks TicksToday ();
 
 
TDate DateIncByDays (TDate date, int dDays);
int DateDiffByDays (TDate d1, TDate d0);    // returns "d1" - "d0" in days
 
TDate DateIncByMonths (TDate date, int dMon);
 
static inline TDate DateFirstOfMonth (TDate date) { return (date & ~0x1f) + 1; }
 
int GetWeekDay (TDate date);    // range is 0..6 (Mon..Sun)
int GetCalWeek (TDate date);
 
 
const char *MonthName (int dm);       
const char *MonthNameShort (int dm);  
const char *DayName (int wd);         
const char *DayNameShort (int wd);    
 
 
 
 
 
 
 
 
// *************************** Timer *******************************************
 
 
typedef void FTimerCallback (class CTimer *timer, void *data);
 
 
class CTimer {
  public:
    CTimer ();
    CTimer (FTimerCallback *_func, void *_data = NULL, void *_creator = NULL) { Set (_func, _data, _creator); }
    CTimer (TTicks _time, TTicks _interval = 0, FTimerCallback *_func = NULL, void *_data = NULL, void *_creator = NULL) { Set (_time, _interval, _func, _data, _creator); }
    virtual ~CTimer () { Clear (); }
 
    void Set (FTimerCallback *_func, void *_data = NULL, void *_creator = NULL);
    void Set (TTicks _time, TTicks _interval = 0, FTimerCallback *_func = NULL, void *_data = NULL, void *_creator = NULL);
 
    void Reschedule (TTicks _time, TTicks _interval = 0);
    void Clear ();                              
    static void DelByCreator (void *_creator);  
    void *GetCreator () { return creator; }
 
    bool Pending () { return isLinked; }
 
    // Timer callback...
    virtual void OnTime () { if (func) func (this, data); }
 
  protected:
    friend bool TimerIterate ();
    friend TTicks TimerGetDelay ();
    friend void TimerRun ();
    friend void *TimerThreadRoutine (void *);
 
    static bool ClassIterateAL ();
    static TTicks GetDelayTimeAL ();
 
    void InsertAL ();
    void UnlinkAL ();
 
    static CTimer *first;   // for chained list
    CTimer *next;           // for chained list
    bool isLinked;          // indicates, whether element is in the linked list
 
    TTicks nextTicks, interval;
    void *creator;        // this object is managed externally, the caller has a reference to it and must remove it
 
    FTimerCallback *func;
    void *data;
};
 
 
 
bool TimerIterate ();
TTicks TimerGetDelay ();
 
void TimerStart ();
int TimerRun (bool catchSignals = true);
void TimerStop ();
 
 
 
 
 
 
 
// ********************** Threading and Synchronization ************************
 
 
typedef void *FThreadRoutine (void *data);
 
 
class CThread {
  public:
    CThread () { running = false; }
    virtual ~CThread () { if (running) Join (); }
 
    void Start (FThreadRoutine *_routine, void *_data = NULL);
    void Start ();  
    void *Join ();  
 
    bool IsRunning () { return running;  } 
 
  protected:
    friend void *CThreadRoutine (void *);
 
    virtual void *Run () { return NULL; } 
 
    bool running;
    pthread_t thread;
};
 
 
class CMutex {
  public:
    CMutex ();
    ~CMutex ();
 
    void Lock ();
    bool TryLock ();
    void Unlock ();
 
  protected:
    friend class CCond;
    pthread_mutex_t mutex;
};
 
 
class CCond {
  public:
    CCond ();
    ~CCond ();
 
    void Wait (CMutex *mutex);
    TTicks Wait (CMutex *mutex, TTicks maxTime);
    void Signal ();           
    void Broadcast ();        
 
  protected:
    pthread_cond_t cond;
};
 
 
class CSleeper {
  public:
    CSleeper ();
    ~CSleeper () { Done (); }
    void Done ();
 
    void EnableCmds (int _cmdRecSize);
 
    void Prepare ();
    void AddReadable (int fd);
    void AddWritable (int fd);
 
    void Sleep (TTicks maxTime = -1);
 
    bool IsReadable (int fd);   
    bool IsWritable (int fd);   
    bool GetCmd (void *retCmdRec);
 
    void PutCmd (const void *cmdRec, TTicks t = 0, TTicks _interval = 0);
    void ClearTimedCmds () { CTimer::DelByCreator (this); }
 
  protected:
    fd_set fdSetRead, fdSetWrite;
    int maxFd, cmdRecSize;
    int selfPipe[2];
};
 
 
 
void Sleep (TTicks mSecs);
 
 
 
 
 
 
 
 
 
 
// *************************** CShell and variants *****************************
 
 
// ***** Abstract base class and functions *****
 
 
class CShell {
  public:
    CShell () { exitCode = -1; }
    virtual ~CShell () {}
 
    virtual bool Start (const char *cmd, bool readStdErr = false) = 0;
    virtual bool StartRestricted (const char *name, const char *args = NULL);
    virtual bool IsRunning () { return !ReadClosed (); }
    virtual void Wait () = 0;
    virtual void Kill (int sig = SIGTERM) { WriteClose (); }
    int ExitCode () { return exitCode; }
 
    int Run (const char *cmd, const char *input = NULL, CString *output = NULL);
 
    virtual void CheckIO (bool *canWrite, bool *canRead, TTicks maxTime = -1) = 0;
    bool WaitUntilReadable (TTicks maxTime = -1) { bool canRead; CheckIO (NULL, &canRead, maxTime); return canRead; }
    bool WaitUntilWritable (TTicks maxTime = -1) { bool canWrite; CheckIO (&canWrite, NULL, maxTime); return canWrite; }
 
    bool Writable () { return WaitUntilWritable (0); }
    virtual void WriteLine (const char *line) = 0;
    void WriteLine (CString *str) { WriteLine (str->Get ()); }
    virtual void WriteClose () = 0;
 
    bool Readable () { return WaitUntilReadable (0); }
    virtual bool ReadLine (CString *str) = 0;
    virtual bool ReadClosed () = 0;
 
  protected:
    int exitCode;
};
 
 
 
 
// ***** CShellBare *****
 
 
class CShellBare: public CShell {
  public:
    CShellBare () { host = NULL; newProcessGroup = false; fdToScript = fdFromScript = childPid = -1; }
    virtual ~CShellBare () { Done (); }
    void Done ();
 
    virtual bool Start (const char *cmd, bool readStdErr = false);
    virtual bool IsRunning ();
    virtual void Wait ();
    virtual void Kill (int sig = SIGTERM); 
 
    virtual void CheckIO (bool *canWrite, bool *canRead, TTicks maxTime = -1);
 
    virtual void WriteLine (const char *line);
    virtual void WriteClose ();
 
    virtual bool ReadLine (CString *str);
    virtual bool ReadClosed () { return fdFromScript < 0 && !readBufMayContainLine; }
 
 
    int ReadFd () { return fdFromScript; }   
    int WriteFd () { return fdToScript; }    
 
    void SetHost (const char *_host);
    const char *Host () { return host; }
    bool HasHost () { return !host.IsEmpty (); }
    void SetNewProcessGroup (bool on = true) { newProcessGroup = on; }
    bool StartSession (bool readStdErr = false) { return Start (NULL, readStdErr); }
 
  protected:
    CString id, host;
    bool newProcessGroup;
    CString readBuf;
    bool readBufMayContainLine;
    int fdToScript, fdFromScript;
    int childPid, killSig;
 
    bool DoWaitPid (int options);
};
 
 
 
// ***** CShellSession *****
 
 
class CShellSession: public CShell {
  public:
    CShellSession () { writeOpen = readOpen = false; }
    virtual ~CShellSession () { Done (); }
    void Done ();
 
    void SetHost (const char *_host) { session.SetHost (_host); }
    const char *Host () { return session.Host (); }
    bool HasHost () { return session.HasHost (); }
 
    virtual bool Start (const char *cmd, bool readStdErr = false);
    virtual void Wait ();
 
    virtual void CheckIO (bool *canWrite, bool *canRead, TTicks maxTime = -1);
 
    virtual void WriteLine (const char *line) { session.WriteLine (line); }
    virtual void WriteClose ();
 
    virtual bool ReadLine (CString *str);
    virtual bool ReadClosed () { return !readOpen; }
 
    int ReadFd () { return session.ReadFd (); }      
    int WriteFd () { return session.WriteFd (); }    
 
  protected:
    CShellBare session;
    bool writeOpen, readOpen;
};
 
 
 
 
 
 
 
// *************************** Service managing ********************************
 
 
// ***** CServiceKeeper *****
 
 
class CServiceKeeper {
  public:
 
    CServiceKeeper () { isOpen = shouldBeOpen = false; tDShort = tDLong = tShortToLong = 0; }
    CServiceKeeper (TTicks _tDShort, TTicks _tDLong = NEVER, TTicks _tShortToLong = NEVER)
      { isOpen = shouldBeOpen = false; Setup (_tDShort, _tDLong, _tShortToLong); }
    ~CServiceKeeper () { Close (); }
 
    void Setup (TTicks _tDShort, TTicks _tDLong = NEVER, TTicks _tShortToLong = NEVER) { tDShort = _tDShort; tDLong = _tDLong; tShortToLong = _tShortToLong; }
 
    void Open () { shouldBeOpen = true; Refresh (); }
    void Close () { shouldBeOpen = false; }
 
    void Refresh ();
 
    void Iterate ();
 
    bool IsOpen () { return isOpen; }
    bool ShouldBeOpen () { return shouldBeOpen; }
 
    virtual void DoOpen () {}
    virtual void DoClose () {}
 
    bool OpenAttemptNow ();
    bool CloseNow ();
 
    void ReportLost ();
    void ReportOpenAttempt (bool success);
    void ReportClosed () { isOpen = false; }
 
  protected:
    bool isOpen, shouldBeOpen;
    TTicks tLastOpen;    // last time the service was known to be open (only valid if 'isOpen == false' and 'shouldBeOpen == true')
    TTicks tNextAttempt; // time of next open attempt (only valid if 'isOpen == false' and 'shouldBeOpen == true')
    TTicks tDShort, tDLong, tShortToLong;
};
 
 
 
 
 
 
 
// *************************** Doxygen Hooks  **********************************
//
// Declare groups for the other modules in "common".
 
 
 
 
 
 
 
#endif