1
0
mirror of https://github.com/VDR4Arch/vdr.git synced 2023-10-10 13:36:52 +02:00
vdr/tools.h

288 lines
8.4 KiB
C
Raw Normal View History

2000-02-19 13:36:48 +01:00
/*
* tools.h: Various tools
*
2000-04-24 09:46:05 +02:00
* See the main source file 'vdr.c' for copyright information and
2000-02-19 13:36:48 +01:00
* how to reach the author.
*
2005-08-27 16:42:28 +02:00
* $Id: tools.h 1.75 2005/08/27 14:40:08 kls Exp $
2000-02-19 13:36:48 +01:00
*/
#ifndef __TOOLS_H
#define __TOOLS_H
2004-12-19 16:33:34 +01:00
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
2002-08-16 09:22:29 +02:00
#include <poll.h>
#include <stddef.h>
#include <stdio.h>
2000-10-03 10:34:48 +02:00
#include <string.h>
2000-02-19 13:36:48 +01:00
#include <syslog.h>
#include <sys/stat.h>
2000-04-24 13:54:23 +02:00
#include <sys/types.h>
2000-02-19 13:36:48 +01:00
typedef unsigned char uchar;
typedef unsigned long long int uint64;
extern int SysLogLevel;
2002-05-13 16:35:49 +02:00
#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() )
2002-05-13 16:35:49 +02:00
#define LOG_ERROR esyslog("ERROR (%s,%d): %m", __FILE__, __LINE__)
#define LOG_ERROR_STR(s) esyslog("ERROR: %s: %m", s)
2000-02-19 13:36:48 +01:00
#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
2001-09-14 14:06:43 +02:00
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; }
2001-09-14 14:06:43 +02:00
template<class T> inline void swap(T &a, T &b) { T t = a; a = b; b = t; }
#endif
2000-12-28 12:57:16 +01:00
#define BCDCHARTOINT(x) (10 * ((x & 0xF0) >> 4) + (x & 0xF))
int BCD2INT(int x);
// Unfortunately there are no platform independent macros for unaligned
// access. so we do it this way:
template<class T> inline T get_unaligned(T *p)
{
struct s { T v; } __attribute__((packed));
return ((s *)p)->v;
}
template<class T> inline void put_unaligned(unsigned int v, T* p)
{
struct s { T v; } __attribute__((packed));
((s *)p)->v = v;
}
class cString {
private:
char *s;
public:
cString(const char *S = NULL, bool TakePointer = false);
virtual ~cString();
operator const char * () const { return s; } // for use in (const char *) context
const char * operator*() const { return s; } // for use in (const void *) context (printf() etc.)
cString &operator=(const cString &String);
2005-08-27 16:42:28 +02:00
static cString sprintf(const char *fmt, ...);
};
2001-08-12 15:22:48 +02:00
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);
int WriteAllOrNothing(int fd, const uchar *Data, int Length, int TimeoutMs = 0, int RetryMs = 0);
///< Writes either all Data to the given file descriptor, or nothing at all.
///< If TimeoutMs is greater than 0, it will only retry for that long, otherwise
///< it will retry forever. RetryMs defines the time between two retries.
char *strcpyrealloc(char *dest, const char *src);
2000-09-09 14:57:43 +02:00
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!
2000-10-29 13:17:22 +01:00
char *skipspace(const char *s);
2000-11-11 16:38:41 +01:00
char *stripspace(char *s);
2001-08-17 13:19:10 +02:00
char *compactspace(char *s);
cString strescape(const char *s, const char *chars);
2001-08-17 13:19:10 +02:00
bool startswith(const char *s, const char *p);
bool endswith(const char *s, const char *p);
2000-10-29 13:17:22 +01:00
bool isempty(const char *s);
2002-10-19 15:33:37 +02:00
int numdigits(int n);
2000-07-23 15:01:31 +02:00
bool isnumber(const char *s);
cString itoa(int n);
cString AddDirectory(const char *DirName, const char *FileName);
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);
2001-02-11 14:53:44 +01:00
bool RemoveEmptyDirectories(const char *DirName, bool RemoveThis = false);
char *ReadLink(const char *FileName); ///< returns a new strings allocated on the heap, which the caller must delete (or NULL in case of an error)
2001-08-11 11:15:41 +02:00
bool SpinUpDisk(const char *FileName);
time_t LastModifiedTime(const char *FileName);
cString WeekDayName(int WeekDay);
cString WeekDayName(time_t t);
cString DayDateTime(time_t t = 0);
cString TimeToString(time_t t);
cString DateString(time_t t);
cString TimeString(time_t t);
2004-12-19 16:33:34 +01:00
class cTimeMs {
private:
uint64 begin;
public:
cTimeMs(void);
2005-01-04 11:06:45 +01:00
static uint64 Now(void);
void Set(int Ms = 0);
bool TimedOut(void);
uint64 Elapsed(void);
};
2004-12-19 16:33:34 +01:00
class cReadLine {
private:
char buffer[MAXPARSEBUFFER];
public:
char *Read(FILE *f);
};
2002-08-16 09:22:29 +02:00
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);
};
2004-12-19 16:33:34 +01:00
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 = DEFFILEMODE);
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);
2000-10-08 09:25:20 +02:00
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);
};
2000-02-19 13:36:48 +01:00
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".
2000-02-19 13:36:48 +01:00
void Append(cListObject *Object);
2002-05-12 14:46:46 +02:00
void Insert(cListObject *Object);
2000-02-19 13:36:48 +01:00
void Unlink(void);
int Index(void) const;
2000-10-29 13:17:22 +01:00
cListObject *Prev(void) const { return prev; }
cListObject *Next(void) const { return next; }
2000-02-19 13:36:48 +01:00
};
class cListBase {
protected:
cListObject *objects, *lastObject;
cListBase(void);
int count;
2000-02-19 13:36:48 +01:00
public:
virtual ~cListBase();
2002-05-12 14:46:46 +02:00
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);
2000-10-29 13:17:22 +01:00
cListObject *Get(int Index) const;
int Count(void) const { return count; }
2001-08-26 14:17:20 +02:00
void Sort(void);
2000-02-19 13:36:48 +01:00
};
template<class T> class cList : public cListBase {
public:
2000-10-29 13:17:22 +01:00
T *Get(int Index) const { return (T *)cListBase::Get(Index); }
T *First(void) const { return (T *)objects; }
2000-12-28 12:57:16 +01:00
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"
2000-02-19 13:36:48 +01:00
};
class cHashObject : public cListObject {
friend class cHashBase;
private:
unsigned int id;
cListObject *object;
public:
cHashObject(cListObject *Object, unsigned int Id) { object = Object; id = Id; }
};
class cHashBase {
private:
cList<cHashObject> **hashTable;
int size;
unsigned int hashfn(unsigned int Id) const { return Id % size; }
protected:
cHashBase(int Size);
public:
virtual ~cHashBase();
void Add(cListObject *Object, unsigned int Id);
void Del(cListObject *Object, unsigned int Id);
cListObject *Get(unsigned int Id) const;
cList<cHashObject> *GetList(unsigned int Id) const;
};
#define HASHSIZE 512
template<class T> class cHash : public cHashBase {
public:
cHash(int Size = HASHSIZE) : cHashBase(Size) {}
T *Get(unsigned int Id) const { return (T *)cHashBase::Get(Id); }
};
2000-02-19 13:36:48 +01:00
#endif //__TOOLS_H