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)) {
1611 #if !__GLIBC_PREREQ(2, 24)
1616 if (strcmp(
result->d_name,
".") && strcmp(
result->d_name,
".."))
1632 for (
int i = 0; i < Size(); i++) {
1633 if (!strcmp(s, At(i)))
1641 for (
int i = 0; i < Size(); i++)
1651 Load(Directory, DirsOnly);
1661 while ((e =
d.Next()) != NULL) {
1664 if (stat(
AddDirectory(Directory, e->d_name), &ds) == 0) {
1665 if (!S_ISDIR(ds.st_mode))
1669 Append(strdup(e->d_name));
1695 return Open(open(FileName, Flags, Mode));
1696 esyslog(
"ERROR: attempt to re-open %s", FileName);
1706 esyslog(
"ERROR: attempt to re-open file descriptor %d", FileDes);
1721 return f >= 0 && FileReady(f, Wait ? 1000 : 0);
1727 struct timeval timeout;
1729 FD_SET(FileDes, &set);
1730 if (TimeoutMs >= 0) {
1731 if (TimeoutMs < 100)
1733 timeout.tv_sec = TimeoutMs / 1000;
1734 timeout.tv_usec = (TimeoutMs % 1000) * 1000;
1736 return select(FD_SETSIZE, &set, NULL, NULL, (TimeoutMs >= 0) ? &timeout : NULL) > 0 && FD_ISSET(FileDes, &set);
1745 tempName = fileName ?
MALLOC(
char, strlen(fileName) + 5) : NULL;
1747 strcat(strcpy(tempName, fileName),
".$$$");
1761 if (!f && fileName && tempName) {
1762 f = fopen(tempName,
"w");
1773 if (ferror(f) != 0) {
1779 if (fclose(f) < 0) {
1784 if (
result && rename(tempName, fileName) < 0) {
1796 #ifndef USE_FADVISE_READ
1797 #define USE_FADVISE_READ 0
1799 #ifndef USE_FADVISE_WRITE
1800 #define USE_FADVISE_WRITE 1
1803 #define WRITE_BUFFER KILOBYTE(800)
1818 fd = open(FileName, Flags, Mode);
1820 #if USE_FADVISE_READ || USE_FADVISE_WRITE
1821 begin = lastpos = ahead = 0;
1828 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
1836 #if USE_FADVISE_READ || USE_FADVISE_WRITE
1839 posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
1843 return close(OldFd);
1854 #define FADVGRAN KILOBYTE(4)
1855 #define READCHUNK MEGABYTE(8)
1865 return posix_fadvise(fd, Offset - (
FADVGRAN - 1), Len + (
FADVGRAN - 1) * 2, POSIX_FADV_DONTNEED);
1870 if (Whence == SEEK_SET && Offset == curpos)
1872 curpos = lseek(fd, Offset, Whence);
1879 #if USE_FADVISE_READ
1880 off_t jumped = curpos-lastpos;
1881 if ((cachedstart < cachedend) && (curpos < cachedstart || curpos > cachedend)) {
1883 FadviseDrop(cachedstart, cachedend-cachedstart);
1884 cachedstart = curpos;
1887 cachedstart =
min(cachedstart, curpos);
1889 ssize_t bytesRead =
safe_read(fd, Data, Size);
1890 if (bytesRead > 0) {
1891 curpos += bytesRead;
1892 #if USE_FADVISE_READ
1893 cachedend =
max(cachedend, curpos);
1897 if (jumped >= 0 && jumped <= (off_t)readahead) {
1901 if (ahead - curpos < (off_t)(readahead / 2)) {
1902 posix_fadvise(fd, curpos, readahead, POSIX_FADV_WILLNEED);
1903 ahead = curpos + readahead;
1904 cachedend =
max(cachedend, ahead);
1906 if (readahead < Size * 32) {
1907 readahead = Size * 32;
1914 #if USE_FADVISE_READ
1915 if (cachedstart < cachedend) {
1916 if (curpos - cachedstart >
READCHUNK * 2) {
1918 FadviseDrop(cachedstart, curpos -
READCHUNK - cachedstart);
1921 else if (cachedend > ahead && cachedend - curpos >
READCHUNK * 2) {
1937 ssize_t bytesWritten =
safe_write(fd, Data, Size);
1938 #if USE_FADVISE_WRITE
1939 if (bytesWritten > 0) {
1940 begin =
min(begin, curpos);
1941 curpos += bytesWritten;
1942 written += bytesWritten;
1943 lastpos =
max(lastpos, curpos);
1945 if (lastpos > begin) {
1955 posix_fadvise(fd, begin - headdrop, lastpos - begin + headdrop, POSIX_FADV_DONTNEED);
1957 begin = lastpos = curpos;
1958 totwritten += written;
1973 off_t headdrop =
min(off_t(curpos - totwritten), off_t(totwritten * 2));
1974 posix_fadvise(fd, curpos - totwritten - headdrop, totwritten + headdrop, POSIX_FADV_DONTNEED);
1980 return bytesWritten;
1988 if (File->
Open(FileName, Flags, Mode) < 0) {
1997 #define LOCKFILENAME ".lock-vdr"
1998 #define LOCKFILESTALETIME 600
2016 if (f < 0 && fileName) {
2017 time_t Timeout = time(NULL) + WaitSeconds;
2019 f = open(fileName, O_WRONLY | O_CREAT | O_EXCL, DEFFILEMODE);
2021 if (errno == EEXIST) {
2023 if (stat(fileName, &fs) == 0) {
2025 esyslog(
"ERROR: removing stale lock file '%s'", fileName);
2026 if (remove(fileName) < 0) {
2033 else if (errno != ENOENT) {
2040 if (errno == ENOSPC) {
2041 esyslog(
"ERROR: can't create lock file '%s' - assuming lock anyway!", fileName);
2049 }
while (f < 0 && time(NULL) < Timeout);
2077 Object->
prev =
this;
2083 Object->
next =
this;
2109 #define LIST_GARBAGE_COLLECTOR_TIMEOUT 5
2122 esyslog(
"ERROR: ListGarbageCollector destroyed without prior Purge()!");
2128 Object->
next = objects;
2130 lastPut = time(NULL);
2143 objects = Object->next;
2153 :stateLock(NeedsLocking)
2171 esyslog(
"ERROR: cListBase::Lock() called for a list that doesn't require locking");
2193 if (Before && Before !=
objects) {
2230 if (From && To && From != To) {
2287 while (
object && Index-- > 0)
2288 object =
object->
Next();
2307 while (
object && i < n) {
2309 object =
object->
Next();
2313 for (i = 0; i < n; i++) {
2337 if (
size < NewSize) {
2344 esyslog(
"ERROR: out of memory");
2376 unsigned int hash =
hashfn(Id);
2387 if (hob->object == Object) {
2397 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)