files.c

Go to the documentation of this file.

/*
 * This file is part of Titan2Reader
 *
 * Copyright (C) 2006, Sebastien Judenherc <sebastien.judenherc@agecodagis.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <ctype.h>
#include <math.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>

#include "common.h"

int nFiles=0; //<! how many files have been opened

int trySeek=-1; //<! do we hope for a seek on this read ?
struct dirent **titanList=NULL; 
int titanListLen=0;             
int titanListIndex=0;           
struct dirent **dayDir=NULL;    
int dayDirLen=0;                
int dayDirIndex=0;              
char fullName[256];             

FILE *eventList=NULL;           
int segmentLength=0;            

void CloseInput(void)
{
        if (titan2File!=0)
        {
                fclose(titan2File);
                titan2File=NULL;
        }
}

FILE * InitEventList(const char *fn)
{
        if (eventList==NULL)
        {
                eventList=fopen(fn,"rt");
                if (eventList==NULL)
                {
                        PrintError("%s: %m\n",fn);
                }
        }
        return(eventList);
}


time_t NextWindow(void)
{
        char line[255];
        double t;
        int len;
        // allow the next seek
        trySeek=-1;
        // an eventFile must be open
        // while the event file is open
        while (eventList!=NULL)
        {
                // read the next entry
                line[0]=0;
                fgets(line,254,eventList);
                // if no more entry exists
                if (line[0]==0)
                {
                        // return -1
                        PrintLog("end of timelist\n");
                        fclose(eventList);
                        eventList=NULL;
                        return(-1);
                }
                // endif
                // if the line should be skipped
                if (line[0]=='#')
                {
                        // skip it
                        continue;
                }
                // endif
                // now interpret the line
                // set begin and end of window
                if (str2time(line,&t)<0)
                {
                        beginWindow=-1;
                }
                else
                {
                        beginWindow=(time_t)t;
                }
                if ((beginWindow<0)||(sscanf(line,"%*s %d",&len)!=1))
                {
                        PrintError("timelist format error: %s",line);
                        return(-1);
                }
                endWindow=beginWindow+len;
                // return begin of window
                PrintLog("############ next window: %s, len=%d\n",
                                time2str((double)beginWindow),len);
                // if preEvent is defined
                if (preEvent!=0xefffffff)
                {
                        // correct beginWindow
                        beginWindow-=preEvent;
                // endif
                }
                // if postEvent is defined
                if (postEvent!=0xefffffff)
                {
                        // set endWindow
                        endWindow=beginWindow+postEvent;
                // endif
                }
                return(beginWindow);
        // end while
        }
        // if the window has already been defined by the command line
        if (cmdLineWindow>0)
        {
                cmdLineWindow=-1;
                return(beginWindow);
        }
        // if we are here, it means that no time window was given, so we
        // just extract everything
        // if we were already doing this
        if ((beginWindow==endWindow)&&(beginWindow==0))
        {
                // return -1
                return(-1);
        }
        // else
        else
        {
                // the code below should be here but causes some warning
        }
        // return begin of window
        beginWindow=0;
        endWindow=0;
        if (timeSegment>0)
        {
                return(-1);
        }
        else
        {
                return(beginWindow);
        }
}

int SequentialSeek(time_t t)
{
        double tf;
        fastSeek=1;
        // reset the input settings
        //ResetInput();
        // raise the seeking flag
        seeking=1;
        // reset the current time
        correctedTime.usecond=0;
        // while the current time is more than 30 minutes before the target
        while ((correctedTime.usecond>>32)+1800<t)
        // do
        {
                int len;
                // prevent printing messages
                printTrigger=-1;
                // reset the current time
                correctedTime.usecond=0;
                // fetch the next file
                titan2File=NextFile();
                // compute the length now
                len=strlen(currentFile);
                // test for the end of input
                if (titan2File==NULL)
                {
                        break;
                }
                // read the time from the filename
                if (strcmp(currentFile+len-4,".ftp")==0)
                {
                        if (str2time(currentFile+len-23,&tf)<0)
                        {
                                PrintError("internal error (%s %s %d)\n",
                                                currentFile,__FILE__,__LINE__);
                                PrintError("make sure that the day-dir is present in the path\n");
                        }
                }
                else
                {
                        if (str2time(currentFile+len-19,&tf)<0)
                        {
                                PrintError("internal error (%s %s %d)\n",
                                                currentFile,__FILE__,__LINE__);
                                PrintError("make sure that the day-dir is present in the path\n");
                        }
                }
                if (tf+3600<t)
                {
                        continue;
                }
                PrintDebug("trying %s\n",currentFile);
                // while the current time is not defined
                while (correctedTime.usecond<=0)
                {
                        // read a frame
                        GetFrame();
                // endwhile
                }
        // endwhile
        }
        // lower the seeking flag
        seeking=0;
        fastSeek=0;
        // print the first frame
        // return some search result
        if ((correctedTime.usecond>>32)+600>=t)
        {
                return(1);
        }
        else
        {
                return(0);
        }
}

int SeekTime(time_t t)
{
        char line[128];
        char fn[128],theFile[128];
        int r;
        time_t at=0,lt=-1;
        int64_t offset=0,lastOffset=0;

        // if seek is not allowed
        if (trySeek==0)
        // then
        {
                // return 0
                return(0);
        // endif
        }

        // if day or disk is used
        if ((inputMode==DAY_MODE)||(inputMode==DISK_MODE))
        // then
        {
                trySeek=0;
                // sequentially search the right file
                return(SequentialSeek(t));
        // endif
        }

        if (strcmp(HWConfig.serialNumber,DEFAULT_SERIAL)==0)
        {
                return(0);
        }

        // if no time window is defined, then seek is useless
        if ((beginWindow<=0)||(t<=0))
        {
                trySeek=0;
                return(0);
        }
        PrintLog("trying to seek %s\n",time2str((double)t));
        // if the cache file is open for write
        r=OpenCacheFileRead(HWConfig.serialNumber,t);
        if (r==1) // open for write
        {
                // cache not usable, we are building the cache
                trySeek=0;
                return(0);
        }
        // -1: still unable to open a cache file
        if (r==-1)
        {
                // just return
                trySeek=0;
                return(0);
        }
        // now the cache file is open for read
        RewindCache();

        // if we are after the starttime of the current time window
        if ((correctedTime.usecond>>32)>beginWindow)
        {
                // then give up
                trySeek=0;
                return(0);
        }

        // raise the seek flag
        seeking=1;

        fn[0]=theFile[0]=0;
        // search the cache file for the latest time before t
        // while not at the end of the file
        while (CacheRead(line)!=NULL)
        {
                int64_t o;
                PrintDebug("'%s'\n",line);
                // read a line
                // if this is not a #TIME line
                if (memcmp(line,"#TIME",5))
                {
                        // skip it
                        continue;
                // endif
                }
                // suppose the previous one was the right one
                if (fn[0]!=0)
                {
                        strcpy(theFile,fn);
                        offset=lastOffset;
                        lt=at;
                }

                // get the time of the line
                if (sscanf(line,"%*s %s %lld %ld",fn,&o,&at)!=3)
                {
                        fn[0]=0;
                        continue;
                }
                if (at<=lt)
                {
                        fn[0]=0;
                        continue;
                }
                // if the time is after the requested time
                if ((at>0)&&(at>t))
                {
                        PrintDebug("at=%d %s\n",at,time2str(at));
                        PrintDebug("lt=%d %s\n",lt,time2str(lt));
                        PrintDebug(" t=%d\n",t);
                        PrintDebug("file=%s, offset=%d\n",theFile,offset);
                        // stop searching
                        break;
                // fi
                }
                lastOffset=o;
        }
        // do not try on next read
        trySeek=0;

        // while a file is available and the daydir and filename don't match
        while (strcmp(theFile,currentFile))
        {
                // fetch the next file
                titan2File=NextFile();
                if (titan2File==NULL)
                {
                        break;
                }
                PrintDebug("%s vs %s\n", theFile,currentFile);
        // end while
        }

        if (titan2File)
        {
                PrintDebug("found: %s %d\n",currentFile,offset);
                fseek(titan2File,offset,SEEK_SET);
        }
        else
        {
                PrintDebug("not found\n");
        }
        // lower the seek flag
        seeking=0;

        // print the first frame
        printTrigger=0;

        return(0);
}

int TitanFileSelect(const struct dirent* t)
{
        int i;
        for (i=0; i<8; i++)
        {
                if (!isdigit(t->d_name[i]))
                {
                        if (t->d_name[i]!='.')
                        {
                                return(0);
                        }
                }
        }
        if (strlen(t->d_name)<8)
        {
                return(0);
        }
        if (strlen(t->d_name)>8)
        {
                if (strcmp(t->d_name+8,".ftp"))
                {
                        return(0);
                }
        }
        return(1);
}

int DayDirSelect(const struct dirent* t)
{
        int i;
        if (strlen(t->d_name)!=10)
        {
                return(0);
        }
        if ((t->d_name[4]!='.')||(t->d_name[7]!='.'))
        {
                return(0);
        }
        for (i=0; i<2; i++)
        {
                if (
                                (!isdigit(t->d_name[i]))||
                                (!isdigit(t->d_name[i+2]))||
                                (!isdigit(t->d_name[i+5]))||
                                (!isdigit(t->d_name[i+8]))
                   )
                {
                        return(0);
                }
        }
        return(1);
}

void FreeDiskDir(void)
{
        int i;
        if (dayDirLen>0)
        {
                for (i=0; i<dayDirLen; i++)
                {
                        free(dayDir[i]);
                }
                free(dayDir);
                dayDir=NULL;
        }
        dayDirLen=0;
}

int OpenDiskDir(const char * path)
{
        // setup baseDir if this is our current mode
        if (inputMode==DISK_MODE)
        {
                baseDir=(char*)path;
                while (baseDir[strlen(baseDir)-1]=='/')
                {
                        baseDir[strlen(baseDir)-1]=0;
                }
        }
        // first free any already allocated buffer
        FreeDiskDir();
        // read the directory content
        dayDirLen=__scandir(path,&dayDir,DayDirSelect,__alphasort);
        dayDirIndex=0;
        //PrintLog("%d entries in %s\n",dayDirLen,path);
        return(dayDirLen);
}

void FreeDayDir(void)
{
        int i;
        if (titanListLen>0)
        {
                for (i=0; i<titanListLen; i++)
                {
                        free(titanList[i]);
                }
                free(titanList);
                titanList=NULL;
        }
        titanListLen=0;
}

int OpenDayDir(const char * path)
{
        // setup baseDir if this is our current mode
        if (inputMode==DAY_MODE)
        {
                baseDir=(char*)path;
        }
        // first free any already allocated buffer
        FreeDayDir();
        // read the directory content
        titanListLen=__scandir(path,&titanList,TitanFileSelect,__alphasort);
        titanListIndex=0;
        //PrintLog("%d entries in %s\n",titanListLen,path);
        return(titanListLen);
}

FILE * NextFile(void)
{
        FILE *f=NULL;

        // first make sure no input file is open
        CloseInput();

        // exit now if we are out of the defined window
        if ((scanAll==0)&&(endWindow>0)&&((correctedTime.usecond>>32)>endWindow))
        {
                FlushDataFiles();
                return(NULL);
        }

        while (f==NULL)
        {
                // start with fullName=naseDir
                if (inputMode!=FILE_MODE)
                {
                        strcpy(fullName,baseDir);
                }
                switch (inputMode)
                {
                        case DISK_MODE: // disk mode
                                // first check if a new daydir must be processed
                                if (titanListIndex>=titanListLen)
                                {
                                        // if no more daydir exists
                                        if (dayDirIndex>=dayDirLen)
                                        // then
                                        {
                                                // abort search
                                                return(NULL);
                                        }
                                        // else
                                        else
                                        {
                                                // open the daydir
                                                sprintf(fullName,"%s/%s",
                                                                baseDir,
                                                                dayDir[dayDirIndex]->d_name);
                                                PrintDebug("reading %s\n",fullName);
                                                OpenDayDir(fullName);
                                                dayDirIndex++;
                                        // endif
                                        }
                                }
                                // if no file was found in the day dir
                                if (titanListIndex>=titanListLen)
                                {
                                        // try next entry
                                        break;
                                // endif
                                }
                                // be sure fullName is still ok
                                // attention: dayDirIndex-1 car dayDirIndex pointe sur le prochain
                                sprintf(fullName,"%s/%s",baseDir,dayDir[dayDirIndex-1]->d_name);
                                // now enter in daydir mode (no break)
                        case DAY_MODE: // daydir mode
                                // if a new entry exists
                                if (titanListIndex<titanListLen)
                                {
                                        if (fullName[strlen(fullName)-1]!='/')
                                        {
                                                strcat(fullName,"/");
                                        }
                                        strcat(fullName,titanList[titanListIndex]->d_name);
                                        // try to open it
                                        //PrintDebug("opening %s\n",currentFile);
                                        currentFile=fullName;
                                        // prepare for the next entry
                                        titanListIndex++;
                                        if ((f=fopen(currentFile,"rb"))==NULL)
                                        {
                                                strcat(currentFile,".ftp");
                                                if ((f=fopen(currentFile,"rb"))==NULL)
                                                {
                                                        break;
                                                }
                                                else
                                                {
                                                        PrintError("%s: %m (n=%d)\n",currentFile,nFiles);
                                                }
                                        }
                                        nFiles++;
                                        setvbuf(f,NULL,_IOFBF,FILE_BUFFER_SIZE);

                                        //printTrigger=totalFrameProcessed+INIT_PRINT_TRIGGER;
                                        inputOffset=0;
                                }
                                // else
                                else
                                {
                                        // this is the end of the input: abort
                                        return(NULL);
                                }
                                break;
                        case FILE_MODE: // file mode
                                // if the file index is larger than the number of files
                                if (iFileInput>=ARGC)
                                {
                                        // stop
                                        return(NULL);
                                }
                                // else
                                else
                                {
                                        // open the file
                                        currentFile=ARGV[iFileInput];
                                        inputOffset=0;
                                        printTrigger=totalFrameProcessed+INIT_PRINT_TRIGGER;
                                        iFileInput++;
                                        if ((f=fopen(currentFile,"rb"))==NULL)
                                        {
                                                PrintError("%s: %m\n",currentFile);
                                                break;
                                        }
                                        setvbuf(f,NULL,_IOFBF,FILE_BUFFER_SIZE);
                                        if (beginOfFile>0)
                                        {
                                                fseek(f,(long)beginOfFile,SEEK_SET);
                                                inputOffset=SafeFtell(f);
                                        }
                                        if (baseDir==NULL)
                                        {
                                                baseDir=currentFile;
                                        }
                                // endif
                                }
                                break;
                }
        }
        return(f);
}

int OpenTempFile(char * template)
{
        char *path;
        static char templ[255];
        path=getenv("RTITAN2TMP");
        if (path)
        {
                sprintf(templ,"%s/%s",path,template);
                strcpy(template,templ);
        }
        else
        {
        }
        return(mkstemp(template));
}

int Rename(const char *oldpath, const char *newpath)
{
        int in, out, ret;
        ret=-1;
        // first try rename()
        if (0==rename(oldpath,newpath))
        {
                return(0);
        }
        if (errno!=EXDEV)
        {
                PrintError("rename %s %s: %m\n",oldpath,newpath);
                return(-1);
        }
        // here, the error is EXDEV, try to copy and remove
        in=open(oldpath,O_RDONLY);
        if (in>=0)
        {
                struct stat st;
                fstat(in, &st);
                out=open(newpath,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR);
                if (out>=0)
                {
                        if (SendFile(out, in, st.st_size)!=st.st_size)
                        {
                                PrintError("rename %s %s: %m\n",oldpath,newpath);
                                ret=-1;
                        }
                        close(out);
                        close(in);
                }
                else
                {
                        close(in);
                }
        }
        else
        {
                close(in);
        }
        unlink(oldpath);
        return(ret);
}

---