List* ReadDirectory(char* name, List* l){ DIR* rep = NULL; struct dirent* current; if ( (rep=opendir(name)) == NULL){ printf("Error\n"); return NULL; } while ((current = readdir(rep)) != NULL){ struct stat stats; if(strcmp(current->d_name, ".") && strcmp(current->d_name, "..")) { char* path = Path(name,current->d_name); stat(path, &stats); if(S_ISDIR(stats.st_mode)){ char temp[MAX_LENGTH] = ""; strncpy(temp,path,MAX_LENGTH); printf("%s \n", temp); l = ReadDirectory(temp,l); } else { if (test_file(current->d_name) == 0){ char temp[MAX_LENGTH] = ""; strncpy(temp,path,MAX_LENGTH); printf("%s\n", temp); l = add_file(l,current->d_name,temp); } } } } closedir(rep); return l; }
/* * ReadDirectory * Read directory tree into memory structure * returns first (dummy) node */ TreeNode *ReadDirectory(TreeNode *node, char *path) { //printf("%s\n", path); DIR *dir = opendir(path); if (!dir) { fprintf(stderr, "Cannot open directory '%s'.\n", path); exit(1); } struct dirent *de; while ((de = readdir(dir))) { if (!strcmp(de->d_name, ".")) continue; if (!strcmp(de->d_name, "..")) continue; char strbuf[MAXPATHLEN]; strcpy(strbuf, path); strcat(strbuf, "/"); strcat(strbuf, de->d_name); //printf("%s\n", strbuf); struct stat st; if (stat(strbuf, &st)) { fprintf(stderr, "Cannot get stat of '%s'.\n", strbuf); exit(1); } //if (S_ISDIR(st.st_mode) && !subdirs) continue; // skip subdirectories total_name_size += strlen(de->d_name); if (S_ISDIR(st.st_mode)) { node = node->New(de->d_name, true); node->dir_id = free_dir_id++; directory_count++; node->directory = ReadDirectory(new TreeNode(), strbuf); } else if (S_ISREG(st.st_mode)) { node = node->New(de->d_name, false); file_count++; } else { fprintf(stderr, "'%s' is not a file or directory!\n", strbuf); exit(1); } } closedir(dir); while (node->prev) node = node->prev; // return first return node; }
void PanelView::Reload(void) //////////////////////////////////////////////////////////////////////// { switch (m_PanelMode) { case PM_NORMAL: ClearFileList(); ReadDirectory(); break; case PM_DISKS: ClearFileList(); ReadDisks(); break; } }
void PanelView::Reload(const char *itemname) //////////////////////////////////////////////////////////////////////// { switch (m_PanelMode) { case PM_NORMAL: ClearFileList(); ReadDirectory(itemname); break; case PM_DISKS: ClearFileList(); ReadDisks(); break; } }
ISOFileSystem::ISOFileSystem(IHandleAllocator *_hAlloc, BlockDevice *_blockDevice, std::string _restrictPath) { if (!_restrictPath.empty()) { size_t pos = _restrictPath.find_first_not_of('/'); while (pos != _restrictPath.npos) { size_t endPos = _restrictPath.find_first_of('/', pos); if (endPos == _restrictPath.npos) endPos = _restrictPath.length(); if (pos != endPos) restrictTree.push_back(_restrictPath.substr(pos, endPos - pos)); pos = _restrictPath.find_first_not_of('/', endPos); } } blockDevice = _blockDevice; hAlloc = _hAlloc; VolDescriptor desc; blockDevice->ReadBlock(16, (u8*)&desc); entireISO.name = ""; entireISO.isDirectory = false; entireISO.startingPosition = 0; entireISO.size = _blockDevice->GetNumBlocks(); entireISO.flags = 0; entireISO.parent = NULL; treeroot = new TreeEntry(); treeroot->isDirectory = true; treeroot->startingPosition = 0; treeroot->size = 0; treeroot->flags = 0; treeroot->parent = NULL; if (memcmp(desc.cd001, "CD001", 5)) { ERROR_LOG(FILESYS, "ISO looks bogus? Giving up..."); return; } u32 rootSector = desc.root.firstDataSector(); u32 rootSize = desc.root.dataLength(); ReadDirectory(rootSector, rootSize, treeroot, 0); }
NS_IMETHODIMP nsJARInputStream::Read(char* aBuffer, PRUint32 aCount, PRUint32 *aBytesRead) { NS_ENSURE_ARG_POINTER(aBuffer); NS_ENSURE_ARG_POINTER(aBytesRead); *aBytesRead = 0; nsresult rv = NS_OK; if (mClosed) return rv; if (mDirectory) { rv = ReadDirectory(aBuffer, aCount, aBytesRead); } else { if (mInflate) { rv = ContinueInflate(aBuffer, aCount, aBytesRead); } else { PRInt32 bytesRead = 0; aCount = PR_MIN(aCount, mInSize - mCurPos); if (aCount) { bytesRead = PR_Read(mFd, aBuffer, aCount); if (bytesRead < 0) return NS_ERROR_FILE_CORRUPTED; mCurPos += bytesRead; if (bytesRead != aCount) { // file is truncated or was lying about size, we're done PR_Close(mFd); mFd = nsnull; return NS_ERROR_FILE_CORRUPTED; } } *aBytesRead = bytesRead; } // be aggressive about closing! // note that sometimes, we will close mFd before we've finished // deflating - this is because zlib buffers the input // So, don't free the ReadBuf/InflateStruct yet. if (mCurPos >= mInSize && mFd) { PR_Close(mFd); mFd = nsnull; } } return rv; }
void PanelView::GotoParent(void) //////////////////////////////////////////////////////////////////////// { // To set the cursor to the child entry where we came from... BString oldpath; SetPanelMode(PM_NORMAL); oldpath.SetTo(m_Path.String()); oldpath.Remove(0,oldpath.FindLast('/')+1); BPath path((const char *)m_Path.String()); if (path.GetParent(&path)==B_OK) m_Path.SetTo(path.Path()); SetPathStringView(); ClearFileList(); ReadDirectory(oldpath.String()); }
static void dump(int fd, uint32 diroff) { unsigned i; lseek(fd, (off_t) 0, 0); if (read(fd, (char*) &hdr, sizeof (hdr)) != sizeof (hdr)) ReadError("TIFF header"); /* * Setup the byte order handling. */ if (hdr.tiff_magic != TIFF_BIGENDIAN && hdr.tiff_magic != TIFF_LITTLEENDIAN) Fatal("Not a TIFF file, bad magic number %u (%#x)", hdr.tiff_magic, hdr.tiff_magic); InitByteOrder(hdr.tiff_magic); /* * Swap header if required. */ if (swabflag) { TIFFSwabShort(&hdr.tiff_version); TIFFSwabLong(&hdr.tiff_diroff); } /* * Now check version (if needed, it's been byte-swapped). * Note that this isn't actually a version number, it's a * magic number that doesn't change (stupid). */ if (hdr.tiff_version != TIFF_VERSION) Fatal("Not a TIFF file, bad version number %u (%#x)", hdr.tiff_version, hdr.tiff_version); printf("Magic: %#x <%s-endian> Version: %#x\n", hdr.tiff_magic, hdr.tiff_magic == TIFF_BIGENDIAN ? "big" : "little", hdr.tiff_version); if (diroff == 0) diroff = hdr.tiff_diroff; for (i = 0; diroff != 0; i++) { if (i > 0) putchar('\n'); diroff = ReadDirectory(fd, i, diroff); } }
void PanelView::Reload(int index) //////////////////////////////////////////////////////////////////////// { switch (m_PanelMode) { case PM_NORMAL: ClearFileList(); ReadDirectory(); if (index > (m_CustomListView->IndexOf(m_CustomListView->LastItem()))) index = m_CustomListView->IndexOf(m_CustomListView->LastItem()); m_CustomListView->Select(index,false); // false -> remove previously selected item(s)... break; case PM_DISKS: ClearFileList(); ReadDisks(); m_CustomListView->Select(index,false); // false -> remove previously selected item(s)... break; } }
ReturnCode ES::DeleteTicket(const u8* ticket_view) { const auto fs = m_ios.GetFS(); const u64 title_id = Common::swap64(ticket_view + offsetof(IOS::ES::TicketView, title_id)); if (!CanDeleteTitle(title_id)) return ES_EINVAL; auto ticket = FindSignedTicket(title_id); if (!ticket.IsValid()) return FS_ENOENT; const u64 ticket_id = Common::swap64(ticket_view + offsetof(IOS::ES::TicketView, ticket_id)); ticket.DeleteTicket(ticket_id); const std::vector<u8>& new_ticket = ticket.GetBytes(); const std::string ticket_path = Common::GetTicketFileName(title_id); if (!new_ticket.empty()) { const auto file = fs->OpenFile(PID_KERNEL, PID_KERNEL, ticket_path, FS::Mode::ReadWrite); if (!file || !file->Write(new_ticket.data(), new_ticket.size())) return ES_EIO; } else { // Delete the ticket file if it is now empty. fs->Delete(PID_KERNEL, PID_KERNEL, ticket_path); } // Delete the ticket directory if it is now empty. const std::string ticket_parent_dir = StringFromFormat("/ticket/%08x", static_cast<u32>(title_id >> 32)); const auto ticket_parent_dir_entries = fs->ReadDirectory(PID_KERNEL, PID_KERNEL, ticket_parent_dir); if (ticket_parent_dir_entries && ticket_parent_dir_entries->empty()) fs->Delete(PID_KERNEL, PID_KERNEL, ticket_parent_dir); return IPC_SUCCESS; }
ISOFileSystem::ISOFileSystem(IHandleAllocator *_hAlloc, BlockDevice *_blockDevice) { blockDevice = _blockDevice; hAlloc = _hAlloc; VolDescriptor desc; blockDevice->ReadBlock(16, (u8*)&desc); entireISO.name = ""; entireISO.isDirectory = false; entireISO.startingPosition = 0; entireISO.size = _blockDevice->GetNumBlocks() * _blockDevice->GetBlockSize(); entireISO.isBlockSectorMode = true; entireISO.flags = 0; entireISO.parent = NULL; if (!memcmp(desc.cd001, "CD001", 5)) { INFO_LOG(FILESYS, "Looks like a valid ISO!"); } else { ERROR_LOG(FILESYS, "ISO looks bogus? trying anyway..."); } treeroot = new TreeEntry; treeroot->isDirectory = true; treeroot->startingPosition = 0; treeroot->size = 0; treeroot->isBlockSectorMode = false; treeroot->flags = 0; treeroot->parent = NULL; u32 rootSector = desc.root.firstDataSectorLE; u32 rootSize = desc.root.dataLengthLE; ReadDirectory(rootSector, rootSize, treeroot); }
void PanelView::EnterDirectory(const char *p) //////////////////////////////////////////////////////////////////////// { char buf[256]; // TODO: mi a leghosszabb? Ki kellene keresni... int len = m_Path.Length(); // Ha mar van elotte / jel... if (m_Path.ByteAt(len-1)=='/') sprintf(buf,"%s%s",m_Path.String(),p); else sprintf(buf,"%s/%s",m_Path.String(),p); if (DoesEntryExist(p)) { m_Path.SetTo(buf); SetPathStringView(); ClearFileList(); ReadDirectory(); } else GotoRoot(); }
nfsstat3 CNFS3Prog::ProcedureLINK(void) { PrintLog("LINK"); char *filePath; diropargs3 link; std::string dirName; std::string fileName; nfsstat3 stat; post_op_attr obj_attributes; wcc_data dir_wcc; filePath = GetPath(); ReadDirectory(dirName, fileName); char *linkFullPath = GetFullPath(dirName, fileName); if (CreateHardLink(linkFullPath, filePath, NULL) == 0) { stat = NFS3ERR_IO; } stat = CheckFile(linkFullPath); if (stat == NFS3_OK) { obj_attributes.attributes_follow = GetFileAttributesForNFS(filePath, &obj_attributes.attributes); if (!obj_attributes.attributes_follow) { stat = NFS3ERR_IO; } } dir_wcc.after.attributes_follow = GetFileAttributesForNFS((char*)dirName.c_str(), &dir_wcc.after.attributes); Write(&stat); Write(&obj_attributes); Write(&dir_wcc); return stat; }
nfsstat3 CNFS3Prog::ProcedureREMOVE(void) { char *path; wcc_data dir_wcc; nfsstat3 stat; PrintLog("REMOVE"); std::string dirName; std::string fileName; ReadDirectory(dirName, fileName); path = GetFullPath(dirName, fileName); stat = CheckFile((char*)dirName.c_str(), path); dir_wcc.before.attributes_follow = GetFileAttributesForNFS((char*)dirName.c_str(), &dir_wcc.before.attributes); if (stat == NFS3_OK) { DWORD fileAttr = GetFileAttributes(path); if ((fileAttr & FILE_ATTRIBUTE_DIRECTORY) && (fileAttr & FILE_ATTRIBUTE_REPARSE_POINT)) { if (RemoveFolder(path) == 0) { stat = NFS3ERR_IO; } } else { if (!RemoveFile(path)) { stat = NFS3ERR_IO; } } } dir_wcc.after.attributes_follow = GetFileAttributesForNFS((char*)dirName.c_str(), &dir_wcc.after.attributes); Write(&stat); Write(&dir_wcc); return stat; }
/***************************************************************************** * Run: Gtk+ thread ***************************************************************************** * this part of the interface is in a separate thread so that we can call * gtk_main() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { #ifndef NEED_GTK2_MAIN /* gtk_init needs to know the command line. We don't care, so we * give it an empty one */ char *p_args[] = { "", NULL }; char **pp_args = p_args; int i_args = 1; int i_dummy; #endif playlist_t *p_playlist; GtkCellRenderer *p_renderer = NULL; GtkTreeViewColumn *p_column = NULL; GtkListStore *p_filelist = NULL; GtkListStore *p_playlist_store = NULL; #ifndef NEED_GTK2_MAIN gtk_set_locale (); msg_Dbg( p_intf, "Starting pda GTK2+ interface" ); gtk_init( &i_args, &pp_args ); #else /* Initialize Gtk+ */ msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" ); gdk_threads_enter(); #endif /* Create some useful widgets that will certainly be used */ /* FIXME: magic path */ add_pixmap_directory("share"); add_pixmap_directory("/usr/share/vlc"); /* Path for pixmaps under linupy 1.4 */ add_pixmap_directory("/usr/local/share/pixmaps/vlc"); /* Path for pixmaps under linupy 2.0 */ add_pixmap_directory("/usr/share/pixmaps/vlc"); p_intf->p_sys->p_window = create_pda(); if (p_intf->p_sys->p_window == NULL) { msg_Err( p_intf, "unable to create pda interface" ); } /* Store p_intf to keep an eye on it */ gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window), "p_intf", p_intf ); /* Set the title of the main window */ gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window), VOUT_TITLE " (PDA Linux interface)"); /* Get the notebook object */ p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data( GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) ); /* Get the slider object */ p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" ); p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" ); if (p_intf->p_sys->p_slider == NULL) msg_Err( p_intf, "Time slider widget not found." ); if (p_intf->p_sys->p_slider_label == NULL) msg_Err( p_intf, "Time label widget not found." ); /* Connect the date display to the slider */ p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) ); if (p_intf->p_sys->p_adj == NULL) msg_Err( p_intf, "Adjustment range not found." ); g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed", G_CALLBACK( E_(GtkDisplayDate) ), p_intf ); p_intf->p_sys->f_adj_oldvalue = 0; p_intf->p_sys->i_adj_oldvalue = 0; /* BEGIN OF FILEVIEW GTK_TREE_VIEW */ p_intf->p_sys->p_tvfile = NULL; p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvFileList"); if (NULL == p_intf->p_sys->p_tvfile) msg_Err(p_intf, "Error obtaining pointer to File List"); /* Insert columns 0 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Insert columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); /* Insert columns 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); /* Insert columns 3 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 ); gtk_tree_view_column_set_sort_column_id(p_column, 3); /* Insert columns 4 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 ); gtk_tree_view_column_set_sort_column_id(p_column, 4); /* Get new directory listing */ p_filelist = gtk_list_store_new (5, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* permissions */ G_TYPE_UINT64, /* File size */ G_TYPE_STRING, /* Owner */ G_TYPE_STRING);/* Group */ ReadDirectory(p_intf, p_filelist, "."); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist)); g_object_unref(p_filelist); /* Model will be released by GtkTreeView */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE); /* END OF FILEVIEW GTK_TREE_VIEW */ /* BEGIN OF PLAYLIST GTK_TREE_VIEW */ p_intf->p_sys->p_tvplaylist = NULL; p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist"); if (NULL == p_intf->p_sys->p_tvplaylist) msg_Err(p_intf, "Error obtaining pointer to Play List"); /* Columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Column 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); #if 0 /* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); #endif /* update the playlist */ p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); p_playlist_store = gtk_list_store_new (3, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* Time */ G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_playlist_store, p_playlist); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store)); g_object_unref(p_playlist_store); vlc_object_release(p_playlist); /* Free the playlist */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist); gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE); /* END OF PLAYLIST GTK_TREE_VIEW */ /* Hide the Preference TAB for now. */ GtkWidget *p_preference_tab = NULL; p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5); if (p_preference_tab != NULL) gtk_widget_hide(p_preference_tab); /* Show the control window */ gtk_widget_show( p_intf->p_sys->p_window ); #ifdef NEED_GTK2_MAIN msg_Dbg( p_intf, "Manage GTK keyboard events using threads" ); while( !p_intf->b_die ) { Manage( p_intf ); /* Sleep to avoid using all CPU - since some interfaces need to * access keyboard events, a 100ms delay is a good compromise */ gdk_threads_leave(); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) msleep( INTF_IDLE_SLEEP ); else msleep( 1000 ); gdk_threads_enter(); } #else msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" ); /* Sleep to avoid using all CPU - since some interfaces needs to access * keyboard events, a 1000ms delay is a good compromise */ if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf ); else i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf ); /* Enter Gtk mode */ gtk_main(); /* Remove the timeout */ gtk_timeout_remove( i_dummy ); #endif gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) ); #ifdef NEED_GTK2_MAIN gdk_threads_leave(); #endif }
// ----------------------------------------------------------------------------- // CAknFileSelectionModel::UpdateItemListL // ----------------------------------------------------------------------------- // TInt CAknFileSelectionModel::UpdateItemListL() { iEntryArray->Reset(); iImageIndexArray.Reset(); CDir* entryArray = ReadDirectory( iCurrentPath.DriveAndPath() ); if ( !entryArray ) { return KErrNotFound; } CleanupStack::PushL( entryArray ); TInt itemCount( entryArray->Count() ); if ( itemCount > 0 ) { TInt filterCount( iFilterArray->Count() ); TInt filterIndex; TBool accepted; CDesC16Array* desC16FoldersArray = new ( ELeave ) CDesC16ArrayFlat( KEntryArrayGranularity ); CleanupStack::PushL( desC16FoldersArray ); CDesC16Array* desC16FilesArray = new ( ELeave ) CDesC16ArrayFlat( KEntryArrayGranularity ); CleanupStack::PushL( desC16FilesArray ); CArrayPakFlat<TEntry>* tmpFoldersArray = new( ELeave ) CArrayPakFlat<TEntry>( KEntryArrayGranularity ); CleanupStack::PushL( tmpFoldersArray ); CArrayPakFlat<TEntry>* tmpFilesArray = new( ELeave ) CArrayPakFlat<TEntry>( KEntryArrayGranularity ); CleanupStack::PushL( tmpFilesArray ); tmpFoldersArray->Reset(); desC16FoldersArray->Reset(); tmpFilesArray->Reset(); desC16FilesArray->Reset(); for ( TInt i( 0 ); i < itemCount; i++ ) // Generate filtered list { accepted = ETrue; // If there are no filters, accept the entry TEntry entry = ( *entryArray )[i]; filterIndex = 0; // Go thru the filters while the entry is accepted while( ( filterIndex < filterCount ) && ( accepted ) ) { accepted = iFilterArray->At( filterIndex )->Accept( iCurrentPath.DriveAndPath(), entry ); filterIndex++; } if ( accepted ) // Directory entry has passed all filters { // Add filename to filtered list if ( entry.IsDir() ) { desC16FoldersArray->AppendL( GetLocalizedName( entry.iName ) ); tmpFoldersArray->AppendL( entry, sizeof( TEntry ) ); } else { desC16FilesArray->AppendL( GetLocalizedName( entry.iName ) ); tmpFilesArray->AppendL( entry, sizeof( TEntry ) ); } } } TInt entryCount = 0; TInt index; TKeyArrayPak key( _FOFF( TEntry, iName ), ECmpCollated ); // Add folder entries desC16FoldersArray->Sort( ECmpCollated ); entryCount = desC16FoldersArray->MdcaCount(); for( TInt j( 0 ); j < entryCount; j++ ) { for( TInt k( 0 ); k < entryCount; k++ ) { if( ( *desC16FoldersArray )[j] == GetLocalizedName( ( *tmpFoldersArray )[k].iName ) && iEntryArray->Find( ( *tmpFoldersArray )[k], key, index ) != 0 ) { TEntry tmpEntry = ( *tmpFoldersArray )[k]; iEntryArray->AppendL( tmpEntry, sizeof( TEntry ) ); // Entry is a directory TFileTypeIcon folderIcon( EFolderIcon ); if( !AknCFDUtility::IsRemoteDrive( iCurrentPath.Drive() ) ) { if ( ContainsSubfolders( tmpEntry.iName ) ) { folderIcon = ESubFolderIcon; } else if ( !ContainsFiles( tmpEntry.iName ) ) { folderIcon = EFolderEmptyIcon; } } iImageIndexArray.Append( folderIcon ); break; } } } // Add file entries desC16FilesArray->Sort( ECmpCollated ); entryCount = desC16FilesArray->MdcaCount(); for( TInt j( 0 ); j < entryCount; j++ ) { for( TInt k( 0 ); k < entryCount; k++ ) { if( ( *desC16FilesArray )[j] == GetLocalizedName( ( *tmpFilesArray )[k].iName ) && iEntryArray->Find( ( *tmpFilesArray )[k], key, index ) != 0 ) { TEntry tmpFile = ( *tmpFilesArray )[k]; iEntryArray->AppendL( tmpFile, sizeof( TEntry ) ); // Entry is a file AppendIconForFileL( tmpFile.iName ); break; } } } CleanupStack::PopAndDestroy( tmpFilesArray ); CleanupStack::PopAndDestroy( tmpFoldersArray ); CleanupStack::Pop( desC16FilesArray ); desC16FilesArray->Reset(); delete desC16FilesArray; CleanupStack::Pop( desC16FoldersArray ); desC16FoldersArray->Reset(); delete desC16FoldersArray; } CleanupStack::PopAndDestroy( entryArray ); if ( AknCFDUtility::DirectoriesOnly( iDialogType ) ) { // Set the current folder name as first item. // Current folder is for example "E:\Images\Holiday\" // Remove trailing backslash, we get "E:\Images\Holiday" // Parse the path with TParse and ask for NameAndExt(). // TParse interpretes "Holiday" as file name and returns it. HBufC * bufFolder = HBufC::NewLC(KMaxPath); * bufFolder = iCurrentPath.DriveAndPath() ; TPtr folder = bufFolder->Des(); AknCFDUtility::RemoveTrailingBackslash( folder ); // ignore error TParsePtr parsedFolder(folder); folder = parsedFolder.NameAndExt(); iFolderEntry.iName = folder; iEntryArray->InsertL( 0, iFolderEntry, sizeof( TEntry ) ); iImageIndexArray.Insert( EThisFolderIcon, 0 ); CleanupStack::PopAndDestroy(); //bufFolder } return iEntryArray->Count(); }
Zip::Zip(Control &control_, char *zipfile_name) : control(control_), magic(0), zipbuffer(NULL) { #ifdef UNIX_FILE_SYSTEM zipfile = SystemFopen(zipfile_name, "rb"); if (zipfile) { int rc = fseek(zipfile, -END_SIZE, SEEK_END); if (rc == 0) { zipbuffer = new char[END_SIZE]; buffer_ptr = zipbuffer; SystemFread(buffer_ptr, sizeof(char), END_SIZE, zipfile); magic = GetU4(); } } #elif defined(WIN32_FILE_SYSTEM) zipfile = CreateFile(zipfile_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); if (zipfile != INVALID_HANDLE_VALUE) { mapfile = CreateFileMapping(zipfile, NULL, PAGE_READONLY, 0, 0, NULL); zipbuffer = (mapfile == INVALID_HANDLE_VALUE ? NULL : (char *) MapViewOfFile(mapfile, FILE_MAP_READ, 0, 0, 0) ); if (zipbuffer) { buffer_ptr = &zipbuffer[GetFileSize(zipfile, NULL) - END_SIZE]; magic = GetU4(); } } #endif // The following was posted to the dev list, but was just // too good to not put in here, the next person to have to // deal with this crap will appreciate it. -=Chris // // From: Mo DeJong <*****@*****.**> // // Ode to a zip file: // // I can't read it forwards // I can't read it backwards // I must know where to begin // so I need to look in the middle // to find the middle, I must know the end // but I don't know where that is, so I guess // // ------------------------------------------------- // This may or may not be a valid zip file. The zip file might have // a file comment so we can't be sure where the END header is located. // We check for the LOC header at byte 0 to make sure this is a valid // zip file and then scan over the file backwards in search of the // END header. if (zipbuffer != NULL && ! IsValid()) { u4 sig = 0; #ifdef UNIX_FILE_SYSTEM int res = fseek(zipfile, 0, SEEK_SET); assert(res == 0); char *tmpbuffer = new char[LOC_SIZE]; buffer_ptr = tmpbuffer; SystemFread(buffer_ptr, sizeof(char), LOC_SIZE, zipfile); sig = GetU4(); delete [] tmpbuffer; buffer_ptr = NULL; if (sig == LOC_SIG) { int block_size = 8192; tmpbuffer = new char[block_size]; char *holdbuffer = new char[8]; char *index_ptr; res = fseek(zipfile, 0, SEEK_END); assert(res == 0); long zip_file_size = ftell(zipfile); int num_loops = zip_file_size / block_size; magic = 0; for (; magic == 0 && num_loops >= 0 ; num_loops--) { if ((ftell(zipfile) - block_size) < 0) { block_size = ftell(zipfile); res = fseek(zipfile, 0L, SEEK_SET); } else { res = fseek(zipfile, -block_size, SEEK_CUR); } assert(res == 0); SystemFread(tmpbuffer, sizeof(char), block_size, zipfile); res = fseek(zipfile, -block_size, SEEK_CUR); // undo fread assert(res == 0); for (index_ptr = tmpbuffer + block_size - 1; index_ptr >= tmpbuffer; index_ptr--) { if (*index_ptr == 'P') { // Check for header signature that spans buffer int span = (tmpbuffer + block_size) - index_ptr; if (span < 4) { memmove(holdbuffer+span, holdbuffer, 3); memmove(holdbuffer, index_ptr, span); buffer_ptr = holdbuffer; } else { buffer_ptr = index_ptr; } sig = GetU4(); if (sig == END_SIG) { // Found the END header, put it in zipbuffer. buffer_ptr = zipbuffer; fseek(zipfile, block_size-span, SEEK_CUR); SystemFread(buffer_ptr, sizeof(char), END_SIZE, zipfile); magic = GetU4(); break; } } } // Copy first 3 bytes into holdbuffer in case sig spans holdbuffer[0] = tmpbuffer[0]; holdbuffer[1] = tmpbuffer[1]; holdbuffer[2] = tmpbuffer[2]; } delete [] tmpbuffer; delete [] holdbuffer; } #elif defined(WIN32_FILE_SYSTEM) buffer_ptr = &zipbuffer[0]; sig = GetU4(); if (sig == LOC_SIG) { buffer_ptr = &zipbuffer[GetFileSize(zipfile, NULL) - END_SIZE]; for ( ; buffer_ptr >= zipbuffer; buffer_ptr--) { if (*buffer_ptr == 'P') { sig = GetU4(); if (sig == END_SIG) { magic = sig; break; } else buffer_ptr -= 4; } } } #endif } ReadDirectory(); }
void ISOFileSystem::ReadDirectory(u32 startsector, u32 dirsize, TreeEntry *root, size_t level) { for (u32 secnum = startsector, endsector = dirsize/2048 + startsector; secnum < endsector; ++secnum) { u8 theSector[2048]; blockDevice->ReadBlock(secnum, theSector); lastReadBlock_ = secnum; for (int offset = 0; offset < 2048; ) { DirectoryEntry &dir = *(DirectoryEntry *)&theSector[offset]; u8 sz = theSector[offset]; // Nothing left in this sector. There might be more in the next one. if (sz == 0) break; const int IDENTIFIER_OFFSET = 33; if (offset + IDENTIFIER_OFFSET + dir.identifierLength > 2048) { ERROR_LOG(FILESYS, "Directory entry crosses sectors, corrupt iso?"); return; } offset += dir.size; bool isFile = (dir.flags & 2) ? false : true; bool relative; TreeEntry *e = new TreeEntry(); if (dir.identifierLength == 1 && (dir.firstIdChar == '\x00' || dir.firstIdChar == '.')) { e->name = "."; relative = true; } else if (dir.identifierLength == 1 && dir.firstIdChar == '\x01') { e->name = ".."; relative = true; } else { e->name = std::string((char *)&dir.firstIdChar, dir.identifierLength); relative = false; } e->size = dir.dataLength(); e->startingPosition = dir.firstDataSector() * 2048; e->isDirectory = !isFile; e->flags = dir.flags; e->parent = root; // Let's not excessively spam the log - I commented this line out. //DEBUG_LOG(FILESYS, "%s: %s %08x %08x %i", e->isDirectory?"D":"F", e->name.c_str(), dir.firstDataSectorLE, e->startingPosition, e->startingPosition); if (e->isDirectory && !relative) { if (dir.firstDataSector() == startsector) { ERROR_LOG(FILESYS, "WARNING: Appear to have a recursive file system, breaking recursion"); } else { bool doRecurse = true; if (!restrictTree.empty()) doRecurse = level < restrictTree.size() && restrictTree[level] == e->name; if (doRecurse) ReadDirectory(dir.firstDataSector(), dir.dataLength(), e, level + 1); else continue; } } root->children.push_back(e); } } }
void CACEdit::OnChange() { CString m_Text; int pos=0,len; if(m_iType == -1) {ASSERT(0); return;} GetWindowText(m_EditText); len = m_EditText.GetLength(); //---------------------------------------------- if(m_iMode & _MODE_FILESYSTEM_ || m_iMode & _MODE_FS_START_DIR_) { if(!m_CursorMode) { if(m_iType == _EDIT_) pos = LOWORD(((CEdit*)this)->CharFromPos(GetCaretPos())); if(m_iType == _COMBOBOX_) pos = m_pEdit->CharFromPos(m_pEdit->GetCaretPos()); if(m_iMode & _MODE_FS_START_DIR_) { if(len) m_Liste.FindString(-1,m_EditText); else m_Liste.ShowWindow(false); } else { if(len > 2 && pos == len) { if(_taccess(m_EditText,0) == 0) { ReadDirectory(m_EditText); } m_Liste.FindString(-1,m_EditText); } else m_Liste.ShowWindow(false); } } // m_CursorMode } //---------------------------------------------- if(m_iMode & _MODE_SEPARATION_) { if(!m_CursorMode) { if(m_iType == _EDIT_) pos = LOWORD(((CEdit*)this)->CharFromPos(GetCaretPos())); if(m_iType == _COMBOBOX_) pos = m_pEdit->CharFromPos(m_pEdit->GetCaretPos()); int left,right; left = FindSepLeftPos(pos-1); right = FindSepRightPos(pos); m_Text = m_EditText.Mid(left,right-left); m_Liste.FindString(-1,m_Text); } } //---------------------------------------------- if(m_iMode & _MODE_STANDARD_) { if(!m_CursorMode) m_Liste.FindString(-1,m_EditText); } //---------------------------------------------- GetParent()->SendMessage(ENAC_UPDATE, EN_UPDATE, GetDlgCtrlID()); }
static void dump(int fd, uint64 diroff) { unsigned i; lseek(fd, (off_t) 0, 0); if (read(fd, (char*) &hdr, sizeof (TIFFHeaderCommon)) != sizeof (TIFFHeaderCommon)) ReadError("TIFF header"); if (hdr.common.tiff_magic != TIFF_BIGENDIAN && hdr.common.tiff_magic != TIFF_LITTLEENDIAN && #if HOST_BIGENDIAN /* MDI is sensitive to the host byte order, unlike TIFF */ MDI_BIGENDIAN != hdr.common.tiff_magic #else MDI_LITTLEENDIAN != hdr.common.tiff_magic #endif ) { Fatal("Not a TIFF or MDI file, bad magic number %u (%#x)", hdr.common.tiff_magic, hdr.common.tiff_magic); } if (hdr.common.tiff_magic == TIFF_BIGENDIAN || hdr.common.tiff_magic == MDI_BIGENDIAN) swabflag = !bigendian; else swabflag = bigendian; if (swabflag) TIFFSwabShort(&hdr.common.tiff_version); if (hdr.common.tiff_version==42) { if (read(fd, (char*) &hdr.classic.tiff_diroff, 4) != 4) ReadError("TIFF header"); if (swabflag) TIFFSwabLong(&hdr.classic.tiff_diroff); printf("Magic: %#x <%s-endian> Version: %#x <%s>\n", hdr.classic.tiff_magic, hdr.classic.tiff_magic == TIFF_BIGENDIAN ? "big" : "little", 42,"ClassicTIFF"); if (diroff == 0) diroff = hdr.classic.tiff_diroff; } else if (hdr.common.tiff_version==43) { if (read(fd, (char*) &hdr.big.tiff_offsetsize, 12) != 12) ReadError("TIFF header"); if (swabflag) { TIFFSwabShort(&hdr.big.tiff_offsetsize); TIFFSwabShort(&hdr.big.tiff_unused); TIFFSwabLong8(&hdr.big.tiff_diroff); } printf("Magic: %#x <%s-endian> Version: %#x <%s>\n", hdr.big.tiff_magic, hdr.big.tiff_magic == TIFF_BIGENDIAN ? "big" : "little", 43,"BigTIFF"); printf("OffsetSize: %#x Unused: %#x\n", hdr.big.tiff_offsetsize,hdr.big.tiff_unused); if (diroff == 0) diroff = hdr.big.tiff_diroff; bigtiff = 1; } else Fatal("Not a TIFF file, bad version number %u (%#x)", hdr.common.tiff_version, hdr.common.tiff_version); for (i = 0; diroff != 0; i++) { if (i > 0) putchar('\n'); diroff = ReadDirectory(fd, i, diroff); } }
void ISOFileSystem::ReadDirectory(u32 startsector, u32 dirsize, TreeEntry *root) { u8 buffer[2048]; int offset = 0; u32 secnum = startsector; u8 theSector[2048]; blockDevice->ReadBlock(secnum, theSector); while (secnum < (dirsize/2048 + startsector)) { DirectoryEntry &dir = *((DirectoryEntry *)buffer); u8 sz = theSector[offset]; if (sz == 0) // NOT the correct way goto nextblock; //done memcpy(&dir, theSector + offset, sz); buffer[2047]=0; offset += dir.size; if (offset >= 2048) { nextblock: offset=0; secnum++; blockDevice->ReadBlock(secnum, theSector); memcpy(&dir, theSector + offset, sz); } bool isFile = (dir.flags & 2) ? false : true; int fnLength = dir.identifierLength; char name[256]; for (int i = 0; i < fnLength; i++) name[i] = buffer[33+i] ? buffer[33+i] : '.'; name[fnLength] = '\0'; if (!strcmp(name, ".")) // "." record continue; if (strlen(name) == 1 && name[0] == '\x01') // ".." record continue; TreeEntry *e = new TreeEntry; e->name = name; e->size = dir.dataLengthLE; e->startingPosition = dir.firstDataSectorLE * 2048; e->isDirectory = !isFile; e->flags = dir.flags; e->isBlockSectorMode = false; DEBUG_LOG(FILESYS, "%s: %s %08x %08x %i", e->isDirectory?"D":"F", name, dir.firstDataSectorLE, e->startingPosition, e->startingPosition); if (e->isDirectory) { if (dir.firstDataSectorLE == startsector) { ERROR_LOG(FILESYS, "WARNING: Appear to have a recursive file system, breaking recursion"); } else { ReadDirectory(dir.firstDataSectorLE, dir.dataLengthLE, e); } } root->children.push_back(e); } }
nfsstat3 CNFS3Prog::ProcedureSYMLINK(void) { PrintLog("SYMLINK"); char* path; post_op_fh3 obj; post_op_attr obj_attributes; wcc_data dir_wcc; nfsstat3 stat; diropargs3 where; symlinkdata3 symlink; DWORD targetFileAttr; DWORD dwFlags; std::string dirName; std::string fileName; ReadDirectory(dirName, fileName); path = GetFullPath(dirName, fileName); Read(&symlink); _In_ LPTSTR lpSymlinkFileName = path; // symlink (full path) // TODO: Maybe revisit this later for a cleaner solution // Convert target path to windows path format, maybe this could also be done // in a safer way by a combination of PathRelativePathTo and GetFullPathName. // Without this conversion nested folder symlinks do not work cross platform. std::string strFromChar; strFromChar.append(symlink.symlink_data.path); // target (should be relative path)); std::replace(strFromChar.begin(), strFromChar.end(), '/', '\\'); _In_ LPTSTR lpTargetFileName = const_cast<LPSTR>(strFromChar.c_str()); std::string fullTargetPath = dirName + std::string("\\") + std::string(lpTargetFileName); // Relative path do not work with GetFileAttributes (directory are not recognized) // so we normalize the path before calling GetFileAttributes TCHAR fullTargetPathNormalized[MAX_PATH]; _In_ LPTSTR fullTargetPathString = const_cast<LPSTR>(fullTargetPath.c_str());; GetFullPathName(fullTargetPathString, MAX_PATH, fullTargetPathNormalized, NULL); targetFileAttr = GetFileAttributes(fullTargetPathNormalized); dwFlags = 0x0; if (targetFileAttr & FILE_ATTRIBUTE_DIRECTORY) { dwFlags = SYMBOLIC_LINK_FLAG_DIRECTORY; } BOOLEAN failed = CreateSymbolicLink(lpSymlinkFileName, lpTargetFileName, dwFlags); if (failed != 0) { stat = NFS3_OK; obj.handle_follows = GetFileHandle(path, &obj.handle); obj_attributes.attributes_follow = GetFileAttributesForNFS(path, &obj_attributes.attributes); } else { stat = NFS3ERR_IO; PrintLog("An error occurs or file already exists."); stat = CheckFile(path); if (stat != NFS3_OK) { stat = NFS3ERR_IO; } } dir_wcc.after.attributes_follow = GetFileAttributesForNFS((char*)dirName.c_str(), &dir_wcc.after.attributes); Write(&stat); if (stat == NFS3_OK) { Write(&obj); Write(&obj_attributes); } Write(&dir_wcc); return stat; }
static void dump(int fd, uint64 diroff) { unsigned i, j; uint64* visited_diroff = NULL; unsigned int count_visited_dir = 0; _TIFF_lseek_f(fd, (_TIFF_off_t) 0, 0); if (read(fd, (char*) &hdr, sizeof (TIFFHeaderCommon)) != sizeof (TIFFHeaderCommon)) ReadError("TIFF header"); if (hdr.common.tiff_magic != TIFF_BIGENDIAN && hdr.common.tiff_magic != TIFF_LITTLEENDIAN && #if HOST_BIGENDIAN /* MDI is sensitive to the host byte order, unlike TIFF */ MDI_BIGENDIAN != hdr.common.tiff_magic #else MDI_LITTLEENDIAN != hdr.common.tiff_magic #endif ) { Fatal("Not a TIFF or MDI file, bad magic number %u (%#x)", hdr.common.tiff_magic, hdr.common.tiff_magic); } if (hdr.common.tiff_magic == TIFF_BIGENDIAN || hdr.common.tiff_magic == MDI_BIGENDIAN) swabflag = !bigendian; else swabflag = bigendian; if (swabflag) TIFFSwabShort(&hdr.common.tiff_version); if (hdr.common.tiff_version==42) { if (read(fd, (char*) &hdr.classic.tiff_diroff, 4) != 4) ReadError("TIFF header"); if (swabflag) TIFFSwabLong(&hdr.classic.tiff_diroff); printf("Magic: %#x <%s-endian> Version: %#x <%s>\n", hdr.classic.tiff_magic, hdr.classic.tiff_magic == TIFF_BIGENDIAN ? "big" : "little", 42,"ClassicTIFF"); if (diroff == 0) diroff = hdr.classic.tiff_diroff; } else if (hdr.common.tiff_version==43) { if (read(fd, (char*) &hdr.big.tiff_offsetsize, 12) != 12) ReadError("TIFF header"); if (swabflag) { TIFFSwabShort(&hdr.big.tiff_offsetsize); TIFFSwabShort(&hdr.big.tiff_unused); TIFFSwabLong8(&hdr.big.tiff_diroff); } printf("Magic: %#x <%s-endian> Version: %#x <%s>\n", hdr.big.tiff_magic, hdr.big.tiff_magic == TIFF_BIGENDIAN ? "big" : "little", 43,"BigTIFF"); printf("OffsetSize: %#x Unused: %#x\n", hdr.big.tiff_offsetsize,hdr.big.tiff_unused); if (diroff == 0) diroff = hdr.big.tiff_diroff; bigtiff = 1; } else Fatal("Not a TIFF file, bad version number %u (%#x)", hdr.common.tiff_version, hdr.common.tiff_version); for (i = 0; diroff != 0; i++) { for(j=0; j<count_visited_dir; j++) { if( visited_diroff[j] == diroff ) { free(visited_diroff); Fatal("Cycle detected in chaining of TIFF directories!"); } } { size_t alloc_size; alloc_size=TIFFSafeMultiply(tmsize_t,(count_visited_dir + 1), sizeof(uint64)); if (alloc_size == 0) { if (visited_diroff) free(visited_diroff); visited_diroff = 0; } else { visited_diroff = (uint64*) realloc(visited_diroff,alloc_size); } } if( !visited_diroff ) Fatal("Out of memory"); visited_diroff[count_visited_dir] = diroff; count_visited_dir ++; if (i > 0) putchar('\n'); diroff = ReadDirectory(fd, i, diroff); } if( visited_diroff ) free(visited_diroff); }
/* * Create */ void Create() { fNDS = fopen(ndsfilename, "wb"); if (!fNDS) { fprintf(stderr, "Cannot open file '%s'.\n", ndsfilename); exit(1); } bool bSecureSyscalls = false; char *headerfilename = (headerfilename_or_size && (strtoul(headerfilename_or_size,0,0) == 0)) ? headerfilename_or_size : 0; u32 headersize = headerfilename_or_size ? strtoul(headerfilename_or_size,0,0) : 0x200; // initial header data if (headerfilename) { // header template FILE *fi = fopen(headerfilename, "rb"); if (!fi) { fprintf(stderr, "Cannot open file '%s'.\n", headerfilename); exit(1); } fread(&header, 1, 0x200, fi); fclose(fi); if ((header.arm9_ram_address + 0x800 == header.arm9_entry_address) || (header.rom_header_size > 0x200)) { bSecureSyscalls = true; } } else // set header default values { // clear header memset(&header, 0, sizeof(header)); memcpy(header.gamecode, "####", 4); if ((arm9RamAddress + 0x800 == arm9Entry) || (headersize > 0x200)) { bSecureSyscalls = true; } else { header.reserved2 = 0x04; // autostart *(unsigned_int *)(((unsigned char *)&header) + 0x0) = 0xEA00002E; // for PassMe's that start @ 0x08000000 } *(unsigned_int *)(((unsigned char *)&header) + 0x60) = 1<<22 | latency2<<16 | 1<<14 | 1<<13 | latency1; // ROM control info 1 *(unsigned_int *)(((unsigned char *)&header) + 0x64) = 1<<29 | latency2<<16 | latency1; // ROM control info 2 *(unsigned_short *)(((unsigned char *)&header) + 0x6E) = 0x051E; // ROM control info 3 } if (headersize) header.rom_header_size = headersize; if (header.rom_header_size == 0) header.rom_header_size = bSecureSyscalls ? 0x4000 : 0x200; // load a logo if (logofilename) { char *p = strrchr(logofilename, '.'); if (!strcmp(p, ".bmp")) { CRaster raster; if (raster.LoadBMP(logofilename) < 0) exit(1); unsigned char white = (raster.palette[0].rgbGreen >= 128) ? 0 : 1; if (LogoConvert(raster.raster, header.logo, white) < 0) exit(1); } else { FILE *fi = fopen(logofilename, "rb"); if (!fi) { fprintf(stderr, "Cannot open file '%s'.\n", logofilename); exit(1); } fread(&header.logo, 1, 156, fi); fclose(fi); } } else if (bSecureSyscalls) // use Nintendo logo { memcpy(((unsigned char *)&header) + 0xC0, nintendo_logo, sizeof(nintendo_logo)); } else // add small NDS loader { if (loadme_size != 156) { fprintf(stderr, "loadme size error\n"); exit(1); } memcpy(header.logo, loadme, loadme_size); // self-contained NDS loader for *Me GBA cartridge boot memcpy(&header.offset_0xA0, "SRAM_V110", 9); // allow GBA cartridge SRAM backup memcpy(&header.offset_0xAC, "PASS01\x96", 7); // automatically start with FlashMe, make it look more like a GBA rom } // override default title/game/maker codes if (title) strncpy(header.title, title, 12); if (gamecode) strncpy(header.gamecode, gamecode, 4); if (makercode) strncpy((char *)header.makercode, makercode, 2); // -------------------------- fseek(fNDS, header.rom_header_size, SEEK_SET); // ARM9 binary if (arm9filename) { header.arm9_rom_offset = (ftell(fNDS) + arm9_align) &~ arm9_align; fseek(fNDS, header.arm9_rom_offset, SEEK_SET); unsigned int entry_address = arm9Entry ? arm9Entry : (unsigned int)header.arm9_entry_address; // template unsigned int ram_address = arm9RamAddress ? arm9RamAddress : (unsigned int)header.arm9_ram_address; // template if (!ram_address && entry_address) ram_address = entry_address; if (!entry_address && ram_address) entry_address = ram_address; if (!ram_address) { ram_address = entry_address = 0x02000000; } // add dummy area for secure syscalls header.arm9_size = 0; if (bSecureSyscalls) { unsigned_int x; FILE *fARM9 = fopen(arm9filename, "rb"); if (fARM9) { fread(&x, sizeof(x), 1, fARM9); fclose(fARM9); if (x != 0xE7FFDEFF) // not already exist? { x = 0xE7FFDEFF; for (int i=0; i<0x800/4; i++) fwrite(&x, sizeof(x), 1, fNDS); header.arm9_size = 0x800; } } } unsigned int size = 0; if (HasElfExtension(arm9filename) || HasElfHeader(arm9filename) ) CopyFromElf(arm9filename, &entry_address, &ram_address, &size); else CopyFromBin(arm9filename, 0, &size); header.arm9_entry_address = entry_address; header.arm9_ram_address = ram_address; header.arm9_size = header.arm9_size + ((size + 3) &~ 3); } else { fprintf(stderr, "ARM9 binary file required.\n"); exit(1); } // ARM9 overlay table if (arm9ovltablefilename) { unsigned_int x1 = 0xDEC00621; fwrite(&x1, sizeof(x1), 1, fNDS); // 0x2106c0de magic unsigned_int x2 = 0x00000AD8; fwrite(&x2, sizeof(x2), 1, fNDS); // ??? unsigned_int x3 = 0x00000000; fwrite(&x3, sizeof(x3), 1, fNDS); // ??? header.arm9_overlay_offset = ftell(fNDS); // do not align fseek(fNDS, header.arm9_overlay_offset, SEEK_SET); unsigned int size = 0; CopyFromBin(arm9ovltablefilename, &size); header.arm9_overlay_size = size; overlay_files += size / sizeof(OverlayEntry); if (!size) header.arm9_overlay_offset = 0; } // COULD BE HERE: ARM9 overlay files, no padding before or between. end is padded with 0xFF's and then followed by ARM7 binary // fseek(fNDS, 1388772, SEEK_CUR); // test for ASME // ARM7 binary header.arm7_rom_offset = (ftell(fNDS) + arm7_align) &~ arm7_align; fseek(fNDS, header.arm7_rom_offset, SEEK_SET); char *devkitProPATH; devkitProPATH = getenv("DEVKITPRO"); #ifdef __WIN32__ // convert to standard windows path if ( devkitProPATH && devkitProPATH[0] == '/' ) { devkitProPATH[0] = devkitProPATH[1]; devkitProPATH[1] = ':'; } #endif if ( !arm7filename) { char arm7PathName[MAXPATHLEN]; if (!devkitProPATH) { fprintf(stderr,"No arm7 specified and DEVKITPRO missing from environment!\n"); exit(1); } strcpy(arm7PathName,devkitProPATH); strcat(arm7PathName,"/libnds/default.elf"); arm7filename = arm7PathName; } unsigned int entry_address = arm7Entry ? arm7Entry : (unsigned int)header.arm7_entry_address; // template unsigned int ram_address = arm7RamAddress ? arm7RamAddress : (unsigned int)header.arm7_ram_address; // template if (!ram_address && entry_address) ram_address = entry_address; if (!entry_address && ram_address) entry_address = ram_address; if (!ram_address) { ram_address = entry_address = 0x037f8000; } unsigned int size = 0; if (HasElfExtension(arm7filename)) CopyFromElf(arm7filename, &entry_address, &ram_address, &size); else CopyFromBin(arm7filename, &size); header.arm7_entry_address = entry_address; header.arm7_ram_address = ram_address; header.arm7_size = ((size + 3) &~ 3); // ARM7 overlay table if (arm7ovltablefilename) { header.arm7_overlay_offset = ftell(fNDS); // do not align fseek(fNDS, header.arm7_overlay_offset, SEEK_SET); unsigned int size = 0; CopyFromBin(arm7ovltablefilename, &size); header.arm7_overlay_size = size; overlay_files += size / sizeof(OverlayEntry); if (!size) header.arm7_overlay_offset = 0; } // COULD BE HERE: probably ARM7 overlay files, just like for ARM9 // if (overlay_files && !overlaydir) { fprintf(stderr, "Overlay directory required!.\n"); exit(1); } // filesystem //if (filerootdir || overlaydir) { // read directory structure free_file_id = overlay_files; free_dir_id++; directory_count++; TreeNode *filetree; if (filerootdir) filetree = ReadDirectory(new TreeNode(), filerootdir); else filetree = new TreeNode(); // dummy root node 0xF000 // calculate offsets required for FNT and FAT _entry_start = 8*directory_count; // names come after directory structs header.fnt_offset = (ftell(fNDS) + fnt_align) &~ fnt_align; header.fnt_size = _entry_start + // directory structs total_name_size + // total number of name characters for dirs and files directory_count*4 + // directory: name length (1), dir id (2), end-character (1) file_count*1 + // files: name length (1) - 3; // root directory only has an end-character file_count += overlay_files; // didn't take overlay files into FNT size, but have to be calculated into FAT size header.fat_offset = (header.fnt_offset + header.fnt_size + fat_align) &~ fat_align; header.fat_size = file_count * 8; // each entry contains top & bottom offset // banner after FNT/FAT if (bannerfilename) { header.banner_offset = (header.fat_offset + header.fat_size + banner_align) &~ banner_align; file_top = header.banner_offset + 0x840; fseek(fNDS, header.banner_offset, SEEK_SET); if (bannertype == BANNER_IMAGE) { char * Ext = strrchr(bannerfilename, '.'); if (Ext && strcasecmp(Ext, ".bmp") == 0) IconFromBMP(); else if (Ext && strcasecmp(Ext, ".grf") == 0) IconFromGRF(); else { fprintf(stderr, "Banner File Error: Unknown extension '%s'!\n", Ext); exit(1); } } else { CopyFromBin(bannerfilename, 0); } } else { file_top = header.fat_offset + header.fat_size; header.banner_offset = 0; } file_end = file_top; // no file data as yet // add (hidden) overlay files for (unsigned int i=0; i<overlay_files; i++) { char s[32]; sprintf(s, OVERLAY_FMT, i/*free_file_id*/); AddFile(overlaydir, "/", s, i/*free_file_id*/); //free_file_id++; // incremented up to overlay_files } // add all other (visible) files AddDirectory(filetree, "/", 0xF000, directory_count); fseek(fNDS, file_end, SEEK_SET); if (verbose) { printf("%u directories.\n", directory_count); printf("%u normal files.\n", file_count - overlay_files); printf("%u overlay files.\n", overlay_files); } } // -------------------------- // align file size unsigned int newfilesize = file_end; //ftell(fNDS); newfilesize = (newfilesize + 3) & ~3; // align to 4 bytes header.application_end_offset = newfilesize; if (newfilesize != file_end ) { fseek(fNDS, newfilesize-1, SEEK_SET); fputc(0, fNDS); } // calculate device capacity newfilesize |= newfilesize >> 16; newfilesize |= newfilesize >> 8; newfilesize |= newfilesize >> 4; newfilesize |= newfilesize >> 2; newfilesize |= newfilesize >> 1; newfilesize++; if (newfilesize <= 128*1024) newfilesize = 128*1024; int devcap = -18; unsigned int x = newfilesize; while (x != 0) { x >>= 1; devcap++; } header.devicecap = (devcap < 0) ? 0 : devcap; // fix up header CRCs and write header header.logo_crc = CalcLogoCRC(header); header.header_crc = CalcHeaderCRC(header); fseek(fNDS, 0, SEEK_SET); fwrite(&header, 0x200, 1, fNDS); fclose(fNDS); }
FileNameDatabaseHeader::FndbOffset FndbManager::ProcessFolder (/*[in]*/ FileNameDatabaseHeader::FndbOffset foParent, /*[in]*/ const char * lpszParentPath, /*[in]*/ const char * lpszFolderName, /*[in]*/ FileNameDatabaseHeader::FndbOffset foFolderName) { const size_t cReservedEntries = 0; if (currentLevel > deepestLevel) { deepestLevel = currentLevel; } vector<string> subDirectoryNames; subDirectoryNames.reserve (40); vector<FILENAMEINFO> fileNames; fileNames.reserve (100); bool done = false; PathName path (lpszParentPath, lpszFolderName); path.MakeAbsolute (); if (pCallback != 0) { if (! pCallback->OnProgress(currentLevel, path.Get())) { throw OperationCancelledException (); } char * lpszSubDirNames = 0; char * lpszFileNames = 0; char * lpszFileNameInfos = 0; done = pCallback->ReadDirectory(path.Get(), &lpszSubDirNames, &lpszFileNames, &lpszFileNameInfos); if (done) { AutoMemoryPointer xxx (lpszSubDirNames); AutoMemoryPointer xxy (lpszFileNames); AutoMemoryPointer xxz (lpszFileNameInfos); const char * lpsz = lpszSubDirNames; while (*lpsz != 0) { subDirectoryNames.push_back (lpsz); lpsz += strlen(lpsz) + 1; } lpsz = lpszFileNames; const char * lpsz2 = lpszFileNameInfos; while (*lpsz != 0) { FILENAMEINFO filenameinfo; filenameinfo.FileName = lpsz; lpsz += strlen(lpsz) + 1; if (lpsz2 != 0) { filenameinfo.Info = lpsz2; lpsz2 += strlen(lpsz2) + 1; } fileNames.push_back (filenameinfo); } } } if (! done) { ReadDirectory (path.Get(), subDirectoryNames, fileNames); } numDirectories += static_cast<unsigned long>(subDirectoryNames.size()); numFiles += static_cast<unsigned long>(fileNames.size()); sort (subDirectoryNames.begin(), subDirectoryNames.end(), StringComparerIgnoringCase()); sort (fileNames.begin(), fileNames.end(), COMPAREFILENAMEINFO()); // store all names; build offset table vector<FileNameDatabaseHeader::FndbOffset> vecfndboff; vecfndboff.reserve ((storeFileNameInfo ? 2 : 1) * fileNames.size() + 2 * subDirectoryNames.size() + cReservedEntries); vector<FILENAMEINFO>::iterator it; vector<string>::iterator it2; for (it = fileNames.begin(); it != fileNames.end(); ++ it) { vecfndboff.push_back (PushBack((*it).FileName.c_str())); } for (it2 = subDirectoryNames.begin(); it2 != subDirectoryNames.end(); ++ it2) { vecfndboff.push_back (PushBack((*it2).c_str())); } for (it2 = subDirectoryNames.begin(); it2 != subDirectoryNames.end(); ++ it2) { vecfndboff.push_back (null_byte); } if (storeFileNameInfo) { for (it = fileNames.begin(); it != fileNames.end(); ++ it) { vecfndboff.push_back (PushBack((*it).Info.c_str())); } } vecfndboff.insert (vecfndboff.end(), cReservedEntries, 0); // store directory data (excluding offsets) FileNameDatabaseDirectory dirdata; dirdata.Init (); dirdata.foName = foFolderName; dirdata.foParent = foParent; dirdata.numSubDirs = static_cast<unsigned long>(subDirectoryNames.size()); dirdata.numFiles = static_cast<unsigned long>(fileNames.size()); dirdata.capacity = static_cast<unsigned long>(vecfndboff.size()); AlignMem (AlignmentDirectory); FileNameDatabaseHeader::FndbOffset foThis = PushBack(&dirdata, offsetof(FileNameDatabaseDirectory, table)); if (vecfndboff.size() == 0) { return (foThis); } // reserve memory for offset table FileNameDatabaseHeader::FndbOffset foOffsetTable = ReserveMem(vecfndboff.size() * sizeof(FileNameDatabaseHeader::FndbOffset)); // recurse into sub-directories and remember offsets PathName pathFolder (lpszParentPath, lpszFolderName, 0); size_t i = 0; ++ currentLevel; for (it2 = subDirectoryNames.begin(); it2 != subDirectoryNames.end(); ++ it2, ++ i) { vecfndboff[dirdata.numFiles + dirdata.numSubDirs + i] // <recursivecall> = ProcessFolder(foThis, pathFolder.Get(), it2->c_str(), vecfndboff[dirdata.numFiles + i]); // </recursivecall> } -- currentLevel; // store offset table SetMem (foOffsetTable, &vecfndboff[0], vecfndboff.size() * sizeof(FileNameDatabaseHeader::FndbOffset)); return (foThis); }
nfsstat3 CNFS3Prog::ProcedureRENAME(void) { char pathFrom[MAXPATHLEN], *pathTo; wcc_data fromdir_wcc, todir_wcc; nfsstat3 stat; PrintLog("RENAME"); std::string dirFromName; std::string fileFromName; ReadDirectory(dirFromName, fileFromName); strcpy_s(pathFrom, GetFullPath(dirFromName, fileFromName)); std::string dirToName; std::string fileToName; ReadDirectory(dirToName, fileToName); pathTo = GetFullPath(dirToName, fileToName); stat = CheckFile((char*)dirFromName.c_str(), pathFrom); fromdir_wcc.before.attributes_follow = GetFileAttributesForNFS((char*)dirFromName.c_str(), &fromdir_wcc.before.attributes); todir_wcc.before.attributes_follow = GetFileAttributesForNFS((char*)dirToName.c_str(), &todir_wcc.before.attributes); if (FileExists(pathTo)) { DWORD fileAttr = GetFileAttributes(pathTo); if ((fileAttr & FILE_ATTRIBUTE_DIRECTORY) && (fileAttr & FILE_ATTRIBUTE_REPARSE_POINT)) { if (RemoveFolder(pathTo) == 0) { stat = NFS3ERR_IO; } } else { if (!RemoveFile(pathTo)) { stat = NFS3ERR_IO; } } } if (stat == NFS3_OK) { errno_t errorNumber = RenameDirectory(pathFrom, pathTo); if (errorNumber != 0) { char buffer[BUFFER_SIZE]; strerror_s(buffer, BUFFER_SIZE, errorNumber); PrintLog(buffer); if (errorNumber == 13) { stat = NFS3ERR_ACCES; } else { stat = NFS3ERR_IO; } } } fromdir_wcc.after.attributes_follow = GetFileAttributesForNFS((char*)dirFromName.c_str(), &fromdir_wcc.after.attributes); todir_wcc.after.attributes_follow = GetFileAttributesForNFS((char*)dirToName.c_str(), &todir_wcc.after.attributes); Write(&stat); Write(&fromdir_wcc); Write(&todir_wcc); return stat; }
void ReadDirectory(const char* szPath, LPSTORAGE pStg) { // recursive function USES_CONVERSION; WIN32_FIND_DATA fData; HANDLE h; char szNewPath[MAX_PATH]; char szStorageName[100]; char szStreamName[100]; char szData[81]; char* pch = NULL; LPSTORAGE pSubStg = NULL; LPSTREAM pStream = NULL; g_nIndent++; strcpy(szNewPath, szPath); strcat(szNewPath, "*.*"); h = ::FindFirstFile(szNewPath, &fData); if (h == (HANDLE) 0xFFFFFFFF) return; // can't find directory do { if (!strcmp(fData.cFileName, "..") || !strcmp(fData.cFileName, ".") ) continue; while((pch = strchr(fData.cFileName, '!')) != NULL) { *pch = '|'; } if (fData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // It's a directory, so make a storage strcpy(szNewPath, szPath); strcat(szNewPath,fData.cFileName); strcat(szNewPath, "\\"); strcpy(szStorageName, fData.cFileName); szStorageName[31] = '\0'; // limit imposed by OLE TRACE("%0.*sStorage = %s\n", (g_nIndent - 1) * 4, g_szBlanks, szStorageName); VERIFY(pStg->CreateStorage(T2COLE(szStorageName), STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pSubStg) == S_OK); ASSERT(pSubStg != NULL); ReadDirectory(szNewPath, pSubStg); pSubStg->Release(); } else { if ((pch = strrchr(fData.cFileName, '.')) != NULL) { if (!stricmp(pch, ".TXT")) { // It's a text file, so make a stream strcpy(szStreamName, fData.cFileName); strcpy(szNewPath, szPath); strcat(szNewPath, szStreamName); szStreamName[32] = '\0'; // OLE max length TRACE("%0.*sStream = %s\n", (g_nIndent - 1) * 4, g_szBlanks, szNewPath); CStdioFile file(szNewPath, CFile::modeRead); // Ignore zero-length files if(file.ReadString(szData, 80)) { TRACE("%s\n", szData); VERIFY(pStg->CreateStream(T2COLE(szStreamName), STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream) == S_OK); ASSERT(pStream != NULL); // Include the null terminator in the stream pStream->Write(szData, strlen(szData) + 1, NULL); pStream->Release(); } } } } } while (::FindNextFile(h, &fData)); g_nIndent--; }
ISOFileSystem::TreeEntry *ISOFileSystem::GetFromPath(const std::string &path, bool catchError) { const size_t pathLength = path.length(); if (pathLength == 0) { // Ah, the device! "umd0:" return &entireISO; } size_t pathIndex = 0; // Skip "./" if (pathLength > pathIndex + 1 && path[pathIndex] == '.' && path[pathIndex + 1] == '/') pathIndex += 2; // Skip "/" if (pathLength > pathIndex && path[pathIndex] == '/') ++pathIndex; if (pathLength <= pathIndex) return treeroot; TreeEntry *entry = treeroot; while (true) { if (!entry->valid) { ReadDirectory(entry); } TreeEntry *nextEntry = nullptr; std::string name = ""; if (pathLength > pathIndex) { size_t nextSlashIndex = path.find_first_of('/', pathIndex); if (nextSlashIndex == std::string::npos) nextSlashIndex = pathLength; const std::string firstPathComponent = path.substr(pathIndex, nextSlashIndex - pathIndex); for (size_t i = 0; i < entry->children.size(); i++) { const std::string &n = entry->children[i]->name; if (firstPathComponent == n) { //yay we got it nextEntry = entry->children[i]; name = n; break; } } } if (nextEntry) { entry = nextEntry; if (!entry->valid) ReadDirectory(entry); pathIndex += name.length(); if (pathIndex < pathLength && path[pathIndex] == '/') ++pathIndex; if (pathLength <= pathIndex) return entry; } else { if (catchError) ERROR_LOG(FILESYS,"File %s not found", path.c_str()); return 0; } } }