33#define MAXSYSLOGBUF 256
41 vsyslog(priority, fmt, ap);
53ssize_t
safe_read(
int filedes,
void *buffer,
size_t size)
56 ssize_t p = read(filedes, buffer, size);
57 if (p < 0 && errno == EINTR) {
58 dsyslog(
"EINTR while reading from file handle %d - retrying", filedes);
65ssize_t
safe_write(
int filedes,
const void *buffer,
size_t size)
68 ssize_t written = size;
69 const unsigned char *ptr = (
const unsigned char *)buffer;
71 p = write(filedes, ptr, size);
74 dsyslog(
"EINTR while writing to file handle %d - retrying", filedes);
82 return p < 0 ? p : written;
94 int w = write(fd, Data + written, Length);
103 Poller.
Poll(RetryMs);
104 if (TimeoutMs > 0 && (TimeoutMs -= t.
Elapsed()) <= 0)
117 int l =
max(dest ? strlen(dest) : 0, strlen(src)) + 1;
118 dest = (
char *)realloc(dest, l);
122 esyslog(
"ERROR: out of memory");
131char *
strn0cpy(
char *dest,
const char *src,
size_t n)
134 for ( ; --n && (*dest = *src) != 0; dest++, src++) ;
154 if (!s || !s1 || !s2 || strcmp(s1, s2) == 0)
157 if (
char *p = strstr(s, s1)) {
164 if (
char *NewBuffer = (
char *)realloc(s, l + l2 - l1 + 1))
167 esyslog(
"ERROR: out of memory");
173 memmove(sof + l2, sof + l1, l - of - l1 + 1);
178 }
while (p = strstr(q, s1));
183const char *
strchrn(
const char *s,
char c,
size_t n)
189 if (*s == c && --n == 0)
210 const char *p = strrchr(s, 0);
212 if (*p == c && --n == 0)
220 const char *p = strrchr(s, c);
221 return p ? p + 1 : s;
227 for (
char *p = s + strlen(s) - 1; p >= s; p--) {
244 memmove(p + 1, q, strlen(q) + 1);
248 memmove(s, t, strlen(t) + 1);
264 else if (t != s && n == 0) {
283 if (strchr(chars, *p)) {
285 buffer =
MALLOC(
char, 2 * strlen(s) + 1);
286 t = buffer + (p - s);
287 s = strcpy(buffer, s);
303 int l = strlen(name);
305 while (
const char *p = strstr(t, name)) {
307 if (p == s || *(p - 1) <=
' ') {
327 memmove(s, s + n, l - n + 1);
345 const char *se = s + strlen(s) - 1;
346 const char *pe = p + strlen(p) - 1;
348 if (*pe-- != *se-- || (se < s && pe >= p))
383 int64_t n = strtoll(s, &t, 10);
399 if (strcmp(*a, s) == 0)
409 if (*FileName ==
'/')
411 return cString::sprintf(
"%s/%s", DirName && *DirName ? DirName :
".", FileName);
414#define DECIMAL_POINT_C '.'
418 static lconv *loc = localeconv();
420 char buf[strlen(s) + 1];
424 *p = *loc->decimal_point;
439 static lconv *loc = localeconv();
441 snprintf(buf,
sizeof(buf), Format, d);
450 snprintf(buf,
sizeof(buf),
"%d", n);
457 if (stat(File1, &st) == 0) {
458 dev_t dev1 = st.st_dev;
459 if (stat(File2, &st) == 0)
460 return st.st_dev == dev1;
474 struct statfs statFs;
475 if (statfs(Directory, &statFs) == 0) {
476 double blocksPerMeg = 1024.0 * 1024.0 / statFs.f_bsize;
478 *UsedMB = int((statFs.f_blocks - statFs.f_bfree) / blocksPerMeg);
479 Free = int(statFs.f_bavail / blocksPerMeg);
489 if (stat(DirName, &ds) == 0) {
490 if (S_ISDIR(ds.st_mode)) {
491 if (access(DirName, R_OK | W_OK | X_OK) == 0)
494 esyslog(
"ERROR: can't access %s", DirName);
497 esyslog(
"ERROR: %s is not a directory", DirName);
504bool MakeDirs(
const char *FileName,
bool IsDirectory)
507 char *s = strdup(FileName);
511 while ((p = strchr(p,
'/')) != NULL || IsDirectory) {
515 if (stat(s, &fs) != 0 || !S_ISDIR(fs.st_mode)) {
516 dsyslog(
"creating directory %s", s);
517 if (mkdir(s, ACCESSPERMS) == -1) {
535 if (stat(FileName, &st) == 0) {
536 if (S_ISDIR(st.st_mode)) {
540 while ((e = d.
Next()) != NULL) {
542 if (FollowSymlinks) {
544 if (lstat(buffer, &st2) == 0) {
545 if (S_ISLNK(st2.st_mode)) {
546 int size = st2.st_size + 1;
547 char *l =
MALLOC(
char, size);
548 int n = readlink(buffer, l, size - 1);
562 else if (errno != ENOENT) {
567 dsyslog(
"removing %s", *buffer);
568 if (remove(buffer) < 0)
577 dsyslog(
"removing %s", FileName);
578 if (remove(FileName) < 0) {
583 else if (errno != ENOENT) {
592 bool HasIgnoredFiles =
false;
597 while ((e = d.
Next()) != NULL) {
598 if (strcmp(e->d_name,
"lost+found")) {
601 if (stat(buffer, &st) == 0) {
602 if (S_ISDIR(st.st_mode)) {
606 else if (RemoveThis && IgnoreFiles &&
StrInArray(IgnoreFiles, e->d_name))
607 HasIgnoredFiles =
true;
617 if (RemoveThis && empty) {
618 if (HasIgnoredFiles) {
619 while (*IgnoreFiles) {
621 if (access(buffer, F_OK) == 0) {
622 dsyslog(
"removing %s", *buffer);
623 if (remove(buffer) < 0) {
631 dsyslog(
"removing %s", DirName);
632 if (remove(DirName) < 0) {
650 while (size >= 0 && (e = d.
Next()) != NULL) {
653 if (stat(buffer, &st) == 0) {
654 if (S_ISDIR(st.st_mode)) {
671 else if (errno != ENOENT)
680 char *TargetName = canonicalize_file_name(FileName);
683 TargetName = strdup(FileName);
692 for (
int n = 0; n < 10; n++) {
698 if (access(buf, F_OK) != 0) {
700 gettimeofday(&tp1, NULL);
701 int f = open(buf, O_WRONLY | O_CREAT, DEFFILEMODE);
704 if (fdatasync(f) < 0)
708 gettimeofday(&tp2, NULL);
709 double seconds = (((
long long)tp2.tv_sec * 1000000 + tp2.tv_usec) - ((
long long)tp1.tv_sec * 1000000 + tp1.tv_usec)) / 1000000.0;
711 dsyslog(
"SpinUpDisk took %.2f seconds", seconds);
718 esyslog(
"ERROR: SpinUpDisk failed");
724 if (Create && access(FileName, F_OK) != 0) {
725 isyslog(
"creating file '%s'", FileName);
726 int f = open(FileName, O_WRONLY | O_CREAT, DEFFILEMODE);
732 if (utime(FileName, NULL) == -1 && errno != ENOENT)
739 if (stat(FileName, &fs) == 0)
747 if (stat(FileName, &fs) == 0)
764#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
765#define MIN_RESOLUTION 5
766 static bool initialized =
false;
767 static bool monotonic =
false;
771 if (clock_getres(CLOCK_MONOTONIC, &tp) == 0) {
772 long Resolution = tp.tv_nsec;
774 if (tp.tv_sec == 0 && tp.tv_nsec <= MIN_RESOLUTION * 1000000) {
775 if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
776 dsyslog(
"cTimeMs: using monotonic clock (resolution is %ld ns)", Resolution);
780 esyslog(
"cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
783 dsyslog(
"cTimeMs: not using monotonic clock - resolution is too bad (%jd s %ld ns)", intmax_t(tp.tv_sec), tp.tv_nsec);
786 esyslog(
"cTimeMs: clock_getres(CLOCK_MONOTONIC) failed");
790 if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
791 return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
792 esyslog(
"cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
797# warning Posix monotonic clock not available
800 if (gettimeofday(&t, NULL) == 0)
801 return (uint64_t(t.tv_sec)) * 1000 + t.tv_usec / 1000;
828#define MT(s, m, v) ((*(s) & (m)) == (v))
829 if (
MT(s, 0xE0, 0xC0) &&
MT(s + 1, 0xC0, 0x80))
831 if (
MT(s, 0xF0, 0xE0) &&
MT(s + 1, 0xC0, 0x80) &&
MT(s + 2, 0xC0, 0x80))
833 if (
MT(s, 0xF8, 0xF0) &&
MT(s + 1, 0xC0, 0x80) &&
MT(s + 2, 0xC0, 0x80) &&
MT(s + 3, 0xC0, 0x80))
845 case 2:
return ((*s & 0x1F) << 6) | (*(s + 1) & 0x3F);
846 case 3:
return ((*s & 0x0F) << 12) | ((*(s + 1) & 0x3F) << 6) | (*(s + 2) & 0x3F);
847 case 4:
return ((*s & 0x07) << 18) | ((*(s + 1) & 0x3F) << 12) | ((*(s + 2) & 0x3F) << 6) | (*(s + 3) & 0x3F);
862 *s++ = ((c >> 6) & 0x1F) | 0xC0;
863 *s = (c & 0x3F) | 0x80;
869 *s++ = ((c >> 12) & 0x0F) | 0xE0;
870 *s++ = ((c >> 6) & 0x3F) | 0x80;
871 *s = (c & 0x3F) | 0x80;
877 *s++ = ((c >> 18) & 0x07) | 0xF0;
878 *s++ = ((c >> 12) & 0x3F) | 0x80;
879 *s++ = ((c >> 6) & 0x3F) | 0x80;
880 *s = (c & 0x3F) | 0x80;
892 while (*s && Symbols--) {
934 while (*s && --Size > 0) {
936 *a++ = (
uchar)(*s++);
953 while (*a && NumChars < Size) {
954 if (Max >= 0 && NumSyms++ >= Max)
962 if (NumChars + sl <= Size) {
987 cd = iconv_open(ToCode, FromCode);
995 if (
cd != (iconv_t)-1)
1003 if (!strcasestr(CharacterTable,
"UTF-8")) {
1006 for (
int i = 0; i < 128; i++)
1010 const char *s = csc.
Convert(buf);
1024 if (
cd != (iconv_t)-1 && From && *From) {
1025 char *FromPtr = (
char *)From;
1026 size_t FromLength = strlen(From);
1029 int NewLength =
max(
length, FromLength * 2);
1030 if (
char *NewBuffer = (
char *)realloc(
result, NewLength)) {
1035 esyslog(
"ERROR: out of memory");
1044 char *Converted = ToPtr;
1045 while (FromLength > 0) {
1046 if (iconv(
cd, &FromPtr, &FromLength, &ToPtr, &ToLength) ==
size_t(-1)) {
1047 if (errno == E2BIG || errno == EILSEQ && ToLength < 1) {
1051 size_t d = ToPtr -
result;
1053 int NewLength =
length + r;
1054 if (
char *NewBuffer = (
char *)realloc(
result, NewLength)) {
1056 Converted =
result = NewBuffer;
1059 esyslog(
"ERROR: out of memory");
1065 if (errno == EILSEQ) {
1072 else if (errno != E2BIG)
1086 s = TakePointer ? (
char *)S : S ? strdup(S) : NULL;
1105 s = String.
s ? strdup(String.
s) : NULL;
1115 if (
this == &String)
1118 s = String.
s ? strdup(String.
s) : NULL;
1124 if (
this != &String) {
1137 s = String ? strdup(String) : NULL;
1144 int l1 =
s ? strlen(
s) : 0;
1145 int l2 = strlen(String);
1146 if (
char *p = (
char *)realloc(
s, l1 + l2 + 1)) {
1148 strcpy(
s + l1, String);
1151 esyslog(
"ERROR: out of memory");
1159 int l1 =
s ? strlen(
s) : 0;
1161 if (
char *p = (
char *)realloc(
s, l1 + l2 + 1)) {
1167 esyslog(
"ERROR: out of memory");
1177 if (Index >= 0 && Index < l)
1193 if (!fmt || vasprintf(&buffer, fmt, ap) < 0) {
1194 esyslog(
"error in vasprintf('%s', ...)", fmt);
1195 buffer = strdup(
"???");
1204 if (!fmt || vasprintf(&buffer, fmt, ap) < 0) {
1205 esyslog(
"error in vasprintf('%s', ...)", fmt);
1206 buffer = strdup(
"???");
1214 WeekDay = WeekDay == 0 ? 6 : WeekDay - 1;
1215 if (0 <= WeekDay && WeekDay <= 6) {
1217 const char *day =
tr(
"MonTueWedThuFriSatSun");
1229 return WeekDayName(localtime_r(&t, &tm_r)->tm_wday);
1234 WeekDay = WeekDay == 0 ? 6 : WeekDay - 1;
1236 case 0:
return tr(
"Monday");
1237 case 1:
return tr(
"Tuesday");
1238 case 2:
return tr(
"Wednesday");
1239 case 3:
return tr(
"Thursday");
1240 case 4:
return tr(
"Friday");
1241 case 5:
return tr(
"Saturday");
1242 case 6:
return tr(
"Sunday");
1243 default:
return "???";
1259 tm *tm = localtime_r(&t, &tm_r);
1260 snprintf(buffer,
sizeof(buffer),
"%s %02d.%02d. %02d:%02d", *
WeekDayName(tm->tm_wday), tm->tm_mday, tm->tm_mon + 1, tm->tm_hour, tm->tm_min);
1267 if (ctime_r(&t, buffer)) {
1268 buffer[strlen(buffer) - 1] = 0;
1278 tm *tm = localtime_r(&t, &tm_r);
1281 strftime(p,
sizeof(buf) - (p - buf),
"%d.%m.%Y", tm);
1289 tm *tm = localtime_r(&t, &tm_r);
1290 strftime(buf,
sizeof(buf),
"%d.%m.%y", tm);
1298 strftime(buf,
sizeof(buf),
"%R", localtime_r(&t, &tm_r));
1304#define JPEGCOMPRESSMEM 500000
1324 int Used = jcd->
size;
1326 if (
uchar *NewBuffer = (
uchar *)realloc(jcd->
mem, NewSize)) {
1327 jcd->
size = NewSize;
1328 jcd->
mem = NewBuffer;
1331 esyslog(
"ERROR: out of memory");
1335 cinfo->dest->next_output_byte = jcd->
mem + Used;
1336 cinfo->dest->free_in_buffer = jcd->
size - Used;
1347 int Used = cinfo->dest->next_output_byte - jcd->
mem;
1348 if (Used < jcd->size) {
1351 jcd->
mem = NewBuffer;
1354 esyslog(
"ERROR: out of memory");
1363 else if (Quality > 100)
1366 jpeg_destination_mgr jdm;
1372 struct jpeg_compress_struct cinfo;
1373 struct jpeg_error_mgr jerr;
1374 cinfo.err = jpeg_std_error(&jerr);
1375 jpeg_create_compress(&cinfo);
1378 cinfo.client_data = &jcd;
1379 cinfo.image_width = Width;
1380 cinfo.image_height = Height;
1381 cinfo.input_components = 3;
1382 cinfo.in_color_space = JCS_RGB;
1384 jpeg_set_defaults(&cinfo);
1385 jpeg_set_quality(&cinfo, Quality, TRUE);
1386 jpeg_start_compress(&cinfo, TRUE);
1389 JSAMPROW rp[Height];
1390 for (
int k = 0; k < Height; k++)
1391 rp[k] = &Mem[rs * k];
1392 jpeg_write_scanlines(&cinfo, rp, Height);
1393 jpeg_finish_compress(&cinfo);
1394 jpeg_destroy_compress(&cinfo);
1404 static char buffer[HOST_NAME_MAX] =
"";
1406 if (gethostname(buffer,
sizeof(buffer)) < 0) {
1408 strcpy(buffer,
"vdr");
1416const char *
cBase64Encoder::b64 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1439 c |= (
data[
i] >> 4) & 0x0F;
1442 c = (
data[
i] << 2) & 0x3F;
1444 c |= (
data[
i] >> 6) & 0x03;
1543 Add(FileHandle, Out);
1548 if (FileHandle >= 0) {
1550 if (
pfd[i].fd == FileHandle &&
pfd[i].events == (Out ? POLLOUT : POLLIN))
1560 esyslog(
"ERROR: too many file handles in cPoller");
1567 if (FileHandle >= 0) {
1569 if (
pfd[i].fd == FileHandle &&
pfd[i].events == (Out ? POLLOUT : POLLIN)) {
1604#if !__GLIBC_PREREQ(2, 24)
1609 if (strcmp(
result->d_name,
".") && strcmp(
result->d_name,
".."))
1625 for (
int i = 0; i < Size(); i++) {
1626 if (!strcmp(s, At(i)))
1634 for (
int i = 0; i < Size(); i++)
1644 Load(Directory, DirsOnly);
1654 while ((e =
d.Next()) != NULL) {
1657 if (stat(
AddDirectory(Directory, e->d_name), &ds) == 0) {
1658 if (!S_ISDIR(ds.st_mode))
1662 Append(strdup(e->d_name));
1688 return Open(open(FileName, Flags, Mode));
1689 esyslog(
"ERROR: attempt to re-open %s", FileName);
1699 esyslog(
"ERROR: attempt to re-open file descriptor %d", FileDes);
1714 return f >= 0 && FileReady(f, Wait ? 1000 : 0);
1720 struct timeval timeout;
1722 FD_SET(FileDes, &set);
1723 if (TimeoutMs >= 0) {
1724 if (TimeoutMs < 100)
1726 timeout.tv_sec = TimeoutMs / 1000;
1727 timeout.tv_usec = (TimeoutMs % 1000) * 1000;
1729 return select(FD_SETSIZE, &set, NULL, NULL, (TimeoutMs >= 0) ? &timeout : NULL) > 0 && FD_ISSET(FileDes, &set);
1738 tempName = fileName ?
MALLOC(
char, strlen(fileName) + 5) : NULL;
1740 strcat(strcpy(tempName, fileName),
".$$$");
1754 if (!f && fileName && tempName) {
1755 f = fopen(tempName,
"w");
1766 if (ferror(f) != 0) {
1772 if (fclose(f) < 0) {
1777 if (
result && rename(tempName, fileName) < 0) {
1789#ifndef USE_FADVISE_READ
1790#define USE_FADVISE_READ 0
1792#ifndef USE_FADVISE_WRITE
1793#define USE_FADVISE_WRITE 1
1796#define WRITE_BUFFER KILOBYTE(800)
1811 fd = open(FileName, Flags, Mode);
1813#if USE_FADVISE_READ || USE_FADVISE_WRITE
1814 begin = lastpos = ahead = 0;
1821 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
1829#if USE_FADVISE_READ || USE_FADVISE_WRITE
1832 posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
1836 return close(OldFd);
1847#define FADVGRAN KILOBYTE(4)
1848#define READCHUNK MEGABYTE(8)
1858 return posix_fadvise(fd, Offset - (
FADVGRAN - 1), Len + (
FADVGRAN - 1) * 2, POSIX_FADV_DONTNEED);
1863 if (Whence == SEEK_SET && Offset == curpos)
1865 curpos = lseek(fd, Offset, Whence);
1873 off_t jumped = curpos-lastpos;
1874 if ((cachedstart < cachedend) && (curpos < cachedstart || curpos > cachedend)) {
1876 FadviseDrop(cachedstart, cachedend-cachedstart);
1877 cachedstart = curpos;
1880 cachedstart =
min(cachedstart, curpos);
1882 ssize_t bytesRead =
safe_read(fd, Data, Size);
1883 if (bytesRead > 0) {
1884 curpos += bytesRead;
1886 cachedend =
max(cachedend, curpos);
1890 if (jumped >= 0 && jumped <= (off_t)readahead) {
1894 if (ahead - curpos < (off_t)(readahead / 2)) {
1895 posix_fadvise(fd, curpos, readahead, POSIX_FADV_WILLNEED);
1896 ahead = curpos + readahead;
1897 cachedend =
max(cachedend, ahead);
1899 if (readahead < Size * 32) {
1900 readahead = Size * 32;
1908 if (cachedstart < cachedend) {
1909 if (curpos - cachedstart >
READCHUNK * 2) {
1911 FadviseDrop(cachedstart, curpos -
READCHUNK - cachedstart);
1914 else if (cachedend > ahead && cachedend - curpos >
READCHUNK * 2) {
1930 ssize_t bytesWritten =
safe_write(fd, Data, Size);
1931#if USE_FADVISE_WRITE
1932 if (bytesWritten > 0) {
1933 begin =
min(begin, curpos);
1934 curpos += bytesWritten;
1935 written += bytesWritten;
1936 lastpos =
max(lastpos, curpos);
1938 if (lastpos > begin) {
1948 posix_fadvise(fd, begin - headdrop, lastpos - begin + headdrop, POSIX_FADV_DONTNEED);
1950 begin = lastpos = curpos;
1951 totwritten += written;
1966 off_t headdrop =
min(off_t(curpos - totwritten), off_t(totwritten * 2));
1967 posix_fadvise(fd, curpos - totwritten - headdrop, totwritten + headdrop, POSIX_FADV_DONTNEED);
1973 return bytesWritten;
1981 if (File->
Open(FileName, Flags, Mode) < 0) {
1990#define LOCKFILENAME ".lock-vdr"
1991#define LOCKFILESTALETIME 600
2009 if (f < 0 && fileName) {
2010 time_t Timeout = time(NULL) + WaitSeconds;
2012 f = open(fileName, O_WRONLY | O_CREAT | O_EXCL, DEFFILEMODE);
2014 if (errno == EEXIST) {
2016 if (stat(fileName, &fs) == 0) {
2018 esyslog(
"ERROR: removing stale lock file '%s'", fileName);
2019 if (remove(fileName) < 0) {
2026 else if (errno != ENOENT) {
2033 if (errno == ENOSPC) {
2034 esyslog(
"ERROR: can't create lock file '%s' - assuming lock anyway!", fileName);
2042 }
while (f < 0 && time(NULL) < Timeout);
2070 Object->
prev =
this;
2076 Object->
next =
this;
2102#define LIST_GARBAGE_COLLECTOR_TIMEOUT 5
2115 esyslog(
"ERROR: ListGarbageCollector destroyed without prior Purge()!");
2121 Object->
next = objects;
2123 lastPut = time(NULL);
2136 objects = Object->next;
2146:stateLock(NeedsLocking)
2164 esyslog(
"ERROR: cListBase::Lock() called for a list that doesn't require locking");
2186 if (Before && Before !=
objects) {
2223 if (From && To && From != To) {
2280 while (
object && Index-- > 0)
2281 object =
object->
Next();
2300 while (
object && i < n) {
2302 object =
object->
Next();
2306 for (i = 0; i < n; i++) {
2330 if (
size < NewSize) {
2337 esyslog(
"ERROR: out of memory");
2369 unsigned int hash =
hashfn(Id);
2380 if (hob->object == Object) {
2390 for (
int i = 0; i <
size; i++) {
cBase64Encoder(const uchar *Data, int Length, int MaxResult=64)
Sets up a new base 64 encoder for the given Data, with the given Length.
const char * NextLine(void)
Returns the next line of encoded data (terminated by '\0'), or NULL if there is no more encoded data.
bool SetLength(int Length)
cCharSetConv(const char *FromCode=NULL, const char *ToCode=NULL)
Sets up a character set converter to convert from FromCode to ToCode.
static const char * SystemCharacterTable(void)
static void SetSystemCharacterTable(const char *CharacterTable)
static char * systemCharacterTable
const char * Convert(const char *From, char *To=NULL, size_t ToLength=0)
Converts the given Text from FromCode to ToCode (as set in the constructor).
static void SleepMs(int TimeoutMs)
Creates a cCondWait object and uses it to sleep for TimeoutMs milliseconds, immediately giving up the...
cDynamicBuffer(int InitialSize=1024)
bool Realloc(int NewSize)
void Append(const uchar *Data, int Length)
bool Load(const char *Directory, bool DirsOnly=false)
cFileNameList(const char *Directory=NULL, bool DirsOnly=false)
static bool FileReady(int FileDes, int TimeoutMs=1000)
bool Ready(bool Wait=true)
bool Open(const char *FileName, int Flags, mode_t Mode=DEFFILEMODE)
void Del(cListObject *Object, unsigned int Id)
cListObject * Get(unsigned int Id) const
cList< cHashObject > ** hashTable
cList< cHashObject > * GetList(unsigned int Id) const
cHashBase(int Size, bool OwnObjects)
Creates a new hash of the given Size.
void Add(cListObject *Object, unsigned int Id)
unsigned int hashfn(unsigned int Id) const
void Ins(cListObject *Object, cListObject *Before=NULL)
bool Contains(const cListObject *Object) const
If a pointer to an object contained in this list has been obtained while holding a lock,...
void Del(cListObject *Object, bool DeleteObject=true)
virtual void Move(int From, int To)
void SetExplicitModify(void)
If you have obtained a write lock on this list, and you don't want it to be automatically marked as m...
void SetModified(void)
Unconditionally marks this list as modified.
bool Lock(cStateKey &StateKey, bool Write=false, int TimeoutMs=0) const
Tries to get a lock on this list and returns true if successful.
const char * needsLocking
cListBase(const char *NeedsLocking=NULL)
const cListObject * Get(int Index) const
void Add(cListObject *Object, cListObject *After=NULL)
void Purge(bool Force=false)
cListGarbageCollector(void)
void Put(cListObject *Object)
cListObject * Prev(void) const
virtual int Compare(const cListObject &ListObject) const
Must return 0 if this object is equal to ListObject, a positive value if it is "greater",...
void Insert(cListObject *Object)
cListObject * Next(void) const
void Append(cListObject *Object)
const T * First(void) const
Returns the first element in this list, or NULL if the list is empty.
const T * Next(const T *Object) const
< Returns the element immediately before Object in this list, or NULL if Object is the first element ...
bool Lock(int WaitSeconds=0)
cLockFile(const char *Directory)
cPoller(int FileHandle=-1, bool Out=false)
bool Add(int FileHandle, bool Out)
bool Poll(int TimeoutMs=0)
void Del(int FileHandle, bool Out)
cReadDir(const char *Directory)
struct dirent * Next(void)
cSafeFile(const char *FileName)
void SetExplicitModify(void)
If you have obtained a write lock on this lock, and you don't want its state to be automatically incr...
void SetModified(void)
Sets this lock to have its state incremented when the current write lock state key is removed.
bool Lock(cStateKey &StateKey, bool Write=false, int TimeoutMs=0)
Tries to get a lock and returns true if successful.
int Find(const char *s) const
cString & CompactChars(char c)
Compact any sequence of characters 'c' to a single character, and strip all of them from the beginnin...
static cString static cString vsprintf(const char *fmt, va_list &ap)
cString(const char *S=NULL, bool TakePointer=false)
static cString sprintf(const char *fmt,...) __attribute__((format(printf
cString & operator=(const cString &String)
cString & Append(const char *String)
cString & Truncate(int Index)
Truncate the string at the given Index (if Index is < 0 it is counted from the end of the string).
static tThreadId ThreadId(void)
uint64_t Elapsed(void) const
void Set(int Ms=0)
Sets the timer.
bool TimedOut(void) const
cTimeMs(int Ms=0)
Creates a timer with ms resolution and an initial timeout of Ms.
static uint64_t Now(void)
cUnbufferedFile is used for large files that are mainly written or read in a streaming manner,...
static cUnbufferedFile * Create(const char *FileName, int Flags, mode_t Mode=DEFFILEMODE)
void SetReadAhead(size_t ra)
ssize_t Write(const void *Data, size_t Size)
int Open(const char *FileName, int Flags, mode_t Mode=DEFFILEMODE)
ssize_t Read(void *Data, size_t Size)
int FadviseDrop(off_t Offset, off_t Len)
off_t Seek(off_t Offset, int Whence)