void openLogfile() { if (logFD != NULL) { TAP_Print("openLogfile: attempting to open file that's already open\r\n"); return; } logFD = TAP_Hdd_Fopen((char *)LOGFILENAME); if (logFD == NULL) { //TAP_Print("File doesn't exist. Creating log file...\r\n"); TAP_Hdd_Create((char *)LOGFILENAME, ATTR_NORMAL); logFD = TAP_Hdd_Fopen((char *)LOGFILENAME); //write the header stuff identifying this machine/firmware logByteCount = sizeof logByteCount; //TAP_Hdd_Fwrite((void *)logByteCount, logByteCount, 1, logFD); TAP_Hdd_Fwrite((void *)"4 ", logByteCount, 1, logFD); //TAP_Print("File marker written...\r\n"); } else { // goto the end of the file //TAP_Hdd_Fseek(logFD, 0, SEEK_END); } }
//---------------- // void WriteDatFile( TYPE_File *writeFile ) { char* currentDir; appendToLogfile("WriteDatFile: Started.", INFO); appendToLogfile("WriteDatFile: GetCurrentDir called.", WARNING); currentDir = GetCurrentDir(); // Store the current directory. appendStringToLogfile("WriteDatFile: GetCurrentDir returned=%s.",currentDir, WARNING); appendStringToLogfile("WriteDatFile: Moving to=%s.",TAPIniDir, WARNING); GotoPath(TAPIniDir); // Go to the Project Directory. if ( TAP_Hdd_Exist( PLAYDATA_FILENAME ) ) TAP_Hdd_Delete( PLAYDATA_FILENAME ); // Just delete any old copies appendToLogfile("WriteDatFile: Creating DATA file.", ERR); TAP_Hdd_Create( PLAYDATA_FILENAME, ATTR_PROGRAM ); // Create the file appendToLogfile("WriteDatFile: Opening DATA file.", ERR); writeFile = TAP_Hdd_Fopen( PLAYDATA_FILENAME ); if ( writeFile == NULL ) return; // Check we can open it appendToLogfile("WriteDatFile: Writing to DATA file.", ERR); TAP_Hdd_Fwrite( playDataBuffer_ini, PLAYBACKDATA_BUFFER_SIZE_ini, 1, writeFile ); // dump the whole buffer in one hit appendToLogfile("WriteDatFile: Closing DATA file.", ERR); TAP_Hdd_Fclose( writeFile ); appendStringToLogfile("WriteDatFile: Returning to=%s.",currentDir, WARNING); GotoPath(currentDir); // Return to the original directory. TAP_MemFree( currentDir ); // Free allocated memory. appendToLogfile("WriteDatFile: Finished.", INFO); }
void Settings_Save() { TYPE_File* fp; TAP_Hdd_ChangeDir( ".." ); TAP_Hdd_ChangeDir( ".." ); TAP_Hdd_ChangeDir( "ProgramFiles" ); if ( !TAP_Hdd_Exist( "Settings" ) ) TAP_Hdd_Create( "Settings", ATTR_FOLDER ); TAP_Hdd_ChangeDir( "Settings" ); if ( !TAP_Hdd_Exist( settingsFile ) ) TAP_Hdd_Create( settingsFile, ATTR_NORMAL ); if ( fp = TAP_Hdd_Fopen(settingsFile) ) { int version = INI_VERSION; int zero[64]; memset( zero, 0, sizeof(zero) ); TAP_Hdd_Fwrite( &version, 1, sizeof(version), fp ); TAP_Hdd_Fwrite( &settings, 1, sizeof(settings), fp ); TAP_Hdd_Fwrite( zero, 1, sizeof(zero), fp ); TAP_Hdd_Fclose( fp ); } }
void Settings_Load() { TYPE_File* fp; bool validSettings = FALSE; TAP_Hdd_ChangeDir( ".." ); TAP_Hdd_ChangeDir( ".." ); TAP_Hdd_ChangeDir( "ProgramFiles" ); TAP_Hdd_ChangeDir( "Settings" ); if ( fp = TAP_Hdd_Fopen(settingsFile) ) { int version = 0; TAP_Hdd_Fread( &version, 1, sizeof(version), fp ); if ( version == INI_VERSION ) { TAP_Hdd_Fread( &settings, 1, sizeof(settings), fp ); validSettings = TRUE; } TAP_Hdd_Fclose( fp ); } if ( !validSettings ) { Settings_Reset(); Settings_Save(); } }
int TAP_Main(void) { char* path = "fileTest.txt"; char line[512]; UFILE *fp; TYPE_File *tf; printf("Starting file tester...\r\n"); PrintMem(); initFile(_INFO); PrintMem(); if (fp = fopen(path, "w")) { if (fputs("This is a test message1\n", fp) == EOF) ShowError(); //TAP_Print("1. File is %d bytes\r\n", TAP_Hdd_Flen(fp->fd)); if (fputs("This is a test message2\n", fp) == EOF) ShowError(); //TAP_Print("2. File is %d bytes\r\n", TAP_Hdd_Flen(fp->fd)); fclose(fp); } PrintMem(); tf = TAP_Hdd_Fopen("fileTest.txt"); TAP_Print("re-opened file is %d bytes\r\n", TAP_Hdd_Flen(tf)); TAP_Hdd_Fclose(tf); printf("Ending file tester...\r\n"); return 0; }
bool ReadConfigurationFile( void ) { TYPE_File *readFile = NULL; int i = 0; dword fileLength = 0; bool schSaveIniFile = FALSE; GotoPath( SETTINGS_FOLDER ); if ( ! TAP_Hdd_Exist( OPTIONS_FILENAME ) ) { GotoTapDir(); TAP_Hdd_ChangeDir( PROJECT_DIRECTORY ); if ( ! TAP_Hdd_Exist( OPTIONS_FILENAME ) ) return FALSE; schSaveIniFile = TRUE; } readFile = TAP_Hdd_Fopen( OPTIONS_FILENAME ); if ( readFile == NULL ) return FALSE; // and we can open it ok dataBuffer_ini = TAP_MemAlloc( DATA_BUFFER_SIZE_ini ); // Read the data in one hit (quicker), then process from RAM memset( dataBuffer_ini, '\0', DATA_BUFFER_SIZE_ini ); // set the whole buffer to the string termination character (null) dataBufferPtr_ini = 0; fileLength = TAP_Hdd_Flen( readFile ); // how big is the file if ( fileLength > DATA_BUFFER_SIZE_ini ) fileLength = DATA_BUFFER_SIZE_ini; // ensure we don't overflow the buffer TAP_Hdd_Fread( dataBuffer_ini, fileLength, 1, readFile ); // grab all the data from the file TAP_Hdd_Fclose( readFile ); if(SetConfigurationVariables() == FALSE) { TAP_MemFree( dataBuffer_ini ); // must return the memory back to the heap SaveConfigurationToFile(); } else { TAP_MemFree( dataBuffer_ini ); // must return the memory back to the heap } if(schSaveIniFile == TRUE) { SaveConfigurationToFile(); GotoTapDir(); TAP_Hdd_ChangeDir( PROJECT_DIRECTORY ); if ( TAP_Hdd_Exist( OPTIONS_FILENAME ) ) TAP_Hdd_Delete( OPTIONS_FILENAME ); } return TRUE; }
// // Open the logfile. // void openLogfile() { logByteCount = 0; // ChangeDirRoot(); // TAP_SystemProc(); // TAP_Hdd_ChangeDir("ProgramFiles"); logFD = TAP_Hdd_Fopen(LOGFILE_NAME); if (logFD == NULL) { // No logfile, so create one. TAP_Hdd_Create(LOGFILE_NAME, ATTR_NORMAL); logFD = TAP_Hdd_Fopen(LOGFILE_NAME); } if (logFD != NULL) { // Go to the end of the file. TAP_Hdd_Fseek(logFD, 0, 2); } }
TYPE_File *HDD_FappendOpen (char *filename) { TYPE_File *file; char buffer[512]; dword pos, blks, i; char *end; InitTAPAPIFix(); if (!TAP_Hdd_Exist(filename)) TAP_Hdd_Create(filename, ATTR_NORMAL); if ((file = TAP_Hdd_Fopen(filename))) { if (TAP_Hdd_Fseek(file, 0, SEEK_SET) != 0) { TAP_Hdd_Fclose(file); file = NULL; } else { pos = 0; do { memset(buffer, 0, sizeof(buffer)); blks = TAP_Hdd_Fread(&buffer, sizeof(buffer), 1, file); for (i = 0, end = buffer; i < sizeof(buffer); i++) if (buffer[i] == '\0') { end = buffer + i; break; } if (i < sizeof(buffer)) break; else pos += sizeof(buffer); } while (blks == 1); pos += end - buffer; if (TAP_Hdd_Fseek(file, pos, SEEK_SET) != pos) { TAP_Hdd_Fclose(file); file = NULL; } } } return file; }
//---------------- // void WriteIniFile( TYPE_File *writeFile ) { GotoPath(SETTINGS_FOLDER); if ( TAP_Hdd_Exist( OPTIONS_FILENAME ) ) TAP_Hdd_Delete( OPTIONS_FILENAME ); // Just delete any old copies TAP_Hdd_Create( OPTIONS_FILENAME, ATTR_PROGRAM ); // Create the file writeFile = TAP_Hdd_Fopen( OPTIONS_FILENAME ); if ( writeFile == NULL ) return; // Check we can open it TAP_Hdd_Fwrite( dataBuffer_ini, DATA_BUFFER_SIZE_ini, 1, writeFile ); // dump the whole buffer in one hit TAP_Hdd_Fclose( writeFile ); }
void LogoManager_ProcessLILAdd(char *AddFileName) { TRACEENTER(); TYPE_File *f; int fs; char *Text, Line[80]; HDD_TAP_PushDir(); HDD_ChangeDir(LOGOROOT); INIOpenFile(LILNAME, NULL); f = TAP_Hdd_Fopen(AddFileName); if(f) { fs = TAP_Hdd_Flen(f); Text = TAP_MemAlloc(fs+1); if(Text) { TAP_Hdd_Fread(Text, 1, fs, f); Text[fs] = '\0'; while(*Text) { ExtractLine(Text, Line); if(Line[0] == '0' && Line[1] == 'x' && Line[18] == '=') { LowerCase(Line); Line[18] = '\0'; INISetString(&Line[2], &Line[19]); } } TAP_MemFree(Text); } TAP_Hdd_Fclose(f); } INISaveFile(LILNAME, INILOCATION_AtCurrentDir, NULL); INICloseFile(); HDD_TAP_PopDir(); TRACEEXIT(); }
// ------------------------------ SaveBitmap ------------------------------------ // bool SaveBitmap (char *strName, int width, int height, byte* pBuffer ) { TYPE_File *pFile; if( !pBuffer || !strName ) return FALSE; TAP_Hdd_Create( strName, ATTR_NORMAL ); pFile = TAP_Hdd_Fopen( strName ); if ( !pFile ) return FALSE; // Write Header BMP_WriteHeader( pFile, width, height ); // write bitmap data TAP_Hdd_Fwrite (pBuffer, width*3, height, pFile); HDD_TouchFile (pFile); TAP_Hdd_Fclose (pFile); return TRUE; }
void tmLogEvent(void) { char tmBuffer[TM_EVENT_BUFFER_SIZE]; TYPE_File* fp; memset (tmBuffer, 0, TM_EVENT_BUFFER_SIZE); TAP_SPrint( tmBuffer, "%02u:%02u:%02u %02u/%02u/%04u, %3u, %3u, %3u %02u:%02u:%02u %02u/%02u/%04u, %3u, %3u, %3u\r\n", hourLast, minLast, secLast, dayLast, monthLast, yearLast, signalLevelLast, signalQualityLast, timersLast, hour, min, sec, day, month, year, signalLevel, signalQuality, timers); if (fp = TAP_Hdd_Fopen (TM_FILENAME)) { TAP_Hdd_Fseek (fp, tmBufferOffset, 0); TAP_Hdd_Fwrite (tmBuffer, 1, strlen(tmBuffer), fp); TAP_Hdd_Fclose (fp); tmBufferOffset += strlen(tmBuffer); tmNumberOfEvents++; if (tmBufferOffset >= (TM_FILE_MAX_LENGTH - TM_EVENT_BUFFER_SIZE)) { ShowMessageWin("Log File Full","Exiting!"); TAP_Exit(); return; } } else { ShowMessageWin("Error! - Unable to open file","Exiting!"); TAP_Exit(); return; } }
bool ReadDatFile( void ) { TYPE_File *readFile; int i; dword fileLength; appendToLogfile("ReadDatFile: Started.", INFO); GotoPath( TAPIniDir ); if ( ! TAP_Hdd_Exist( PLAYDATA_FILENAME ) ) { appendToLogfile("ReadDatFile: no PLAYDATA file found.", ERR); return FALSE; // check the ini file exits in the current directory } readFile = TAP_Hdd_Fopen( PLAYDATA_FILENAME ); if ( readFile == NULL ) return FALSE; // and we can open it ok playDataBuffer_ini = TAP_MemAlloc( PLAYBACKDATA_BUFFER_SIZE_ini ); // Read the data in one hit (quicker), then process from RAM memset( playDataBuffer_ini, '\0', PLAYBACKDATA_BUFFER_SIZE_ini ); // set the whole buffer to the string termination character (null) playDataBufferPtr_ini = 0; fileLength = TAP_Hdd_Flen( readFile ); // how big is the file if ( fileLength > PLAYBACKDATA_BUFFER_SIZE_ini ) fileLength = PLAYBACKDATA_BUFFER_SIZE_ini; // ensure we don't overflow the buffer TAP_Hdd_Fread( playDataBuffer_ini, fileLength, 1, readFile ); // grab all the data from the file TAP_Hdd_Fclose( readFile ); SetDatVariables(); TAP_MemFree( playDataBuffer_ini ); // must return the memory back to the heap appendToLogfile("ReadDatFile: Finished.", INFO); return TRUE; }
//------------ // void ReadLogoFile() { TYPE_File *logoFile; TYPE_logoArray *logoPointer; dword dataSize; byte *junkBuffer; char channelName[CHANNEL_NAME_SIZE]; int i; //+++ // TAP_Hdd_ChangeDir("UK TAP Project"); GotoPath( TAPIniDir ); if ( ! TAP_Hdd_Exist( "logo.dat" ) ) return; // check our logo file exits in the current directory logoFile = TAP_Hdd_Fopen( "logo.dat" ); if ( logoFile == NULL ) return; // and we can open it ok junkBuffer = TAP_MemAlloc(LOGO_DATA_SIZE); // create a place to read in unwanted logos while ( TAP_Hdd_Ftell( logoFile ) < TAP_Hdd_Flen( logoFile ) ) // Keep reading logos until we reach the end of file { TAP_Hdd_Fread( channelName, CHANNEL_NAME_SIZE, 1, logoFile ); // read the channel name if ( findChannelPointer( channelName, &logoPointer ) ) // cross referece the array to find this entry { // if the channel exists -> TAP_Hdd_Fread( logoPointer->logo, LOGO_DATA_SIZE, 1, logoFile ); // read the logo bitmap logoPointer->processedFlag = TRUE; // mark this channel as having a logo in the cache } else { // else channel doesn't appear in service list -> TAP_Hdd_Fread( junkBuffer, LOGO_DATA_SIZE, 1, logoFile ); // must read the logo, otherwise read pointer will get stuck } } TAP_Hdd_Fclose( logoFile ); // TAP_Hdd_ChangeDir(".."); // return to original directory TAP_MemFree( junkBuffer ); }
void LogEntryGeneric(char *ProgramName, bool Console, char *Text) { TRACEENTER(); char *s; int l; TYPE_File *File; char TimeResult[40]; char CRLF[] = {'\r', '\n'}; byte Sec; byte *ISOText; #define FILENAME "TAPSystem.log" if(!ProgramName || !Text) { TRACEEXIT(); return; } HDD_TAP_PushDir(); if(!HDD_ChangeDir("/ProgramFiles/Settings")) { HDD_ChangeDir("/ProgramFiles"); if(!TAP_Hdd_Exist("Settings")) TAP_Hdd_Create("Settings", ATTR_FOLDER); HDD_ChangeDir("Settings"); } l = strlen(ProgramName) + strlen(Text) + 4; s = TAP_MemAlloc(l); if(s) { memset(s, 0, l); TAP_SPrint(s, "%s: %s", ProgramName, Text); StrToISOAlloc(s, &ISOText); if(ISOText) { TimeFormat(Now(&Sec), Sec, TIMESTAMP_YMDHMS, TimeResult); strcat(TimeResult, " "); if(!TAP_Hdd_Exist(FILENAME)) TAP_Hdd_Create(FILENAME, ATTR_NORMAL); if((File = TAP_Hdd_Fopen(FILENAME)) != NULL) { TAP_Hdd_Fseek(File, 0, SEEK_END); TAP_Hdd_Fwrite(TimeResult, strlen(TimeResult), 1, File); TAP_Hdd_Fwrite(ISOText, strlen(ISOText), 1, File); TAP_Hdd_Fwrite(CRLF, 2, 1, File); TAP_Hdd_Fclose(File); } if(Console) { TAP_PrintNet("%s%s\n", TimeResult, ISOText); } TAP_MemFree(ISOText); } TAP_MemFree(s); } HDD_TAP_PopDir(); TRACEEXIT(); }
/* returns a pointer to the open file. A null pointer value indicates an error The character string mode specifies the type of access requested for the file, as follows: "r" Opens for reading. If the file does not exist or cannot be found, the fopen call fails. "w" Opens an empty file for writing. If the given file exists, its contents are destroyed. */ UFILE* fopen(char* name, char* mode) { #ifdef _WIN32 int fd; #else TYPE_File *fd; #endif UFILE *fp; //printf("Opening file %s for %c\n", name, *mode); //dumpBuffer(); if (*mode != 'r' && *mode != 'w' && *mode != 'a') { return NULL; } for (fp = _iob; fp < _iob + OPEN_MAX; fp++) if ((fp->flag & (_READ | _WRITE)) == 0) break; /* found free slot */ if (fp >= _iob + OPEN_MAX) { /* no free slots */ return NULL; } #ifdef _WIN32 if (*mode == 'w') fd = creat(name, 0666); else if (*mode == 'a') { if ((fd = open(name, O_WRONLY, 0)) == -1) fd = creat(name, 0666); lseek(fd, 0L, 2L); } else fd = open(name, O_RDONLY, 0); if (fd == -1) { return NULL; } #else if (*mode == 'w') TAP_Hdd_Create(name, ATTR_NORMAL); //TAP_Hdd_Delete(name); else if (*mode == 'a') if (!TAP_Hdd_Exist(name)) TAP_Hdd_Create(name, ATTR_NORMAL); fd = TAP_Hdd_Fopen( name ); if (fd == 0) { /* couldn't access name */ return NULL; } if (*mode == 'a') TAP_Hdd_Fseek(fd, 0L, 2L); #endif fp->fd = fd; fp->cnt = 0; fp->size = 0; fp->base = NULL; fp->flag = (*mode == 'r') ? _READ : _WRITE; #ifdef _TAP fp->size = TAP_Hdd_Flen(fd); //TAP_Print("file size: %d\r\n", fp->size); //fp->flag |= _UNBUF; // #endif //dumpBuffer(); return fp; }
void LogoManager_LogoCacheRebuild(void) { TRACEENTER(); char ID[4]; dword Version; TYPE_File *f, *fLogo; int i, j, k, NrFiles; TYPE_FolderEntry FolderEntry; dword LogoIndex; byte *PixelData, *TempBuffer; dword BufferSize, CompressedSize; TYPE_GrData *grData; int LogosConverted; char LogoPath[FBLIB_DIR_SIZE]; if(LogoManager_CB) LogoManager_CB(2, -1); //Step 1: Kill the current cache HDD_TAP_PushDir(); HDD_ChangeDir(LOGOROOT); TAP_Hdd_Delete(LOGOCACHE); //Step 2: iterate through all directories and count the number of logos LogoManager_NrLogos = 0; for(i = LGST_3pgstyle; i < LGST_NRITEMS; i++) { for(j = LGAR_43; j < LGAR_NRITEMS; j++) { if(HDD_ChangeDir(LogoManager_GetDirectory(i, j, LogoPath))) { NrFiles = TAP_Hdd_FindFirst(&FolderEntry, "qtl|qsl|ibl"); for(k = 0; k < NrFiles; k++) { if(FolderEntry.attr == ATTR_NORMAL) { FixInvalidFileName(FolderEntry.name); LogoManager_NrLogos++; } TAP_Hdd_FindNext(&FolderEntry); } } } } if(LogoManager_CB) LogoManager_CB(3, LogoManager_NrLogos); //Step 3: build the basic cache file LogosConverted = 0; if(LogoManager_LogoData) TAP_MemFree(LogoManager_LogoData); LogoManager_LogoData = TAP_MemAlloc(LogoManager_NrLogos * sizeof(tLogoData)); if(LogoManager_LogoData) { memset(LogoManager_LogoData, 0, LogoManager_NrLogos * sizeof(tLogoData)); HDD_ChangeDir(LOGOROOT); if(!TAP_Hdd_Exist(LOGOCACHE)) TAP_Hdd_Create(LOGOCACHE, ATTR_NORMAL); f = TAP_Hdd_Fopen(LOGOCACHE); if(f) { strcpy(ID, LOGOCACHEID); Version = LOGOCACHEVERSION; TAP_Hdd_Fwrite(ID, 4, 1, f); TAP_Hdd_Fwrite(&Version, sizeof(dword), 1, f); TAP_Hdd_Fwrite(&LogoManager_NrLogos, sizeof(dword), 1, f); TAP_Hdd_Fwrite(LogoManager_LogoData, sizeof(tLogoData), LogoManager_NrLogos, f); //Step 4: iterate through all directories again, compress the data and save it to the cache LogoIndex = 0; for(i = LGST_3pgstyle; i < LGST_NRITEMS; i++) { for(j = LGAR_43; j < LGAR_NRITEMS; j++) { if(HDD_ChangeDir(LogoManager_GetDirectory(i, j, LogoPath))) { NrFiles = TAP_Hdd_FindFirst(&FolderEntry, "qtl|qsl|ibl"); for(k = 0; k < NrFiles; k++) { if(LogoManager_CB) LogoManager_CB(2, LogosConverted * 100 / LogoManager_NrLogos); if(FolderEntry.attr == ATTR_NORMAL) { LogoManager_LogoData[LogoIndex].ChannelID = 0; strncpy(LogoManager_LogoData[LogoIndex].LogoName, FolderEntry.name, MAXLOGONAME); LogoManager_LogoData[LogoIndex].LogoName[MAXLOGONAME] = '\0'; LogoManager_LogoData[LogoIndex].LogoName[strlen(LogoManager_LogoData[LogoIndex].LogoName) - 4] = '\0'; LogoManager_LogoData[LogoIndex].Style = i; if(StringEndsWith(FolderEntry.name, ".qtl")) LogoManager_LogoData[LogoIndex].Size = LGSZ_qtl; if(StringEndsWith(FolderEntry.name, ".qsl")) LogoManager_LogoData[LogoIndex].Size = LGSZ_qsl; if(StringEndsWith(FolderEntry.name, ".ibl")) LogoManager_LogoData[LogoIndex].Size = LGSZ_ibl; LogoManager_LogoData[LogoIndex].Aspect = j; LogoManager_LogoData[LogoIndex].grData = NULL; fLogo = TAP_Hdd_Fopen(FolderEntry.name); if(fLogo) { BufferSize = TAP_Hdd_Flen(fLogo) - 8; PixelData = TAP_MemAlloc(BufferSize + 8); TempBuffer = TAP_MemAlloc(sizeof(TYPE_GrData) + BufferSize); if(PixelData && TempBuffer) { TAP_Hdd_Fread(PixelData, BufferSize + 8, 1, fLogo); CompressedSize = CompressTFD(&PixelData[8], BufferSize, &TempBuffer[sizeof(TYPE_GrData)], 0x0001, 0xffff, NULL); TAP_Put16bit(&TempBuffer[sizeof(TYPE_GrData) + 0x0e], 0xffff); grData = (TYPE_GrData*)TempBuffer; grData->version = 1; grData->reserved = 0; grData->dataFormat = OSD_1555; grData->compessMethod = COMPRESS_Tfp; grData->data = NULL; grData->dataSize = BufferSize; grData->width = TAP_Get32bit(&PixelData[0]); grData->height = TAP_Get32bit(&PixelData[4]); LogoManager_LogoData[LogoIndex].CachePosition = TAP_Hdd_Ftell(f); LogoManager_LogoData[LogoIndex].grDataSize = sizeof(TYPE_GrData) + CompressedSize; TAP_Hdd_Fwrite(grData, LogoManager_LogoData[LogoIndex].grDataSize, 1, f); LogoIndex++; } if(PixelData) TAP_MemFree(PixelData); if(TempBuffer) TAP_MemFree(TempBuffer); TAP_Hdd_Fclose(fLogo); } else { if(LogoManager_CB) LogoManager_CB(-1, 2); } LogosConverted++; } TAP_Hdd_FindNext(&FolderEntry); } } } } //Step 5: if the LIL exists, read and update the ChannelID of all Logos //Step 6: rewrite the cache structure to update all pointers TAP_Hdd_Fseek(f, sizeof(ID) + sizeof(dword) + sizeof(dword), SEEK_SET); TAP_Hdd_Fwrite(LogoManager_LogoData, sizeof(tLogoData), LogoManager_NrLogos, f); TAP_Hdd_Fclose(f); } } HDD_TAP_PopDir(); if(LogoManager_CB) LogoManager_CB(4, 0); TRACEEXIT(); }
void tmInitialise(void) { char tmBuffer[TM_FILE_BLOCK_SIZE]; char hddBuffer[1]; byte i; TYPE_File* fp; memset (tmBuffer, 0, TM_FILE_BLOCK_SIZE); if (!TAP_Hdd_Exist (TM_FILENAME)) { TAP_Hdd_Create (TM_FILENAME, ATTR_NORMAL); if (fp = TAP_Hdd_Fopen (TM_FILENAME)) { for (i = 0; i < TM_FILE_MAX_LENGTH / TM_FILE_BLOCK_SIZE; i++) { TAP_Hdd_Fwrite (tmBuffer, 1, TM_FILE_BLOCK_SIZE, fp); } TAP_Hdd_Fseek (fp, 0, 0); TAP_Hdd_Fwrite (TM_INFO, 1, sizeof(TM_INFO), fp); tmBufferOffset = sizeof(TM_INFO) - 1; tmNumberOfEvents = 0; TAP_Hdd_Fclose (fp); } } else { if (fp = TAP_Hdd_Fopen (TM_FILENAME)) { tmBufferOffset = 0; tmExitFL = FALSE; while ( (tmExitFL == FALSE) && (tmBufferOffset < TM_FILE_MAX_LENGTH) ) { TAP_Hdd_Fseek (fp, tmBufferOffset, 0); TAP_Hdd_Fread (hddBuffer, 1, 1, fp); if(hddBuffer[0] != 0) { tmBufferOffset++; if(hddBuffer[0] == 0x0A) { tmNumberOfEvents++; } } else { tmExitFL = TRUE; } } tmNumberOfEvents -= 2; TAP_Hdd_Fclose (fp); if (tmBufferOffset >= (TM_FILE_MAX_LENGTH - TM_EVENT_BUFFER_SIZE)) { ShowMessageWin("Log File Full","Exiting!"); TAP_Exit(); return; } } } ShowMessageWin("Time Monitor Tap v1.0","Started"); }
int LogoManager_UpdateLIL(void) { TRACEENTER(); typedef struct { ulong64 ChannelID; char Name[MAXLOGONAME+1]; }tNewIDs; int nTvSvc, nRadioSvc; int i; TYPE_TapChInfo chInfo; char s[255], LogoName[MAX_SvcName + 1]; SYSTEM_TYPE SystemType; tFlashSatTable SatInfo; word SatPos; ulong64 ChannelID; tNewIDs *NewIDs; int NewIDCount; SystemType = GetSystemType(); HDD_TAP_PushDir(); HDD_ChangeDir(LOGOROOT); TAP_Channel_GetTotalNum(&nTvSvc, &nRadioSvc); NewIDs = TAP_MemAlloc((nTvSvc + nRadioSvc) * sizeof(tNewIDs)); NewIDCount = 0; INIOpenFile(LILNAME, NULL); for(i = 0; i < nTvSvc; i++) { TAP_Channel_GetInfo(SVC_TYPE_Tv, i, &chInfo); FlashSatTablesGetInfo(chInfo.satIdx, &SatInfo); switch(SystemType) { case ST_S: case ST_TMSS: { SatPos = SatInfo.SatPosition; break; } default: SatPos = 0; break; } ChannelID = LogoManager_CalculateChannelID(SatPos, chInfo.orgNetId, chInfo.tsId, chInfo.svcId); TAP_SPrint(s, "%16.16llx", ChannelID); if(!INIKeyExists(s)) { NewIDs[NewIDCount].ChannelID = ChannelID; strcpy(NewIDs[NewIDCount].Name, LogoManager_ChannelNameToLogoName(chInfo.chName, LogoName, sizeof(LogoName))); if(NewIDs[NewIDCount].Name[0]) NewIDCount++; } } for(i = 0; i < nRadioSvc; i++) { TAP_Channel_GetInfo(SVC_TYPE_Radio, i, &chInfo); FlashSatTablesGetInfo(chInfo.satIdx, &SatInfo); switch(SystemType) { case ST_S: case ST_TMSS: { SatPos = SatInfo.SatPosition; break; } default: SatPos = 0; break; } ChannelID = LogoManager_CalculateChannelID(SatPos, chInfo.orgNetId, chInfo.tsId, chInfo.svcId); TAP_SPrint(s, "%16.16llx", ChannelID); if(!INIKeyExists(s)) { NewIDs[NewIDCount].ChannelID = ChannelID; TAP_SPrint(NewIDs[NewIDCount].Name, "r_%s", LogoManager_ChannelNameToLogoName(chInfo.chName, LogoName, sizeof(LogoName))); if(NewIDs[NewIDCount].Name[0]) NewIDCount++; } } INICloseFile(); if(NewIDCount > 0) { TYPE_File *f; word year; byte month, day, weekDay; if(!TAP_Hdd_Exist(LILNAME)) TAP_Hdd_Create(LILNAME, ATTR_NORMAL); f = TAP_Hdd_Fopen(LILNAME); if(!f) { HDD_TAP_PopDir(); if(LogoManager_CB) LogoManager_CB(-1, 3); TRACEEXIT(); return -1; } TAP_Hdd_Fseek(f, 0, SEEK_END); TAP_ExtractMjd(Now(NULL) >> 16, &year, &month, &day, &weekDay); TAP_SPrint(s, "\n\n# Added %4.4d-%2.2d-%2.2d\n", year, month, day); TAP_Hdd_Fwrite(s, 1, strlen(s), f); for(i = 0; i < NewIDCount; i++) { TAP_SPrint(s, "%16.16llx=%s\n", NewIDs[i].ChannelID, NewIDs[i].Name); TAP_Hdd_Fwrite(s, 1, strlen(s), f); } TAP_Hdd_Fclose(f); if(LogoManager_CB) LogoManager_CB(5, NewIDCount); }
void AutoStartPage::PopulateList() { m_taps.clear(); // Get a list of TAPs in the current Auto Start TAP_Hdd_ChangeDir( autoStartPath ); TYPE_File file; int index = 0; for ( dword totalEntry = TAP_Hdd_FindFirst( &file ); totalEntry > 0; ) { if ( file.attr == ATTR_NORMAL ) { char* ext = strrchr(file.name, '.'); if ( ext ) { // ensure we're only looking at .tap files ++ext; bool enabled = stricmp( ext, "tap" ) == 0; if ( enabled || stricmp( ext, "nap" ) == 0 ) { // that we can open TYPE_File* f = TAP_Hdd_Fopen( file.name ); if ( f ) { // read the TAP header tTAPHeader header; memset( &header, 0, sizeof(header) ); TAP_Hdd_Fread( &header, sizeof(header), 1, f ); TAP_Hdd_Fclose( f ); // ensure that it's actually a TAP format file if ( strncmp( header.Signature, "TFAPMIPS", 8 ) == 0 ) { m_taps.push_back(AutoStartTAP()); AutoStartTAP& t = m_taps.back(); // store the filename with the extension .tap in the order array *ext = 't'; t.index = index; t.filename = file.name; t.enabled = enabled; t.id = header.TAPID; t.name = header.Name; // and generate the text that will be shown in the footer t.footer.format( "%s\n%s\n%s\n", header.Description, header.AuthorName, header.EtcStr ); ++index; } } } } } dword currentEntry = TAP_Hdd_FindNext( &file ); if ( totalEntry == currentEntry || currentEntry == 0 ) break; } // Remove the Loading message and redraw the window contents DiscardItems(); for (unsigned int i=0; i < m_taps.size(); ++i) AddItem(new TAPListItem(this, i)); AddItem(new FooterActionListItem(this, &Commit, "Press OK to save the new TAP order\nTAPs will be loaded in this order next time the unit wakes from standby", 0, "", "Save Changes")); AddItem(new FooterActionListItem(this, &Backup, "Press OK to backup the TAP order and enabled state as listed above", 0, "", "Backup")); AddItem(new FooterActionListItem(this, &Restore, "Press OK to restore the previous backup to the list above\nThis does not save changes to disk", 0, "", "Restore")); Draw(); }
TYPE_File *HDD_FappendOpen(char *FileName) { TRACEENTER(); TYPE_File *file; char buffer[512]; dword pos, blks, i; char *end; char TAPPath[FBLIB_DIR_SIZE], Name[FBLIB_DIR_SIZE]; if(!FileName || !*FileName) { TRACEEXIT(); return NULL; } ConvertPathType(FileName, TAPPath, PF_TAPPathOnly); ConvertPathType(FileName, Name, PF_FileNameOnly); HDD_TAP_PushDir(); if(*TAPPath) HDD_ChangeDir(TAPPath); if(!TAP_Hdd_Exist(Name)) TAP_Hdd_Create(Name, ATTR_NORMAL); if((file = TAP_Hdd_Fopen(Name))) { if(TAP_Hdd_Fseek(file, 0, SEEK_SET) != 0) { TAP_Hdd_Fclose(file); file = NULL; } else { pos = 0; do { memset(buffer, 0, sizeof(buffer)); blks = TAP_Hdd_Fread(&buffer, sizeof(buffer), 1, file); for(i = 0, end = buffer; i < sizeof(buffer); i++) if(buffer[i] == '\0') { end = buffer + i; break; } if(i < sizeof(buffer)) break; else pos += sizeof(buffer); } while(blks == 1); pos += end - buffer; if(TAP_Hdd_Fseek(file, pos, SEEK_SET) != pos) { TAP_Hdd_Fclose(file); file = NULL; } } } HDD_TAP_PopDir(); TRACEEXIT(); return file; }