33 #define MAXSYSLOGBUF 256
41 vsyslog(priority, fmt, ap);
53 ssize_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);
65 ssize_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");
131 char *
strn0cpy(
char *dest,
const char *src,
size_t n)
136 for ( ; --n && (*dest = *src) != 0; dest++, src++) ;
157 if (!s || !s1 || !*s1 || !s2 || strcmp(s1, s2) == 0)
160 if (
char *p = strstr(s, s1)) {
167 if (
char *NewBuffer = (
char *)realloc(s, l + l2 - l1 + 1))
170 esyslog(
"ERROR: out of memory");
176 memmove(sof + l2, sof + l1, l - of - l1 + 1);
181 }
while (p = strstr(q, s1));
186 const char *
strchrn(
const char *s,
char c,
size_t n)
192 if (*s == c && --n == 0)
213 const char *p = strrchr(s, 0);
215 if (*p == c && --n == 0)
223 const char *p = strrchr(s, c);
224 return p ? p + 1 : s;
230 for (
char *p = s + strlen(s) - 1; p >= s; p--) {
247 memmove(p + 1, q, strlen(q) + 1);
251 memmove(s, t, strlen(t) + 1);
267 else if (t != s && n == 0) {
286 if (strchr(chars, *p)) {
288 buffer =
MALLOC(
char, 2 * strlen(s) + 1);
289 t = buffer + (p - s);
290 s = strcpy(buffer, s);
306 int l = strlen(name);
308 while (
const char *p = strstr(t, name)) {
310 if (p == s || *(p - 1) <=
' ') {
330 memmove(s, s + n, l - n + 1);
348 const char *se = s + strlen(s) - 1;
349 const char *pe = p + strlen(p) - 1;
351 if (*pe-- != *se-- || (se < s && pe >= p))
386 int64_t n = strtoll(s, &t, 10);
402 if (strcmp(*a, s) == 0)
412 if (*FileName ==
'/')
414 return cString::sprintf(
"%s/%s", DirName && *DirName ? DirName :
".", FileName);
417 #define DECIMAL_POINT_C '.'
421 static lconv *loc = localeconv();
423 char buf[strlen(s) + 1];
427 *p = *loc->decimal_point;
442 static lconv *loc = localeconv();
444 snprintf(buf,
sizeof(buf), Format, d);
453 snprintf(buf,
sizeof(buf),
"%d", n);
460 if (stat(File1, &st) == 0) {
461 dev_t dev1 = st.st_dev;
462 if (stat(File2, &st) == 0)
463 return st.st_dev == dev1;
477 struct statfs statFs;
478 if (statfs(Directory, &statFs) == 0) {
479 double blocksPerMeg = 1024.0 * 1024.0 / statFs.f_bsize;
481 *UsedMB = int((statFs.f_blocks - statFs.f_bfree) / blocksPerMeg);
482 Free = int(statFs.f_bavail / blocksPerMeg);
492 if (stat(DirName, &ds) == 0) {
493 if (S_ISDIR(ds.st_mode)) {
494 if (access(DirName, R_OK | W_OK | X_OK) == 0)
497 esyslog(
"ERROR: can't access %s", DirName);
500 esyslog(
"ERROR: %s is not a directory", DirName);
507 bool MakeDirs(
const char *FileName,
bool IsDirectory)
510 char *s = strdup(FileName);
514 while ((p = strchr(p,
'/')) != NULL || IsDirectory) {
518 if (stat(s, &fs) != 0 || !S_ISDIR(fs.st_mode)) {
519 dsyslog(
"creating directory %s", s);
520 if (mkdir(s, ACCESSPERMS) == -1) {
538 if (stat(FileName, &st) == 0) {
539 if (S_ISDIR(st.st_mode)) {
543 while ((e = d.
Next()) != NULL) {
545 if (FollowSymlinks) {
547 if (lstat(buffer, &st2) == 0) {
548 if (S_ISLNK(st2.st_mode)) {
549 int size = st2.st_size + 1;
550 char *l =
MALLOC(
char, size);
551 int n = readlink(buffer, l, size - 1);
565 else if (errno != ENOENT) {
570 dsyslog(
"removing %s", *buffer);
571 if (remove(buffer) < 0)
580 dsyslog(
"removing %s", FileName);
581 if (remove(FileName) < 0) {
586 else if (errno != ENOENT) {
595 bool HasIgnoredFiles =
false;
600 while ((e = d.
Next()) != NULL) {
601 if (strcmp(e->d_name,
"lost+found")) {
604 if (stat(buffer, &st) == 0) {
605 if (S_ISDIR(st.st_mode)) {
609 else if (RemoveThis && IgnoreFiles &&
StrInArray(IgnoreFiles, e->d_name))
610 HasIgnoredFiles =
true;
620 if (RemoveThis && empty) {
621 if (HasIgnoredFiles) {
622 while (*IgnoreFiles) {
624 if (access(buffer, F_OK) == 0) {
625 dsyslog(
"removing %s", *buffer);
626 if (remove(buffer) < 0) {
634 dsyslog(
"removing %s", DirName);
635 if (remove(DirName) < 0) {
653 while (size >= 0 && (e = d.
Next()) != NULL) {
656 if (stat(buffer, &st) == 0) {
657 if (S_ISDIR(st.st_mode)) {
674 else if (errno != ENOENT)
683 char *TargetName = canonicalize_file_name(FileName);
686 TargetName = strdup(FileName);
695 for (
int n = 0; n < 10; n++) {
701 if (access(buf, F_OK) != 0) {
703 gettimeofday(&tp1, NULL);
704 int f = open(buf, O_WRONLY | O_CREAT, DEFFILEMODE);
707 if (fdatasync(f) < 0)
711 gettimeofday(&tp2, NULL);
712 double seconds = (((
long long)tp2.tv_sec * 1000000 + tp2.tv_usec) - ((
long long)tp1.tv_sec * 1000000 + tp1.tv_usec)) / 1000000.0;
714 dsyslog(
"SpinUpDisk took %.2f seconds", seconds);
721 esyslog(
"ERROR: SpinUpDisk failed");
727 if (Create && access(FileName, F_OK) != 0) {
728 isyslog(
"creating file '%s'", FileName);
729 int f = open(FileName, O_WRONLY | O_CREAT, DEFFILEMODE);
735 if (utime(FileName, NULL) == -1 && errno != ENOENT)
742 if (stat(FileName, &fs) == 0)
750 if (stat(FileName, &fs) == 0)
767 #if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
768 #define MIN_RESOLUTION 5
769 static bool initialized =
false;
770 static bool monotonic =
false;
774 if (clock_getres(CLOCK_MONOTONIC, &tp) == 0) {
775 long Resolution = tp.tv_nsec;
777 if (tp.tv_sec == 0 && tp.tv_nsec <= MIN_RESOLUTION * 1000000) {
778 if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
779 dsyslog(
"cTimeMs: using monotonic clock (resolution is %ld ns)", Resolution);
783 esyslog(
"cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
786 dsyslog(
"cTimeMs: not using monotonic clock - resolution is too bad (%jd s %ld ns)", intmax_t(tp.tv_sec), tp.tv_nsec);
789 esyslog(
"cTimeMs: clock_getres(CLOCK_MONOTONIC) failed");
793 if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
794 return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
795 esyslog(
"cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
800 # warning Posix monotonic clock not available
803 if (gettimeofday(&t, NULL) == 0)
804 return (uint64_t(t.tv_sec)) * 1000 + t.tv_usec / 1000;
831 #define MT(s, m, v) ((*(s) & (m)) == (v))
832 if (
MT(s, 0xE0, 0xC0) &&
MT(s + 1, 0xC0, 0x80))
834 if (
MT(s, 0xF0, 0xE0) &&
MT(s + 1, 0xC0, 0x80) &&
MT(s + 2, 0xC0, 0x80))
836 if (
MT(s, 0xF8, 0xF0) &&
MT(s + 1, 0xC0, 0x80) &&
MT(s + 2, 0xC0, 0x80) &&
MT(s + 3, 0xC0, 0x80))
848 case 2:
return ((*s & 0x1F) << 6) | (*(s + 1) & 0x3F);
849 case 3:
return ((*s & 0x0F) << 12) | ((*(s + 1) & 0x3F) << 6) | (*(s + 2) & 0x3F);
850 case 4:
return ((*s & 0x07) << 18) | ((*(s + 1) & 0x3F) << 12) | ((*(s + 2) & 0x3F) << 6) | (*(s + 3) & 0x3F);
865 *s++ = ((c >> 6) & 0x1F) | 0xC0;
866 *s = (c & 0x3F) | 0x80;
872 *s++ = ((c >> 12) & 0x0F) | 0xE0;
873 *s++ = ((c >> 6) & 0x3F) | 0x80;
874 *s = (c & 0x3F) | 0x80;
880 *s++ = ((c >> 18) & 0x07) | 0xF0;
881 *s++ = ((c >> 12) & 0x3F) | 0x80;
882 *s++ = ((c >> 6) & 0x3F) | 0x80;
883 *s = (c & 0x3F) | 0x80;
895 while (*s && Symbols--) {
941 while (*s && --Size > 0) {
943 *a++ = (
uchar)(*s++);
960 while (*a && NumChars < Size) {
961 if (Max >= 0 && NumSyms++ >= Max)
969 if (NumChars + sl <= Size) {
994 cd = iconv_open(ToCode, FromCode);
1002 if (
cd != (iconv_t)-1)
1010 if (!strcasestr(CharacterTable,
"UTF-8")) {
1013 for (
int i = 0; i < 128; i++)
1017 const char *s = csc.
Convert(buf);
1031 if (
cd != (iconv_t)-1 && From && *From) {
1032 char *FromPtr = (
char *)From;
1033 size_t FromLength = strlen(From);
1036 int NewLength =
max(
length, FromLength * 2);
1037 if (
char *NewBuffer = (
char *)realloc(
result, NewLength)) {
1042 esyslog(
"ERROR: out of memory");
1051 char *Converted = ToPtr;
1052 while (FromLength > 0) {
1053 if (iconv(
cd, &FromPtr, &FromLength, &ToPtr, &ToLength) ==
size_t(-1)) {
1054 if (errno == E2BIG || errno == EILSEQ && ToLength < 1) {
1058 size_t d = ToPtr -
result;
1060 int NewLength =
length + r;
1061 if (
char *NewBuffer = (
char *)realloc(
result, NewLength)) {
1063 Converted =
result = NewBuffer;
1066 esyslog(
"ERROR: out of memory");
1072 if (errno == EILSEQ) {
1079 else if (errno != E2BIG)
1093 s = TakePointer ? (
char *)S : S ? strdup(S) : NULL;
1112 s = String.
s ? strdup(String.
s) : NULL;
1122 if (
this == &String)
1125 s = String.
s ? strdup(String.
s) : NULL;
1131 if (
this != &String) {
1144 s = String ? strdup(String) : NULL;
1151 int l1 =
s ? strlen(
s) : 0;
1152 int l2 = strlen(String);
1153 if (
char *p = (
char *)realloc(
s, l1 + l2 + 1)) {
1155 strcpy(
s + l1, String);
1158 esyslog(
"ERROR: out of memory");
1166 int l1 =
s ? strlen(
s) : 0;
1168 if (
char *p = (
char *)realloc(
s, l1 + l2 + 1)) {
1174 esyslog(
"ERROR: out of memory");
1184 if (Index >= 0 && Index < l)
1200 if (!fmt || vasprintf(&buffer, fmt, ap) < 0) {
1201 esyslog(
"error in vasprintf('%s', ...)", fmt);
1202 buffer = strdup(
"???");
1211 if (!fmt || vasprintf(&buffer, fmt, ap) < 0) {
1212 esyslog(
"error in vasprintf('%s', ...)", fmt);
1213 buffer = strdup(
"???");
1221 WeekDay = WeekDay == 0 ? 6 : WeekDay - 1;
1222 if (0 <= WeekDay && WeekDay <= 6) {
1224 const char *day =
tr(
"MonTueWedThuFriSatSun");
1236 return WeekDayName(localtime_r(&t, &tm_r)->tm_wday);
1241 WeekDay = WeekDay == 0 ? 6 : WeekDay - 1;
1243 case 0:
return tr(
"Monday");
1244 case 1:
return tr(
"Tuesday");
1245 case 2:
return tr(
"Wednesday");
1246 case 3:
return tr(
"Thursday");
1247 case 4:
return tr(
"Friday");
1248 case 5:
return tr(
"Saturday");
1249 case 6:
return tr(
"Sunday");
1250 default:
return "???";
1266 tm *tm = localtime_r(&t, &tm_r);
1267 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);
1274 if (ctime_r(&t, buffer)) {
1275 buffer[strlen(buffer) - 1] = 0;
1285 tm *tm = localtime_r(&t, &tm_r);
1288 strftime(p,
sizeof(buf) - (p - buf),
"%d.%m.%Y", tm);
1296 tm *tm = localtime_r(&t, &tm_r);
1297 strftime(buf,
sizeof(buf),
"%d.%m.%y", tm);
1305 strftime(buf,
sizeof(buf),
"%R", localtime_r(&t, &tm_r));
1311 #define JPEGCOMPRESSMEM 500000
1331 int Used = jcd->
size;
1333 if (
uchar *NewBuffer = (
uchar *)realloc(jcd->
mem, NewSize)) {
1334 jcd->
size = NewSize;
1335 jcd->
mem = NewBuffer;
1338 esyslog(
"ERROR: out of memory");
1342 cinfo->dest->next_output_byte = jcd->
mem + Used;
1343 cinfo->dest->free_in_buffer = jcd->
size - Used;
1354 int Used = cinfo->dest->next_output_byte - jcd->
mem;
1355 if (Used < jcd->size) {
1358 jcd->
mem = NewBuffer;
1361 esyslog(
"ERROR: out of memory");
1370 else if (Quality > 100)
1373 jpeg_destination_mgr jdm;
1379 struct jpeg_compress_struct cinfo;
1380 struct jpeg_error_mgr jerr;
1381 cinfo.err = jpeg_std_error(&jerr);
1382 jpeg_create_compress(&cinfo);
1385 cinfo.client_data = &jcd;
1386 cinfo.image_width = Width;
1387 cinfo.image_height = Height;
1388 cinfo.input_components = 3;
1389 cinfo.in_color_space = JCS_RGB;
1391 jpeg_set_defaults(&cinfo);
1392 jpeg_set_quality(&cinfo, Quality, TRUE);
1393 jpeg_start_compress(&cinfo, TRUE);
1396 JSAMPROW rp[Height];
1397 for (
int k = 0; k < Height; k++)
1398 rp[k] = &Mem[rs * k];
1399 jpeg_write_scanlines(&cinfo, rp, Height);
1400 jpeg_finish_compress(&cinfo);
1401 jpeg_destroy_compress(&cinfo);
1411 static char buffer[HOST_NAME_MAX] =
"";
1413 if (gethostname(buffer,
sizeof(buffer)) < 0) {
1415 strcpy(buffer,
"vdr");
1423 const char *
cBase64Encoder::b64 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1446 c |= (
data[
i] >> 4) & 0x0F;
1449 c = (
data[
i] << 2) & 0x3F;
1451 c |= (
data[
i] >> 6) & 0x03;
1550 Add(FileHandle, Out);
1555 if (FileHandle >= 0) {
1557 if (
pfd[i].fd == FileHandle &&
pfd[i].events == (Out ? POLLOUT : POLLIN))
1567 esyslog(
"ERROR: too many file handles in cPoller");
1574 if (FileHandle >= 0) {
1576 if (
pfd[i].fd == FileHandle &&
pfd[i].events == (Out ? POLLOUT : POLLIN)) {
1613 #if !__GLIBC_PREREQ(2, 24)
1618 if (strcmp(
result->d_name,
".") && strcmp(
result->d_name,
".."))
1634 for (
int i = 0; i < Size(); i++) {
1635 if (!strcmp(s, At(i)))
1643 for (
int i = 0; i < Size(); i++)
1653 Load(Directory, DirsOnly);
1663 while ((e =
d.Next()) != NULL) {
1666 if (stat(
AddDirectory(Directory, e->d_name), &ds) == 0) {
1667 if (!S_ISDIR(ds.st_mode))
1671 Append(strdup(e->d_name));
1697 return Open(open(FileName, Flags, Mode));
1698 esyslog(
"ERROR: attempt to re-open %s", FileName);
1708 esyslog(
"ERROR: attempt to re-open file descriptor %d", FileDes);
1723 return f >= 0 && FileReady(f, Wait ? 1000 : 0);
1729 struct timeval timeout;
1731 FD_SET(FileDes, &set);
1732 if (TimeoutMs >= 0) {
1733 if (TimeoutMs < 100)
1735 timeout.tv_sec = TimeoutMs / 1000;
1736 timeout.tv_usec = (TimeoutMs % 1000) * 1000;
1738 return select(FD_SETSIZE, &set, NULL, NULL, (TimeoutMs >= 0) ? &timeout : NULL) > 0 && FD_ISSET(FileDes, &set);
1747 tempName = fileName ?
MALLOC(
char, strlen(fileName) + 5) : NULL;
1749 strcat(strcpy(tempName, fileName),
".$$$");
1763 if (!f && fileName && tempName) {
1764 f = fopen(tempName,
"w");
1775 if (ferror(f) != 0) {
1781 if (fclose(f) < 0) {
1786 if (
result && rename(tempName, fileName) < 0) {
1798 #ifndef USE_FADVISE_READ
1799 #define USE_FADVISE_READ 0
1801 #ifndef USE_FADVISE_WRITE
1802 #define USE_FADVISE_WRITE 1
1805 #define WRITE_BUFFER KILOBYTE(800)
1820 fd = open(FileName, Flags, Mode);
1822 #if USE_FADVISE_READ || USE_FADVISE_WRITE
1823 begin = lastpos = ahead = 0;
1830 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
1838 #if USE_FADVISE_READ || USE_FADVISE_WRITE
1841 posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
1845 return close(OldFd);
1856 #define FADVGRAN KILOBYTE(4)
1857 #define READCHUNK MEGABYTE(8)
1867 return posix_fadvise(fd, Offset - (
FADVGRAN - 1), Len + (
FADVGRAN - 1) * 2, POSIX_FADV_DONTNEED);
1872 if (Whence == SEEK_SET && Offset == curpos)
1874 curpos = lseek(fd, Offset, Whence);
1881 #if USE_FADVISE_READ
1882 off_t jumped = curpos-lastpos;
1883 if ((cachedstart < cachedend) && (curpos < cachedstart || curpos > cachedend)) {
1885 FadviseDrop(cachedstart, cachedend-cachedstart);
1886 cachedstart = curpos;
1889 cachedstart =
min(cachedstart, curpos);
1891 ssize_t bytesRead =
safe_read(fd, Data, Size);
1892 if (bytesRead > 0) {
1893 curpos += bytesRead;
1894 #if USE_FADVISE_READ
1895 cachedend =
max(cachedend, curpos);
1899 if (jumped >= 0 && jumped <= (off_t)readahead) {
1903 if (ahead - curpos < (off_t)(readahead / 2)) {
1904 posix_fadvise(fd, curpos, readahead, POSIX_FADV_WILLNEED);
1905 ahead = curpos + readahead;
1906 cachedend =
max(cachedend, ahead);
1908 if (readahead < Size * 32) {
1909 readahead = Size * 32;
1916 #if USE_FADVISE_READ
1917 if (cachedstart < cachedend) {
1918 if (curpos - cachedstart >
READCHUNK * 2) {
1920 FadviseDrop(cachedstart, curpos -
READCHUNK - cachedstart);
1923 else if (cachedend > ahead && cachedend - curpos >
READCHUNK * 2) {
1939 ssize_t bytesWritten =
safe_write(fd, Data, Size);
1940 #if USE_FADVISE_WRITE
1941 if (bytesWritten > 0) {
1942 begin =
min(begin, curpos);
1943 curpos += bytesWritten;
1944 written += bytesWritten;
1945 lastpos =
max(lastpos, curpos);
1947 if (lastpos > begin) {
1957 posix_fadvise(fd, begin - headdrop, lastpos - begin + headdrop, POSIX_FADV_DONTNEED);
1959 begin = lastpos = curpos;
1960 totwritten += written;
1975 off_t headdrop =
min(off_t(curpos - totwritten), off_t(totwritten * 2));
1976 posix_fadvise(fd, curpos - totwritten - headdrop, totwritten + headdrop, POSIX_FADV_DONTNEED);
1982 return bytesWritten;
1990 if (File->
Open(FileName, Flags, Mode) < 0) {
1999 #define LOCKFILENAME ".lock-vdr"
2000 #define LOCKFILESTALETIME 600
2018 if (f < 0 && fileName) {
2019 time_t Timeout = time(NULL) + WaitSeconds;
2021 f = open(fileName, O_WRONLY | O_CREAT | O_EXCL, DEFFILEMODE);
2023 if (errno == EEXIST) {
2025 if (stat(fileName, &fs) == 0) {
2027 esyslog(
"ERROR: removing stale lock file '%s'", fileName);
2028 if (remove(fileName) < 0) {
2035 else if (errno != ENOENT) {
2042 if (errno == ENOSPC) {
2043 esyslog(
"ERROR: can't create lock file '%s' - assuming lock anyway!", fileName);
2051 }
while (f < 0 && time(NULL) < Timeout);
2079 Object->
prev =
this;
2085 Object->
next =
this;
2111 #define LIST_GARBAGE_COLLECTOR_TIMEOUT 5
2124 esyslog(
"ERROR: ListGarbageCollector destroyed without prior Purge()!");
2130 Object->
next = objects;
2132 lastPut = time(NULL);
2145 objects = Object->next;
2155 :stateLock(NeedsLocking)
2173 esyslog(
"ERROR: cListBase::Lock() called for a list that doesn't require locking");
2195 if (Before && Before !=
objects) {
2232 if (From && To && From != To) {
2289 while (
object && Index-- > 0)
2290 object =
object->
Next();
2309 while (
object && i < n) {
2311 object =
object->
Next();
2315 for (i = 0; i < n; i++) {
2339 if (
size < NewSize) {
2346 esyslog(
"ERROR: out of memory");
2378 unsigned int hash =
hashfn(Id);
2389 if (hob->object == Object) {
2399 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 void SetSystemCharacterTable(const char *CharacterTable)
static char * systemCharacterTable
static const char * SystemCharacterTable(void)
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",...
cListObject * Next(void) const
void Insert(cListObject *Object)
void Append(cListObject *Object)
const T * Next(const T *Object) const
< Returns the element immediately before Object in this list, or NULL if Object is the first element ...
const T * First(void) const
Returns the first element in this list, or NULL if the list is empty.
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.
virtual void Clear(void) override
int Find(const char *s) const
virtual ~cStringList() override
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)