int strutil_isTextFile(const char *path) {
FILE_STREAM_T fs;
int rc = 0;
unsigned char buf[256];
size_t sz;
size_t idx;
FILE_OFFSET_T fSize;
if(OpenMediaReadOnly(&fs, path) != 0) {
return 0;
}
fSize = fs.size;
while(fs.offset < fSize) {
sz = sizeof(buf);
if(fs.offset + sz > fSize) {
sz = (size_t) (fSize - fs.offset);
}
if(ReadFileStream(&fs, buf, sz) != sz) {
break;
}
// Simply check if the file is a text file
for(idx = 0; idx < sz; idx++) {
//if(!isascii(buf[idx])) {
if(!avc_istextchar(buf[idx])) {
CloseMediaFile(&fs);
return 0;
}
}
if(fs.offset == fSize) {
rc = 1;
}
}
CloseMediaFile(&fs);
return rc;
}
int image_open(const char *path, IMAGE_GENERIC_DESCR_T *pImg,
enum MEDIA_FILE_TYPE mediaType) {
int rc = 0;
uint32_t sz;
FILE_STREAM_T fs;
if(!path || !pImg) {
return -1;
}
pImg->mediaType = mediaType;
memset(&fs, 0, sizeof(fs));
if(OpenMediaReadOnly(&fs, path) < 0) {
return -1;
}
if(fs.size > IMAGE_MAX_SIZE) {
LOG(X_ERROR("File %s size %llu exceeds max %d"),
fs.filename, fs.size, IMAGE_MAX_SIZE);
rc = -1;
} else if(fs.size < 4) {
LOG(X_ERROR("File %s size is too small %llu"), fs.filename, fs.size);
rc = -1;
}
if(rc >= 0) {
memset(&pImg->bs, 0, sizeof(pImg->bs));
pImg->bs.sz = (unsigned int) fs.size;
if(!(pImg->bs.buf = avc_calloc(1, pImg->bs.sz))) {
rc = -1;
}
}
if(rc >= 0) {
while(pImg->bs.idx < fs.size) {
if((sz = (uint32_t) (fs.size - pImg->bs.idx)) > 4096) {
sz = 4096;
}
if((rc = ReadFileStream(&fs, &pImg->bs.buf[pImg->bs.idx], sz)) != sz) {
rc = -1;
break;
}
pImg->bs.idx += rc;
}
if(rc >= 0) {
rc = pImg->bs.idx;
}
pImg->bs.idx = 0;
}
CloseMediaFile(&fs);
pImg->width = 0;
pImg->height = 0;
if(rc >= 0) {
switch(mediaType) {
case MEDIA_FILE_TYPE_PNG:
png_parse(pImg);
break;
case MEDIA_FILE_TYPE_BMP:
bmp_parse_hdr(pImg);
break;
default:
break;
}
}
return rc;
}
int metafile_isvalidFile(const char *path) {
FILE_STREAM_T fs;
int rc = 0;
unsigned char buf[128];
struct stat st;
size_t sz;
size_t idx;
int is_nl = 0;
FILE_OFFSET_T fSize;
if(!path) {
return 0;
}
if(fileops_stat(path, &st) != 0 || (st.st_mode & S_IFDIR)) {
return 0;
}
if(OpenMediaReadOnly(&fs, path) != 0) {
return 0;
}
if((fSize = fs.size) > METAFILE_FILE_CHK_SZMAX) {
fSize = METAFILE_FILE_CHK_SZMAX;
}
while(fs.offset < fSize && rc != 1) {
sz = sizeof(buf);
if(fs.offset + sz > fSize) {
sz = (size_t) (fSize - fs.offset);
}
if(ReadFileStream(&fs, buf, sz) != sz) {
break;
}
for(idx = 0; idx < sz; idx++) {
if(!avc_istextchar(buf[idx])) {
CloseMediaFile(&fs);
return 0;
}
if(buf[idx] == '\n') {
is_nl = 1;
} else {
if(is_nl) {
if(!memcmp(&buf[idx], METAFILE_KEY_FILE, strlen(METAFILE_KEY_FILE)) ||
!memcmp(&buf[idx], METAFILE_KEY_DEVICE, strlen(METAFILE_KEY_DEVICE)) ||
!memcmp(&buf[idx], METAFILE_KEY_TITLE, strlen(METAFILE_KEY_TITLE)) ||
!memcmp(&buf[idx], METAFILE_KEY_DESCRIPTION, strlen(METAFILE_KEY_DESCRIPTION)) ||
!memcmp(&buf[idx], METAFILE_KEY_IGNORE, strlen(METAFILE_KEY_IGNORE)) ||
!memcmp(&buf[idx], METAFILE_KEY_RTMP_PROXY, strlen(METAFILE_KEY_RTMP_PROXY)) ||
!memcmp(&buf[idx], METAFILE_KEY_RTSP_PROXY, strlen(METAFILE_KEY_RTSP_PROXY)) ||
!memcmp(&buf[idx], METAFILE_KEY_HTTP_PROXY, strlen(METAFILE_KEY_HTTP_PROXY)) ||
!memcmp(&buf[idx], METAFILE_KEY_METHODS, strlen(METAFILE_KEY_METHODS)) ||
!memcmp(&buf[idx], METAFILE_KEY_TOKEN, strlen(METAFILE_KEY_TOKEN)) ||
!memcmp(&buf[idx], METAFILE_KEY_XCODEARGS, strlen(METAFILE_KEY_XCODEARGS))) {
rc = 1;
break;
}
}
is_nl = 0;
}
}
}
CloseMediaFile(&fs);
return rc;
}
static int update_fileentry(FILE_LIST_T *pFileList, const char *mediaName,
const char *mediaPath, FILE_LIST_ENTRY_T **ppEntry) {
MEDIA_DESCRIPTION_T mediaDescr;
FILE_STREAM_T fileStream;
FILE_LIST_ENTRY_T *pFileEntryCur = NULL;
FILE_LIST_ENTRY_T *pFileEntryNew = NULL;
FILE_LIST_ENTRY_T fileEntry;
char buf[VSX_MAX_PATH_LEN];
struct stat st;
struct stat st2;
int havestat = 0;
size_t szt;
int fileChanged = 1;
memset(&fileEntry, 0, sizeof(fileEntry));
//fprintf(stdout, "looking for '%s'\n", mediaName);
if((pFileEntryCur = file_list_find(pFileList, mediaName))) {
//fprintf(stdout, "found entry '%s' numTn:%d\n", pFileEntryCur->name, pFileEntryCur->numTn);
// mark the entry as current to avoid deletion
pFileEntryCur->flag = 1;
if((havestat = !fileops_stat(mediaPath, &st)) == 0) {
LOG(X_ERROR("Unable to stat '%s'"), mediaPath);
} else if(st.st_size == pFileEntryCur->size &&
st.st_ctime == pFileEntryCur->tm) {
fileChanged = 0;
//
// Special case to probe for recent creation .seek file
// since the last time this entry was written
//
if(pFileEntryCur->duration == 0) {
buf[sizeof(buf) - 1] = '\0';
strncpy(buf, mediaPath, sizeof(buf) - 1);
if((szt = strlen(buf))) {
strncpy(&buf[szt], MP2TS_FILE_SEEKIDX_NAME, sizeof(buf) - szt - 1);
}
if(fileops_stat(buf, &st2) == 0) {
fileChanged = 1;
}
}
}
pFileEntryNew = pFileEntryCur;
} else {
// Check for invalid chars - ',' is used as a delimeter in .avcfidx
if(strchr(mediaName, ',') || mediaName[0] == '#' || mediaName[0] == ' ' ||
mediaName[0] == '=') {
LOG(X_WARNING("Illegal filename '%s' not added to database"), mediaPath);
pFileEntryNew = NULL;
fileChanged = 0;
} else {
LOG(X_DEBUG("Could not find database entry '%s'"), mediaPath);
pFileEntryNew = &fileEntry;
}
}
if(fileChanged) {
if(OpenMediaReadOnly(&fileStream, mediaPath) == 0) {
memset(&mediaDescr, 0, sizeof(mediaDescr));
if(filetype_getdescr(&fileStream, &mediaDescr, 1) == 0) {
pFileEntryNew->flag = 1;
pFileEntryNew->duration = mediaDescr.durationSec;
pFileEntryNew->size = mediaDescr.totSz;
if(!havestat && (havestat = !fileops_stat(mediaPath, &st)) == 0) {
LOG(X_ERROR("Unable to stat new entry '%s'"), mediaPath);
}
if(havestat) {
pFileEntryNew->tm = st.st_ctime;
//fprintf(stderr, "-----------set tm:%ld %s\n", pFileEntryNew->tm, mediaPath);
}
if(mediaDescr.haveVid) {
create_viddescrstr(&mediaDescr, pFileEntryNew->vstr, sizeof(pFileEntryNew->vstr));
}
if(mediaDescr.haveAud) {
create_auddescrstr(&mediaDescr, pFileEntryNew->astr, sizeof(pFileEntryNew->astr));
//fprintf(stdout, "aud descr:'%s'\n", pFileEntryNew->astr);
}
} else {
pFileEntryNew->flag = 1;
pFileEntryNew->size = fileStream.size;
}
CloseMediaFile(&fileStream);
} // end of OpenMediaReadOnly
if(pFileEntryCur == NULL) {
pFileEntryNew->name[sizeof(pFileEntryNew->name) - 1] = '\0';
strncpy(pFileEntryNew->name, mediaName, sizeof(pFileEntryNew->name) - 1);
pFileEntryCur = file_list_addcopy(pFileList, pFileEntryNew);
}
} // end of if(fileChanged)
if(ppEntry) {
*ppEntry = pFileEntryCur;
}
return fileChanged;
}
