mirror of
https://github.com/VDR4Arch/vdr.git
synced 2023-10-10 13:36:52 +02:00
267 lines
7.3 KiB
C++
267 lines
7.3 KiB
C++
/*
|
|
* tools.h: Various tools
|
|
*
|
|
* See the main source file 'vdr.c' for copyright information and
|
|
* how to reach the author.
|
|
*
|
|
* $Id: tools.h 1.61 2004/12/19 18:06:10 kls Exp $
|
|
*/
|
|
|
|
#ifndef __TOOLS_H
|
|
#define __TOOLS_H
|
|
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <objalloc.h>
|
|
#include <poll.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <syslog.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
typedef unsigned char uchar;
|
|
typedef unsigned long long int uint64;
|
|
|
|
extern int SysLogLevel;
|
|
|
|
#define esyslog(a...) void( (SysLogLevel > 0) ? syslog(LOG_ERR, a) : void() )
|
|
#define isyslog(a...) void( (SysLogLevel > 1) ? syslog(LOG_INFO, a) : void() )
|
|
#define dsyslog(a...) void( (SysLogLevel > 2) ? syslog(LOG_DEBUG, a) : void() )
|
|
|
|
#define LOG_ERROR esyslog("ERROR (%s,%d): %m", __FILE__, __LINE__)
|
|
#define LOG_ERROR_STR(s) esyslog("ERROR: %s: %m", s)
|
|
|
|
#define SECSINDAY 86400
|
|
|
|
#define KILOBYTE(n) ((n) * 1024)
|
|
#define MEGABYTE(n) ((n) * 1024 * 1024)
|
|
|
|
#define MAXPARSEBUFFER KILOBYTE(10)
|
|
|
|
#define MALLOC(type, size) (type *)malloc(sizeof(type) * (size))
|
|
|
|
#define DELETENULL(p) (delete (p), p = NULL)
|
|
|
|
#define CHECK(s) { if ((s) < 0) LOG_ERROR; } // used for 'ioctl()' calls
|
|
#define FATALERRNO (errno != EAGAIN && errno != EINTR)
|
|
|
|
#ifndef __STL_CONFIG_H // in case some plugin needs to use the STL
|
|
template<class T> inline T min(T a, T b) { return a <= b ? a : b; }
|
|
template<class T> inline T max(T a, T b) { return a >= b ? a : b; }
|
|
template<class T> inline int sgn(T a) { return a < 0 ? -1 : a > 0 ? 1 : 0; }
|
|
template<class T> inline void swap(T &a, T &b) { T t = a; a = b; b = t; }
|
|
#endif
|
|
|
|
#define BCDCHARTOINT(x) (10 * ((x & 0xF0) >> 4) + (x & 0xF))
|
|
int BCD2INT(int x);
|
|
|
|
ssize_t safe_read(int filedes, void *buffer, size_t size);
|
|
ssize_t safe_write(int filedes, const void *buffer, size_t size);
|
|
void writechar(int filedes, char c);
|
|
char *strcpyrealloc(char *dest, const char *src);
|
|
char *strn0cpy(char *dest, const char *src, size_t n);
|
|
char *strreplace(char *s, char c1, char c2);
|
|
char *strreplace(char *s, const char *s1, const char *s2); ///< re-allocates 's' and deletes the original string if necessary!
|
|
char *skipspace(const char *s);
|
|
char *stripspace(char *s);
|
|
char *compactspace(char *s);
|
|
bool startswith(const char *s, const char *p);
|
|
bool endswith(const char *s, const char *p);
|
|
bool isempty(const char *s);
|
|
int numdigits(int n);
|
|
bool isnumber(const char *s);
|
|
int FreeDiskSpaceMB(const char *Directory, int *UsedMB = NULL);
|
|
bool DirectoryOk(const char *DirName, bool LogErrors = false);
|
|
bool MakeDirs(const char *FileName, bool IsDirectory = false);
|
|
bool RemoveFileOrDir(const char *FileName, bool FollowSymlinks = false);
|
|
bool RemoveEmptyDirectories(const char *DirName, bool RemoveThis = false);
|
|
char *ReadLink(const char *FileName);
|
|
bool SpinUpDisk(const char *FileName);
|
|
time_t LastModifiedTime(const char *FileName);
|
|
|
|
class cTimeMs {
|
|
private:
|
|
uint64 begin;
|
|
public:
|
|
cTimeMs(void);
|
|
void Set(int Ms = 0);
|
|
bool TimedOut(void);
|
|
uint64 Now(void);
|
|
uint64 Elapsed(void);
|
|
};
|
|
|
|
class cBufferedStringFunction {
|
|
protected:
|
|
char *buffer;
|
|
const char *result;
|
|
public:
|
|
cBufferedStringFunction(void);
|
|
virtual ~cBufferedStringFunction();
|
|
const char * operator * () { return result; }
|
|
};
|
|
|
|
template<int size> class cBufferedStringFunctionFix : public cBufferedStringFunction {
|
|
protected:
|
|
char buffer[size];
|
|
const char *result;
|
|
public:
|
|
cBufferedStringFunctionFix(void) { result = ""; } // makes sure dereferencing it doesn't hurt
|
|
const char * operator * () { return result; }
|
|
};
|
|
|
|
class cAddDirectory : public cBufferedStringFunction {
|
|
public:
|
|
cAddDirectory(const char *DirName, const char *FileName);
|
|
};
|
|
|
|
class cStrEscape : public cBufferedStringFunction {
|
|
public:
|
|
cStrEscape(const char *s, const char *chars);
|
|
};
|
|
|
|
class cCtime : public cBufferedStringFunctionFix<32> {
|
|
public:
|
|
cCtime(time_t Time);
|
|
};
|
|
|
|
class cItoa : public cBufferedStringFunctionFix<16> {
|
|
public:
|
|
cItoa(int n);
|
|
};
|
|
|
|
class cWeekDayName : public cBufferedStringFunctionFix<4> {
|
|
private:
|
|
void WeekDayName(int WeekDay);
|
|
public:
|
|
cWeekDayName(int WeekDay);
|
|
cWeekDayName(time_t t);
|
|
};
|
|
|
|
class cDayDateTime : public cBufferedStringFunctionFix<32> {
|
|
public:
|
|
cDayDateTime(time_t t = 0);
|
|
};
|
|
|
|
class cReadLine {
|
|
private:
|
|
char buffer[MAXPARSEBUFFER];
|
|
public:
|
|
char *Read(FILE *f);
|
|
};
|
|
|
|
class cPoller {
|
|
private:
|
|
enum { MaxPollFiles = 16 };
|
|
pollfd pfd[MaxPollFiles];
|
|
int numFileHandles;
|
|
public:
|
|
cPoller(int FileHandle = -1, bool Out = false);
|
|
bool Add(int FileHandle, bool Out);
|
|
bool Poll(int TimeoutMs = 0);
|
|
};
|
|
|
|
class cReadDir {
|
|
private:
|
|
DIR *directory;
|
|
struct dirent *result;
|
|
union { // according to "The GNU C Library Reference Manual"
|
|
struct dirent d;
|
|
char b[offsetof(struct dirent, d_name) + NAME_MAX + 1];
|
|
} u;
|
|
public:
|
|
cReadDir(const char *Directory);
|
|
~cReadDir();
|
|
bool Ok(void) { return directory != NULL; }
|
|
struct dirent *Next(void);
|
|
};
|
|
|
|
class cFile {
|
|
private:
|
|
static bool files[];
|
|
static int maxFiles;
|
|
int f;
|
|
public:
|
|
cFile(void);
|
|
~cFile();
|
|
operator int () { return f; }
|
|
bool Open(const char *FileName, int Flags, mode_t Mode = S_IRUSR | S_IWUSR | S_IRGRP);
|
|
bool Open(int FileDes);
|
|
void Close(void);
|
|
bool IsOpen(void) { return f >= 0; }
|
|
bool Ready(bool Wait = true);
|
|
static bool AnyFileReady(int FileDes = -1, int TimeoutMs = 1000);
|
|
static bool FileReady(int FileDes, int TimeoutMs = 1000);
|
|
static bool FileReadyForWriting(int FileDes, int TimeoutMs = 1000);
|
|
};
|
|
|
|
class cSafeFile {
|
|
private:
|
|
FILE *f;
|
|
char *fileName;
|
|
char *tempName;
|
|
public:
|
|
cSafeFile(const char *FileName);
|
|
~cSafeFile();
|
|
operator FILE* () { return f; }
|
|
bool Open(void);
|
|
bool Close(void);
|
|
};
|
|
|
|
class cLockFile {
|
|
private:
|
|
char *fileName;
|
|
int f;
|
|
public:
|
|
cLockFile(const char *Directory);
|
|
~cLockFile();
|
|
bool Lock(int WaitSeconds = 0);
|
|
void Unlock(void);
|
|
};
|
|
|
|
class cListObject {
|
|
private:
|
|
cListObject *prev, *next;
|
|
public:
|
|
cListObject(void);
|
|
virtual ~cListObject();
|
|
virtual int Compare(const cListObject &ListObject) const { return 0; }
|
|
///< Must return 0 if this object is equal to ListObject, a positive value
|
|
///< if it is "greater", and a negative value if it is "smaller".
|
|
void Append(cListObject *Object);
|
|
void Insert(cListObject *Object);
|
|
void Unlink(void);
|
|
int Index(void);
|
|
cListObject *Prev(void) const { return prev; }
|
|
cListObject *Next(void) const { return next; }
|
|
};
|
|
|
|
class cListBase {
|
|
protected:
|
|
cListObject *objects, *lastObject;
|
|
cListBase(void);
|
|
public:
|
|
virtual ~cListBase();
|
|
void Add(cListObject *Object, cListObject *After = NULL);
|
|
void Ins(cListObject *Object, cListObject *Before = NULL);
|
|
void Del(cListObject *Object, bool DeleteObject = true);
|
|
virtual void Move(int From, int To);
|
|
void Move(cListObject *From, cListObject *To);
|
|
virtual void Clear(void);
|
|
cListObject *Get(int Index) const;
|
|
int Count(void) const;
|
|
void Sort(void);
|
|
};
|
|
|
|
template<class T> class cList : public cListBase {
|
|
public:
|
|
T *Get(int Index) const { return (T *)cListBase::Get(Index); }
|
|
T *First(void) const { return (T *)objects; }
|
|
T *Last(void) const { return (T *)lastObject; }
|
|
T *Prev(const T *object) const { return (T *)object->cListObject::Prev(); } // need to call cListObject's members to
|
|
T *Next(const T *object) const { return (T *)object->cListObject::Next(); } // avoid ambiguities in case of a "list of lists"
|
|
};
|
|
|
|
#endif //__TOOLS_H
|