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 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 ); } }
/* fclose returns 0 if the stream is successfully closed. return EOF to indicate an error. */ int fclose(UFILE *f) { #ifdef _WIN32 int fd; #else TYPE_File *fd; #endif if (f == NULL) return -1; fd = f->fd; fflush(f); f->cnt = 0; f->ptr = NULL; if (f->base != NULL) free(f->base); f->base = NULL; f->flag = 0; #ifdef _WIN32 f->fd = -1; return close(fd); #else //printf("file size: %d\n", (int)f->size); f->fd->size = f->size; TAP_Hdd_Fclose(fd); f->fd = NULL; return 0; #endif }
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; }
void closeLogfile(void) { if (logFD != NULL) { char buff[512]; int rem; memset(buff, 0, sizeof buff); // Space pad the end of the last 512 byte block as the Toppy writes in 512 bytes blocks TAP_Hdd_Fseek(logFD, logByteCount, SEEK_SET); strcpy(buff, "********** End Of File **********\r\n"); TAP_Hdd_Fwrite((void*)buff, strlen(buff), 1, logFD); /* rem = logByteCount % 512; if (rem > 0) { memset(buff, 0, rem+1); TAP_Hdd_Fwrite(buff, rem, 1, logFD); } */ //TAP_Hdd_Fwrite((void*)"\r\n", strlen("\r\n"), 1, logFD); //logByteCount += 2; // goto the start of the file and write length marker //TAP_Hdd_Fseek(logFD, 0, SEEK_SET); //TAP_Hdd_Fwrite(&_logSig, sizeof _logSig, 1, logFD); //TAP_Hdd_Fseek(logFD, _logSig.logSize, SEEK_SET); //TAP_Hdd_Fwrite((void *)"************** end of file *************\n", 41, 1, logFD); TAP_Hdd_Fclose(logFD); logFD = NULL; } }
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; }
//---------------- // 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 ); }
// // Close the logfile. // void closeLogfile() { if (logFD != NULL) { // Make the end of the logfile stop on a 512 byte boundary. appendToLogfile("********** End of logfile **********", INFO); while ((logByteCount % 512) != 510) { TAP_Hdd_Fwrite(" ", 1, 1, logFD); logByteCount++; } TAP_Hdd_Fwrite((void*)"\r\n", strlen("\r\n"), 1, logFD); logByteCount += 2; TAP_Hdd_Fclose(logFD); logFD = NULL; } }
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 StringDBLoadFromFile(tStringDB *StringDB, TYPE_File *f) { TRACEENTER(); dword l, p; if(!StringDB || !f) { TRACEEXIT(); return FALSE; } TAP_MemFree(StringDB->DB); //DB Size TAP_Hdd_Fread(&l, sizeof(dword), 1, f); StringDB->DB = TAP_MemAlloc(l); if(!StringDB->DB) { StringDB->DBSize = 0; TAP_Hdd_Fclose(f); TRACEEXIT(); return FALSE; } StringDB->DBSize = l; StringDB->DBEnd = l + StringDB->DB - 1; //Current pointer TAP_Hdd_Fread(&p, sizeof(dword), 1, f); StringDB->DBPtr = p + StringDB->DB; TAP_Hdd_Fread(StringDB->DB, 1, l, f); TRACEEXIT(); return TRUE; }
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(); }
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); }
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; }
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(); }