void CServerRemoteAccess::SetValue(const char *variable, const char *value) { FileHandle_t f; struct cvar_s *var; if (!Q_stricmp(variable, "map")) { Cbuf_AddText("changelevel "); Cbuf_AddText((char*)value); Cbuf_AddText("\n"); Cbuf_Execute(); } else if (!Q_stricmp(variable, "mapcycle")) { f = FS_Open(mapcyclefile.string, "wt"); if (!f) { Con_Printf("Couldn't write to read-only file %s, using file _dev_mapcycle.txt instead.\n", mapcyclefile.string); Cvar_DirectSet(&mapcyclefile, "_temp_mapcycle.txt"); f = FS_Open(mapcyclefile.string, "wt"); } if (f) { FS_Write(value, Q_strlen(value) + 1, 1, f); FS_Close(f); } } else { var = Cvar_FindVar(variable); if (var) Cvar_DirectSet(var, value); } }
/* =============== Host_WriteConfig Writes key bindings and archived cvars to config.cfg =============== */ void Host_WriteConfig( void ) { kbutton_t *mlook, *jlook; file_t *f; // if client not loaded, client cvars will lost if( !clgame.hInstance ) { MsgDev( D_NOTE, "Client not loaded, skipping config save!\n" ); return; } MsgDev( D_NOTE, "Host_WriteConfig()\n" ); f = FS_Open( "config.cfg", "w", true ); if( f ) { FS_Printf( f, "//=======================================================================\n"); FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY )); FS_Printf( f, "//\t\t\tconfig.cfg - archive of cvars\n" ); FS_Printf( f, "//=======================================================================\n" ); Cmd_WriteVariables( f ); FS_Printf( f, "exec keyboard.cfg\n" ); FS_Printf( f, "exec userconfig.cfg\n" ); FS_Close( f ); } else MsgDev( D_ERROR, "Couldn't write config.cfg.\n" ); if( cls.initialized && ( cls.keybind_changed || !FS_FileExists( "keyboard.cfg", true ) ) ) { f = FS_Open( "keyboard.cfg", "w", true ); if( f ) { FS_Printf( f, "//=======================================================================\n"); FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY )); FS_Printf( f, "//\t\t\tkeyboard.cfg - archive of keybindings\n" ); FS_Printf( f, "//=======================================================================\n" ); Key_WriteBindings( f ); mlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_mlook" ); jlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_jlook" ); if( mlook && ( mlook->state & 1 )) FS_Printf( f, "+mlook\n" ); if( jlook && ( jlook->state & 1 )) FS_Printf( f, "+jlook\n" ); FS_Close( f ); } else MsgDev( D_ERROR, "Couldn't write keyboard.cfg.\n" ); } else MsgDev( D_NOTE, "Keyboard configuration not changed\n" ); }
/***************************************************************************** * FUNCTION * vid_create_dummy_video_file * DESCRIPTION * * PARAMETERS * void * RETURNS * void *****************************************************************************/ void vid_create_dummy_video_file(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ FS_HANDLE fd = -1; kal_uint32 len; kal_int32 result; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ #ifdef __NVRAM_IN_USB_MS__ if (stack_query_boot_mode() == USBMS_BOOT) { return; } #endif /* __NVRAM_IN_USB_MS__ */ /* creat folder */ fd = FS_Open((kal_uint16*)VID_SYSTEM_FOLDER, FS_OPEN_DIR | FS_READ_ONLY); if (fd >= 0) { /* path already exist */ FS_Close(fd); } else { /* file not exist */ fd = FS_CreateDir((kal_uint16*)VID_SYSTEM_FOLDER); } if ((fd = FS_Open((kal_wchar*) VID_DUMMY_INIT_FILE, FS_READ_ONLY)) >= 0) { FS_Close(fd); return; } else if ((fd = FS_Open((kal_wchar*) VID_INIT_FILE, FS_READ_ONLY)) >= 0) { FS_Close(fd); /* FS_Rename((kal_wchar*)VID_INIT_FILE, (kal_wchar*)VID_DUMMY_INIT_FILE); */ return; } fd = FS_Open((kal_wchar*) VID_DUMMY_INIT_FILE, FS_CREATE | FS_READ_WRITE); if (fd >= 0) { result = FS_Write(fd, DUMMY_VIDEO_FILE_CONTENT, kal_wstrlen(DUMMY_VIDEO_FILE_CONTENT) * ENCODE_BYTE, &len); FS_Close(fd); } }
/***************************************************************************** * FUNCTION * applib_get_file_size * DESCRIPTION * This function is used to get the size of one file. * PARAMETERS * filename [IN] The filename * RETURNS * file size. *****************************************************************************/ kal_uint32 applib_get_file_size(kal_wchar *filename) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_int32 fileHandle; kal_uint32 fileSize = 0; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (filename == NULL) { return 0; } fileHandle = FS_Open(filename, APPLIB_ASYNC_FILE_READ | FS_NONBLOCK_MODE | FS_OPEN_SHARED); if (fileHandle < 0) { return 0; } FS_GetFileSize(fileHandle, &fileSize); FS_Close(fileHandle); return fileSize; }
kal_int32 SDS_ReadNvramFileInRecord_sim(const kal_uint16 *pFilename, kal_uint8* pBuf, kal_uint32 bufLen) { kal_int32 status; kal_uint32 readLen, fileLen; kal_int32 fd = FS_Open(pFilename, FS_OPEN_NO_DIR | FS_READ_ONLY); ASSERT(fd >= 0); status = FS_GetFileSize(fd, &fileLen); ASSERT(status >= 0); if(pBuf == NULL && bufLen == 0) { return fileLen; } if(bufLen < fileLen) { return SDS_BUF_TOO_SMALL; } status = FS_Read(fd, pBuf, fileLen, &readLen); ASSERT(status >= 0 && readLen == fileLen); FS_Close(fd); return readLen; }
/* ====================== SV_Map_f handle a map <mapname> command from the console or progs. ====================== */ void SV_Map_f (void) { char expanded[MAX_QPATH]; qfile_t *f; if (Cmd_Argc() != 2) { Com_Printf ("map <mapname> : continue game on a new map\n"); return; } // check to make sure the level exists Q_snprintf (expanded, sizeof(expanded), "maps/%s.bsp", Cmd_Argv(1)); f = FS_Open (expanded, "rb", false, true); if (!f) return; FS_Close (f); if (sv.mvdrecording) SV_MVDStop_f(); NET_ServerConfig (true); if (!dedicated) CL_BeginLocalConnection (); SV_BroadcastCommand ("changing\n"); SV_SendMessagesToAll (); SV_SpawnServer (Cmd_Argv(1), !Q_stricmp(Cmd_Argv(0), "devmap")); SV_BroadcastCommand ("reconnect\n"); }
static GPSAppDataBackupError_t GPSAppDataBackupWriteAttrFile(kal_bool bNewCreate) { FS_HANDLE file_handle; int result; kal_uint32 len; //create file file_handle = FS_Open((kal_uint16*)gGPSAppDataBackupAttrFileName, (bNewCreate == KAL_TRUE ? FS_CREATE : 0) | FS_READ_WRITE); if (file_handle < FS_NO_ERROR) { //fail to create return GPSAPP_DATABACKUP_ERROR_OPEN_FAIL; } //write result = FS_Write(file_handle, gGPSAppDataBackAttrCache, sizeof(gGPSAppDataBackAttrCache), &len); FS_Close(file_handle); if (result != FS_NO_ERROR || len != sizeof(gGPSAppDataBackAttrCache)) { return GPSAPP_DATABACKUP_ERROR_WRITE_FAIL; } else { return GPSAPP_DATABACKUP_ERROR_NONE; } }
/* =============== Host_WriteConfig Writes key bindings and archived cvars to config.cfg =============== */ void Host_WriteConfig( void ) { kbutton_t *mlook, *jlook; file_t *f; if( !clgame.hInstance ) return; MsgDev( D_NOTE, "Host_WriteConfig()\n" ); f = FS_Open( "config.cfg", "w", false ); if( f ) { FS_Printf( f, "//=======================================================================\n"); FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY )); FS_Printf( f, "//\t\t\tconfig.cfg - archive of cvars\n" ); FS_Printf( f, "//=======================================================================\n" ); Key_WriteBindings( f ); Cmd_WriteVariables( f ); mlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_mlook" ); jlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_jlook" ); if( mlook && ( mlook->state & 1 )) FS_Printf( f, "+mlook\n" ); if( jlook && ( jlook->state & 1 )) FS_Printf( f, "+jlook\n" ); FS_Printf( f, "exec userconfig.cfg" ); FS_Close( f ); } else MsgDev( D_ERROR, "Couldn't write config.cfg.\n" ); }
void Key_EnumCmds_f( void ) { file_t *f; FS_AllowDirectPaths( true ); if( FS_FileExists( "../help.txt", false )) { Msg( "help.txt already exist\n" ); FS_AllowDirectPaths( false ); return; } f = FS_Open( "../help.txt", "w", false ); if( f ) { FS_Printf( f, "//=======================================================================\n"); FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY )); FS_Printf( f, "//\t\thelp.txt - xash commands and console variables\n"); FS_Printf( f, "//=======================================================================\n"); FS_Printf( f, "\n\n\t\t\tconsole variables\n\n"); Cvar_LookupVars( 0, NULL, f, Cmd_WriteHelp ); FS_Printf( f, "\n\n\t\t\tconsole commands\n\n"); Cmd_LookupCmds( NULL, f, Cmd_WriteHelp ); FS_Printf( f, "\n\n"); FS_Close( f ); Msg( "help.txt created\n" ); } else MsgDev( D_ERROR, "Couldn't write help.txt.\n"); FS_AllowDirectPaths( false ); }
static kal_bool GPSLocateNvramStoreData(void) { FS_HANDLE file_handle; int result; unsigned int len; if (app_ucs2_strlen((const kal_int8*)gGPSLocateNvramFullPathFileName) == 0) { //empty file name return KAL_FALSE; } //open file file_handle = FS_Open(gGPSLocateNvramFullPathFileName, FS_READ_WRITE); if (file_handle < FS_NO_ERROR) { //fail to open return KAL_FALSE; } //write result = FS_Write(file_handle, &(gGPSLocateNvramDataCache.Cache), sizeof(GPSLocateNvramDataStruct_t), &len); FS_Close(file_handle); if (result != FS_NO_ERROR || len != sizeof(GPSLocateNvramDataStruct_t)) { return KAL_FALSE; } else { return KAL_TRUE; } }
PRIVATE INT32 _fsTraceFileOpen(CONST CHAR *name, UINT32 iFlag, UINT32 iMode) { INT32 result; INT32 fd = -1; UINT32 uni_len = 0; UINT8* uni_name = NULL; if((result = ML_LocalLanguage2UnicodeBigEnding(name, DSM_StrLen(name),&uni_name,&uni_len,NULL) )!= ERR_SUCCESS){ if(uni_name){ CSW_Free(uni_name); uni_name = NULL; } CSW_TRACE(BASE_BAL_TS_ID,"fstrace:%s:%u:ML_LocalLanguage2UnicodeBigEnding ret %d",__FUNCTION__, __LINE__,result); return -1; } fd = FS_Open(uni_name,iFlag,iMode); if(uni_name){ CSW_Free(uni_name); uni_name = NULL; } return fd; }
void R_CreateDetailTexturesList( const char *filename ) { file_t *detail_txt = NULL; const char *detail_name, *texname; int i; for( i = 0; i < cl.worldmodel->numtextures; i++ ) { texname = cl.worldmodel->textures[i]->name; detail_name = R_DetailTextureForName( texname ); if( !detail_name ) continue; // detailtexture detected if( detail_name ) { if( !detail_txt ) detail_txt = FS_Open( filename, "w", false ); if( !detail_txt ) { MsgDev( D_ERROR, "Can't write %s\n", filename ); break; } // store detailtexture description FS_Printf( detail_txt, "%s detail/%s 10.0 10.0\n", texname, detail_name ); } } if( detail_txt ) FS_Close( detail_txt ); }
static kal_bool GPSLocateNvramLoadData(void) { FS_HANDLE file_handle; int result; unsigned int len; GPSLocateNvramDataStruct_t tmpCache; if (app_ucs2_strlen((const kal_int8*)gGPSLocateNvramFullPathFileName) == 0) { //empty file name return KAL_FALSE; } //open file file_handle = FS_Open(gGPSLocateNvramFullPathFileName, FS_READ_ONLY); if (file_handle < FS_NO_ERROR) { //fail to open return KAL_FALSE; } //read result = FS_Read(file_handle, &tmpCache, sizeof(GPSLocateNvramDataStruct_t), &len); FS_Close(file_handle); if (result != FS_NO_ERROR || len != sizeof(GPSLocateNvramDataStruct_t)) { //read fail return KAL_FALSE; } //copy data to global cache memcpy(&(gGPSLocateNvramDataCache.Cache), &tmpCache, sizeof(GPSLocateNvramDataStruct_t)); gGPSLocateNvramDataCache.Valid = KAL_TRUE; return KAL_TRUE; }
void vm_log_init(char* filename, int log_level) { char wfilename[MAX_APP_NAME_LEN]; def_log_level = log_level; log_init = 0; strcpy(logModule, MRE_DEFAULT_LOG_MODULE); _modFile[0] = 0; _cache_file_ = NULL; _lineNo = 0; _logAllModule = TRUE; mmi_chset_convert( MMI_CHSET_ASCII, MMI_CHSET_UCS2, (VMCHAR *)filename, (VMCHAR *)wfilename, MAX_APP_NAME_LEN); if ((log_file = FS_Open((WCHAR *)wfilename,FS_CREATE_ALWAYS)) < 0) { return; } log_init = 1; }
/***************************************************************************** * FUNCTION * PmgCheckImyMidFileSize * DESCRIPTION * * PARAMETERS * path [?] * RETURNS * *****************************************************************************/ PMG_ADDFILE_ERRNO PmgCheckImyMidFileSize(S8 *path) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S8 *file_ext_p; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ file_ext_p = PmgGetFileExt(path); if (mmi_ucs2ncmp(file_ext_p, (S8*) L"mid", 3) == 0 || mmi_ucs2ncmp(file_ext_p, (S8*) L"MID", 3) == 0 || mmi_ucs2ncmp(file_ext_p, (S8*) L"imy", 3) == 0 || mmi_ucs2ncmp(file_ext_p, (S8*) L"IMY", 3) == 0) { FS_HANDLE h; kal_uint32 file_size = 0; /* U32 file_size=0; */ h = FS_Open((U16*) path, FS_READ_ONLY); if (h) { FS_GetFileSize(h, &file_size); FS_Close(h); } else { return PMG_ADDFILE_ERR_UNKNOWN; } if (file_size > mdi_audio_get_midi_size_limit() ) { return PMG_ADDFILE_ERR_FILE_TOO_LARGE; } } return PMG_ADDFILE_ERR_SUCCESS; }
/***************************************************************************** * FUNCTION * PmgQueryFileExistBySlot * DESCRIPTION * * PARAMETERS * slot [IN] * RETURNS * *****************************************************************************/ BOOL PmgQueryFileExistBySlot(U8 slot) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ S8 buf[MAX_EXT_MELODY_FULLNAME_WIDTH]; FS_HANDLE h; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (slot > MAXIMUM_EXT_MELODY_NUM) { return MMI_FALSE; } PmgConstructPathFileName( buf, sizeof(buf), (S8*) gPmgExtMelodyInfo.info[slot].filepath, (S8*) gPmgExtMelodyInfo.info[slot].filename); h = FS_Open((WCHAR*)buf, FS_READ_ONLY); if (h > 0) { FS_Close(h); return MMI_TRUE; } else { return MMI_FALSE; } }
void nandread() { if(*((u32*)0x02ffe230) != 0x4b344445 && *((u32*)0x02ffe230) != 0x484e4145)return; void (*FS_InitCtx)(u8*); int (*FS_Open)(u8*, char*, u32); int (*FS_Close)(u8*); int (*FS_Read)(u8*, u8*, u32); u8 ctx[0x48]; if(*((u32*)0x02ffe230) == 0x4b344445) { FS_InitCtx = (void*)0x20a1c6c; FS_Open = (void*)0x20a1ea4; FS_Close = (void*)0x20a1f28; } else if(*((u32*)0x02ffe230) == 0x484e4145)//launcher. note that this launcher stuff is for on-the-fly patching stuff, no nand-based only hax. { FS_InitCtx = (void*)0x26baf99; FS_Open = (void*)0x26bb4c5; FS_Close = (void*)0x26bb511; FS_Read = (void*)0x26bb581; } if(*((u32*)0x02ffe230) == 0x4b344445) { nandread_asm(); DC_FlushAll(); REG_IME = 1; FS_InitCtx(ctx); if(FS_Open(ctx, "nand:/<tmpjump>", 1)==1)FS_Close(ctx); REG_IME = 0; } else if(*((u32*)0x02ffe230) == 0x484e4145) { REG_IME = 1; FS_InitCtx(ctx); if(FS_Open(ctx, "nand:/sys/arm7hax.bin", 1)==1) { FS_Read(ctx, (void*)0x3780260, 0x40);//this is the beginning of the nand_read_sectors func. since this data won't get written there until after that func returns, another read is triggered below. FS_Close(ctx); FS_InitCtx(ctx); if(FS_Open(ctx, "nand:/<tmpjump>", 1)==1)FS_Close(ctx);//unless the arm7hax code returns,(my local code doesn't) this will hang. } REG_IME = 0; } }
qboolean HPAK_ResourceForIndex( const char *filename, int index, resource_t *pRes ) { file_t *f; hpak_header_t hdr; hpak_container_t hpakcontainer; string pakname; if( !filename || !filename[0] ) return false; Q_strncpy( pakname, filename, sizeof( pakname )); FS_StripExtension( pakname ); FS_DefaultExtension( pakname, ".hpk" ); f = FS_Open( pakname, "rb", false ); FS_Read( f, &hdr, sizeof( hdr )); if( hdr.ident != IDCUSTOMHEADER ) { MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s it's not a HPK file.\n", pakname ); FS_Close( f ); return false; } if( hdr.version != IDCUSTOM_VERSION ) { MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s has invalid version (%i should be %i).\n", pakname, hdr.version, IDCUSTOM_VERSION ); FS_Close( f ); return false; } FS_Seek( f, hdr.seek, SEEK_SET ); FS_Read( f, &hpakcontainer.count, sizeof( hpakcontainer.count )); if( hpakcontainer.count < 1 || hpakcontainer.count > MAX_FILES_IN_WAD ) { MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s has too many lumps %u.\n", pakname, hpakcontainer.count ); FS_Close( f ); return false; } if( index < 1 || index > hpakcontainer.count ) { MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s, lump with index %i doesn't exist.\n", pakname, index ); FS_Close( f ); return false; } hpakcontainer.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpakcontainer.count ); // we could just seek the right data... FS_Read( f, hpakcontainer.dirs, sizeof( hpak_dir_t ) * hpakcontainer.count ); *pRes = hpakcontainer.dirs[index-1].DirectoryResource; Mem_Free( hpakcontainer.dirs ); FS_Close( f ); return true; }
/* <2aac9> ../engine/hashpak.c:772 */ qboolean HPAK_ResourceForIndex(char *pakname, int nIndex, struct resource_s *pResource) { hash_pack_header_t header; hash_pack_directory_t directory; hash_pack_entry_t *entry; char name[MAX_PATH]; FileHandle_t fp; if (cmd_source != src_command) return FALSE; Q_snprintf(name, ARRAYSIZE(name), "%s", pakname); #ifdef REHLDS_FIXES name[ARRAYSIZE(name) - 1] = 0; #endif // REHLDS_FIXES COM_DefaultExtension(name, HASHPAK_EXTENSION); fp = FS_Open(name, "rb"); if (!fp) { Con_Printf("ERROR: couldn't open %s.\n", name); return FALSE; } FS_Read(&header, sizeof(hash_pack_header_t), 1, fp); if (Q_strncmp(header.szFileStamp, "HPAK", sizeof(header.szFileStamp))) { Con_Printf("%s is not an HPAK file\n", name); FS_Close(fp); return FALSE; } if (header.version != HASHPAK_VERSION) { Con_Printf("HPAK_List: version mismatch\n"); FS_Close(fp); return FALSE; } FS_Seek(fp, header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD); FS_Read(&directory.nEntries, 4, 1, fp); if (directory.nEntries < 1 || (unsigned int)directory.nEntries > MAX_FILE_ENTRIES) { Con_Printf("ERROR: HPAK had bogus # of directory entries: %i\n", directory.nEntries); FS_Close(fp); return FALSE; } if (nIndex < 1 || nIndex > directory.nEntries) { Con_Printf("ERROR: HPAK bogus directory entry request: %i\n", nIndex); FS_Close(fp); return FALSE; } directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries); FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp); entry = &directory.p_rgEntries[nIndex - 1]; Q_memcpy(pResource, &entry->resource, sizeof(resource_t)); FS_Close(fp); Mem_Free(directory.p_rgEntries); return TRUE; }
void VERIFY_DATA_TO_DSP_START( void ) { if( fs_handle ) FS_Close( fs_handle ); fs_handle = FS_Open( (const kal_wchar*)fname, FS_CREATE_ALWAYS ); ASSERT( fs_handle > 0 ); uDSPBufferSize = 8192; uDSPBufferRead = 0; uDSPBufferWrite = 0; }
/***************************************************************************** * FUNCTION * jma_audio_recorder_timer_expired * DESCRIPTION * This function handles if audio recorder timer is expired * PARAMETERS * mma_type [IN] * java_recorder [IN] * int reocrder(?) * RETURNS * void *****************************************************************************/ void jma_audio_recorder_timer_expired(kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 record_size = 0; kal_int32 ticks = kal_milli_secs_to_ticks(200); /* 200 ms */ FS_HANDLE file_handle; kal_int32 result; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_TIMER_EXPIRED, vm_id, audio_recorder[vm_id].id, audio_recorder[vm_id].state); JMA_CS_ENTER(vm_id, JMA_VOID); if (audio_recorder[vm_id].state != JAVA_MEDIA_STATE_RECORDING) { JMA_CS_LEAVE(JMA_VOID); } EXT_ASSERT(audio_recorder[vm_id].state == JAVA_MEDIA_STATE_RECORDING, 0, 0, 0); /* Get file size */ file_handle = FS_Open(audio_recorder[vm_id].filename, FS_READ_ONLY | FS_OPEN_SHARED); if (file_handle <= 0) { kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL); kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, file_handle); JMA_CS_LEAVE(JMA_VOID); } result = FS_GetFileSize(file_handle, &record_size); result = FS_Close(file_handle); if(1 == result) { kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, record_size+1); } kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, record_size); /* Reach record size limit */ if (record_size >= audio_recorder[vm_id].record_size_limit) { /* State will be changed */ jma_mvm_audio_recorder_commit(vm_id, audio_recorder[vm_id].id); jvm_post_mma_event(MMA_EVENT_RECORD_STOPPED, audio_recorder[vm_id].id, audio_recorder[vm_id].current_time); } else /* re-start timer */ { kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_STACK_START_TIMER); stack_start_timer(&java_media_timer, JAVA_MEDIA_TIMER_AUDIO_RECORDER + vm_id, ticks); } JMA_CS_LEAVE(JMA_VOID); }
/***************************************************************************** * FUNCTION * applib_async_file_task_start * DESCRIPTION * * PARAMETERS * op [?] * mod_id [IN] * filename [?] * access_mode [IN] * es [?] * callback [IN] * return_arg [?] * RETURNS * *****************************************************************************/ kal_bool applib_async_file_task_start( applib_async_file_task_struct *op, module_type mod_id, kal_wchar *filename, applib_async_file_mode_enum access_mode, event_scheduler *es, applib_aysnc_file_task_callback_fn callback, void *return_arg) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ int fileHandle; int openMode; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (op == NULL || filename == NULL) { return KAL_FALSE; } kal_mem_set(op, 0, sizeof(applib_async_file_task_struct)); switch (access_mode) { case APPLIB_ASYNC_FILE_MODE_READ: openMode = APPLIB_ASYNC_FILE_READ | FS_NONBLOCK_MODE | FS_OPEN_SHARED; break; case APPLIB_ASYNC_FILE_MODE_READ_WRITE: case APPLIB_ASYNC_FILE_MODE_WRITE: openMode = APPLIB_ASYNC_FILE_WRITE | APPLIB_ASYNC_FILE_CREATE | FS_NONBLOCK_MODE; break; default: openMode = APPLIB_ASYNC_FILE_WRITE | APPLIB_ASYNC_FILE_CREATE | FS_NONBLOCK_MODE; break; } fileHandle = FS_Open(filename, openMode); if (fileHandle < 0) { return KAL_FALSE; } op->mod_id = mod_id; op->isFSopen = KAL_TRUE; op->fileHandle = fileHandle; op->es = es; op->callback = callback; op->arg_in_callback = return_arg; return KAL_TRUE; }
/* <2ae8e> ../engine/hashpak.c:1599 */ NOXREF char *HPAK_GetItem(int item) { NOXREFCHECK; int nCurrent; hash_pack_header_t header; hash_pack_directory_t directory; hash_pack_entry_t *entry; static char name[MAX_PATH]; char szFileName[MAX_PATH]; FileHandle_t fp; HPAK_FlushHostQueue(); Q_snprintf(name, ARRAYSIZE(name), "%s", "custom"); COM_DefaultExtension(name, HASHPAK_EXTENSION); fp = FS_Open(name, "rb"); if (!fp) return ""; FS_Read(&header, sizeof(hash_pack_header_t), 1, fp); if (Q_strncmp(header.szFileStamp, "HPAK", sizeof(header.szFileStamp))) { Con_Printf("%s is not an HPAK file\n", name); FS_Close(fp); return ""; } if (header.version != HASHPAK_VERSION) { Con_Printf("HPAK_List: version mismatch\n"); FS_Close(fp); return ""; } FS_Seek(fp, header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD); FS_Read(&directory.nEntries, 4, 1, fp); if (directory.nEntries < 1 || (unsigned int)directory.nEntries > MAX_FILE_ENTRIES) { Con_Printf("ERROR: HPAK had bogus # of directory entries: %i\n", directory.nEntries); FS_Close(fp); return ""; } directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries); FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp); nCurrent = directory.nEntries - 1; if (nCurrent > item) nCurrent = item; entry = &directory.p_rgEntries[nCurrent]; COM_FileBase(entry->resource.szFileName, szFileName); Q_snprintf(name, sizeof(name), "!MD5%s", MD5_Print(entry->resource.rgucMD5_hash)); FS_Close(fp); Mem_Free(directory.p_rgEntries); return name; }
/***************************************************************************** * FUNCTION * xml_generate_inline_element * DESCRIPTION * This function is for application to generate a whole element without child element * and attribute, only content. just as following: <a> test </a>. * PARAMETERS * hd [IN] handle of generator * el [IN] element name * data [IN] Filename or buffer with data. * datalen [IN] if with buffer, datalen is the length of buffer, * if with file, datalen should be 0 * RETURNS * <0: means failed, returns error code; * 0 : means succeed; *****************************************************************************/ kal_int32 xml_generate_inline_element(XG_HANDLE hd, const kal_char* el, kal_char* data, kal_uint32 datalen) { kal_int32 ret; kal_uint32 len_read, len; FS_HANDLE fhandle = -1; kal_char tempbuf[TEMP_BUF_LEN]; if ((ret = xml_generate_stag(hd, el, NULL, 0)) < 0) { return ret; } if (datalen == 0) { fhandle = FS_Open((WCHAR*)data, FS_READ_ONLY); if (fhandle < 0) { return XG_E_FAIL; } ret = FS_GetFileSize(fhandle, &len); if (ret < 0) { FS_Close(fhandle); return XG_E_FAIL; } while ((ret = FS_Read(fhandle, tempbuf, TEMP_BUF_LEN-1, &len_read)) >= FS_NO_ERROR) { if (len_read == 0) { break; } if ((ret=xml_generate_converted_data(hd, tempbuf, len_read)) < 0) { return ret; } } FS_Close(fhandle); } else { if ((ret = xml_generate_converted_data(hd, data, datalen)) < 0) { return ret; } } /* if ((ret = xml_generate_data(hd, data, datalen)) < 0) { return ret; } */ return xml_generate_etag(hd, el); }
void VERIFY_DATA_TO_DSP_RESUME( void ) { kal_uint32 uFileSize; kal_int32 ret; fs_handle = FS_Open( (const kal_wchar*)fname, FS_READ_WRITE|FS_CREATE ); ASSERT( fs_handle > 0 ); if(FS_GetFileSize(fs_handle, &uFileSize) < 0) ASSERT(0); if(FS_Seek(fs_handle, uFileSize, FS_FILE_BEGIN) < 0) ASSERT(0); uDSPBufferSize = 8192; }
void SCR_CreateStartupVids( void ) { file_t *f; f = FS_Open( "media/StartupVids.txt", "w", false ); if( !f ) return; // make standard video playlist: sierra, valve FS_Print( f, "media/sierra.avi\n" ); FS_Print( f, "media/valve.avi\n" ); FS_Close( f ); }
/****************************************************************************** * Function: * GPSAppDataBackupStore * * Usage: * Store data to backup files. * * Parameters: * pBuff - pointer to caller's data buffer, which contains data to be stored. * Length - data length (in byte) * * Return: * Error code ******************************************************************************/ GPSAppDataBackupError_t GPSAppDataBackupStore( const kal_uint8* pBuff, kal_uint16 Length ) { kal_uint16 FileName[GPSAPP_DATABACKUP_FULLPATHNAME_LEN_MAX]; GPSAppDataBackupError_t ErrCode = GPSAPP_DATABACKUP_ERROR_NONE; FS_HANDLE file_handle; int result; kal_uint32 len; kal_int32 FileID; if (pBuff == NULL || Length == 0) { return GPSAPP_DATABACKUP_ERROR_INVALID_PARAM; } //take the semaphore kal_take_sem(gGPSAppDataBackupSem, KAL_INFINITE_WAIT); //apply file name if ((FileID = GPSAppDataBackupApplyCell(FileName, CELLATTR_FREE)) < 0) { ErrCode = GPSAPP_DATABACKUP_ERROR_STORAGE_FULL; goto _RelSem_Return_; } //create file file_handle = FS_Open(FileName, FS_CREATE | FS_READ_WRITE); if (file_handle < FS_NO_ERROR) { //fail to open ErrCode = GPSAPP_DATABACKUP_ERROR_OPEN_FAIL; #if _GPSAPP_DATABACKUP_DBG_ trace_printf("GPSAppDataBackupStore: Open fail (%d)", file_handle); #endif //_GPSAPP_DATABACKUP_DBG_ goto _RelSem_Return_; } //write result = FS_Write(file_handle, (void*)pBuff, Length, &len); FS_Close(file_handle); if (result != FS_NO_ERROR || len != Length) { ErrCode = GPSAPP_DATABACKUP_ERROR_WRITE_FAIL; goto _RelSem_Return_; } //update attr GPSAppDataBackupUpdateAttrCache(FileID, ATTRUPDATE_ADD); ErrCode = GPSAppDataBackupWriteAttrFile(KAL_FALSE); _RelSem_Return_: //release semaphore kal_give_sem(gGPSAppDataBackupSem); return ErrCode; }
/* ===================== CL_WriteErrorMessage write net_message into buffer.dat for debugging ===================== */ void CL_WriteErrorMessage( int current_count, sizebuf_t *msg ) { file_t *fp; const char *buffer_file = "buffer.dat"; fp = FS_Open( buffer_file, "wb", false ); if( !fp ) return; FS_Write( fp, &starting_count, sizeof( int )); FS_Write( fp, ¤t_count, sizeof( int )); FS_Write( fp, BF_GetData( msg ), BF_GetMaxBytes( msg )); FS_Close( fp ); MsgDev( D_INFO, "Wrote erroneous message to %s\n", buffer_file ); }
SFFS_HANDLE SFFS_Open(UString path,SFUint flags) { #ifdef WIN32 g_kernal.fpFile=_wfopen(path,(flags&SFFSF_READ)?L"rb":L"wb"); if(!g_kernal.fpFile) return 0; return 1; #else //暂时关闭存档功能 g_kernal.hFile=FS_Open(path,(flags&SFFSF_READ)?FS_READ_ONLY:(FS_READ_WRITE|FS_CREATE)); if(g_kernal.hFile<0)//??? return 0; return 1; #endif }
static void handle_buffer_content(msf_sas_handle_t* handle, msf_sas_op_t *op) { int file_handle; int size_remain; int bytes_written; int size; if(!op->data) { msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_SAVE_AS_FAIL)); op->state = MSF_SAS_STATE_MESSAGE_WAIT; return; } FS_Delete((WCHAR *)op->file_name); file_handle = FS_Open((WCHAR *)op->file_name, FS_READ_WRITE | FS_CREATE | FS_OPEN_SHARED); if (file_handle <= 0) { msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_SAVE_AS_FAIL)); op->state = MSF_SAS_STATE_MESSAGE_WAIT; return; } size_remain = op->data_len; bytes_written = 0; while (size_remain > 0) { if (FS_Write(file_handle, (void *)(op->data), size_remain, (UINT*) & size) != FS_NO_ERROR) { msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_SAVE_AS_FAIL)); op->state = MSF_SAS_STATE_MESSAGE_WAIT; return; } if (size <= 0) { break; } } op->status = MSF_SAS_RETURN_OK; op->state = MSF_SAS_STATE_FINISHED; return; }