예제 #1
0
파일: MpkManip.cpp 프로젝트: lorichen/xgame
	bool MpkManip::extractDir(const char* source,const char* target,bool replaceExist,IMpkManipCallback *pCallback,void *p)
	{
		bool bOk = true;

		std::string strSource = source;
		if(!strSource.empty())
			strSource = strSource + "\\*"; 
		else
			strSource = "*";

		SFILE_FIND_DATA fileFindData;
		HANDLE hFind = SFileFindFirstFile(m_hMpk,strSource.c_str(),&fileFindData,0);
		if(hFind)
		{
			do
			{
				std::string targetFilename = std::string(target) + "\\" + fileFindData.cFileName;
				if(pCallback)
				{
					pCallback->onProcessFile(fileFindData.cFileName,p);
				}

				if(!extractFile(fileFindData.cFileName,targetFilename.c_str(),replaceExist))
				{
					bOk = false;
				}
			}
			while(SFileFindNextFile(hFind,&fileFindData));
			SFileFindClose(hFind);
		}

		return bOk;
	}
예제 #2
0
void extractFileEntry(GCMFileEntryStruct *e) {
	/*
	**  this gets called from recurseFileEntry()
	**  because of this,  we only need to create a directory if e is a directory
	*/
	
	if (!e) return;
	
	GCMFetchFilenameForFileEntry(gcmFile, e);
	
	//for building the path for where we're making dirs and extracting...
	char s[1024];
	char fp[256] = "";
	
	//now do the actual work...
	if (e->isDir) {
		GCMGetFullPathForFileEntry(gcmFile, e, fp);
	
		strcpy(s, extractRootPath);
		strcat(s, fp);
	
		lastDir = e;
		
		//printf("mkdir %s\n", s);
		
		if (e->index == 0) {
			//if it's the root directory, we're gonna create a directory to extract into named filename.FILES
			strcat(extractRootPath, "/");
			strcat(extractRootPath, filename);
			strcat(extractRootPath, ".FILES");
			
		//	printf("MAKING NEW DIR! %s\n", extractRootPath);
			
			mkdir(extractRootPath, S_IRWXU);
		} else {
			mkdir(s, S_IRWXU);
		}
		
	} else {
		GCMGetFullPathForFileEntry(gcmFile, lastDir, fp);
		strcpy(s, extractRootPath);
		strcat(s, fp);
		strcat(s, "/");
		strcat(s, e->filename);
		
		printf("extracting %s\n", s);
		
		extractFile(e, s);
	}
	//GCMFetchDataForFileEntry(gcmFile, e);
	//DOESN'T WORK!!!!!!!
	return;
}
예제 #3
0
bool BSA::extractAll(const std::string& outputDirName, uint32_t& extractedFileCount)
{
  extractedFileCount = 0;
  if (!hasAllStructureData())
  {
    std::cout << "BSA::extractAll: Error: not all structure data is present "
              << "to properly fulfill the requested operation!\n";
    return false;
  }

  //check for output directory
  if (!directoryExists(outputDirName))
  {
    if (!createDirectoryRecursive(outputDirName))
    {
      std::cout << "BSA::extractAll: Error: Could not create destination directory \""
                << outputDirName << "\".\n";
      return false;
    }
  }

  uint32_t i, j;
  for (i=0; i<m_FolderBlocks.size(); ++i)
  {
    //create output directory, if necessary
    if (!directoryExists(outputDirName+MWTP::pathDelimiter+m_FolderBlocks[i].folderName))
    {
      if (!createDirectoryRecursive(outputDirName+MWTP::pathDelimiter+m_FolderBlocks[i].folderName))
      {
        std::cout << "BSA::extractAll: Error: Could not create destination subdirectory \""
                  << outputDirName+MWTP::pathDelimiter+m_FolderBlocks[i].folderName << "\".\n";
        return false;
      }
    }
    //now extract each file in that directory
    for (j=0; j<m_FolderBlocks[i].files.size(); ++j)
    {
      if (!extractFile(i, j, outputDirName+MWTP::pathDelimiter+m_FolderBlocks[i].folderName
           +MWTP::pathDelimiter+m_FolderBlocks[i].files[j].fileName))
      {
        std::cout << "BSA::extractAll: Error: Could not extract file \""
                  <<m_FolderBlocks[i].folderName+MWTP::pathDelimiter
                    +m_FolderBlocks[i].files[j].fileName<< "\".\n";
        return false;
      }//if
      ++extractedFileCount;
    }//for j
  }//for i

  return true;
}
예제 #4
0
파일: unadf.c 프로젝트: NF6X/ADFlib
void extractTree(struct Volume *vol, struct List* tree, char *path, unsigned char *extbuf,
    BOOL pflag, BOOL qflag)
{
	struct Entry* entry;
    char *buf;
    char sysbuf[200];

    while(tree) {
        entry = (struct Entry*)tree->content;
        if (entry->type==ST_DIR) {
            buf = NULL;
            if (strlen(path)>0) {
                buf=(char*)malloc(strlen(path)+1+strlen(entry->name)+1);
                if (!buf) return;
                sprintf(buf,"%s%c%s",path,DIRSEP,entry->name);
                sprintf(sysbuf,"%s %s",MKDIR,buf);
                if (!qflag) printf("x - %s%c\n",buf,DIRSEP);
            }
            else {
                sprintf(sysbuf,"%s %s",MKDIR,entry->name);
                if (!qflag) printf("x - %s%c\n",entry->name,DIRSEP);
            }

            if (!pflag) system(sysbuf);

	        if (tree->subdir!=NULL) {
                if (adfChangeDir(vol,entry->name)==RC_OK) {
                    if (buf!=NULL)
                        extractTree(vol,tree->subdir,buf,extbuf, pflag, qflag);
                    else
                        extractTree(vol,tree->subdir,entry->name,extbuf, pflag, qflag);
                    adfParentDir(vol);
                }
                else {
                    if (strlen(path)>0)
                        fprintf(stderr,"ExtractTree : dir \"%s/%s\" not found.\n",path,entry->name);
                    else
                        fprintf(stderr,"ExtractTree : dir \"%s\" not found.\n",entry->name);
                }
            }

            if (buf!=NULL)
                free(buf);
        }
        else if (entry->type==ST_FILE) {
            extractFile(vol,entry->name,path,extbuf, pflag, qflag);
        }
        tree = tree->next;
    }
}
예제 #5
0
bool BSA::extractFile(const std::string& inArchiveFileName, const std::string& outputFileName)
{
  if (!hasAllStructureData())
  {
    std::cout << "BSA::extractFile: Error: not all structure data is present "
              << "to properly fulfill the requested operation!\n";
    return false;
  }

  uint32_t folderIndex, fileIndex;
  getIndexPairForFile(inArchiveFileName, folderIndex, fileIndex);

  //use the above function for the rest
  return extractFile(folderIndex, fileIndex, outputFileName);
}
예제 #6
0
string BSAFile::extract(const string& path)
{
	string dir, file;
	auto pos = path.find_last_of("/\\");
	if (pos != string::npos)
	{
		dir = path.substr(0, pos);
		file = path.substr(pos + 1);
	}
	else
		file = path;

	auto dirHash = pathHash(dir);
	auto fileHash = pathHash(file);

	return extractFile(dirHash, fileHash);
}
예제 #7
0
bool BSA::extractFolder(const uint32_t folderIndex, const std::string& outputDirName, uint32_t& extractedFileCount)
{
  extractedFileCount = 0;
  if (!hasAllStructureData())
  {
    std::cout << "BSA::extractFolder: Error: not all structure data is present "
              << "to properly fulfill the requested operation!\n";
    return false;
  }

  if ((folderIndex==cIndexNotFound) or (folderIndex>=m_FolderBlocks.size()))
  {
    std::cout << "BSA::extractFolder: Error: invalid folder index!\n";
    return false;
  }

  //check for output directory
  if (!directoryExists(outputDirName))
  {
    if (!createDirectoryRecursive(outputDirName))
    {
      std::cout << "BSA::extractFolder: Error: Could not create destination directory \""
                << outputDirName << "\".\n";
      return false;
    }
  }

  uint32_t file_index;
  //now extract each file in that directory
  for (file_index=0; file_index<m_FolderBlocks[folderIndex].files.size(); ++file_index)
  {
    if (!extractFile(folderIndex, file_index, outputDirName+MWTP::pathDelimiter
         +m_FolderBlocks[folderIndex].files[file_index].fileName))
    {
      std::cout << "BSA::extractFolder: Error: Could not extract file \""
                << m_FolderBlocks[folderIndex].folderName+MWTP::pathDelimiter
                  +m_FolderBlocks[folderIndex].files[file_index].fileName<< "\".\n";
      return false;
    }//if
    ++extractedFileCount;
  }//for file_index

  return true;
}
예제 #8
0
파일: pkg2rpkg.cpp 프로젝트: 4auka/OpenSR
int pkg2rpkg(const std::string& inputFile, const std::string& outputFile, Rangers::RPKGCompression compression)
{
    ifstream pkgfile(inputFile.c_str(), ios::binary | ios::in);
    std::map<RPKGEntry*, PKGItem*> itemMap;
    PKGItem *root = loadPKG(pkgfile);
    if (root->childCount != 1)
    {
        std::cout << "Incorrect input file" << endl;
        return -1;
    }
    countFiles(L"", root, itemMap);

    //FIXME: OH SHI~
    std::vector<RPKGEntry> files;
    std::vector<PKGItem> pkgfiles;
    for (std::map<RPKGEntry*, PKGItem*>::iterator i = itemMap.begin(); i != itemMap.end(); i++)
    {
        files.push_back(*(i->first));
        pkgfiles.push_back(*(i->second));
    }

    int c = itemMap.size();

    uint32_t headerSize = calculateRPKGHeaderSize(files);
    ofstream outfile(outputFile.c_str(), ios::binary | ios::out);
    //FIXME: Better way to fill file
    for (int i = 0; i < headerSize + 8; i++)
        outfile.put(0);

    for (int i = 0; i < files.size(); i++)
    {
        wcout << files[i].name << endl;
        unsigned char *data = extractFile(pkgfiles[i], pkgfile);
        appendRPKGFile(outfile, files[i], (const char*)data, pkgfiles[i].size, compression);
        delete data;
    }
    outfile.seekp(0, ios_base::beg);
    writeRPKGHeader(outfile, files);

    cleanup(root);
    delete root;
    outfile.close();
    pkgfile.close();
}
void KTNEFMain::contextMenuEvent( QContextMenuEvent *event )
{
  QList<KTNEFAttach *> list = mView->getSelection();
  if ( !list.count() ) {
    return;
  }

  QAction *view = 0;
  QAction *viewWith = 0;
  QAction *prop = 0;
  KMenu *menu = new KMenu();
  if ( list.count() == 1 ) {
    view = menu->addAction( KIcon( "document-open" ),
                            i18nc( "@action:inmenu", "View" ) );
    viewWith = menu->addAction( i18nc( "@action:inmenu", "View With..." ) );
    menu->addSeparator();
  }
  QAction *extract = menu->addAction( i18nc( "@action:inmenu", "Extract" ) );
  QAction *extractTo = menu->addAction( KIcon( "archive-extract" ),
                                        i18nc( "@action:inmenu", "Extract To..." ) );
  if ( list.count() == 1 ) {
    menu->addSeparator();
   prop = menu->addAction( KIcon( "document-properties" ),
                           i18nc( "@action:inmenu", "Properties" ) );
  }

  QAction *a = menu->exec( event->globalPos(), 0 );
  if ( a ) {
    if ( a == view ) {
      viewFile();
    } else if ( a == viewWith ) {
      viewFileAs();
    } else if ( a == extract ) {
      extractFile();
    } else if ( a == extractTo ) {
      extractFileTo();
    } else if ( a == prop ) {
      propertiesFile();
    }
  }
  delete menu;
}
예제 #10
0
  std::vector<openstudio::path> UnzipFile::extractAllFiles(const openstudio::path &outputPath) const
  {
    std::vector<openstudio::path> files = listFiles();

    std::vector<openstudio::path> retfiles;

    for (std::vector<openstudio::path>::const_iterator itr = files.begin();
         itr != files.end();
         ++itr)
    {
      if (toString(itr->filename())=="." || toString(itr->filename())=="/")
      {
        // This is a directory - skip it
      } else {
        retfiles.push_back(extractFile(*itr, outputPath));
      }
    }

    return retfiles;
  }
bool MROMInstaller::extractTarball(const std::string& base, const std::string& name, const std::string& tarball)
{
	gui_print("Extrating tarball %s...\n", tarball.c_str());

	system("rm /tmp/tarballs/rom.tar.gz");
	if(!extractFile(tarball, "/tmp/tarballs/rom.tar.gz"))
		return false;

	bool res = true;

	char cmd[256];
	sprintf(cmd, "gnutar --numeric-owner --overwrite -C \"%s\" -xf /tmp/tarballs/rom.tar.gz", (base + "/" + name).c_str());
	if(system(cmd) != 0)
	{
		gui_print("Failed to extract tarball %s for folder %s!\n", tarball.c_str(), name.c_str());
		res = false;
	}

	system("rm /tmp/tarballs/rom.tar.gz");
	return res;
}
예제 #12
0
int main(int argc, char **argv) {
    const char *filename = "test3.xml";
    const char *pattern = "preserved";
    xmlDocPtr doc;

    if (argc == 3) {
        filename = argv[1];
	pattern = argv[2];
    }

    /*
     * this initialize the library and check potential ABI mismatches
     * between the version it was compiled for and the actual shared
     * library used.
     */
    LIBXML_TEST_VERSION

    doc = extractFile(filename, (const xmlChar *) pattern);
    if (doc != NULL) {
        /*
	 * ouptut the result.
	 */
        xmlDocDump(stdout, doc);
	/*
	 * don't forget to free up the doc
	 */
	xmlFreeDoc(doc);
    }


    /*
     * Cleanup function for the XML library.
     */
    xmlCleanupParser();
    /*
     * this is to debug memory for regression tests
     */
    xmlMemoryDump();
    return(0);
}
예제 #13
0
size_t ZipArchive::extractFilesToDirectory(const std::string& dirName,
                                           const bool replaceExistingFiles)
{
    std::string currentDir = FileSystem::currentDirectory();
    if (FileSystem::changeDirectory(dirName) == false) {
        LERROR("extractFilesToDirectory(): failed to locate target directory '" << dirName << "'!");
        return 0;
    }

    LINFO("extracting following files to directory '" << dirName << "'...");
    size_t counter = 0;
    for (ArchiveMap::const_iterator it = files_.begin(); it != files_.end(); ++it) {
        File* xFile = extractFile(it->second.fileName_, TARGET_DISK, "", true, replaceExistingFiles);
        if (xFile != 0) {
            xFile->close();
            delete xFile;
            ++counter;
        }
    }

    FileSystem::changeDirectory(currentDir);
    return counter;
}
예제 #14
0
bool FindSubtitlesWindow::uncompressZip(const QString & filename, const QString & output_path, const QString & preferred_output_name) {
	qDebug("FindSubtitlesWindow::uncompressZip: zip file '%s', output_path '%s', save subtitle as '%s'", 
           filename.toUtf8().constData(), output_path.toUtf8().constData(),
           preferred_output_name.toUtf8().constData());

	QuaZip zip(filename);

	if (!zip.open(QuaZip::mdUnzip)) {
	    qWarning("FindSubtitlesWindow::uncompressZip: open zip failed: %d", zip.getZipError());
	    return false;
	}

	zip.setFileNameCodec("IBM866");
	qDebug("FindSubtitlesWindow::uncompressZip: %d entries", zip.getEntriesCount());
	qDebug("FindSubtitlesWindow::uncompressZip: global comment: '%s'", zip.getComment().toUtf8().constData());

	QStringList sub_files;
	QuaZipFileInfo info;

	for (bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) {
		if (!zip.getCurrentFileInfo(&info)) {
			qWarning("FindSubtitlesWindow::uncompressZip: getCurrentFileInfo(): %d\n", zip.getZipError());
			return false;
		}
	    qDebug("FindSubtitlesWindow::uncompressZip: file '%s'", info.name.toUtf8().constData());
		if (QFileInfo(info.name).suffix() != "nfo") sub_files.append(info.name);
	}

	qDebug("FindSubtitlesWindow::uncompressZip: list of subtitle files:");
	for (int n=0; n < sub_files.count(); n++) {
		qDebug("FindSubtitlesWindow::uncompressZip: subtitle file %d '%s'", n, sub_files[n].toUtf8().constData());
	}

	if (sub_files.count() == 1) {
		// If only one file, just extract it
		QString output_name = output_path +"/"+ preferred_output_name;
		if (extractFile(zip, sub_files[0], output_name )) {
			status->setText(tr("Subtitle saved as %1").arg(preferred_output_name));
			emit subtitleDownloaded(output_name);
		} else {
			return false;
		}
	} else {
		// More than one file
		SubChooserDialog d(this);

		for (int n=0; n < sub_files.count(); n++) {
			d.addFile(sub_files[n]);
		}

		if (d.exec() == QDialog::Rejected) return false;

		QStringList files_to_extract = d.selectedFiles();
		int extracted_count = 0;
		for (int n=0; n < files_to_extract.count(); n++) {
			QString file = files_to_extract[n];
			bool ok = extractFile(zip, file, output_path +"/"+ file);
			qDebug("FindSubtitlesWindow::uncompressZip: extracted %s ok: %d", file.toUtf8().constData(), ok);
			if (ok) extracted_count++;
		}
		status->setText(tr("%1 subtitle(s) extracted","", extracted_count).arg(extracted_count));
		if (extracted_count > 0) {
			emit subtitleDownloaded( output_path +"/"+ files_to_extract[0] );
		}
	}

	zip.close();
	return true;
}
예제 #15
0
static void * mozload(const char * path, void *zip,
                      struct cdir_entry *cdir_start, uint16_t cdir_entries)
{
#ifdef DEBUG
  struct timeval t0, t1;
  gettimeofday(&t0, 0);
#endif

  struct cdir_entry *entry = find_cdir_entry(cdir_start, cdir_entries, path);
  struct local_file_header *file = (struct local_file_header *)((char *)zip + letoh32(entry->offset));
  void * data = ((char *)&file->data) + letoh16(file->filename_size) + letoh16(file->extra_field_size);
  void * handle;

  if (extractLibs) {
    char fullpath[PATH_MAX];
    snprintf(fullpath, PATH_MAX, "%s/%s", getenv("CACHE_PATH"), path);
    __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "resolved %s to %s", path, fullpath);
    extractFile(fullpath, entry, data);
    handle = __wrap_dlopen(fullpath, RTLD_LAZY);
    if (!handle)
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't load %s because %s", fullpath, __wrap_dlerror());
#ifdef DEBUG
    gettimeofday(&t1, 0);
    __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "%s: spent %d", path,
                        (((long long)t1.tv_sec * 1000000LL) +
                          (long long)t1.tv_usec) -
                        (((long long)t0.tv_sec * 1000000LL) +
                          (long long)t0.tv_usec));
#endif
    return handle;
  }

  size_t offset = letoh32(entry->offset) + sizeof(*file) + letoh16(file->filename_size) + letoh16(file->extra_field_size);
  bool skipLibCache = false;
  int fd = zip_fd;
  void * buf = NULL;
  uint32_t lib_size = letoh32(entry->uncompressed_size);
  int cache_fd = 0;
  if (letoh16(file->compression) == DEFLATE) {
    cache_fd = lookupLibCacheFd(path);
    fd = cache_fd;
    if (fd < 0)
      fd = createAshmem(lib_size, path);
#ifdef DEBUG
    else
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Loading %s from cache", path);
#endif
    if (fd < 0) {
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't open " ASHMEM_NAME_DEF ", Error %d, %s, bailing out", errno, strerror(errno));
      return NULL;
    }
    buf = mmap(NULL, lib_size,
               PROT_READ | PROT_WRITE,
               MAP_SHARED, fd, 0);
    if (buf == (void *)-1) {
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't mmap decompression buffer");
      close(fd);
      return NULL;
    }

    offset = 0;

    if (cache_fd < 0) {
      extractLib(entry, data, buf);
#ifdef ANDROID_ARM_LINKER
      /* We just extracted data that is going to be executed in the future.
       * We thus need to ensure Instruction and Data cache coherency. */
      cacheflush((unsigned) buf, (unsigned) buf + entry->uncompressed_size, 0);
#endif
      addLibCacheFd(path, fd, lib_size, buf);
    }

    // preload libxul, to avoid slowly demand-paging it
    if (!strcmp(path, "libxul.so"))
      madvise(buf, entry->uncompressed_size, MADV_WILLNEED);
    data = buf;
  }

#ifdef DEBUG
  __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Loading %s with len %d (0x%08x) and offset %d (0x%08x)", path, lib_size, lib_size, offset, offset);
#endif

  handle = moz_mapped_dlopen(path, RTLD_LAZY, fd, data,
                             lib_size, offset);
  if (!handle)
    __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't load %s because %s", path, __wrap_dlerror());

  if (buf)
    munmap(buf, lib_size);

#ifdef DEBUG
  gettimeofday(&t1, 0);
  __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "%s: spent %d", path, (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
               (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec));
#endif

  return handle;
}
예제 #16
0
int 
main(int argc ,char **argv)
{
	char *filename ="p";
	int i = 0;

	if (argc < 2) {
		fprintf (stderr,"Usage: %s [-v] [-l] [-e file] _filename_\nWhere: -l: list files in update payload\n       -e _file: extract file from update payload (use \"*\" for all files)\n", argv[0]);
		exit(10);
		}
	
	for (i = 1;
	     i < argc -1;
	     i++)
	    {
		// This is super quick/dirty. You might want to rewrite with getopt, etc..
		if (strcmp (argv[i], "-l") == 0) { g_list++;} 
		if (strcmp (argv[i] , "-v") == 0) { g_verbose++;}
		if (strcmp (argv[i], "-e") == 0) { g_extract = argv[i+1]; i++;}

	    }
	
	filename =argv[argc-1];
	//unsigned char buf[4096];

	int fd = open (filename, O_RDONLY);
	if (fd < 0) { perror (filename); exit(1);}


#if 0
 	// Don't need this anymore :-)

	// Cheat - actually use 0x00 0x50 0x81 0xb4 as an anchor
	
	read (fd, buf, 4096);
	for (i = 0 ; i < 4096; i++)
	{
		if ((buf[i] == 0x00) && (buf[i+1] == 0x50) && (buf[i + 2] == 0x81) && (buf[i+3] == 0xb4))
		{
			printf("Got anchor\n");
			lseek(fd, i-26, SEEK_SET);
			break;

			
		}

	}
	if (i == 4096) { fprintf (stderr, "Unable to find anchor\n"); exit(5);}
	// Otherwise, we can start reading entries from here:

#endif
	
	i = 0;
	int bytes_read = 1;

	struct entry *ent = alloca (sizeof(struct entry));
	while(bytes_read ){
	bytes_read = read(fd, (void *) ent, sizeof(struct entry));
	if (bytes_read <= 0) { // fprintf (stderr, "Error reading next entry or EOF (this could be OK if it's the last entry, @TODO implement == 0 or fstat on filesize..)\n"); 
			exit(1);}
	i+= bytes_read;

	uint32_t	size = swap32(ent->fileSize);

	// Get Name (immediately after the entry)
	char *name = alloca(ntohs(ent->nameLen) + 1);
	bytes_read = read (fd , (void *) name, ntohs(ent->nameLen));
	if (bytes_read <= 0) { fprintf (stderr, "Error reading Name. This is not ok\n"); exit(2);}

	i+= bytes_read;
	name[ntohs(ent->nameLen)] = '\0';
	if (g_list){ 
	if (g_verbose) {
	printf ("Entry @0x%d: UID: %d GID: %d Size: %d (0x%x) Namelen: %d Name: ", i,
							ntohs(ent->uid), ntohs(ent->gid),
						     size, size,
						      ntohs(ent->nameLen));
	}
	printf ("%s\n", name);}



	// Get size (immediately after the name)
	uint32_t	fileSize = swap32(ent->fileSize);
	if (fileSize) 
		{
			char *file = malloc (fileSize);
			bytes_read = read (fd, (void *) file, fileSize);
			// Zero length file sizes are apparently ok..
			if (bytes_read <= 0) { fprintf (stderr, "Error reading file. This is not ok \n"); exit(3);}
			i+= bytes_read;
			if (g_extract) { extractFile(file, name, fileSize, g_extract);}
			free(file);
		}




	} // Back to loop


	

	close(fd);

}
예제 #17
0
static void * mozload(const char * path, void *zip,
                      struct cdir_entry *cdir_start, uint16_t cdir_entries)
{
#ifdef DEBUG
  struct timeval t0, t1;
  gettimeofday(&t0, 0);
#endif

  struct cdir_entry *entry = find_cdir_entry(cdir_start, cdir_entries, path);
  struct local_file_header *file = (struct local_file_header *)((char *)zip + letoh32(entry->offset));
  void * data = ((char *)&file->data) + letoh16(file->filename_size) + letoh16(file->extra_field_size);
  void * handle;

  if (extractLibs) {
    char fullpath[PATH_MAX];
    snprintf(fullpath, PATH_MAX, "%s/%s", getenv("CACHE_PATH"), path);
    __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "resolved %s to %s", path, fullpath);
    extractFile(fullpath, entry, data);
    handle = __wrap_dlopen(fullpath, RTLD_LAZY);
    if (!handle)
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't load %s because %s", fullpath, __wrap_dlerror());
#ifdef DEBUG
    gettimeofday(&t1, 0);
    __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "%s: spent %d", path,
                        (((long long)t1.tv_sec * 1000000LL) +
                          (long long)t1.tv_usec) -
                        (((long long)t0.tv_sec * 1000000LL) +
                          (long long)t0.tv_usec));
#endif
    return handle;
  }

  size_t offset = letoh32(entry->offset) + sizeof(*file) + letoh16(file->filename_size) + letoh16(file->extra_field_size);
  bool skipLibCache = false;
  int fd = zip_fd;
  void * buf = NULL;
  uint32_t lib_size = letoh32(entry->uncompressed_size);
  int cache_fd = 0;
  if (letoh16(file->compression) == DEFLATE) {
    cache_fd = lookupLibCacheFd(path);
    fd = cache_fd;
    if (fd < 0) {
      char fullpath[PATH_MAX];
      snprintf(fullpath, PATH_MAX, "%s/%s", getenv("CACHE_PATH"), path);
      fd = open(fullpath, O_RDWR);
      struct stat status;
      if (stat(fullpath, &status) ||
          status.st_size != lib_size ||
          apk_mtime > status.st_mtime) {
        unlink(fullpath);
        fd = -1;
      } else {
        cache_fd = fd;
        addLibCacheFd(path, fd);
      }
    }
    if (fd < 0)
      fd = createAshmem(lib_size, path);
#ifdef DEBUG
    else
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Loading %s from cache", path);
#endif
    if (fd < 0) {
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't open " ASHMEM_NAME_DEF ", Error %d, %s, using a file", errno, strerror(errno));
      char fullpath[PATH_MAX];
      snprintf(fullpath, PATH_MAX, "%s/%s", getenv("CACHE_PATH"), path);
      fd = open(fullpath, O_RDWR | O_CREAT);
      if (fd < 0) {
        __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't create a file either, giving up");
        return NULL;
      }
      // we'd like to use fallocate here, but it doesn't exist currently?
      if (lseek(fd, lib_size - 1, SEEK_SET) == (off_t) - 1) {
         __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "seeking file failed");
        close(fd);
        return NULL;
      }
      if (write(fd, "", 1) != 1) {
        __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "writting one byte to the file failed");
        close(fd);
        return NULL;
      }
      skipLibCache = true;
      addLibCacheFd(path, fd);
    }
    buf = mmap(NULL, lib_size,
               PROT_READ | PROT_WRITE,
               MAP_SHARED, fd, 0);
    if (buf == (void *)-1) {
      __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't mmap decompression buffer");
      close(fd);
      return NULL;
    }

    offset = 0;

    if (cache_fd < 0) {
      extractLib(entry, data, buf);
#ifdef ANDROID_ARM_LINKER
      /* We just extracted data that is going to be executed in the future.
       * We thus need to ensure Instruction and Data cache coherency. */
      cacheflush((unsigned) buf, (unsigned) buf + entry->uncompressed_size, 0);
#endif
      if (!skipLibCache)
        addLibCacheFd(path, fd, lib_size, buf);
    }

    // preload libxul, to avoid slowly demand-paging it
    if (!strcmp(path, "libxul.so"))
      madvise(buf, entry->uncompressed_size, MADV_WILLNEED);
    data = buf;
  }

#ifdef DEBUG
  __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Loading %s with len %d (0x%08x) and offset %d (0x%08x)", path, lib_size, lib_size, offset, offset);
#endif

  handle = moz_mapped_dlopen(path, RTLD_LAZY, fd, data,
                             lib_size, offset);
  if (!handle)
    __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't load %s because %s", path, __wrap_dlerror());

  // if we're extracting the libs to disk and cache_fd is not valid then 
  // keep this buffer around so it can be used to write to disk
  if (buf && (!extractLibs || cache_fd >= 0))
    munmap(buf, lib_size);

#ifdef DEBUG
  gettimeofday(&t1, 0);
  __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "%s: spent %d", path, (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
               (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec));
#endif

  return handle;
}
예제 #18
0
파일: far.c 프로젝트: ASchurman/Far
FAR_RTRN farExtract(char* archiveName,
                    char** fileArgs,
                    unsigned char numFileArgs)
{
    FILE* archive; // the archive from which we are extracting
    unsigned int numFiles; // the number of files in archive
    
    charBuffer* filename; // the name of a file read from archive
    unsigned int fileSize; // the size of a file read from archive
    
    char** slashedFileArgs = NULL; /* holds the strings of fileArgs with a '/'
                                    * added to the end if it's not already
                                    * there. Used to compare directory paths */
    
    unsigned int* usedArgs = NULL; /* holds the indicies of entries in fileArgs
                                    * and slashedFileArgs that caused
                                    * extractions */
    unsigned int numUsedArgs = 0; // the number of elements in usedArgs
    
    archive = fopen(archiveName, "rb");
    if(!archive)
    {
        return invalidArchiveNameError();
    }
    else if(fread(&numFiles, sizeof(unsigned int), 1, archive) < 1)
    {
        fclose(archive);
        return corruptedArchiveError();
    }
    
    if(numFileArgs > 0)
    {
        // initialize slashedFileArgs
        slashedFileArgs = malloc(sizeof(char*) * numFileArgs);
        for(unsigned int i = 0; i < numFileArgs; i++)
        {
            slashedFileArgs[i] = ensureSingleSlash(fileArgs[i]);
        }
    }
    
    filename = charBufferNew();
    
    // move through archive, extracting all files that should be extracted
    for(unsigned int i = 0; i < numFiles; i++)
    {
        // get filename and fileSize
        if(getFileName(archive, filename) ||
           fread(&fileSize, sizeof(unsigned int), 1, archive) < 1)
        {
            // failure
            fclose(archive);
            charBufferDelete(filename);
            if(slashedFileArgs) charArrayDelete(slashedFileArgs, numFileArgs);
            return corruptedArchiveError();
        }
        
        // extract all files if we weren't passed any fileArgs
        if(numFileArgs == 0)
        {
            if(extractFile(archive, filename->str, fileSize) < 0)
            {
                // corrupted archive
                fclose(archive);
                charBufferDelete(filename);
                if(slashedFileArgs) charArrayDelete(slashedFileArgs,
                                                    numFileArgs);
                return corruptedArchiveError();
            }
            continue;
        }
        
        // compare filename to the arguments passed to 'x'
        int exactMatchIndex = isDuplicateFile(filename->str,
                                              fileArgs,
                                              numFileArgs);
        int directoryMatchIndex = isDirectoryMatch(filename->str,
                                                   slashedFileArgs,
                                                   numFileArgs);
        
        // remember which file argument caused this extraction, if one is
        // to occur
        if(exactMatchIndex >= 0)
        {
            usedArgs = uintArrayAdd(usedArgs, numUsedArgs, exactMatchIndex);
            numUsedArgs++;
        }
        else if(directoryMatchIndex >= 0)
        {
            usedArgs = uintArrayAdd(usedArgs, numUsedArgs, directoryMatchIndex);
            numUsedArgs++;
        }
        
        if(exactMatchIndex >= 0 || directoryMatchIndex >= 0)
        {
            if(extractFile(archive, filename->str, fileSize) < 0)
            {
                // corrupted archive
                fclose(archive);
                charBufferDelete(filename);
                if(slashedFileArgs) charArrayDelete(slashedFileArgs,
                                                    numFileArgs);
                return corruptedArchiveError();
            }
        }
        else
        {
            // move past file body without extracting
            for(unsigned int j = 0; j < fileSize; j++)
            {
                int c = fgetc(archive);
                if(c == EOF)
                {
                    // unexpected EOF; corrupted archive
                    fclose(archive);
                    charBufferDelete(filename);
                    if(slashedFileArgs) charArrayDelete(slashedFileArgs,
                                                        numFileArgs);
                    return corruptedArchiveError();
                }
            }
        }
    }
    
    // print messages to stderr about unused filename arguments
    printUnusedArgs(fileArgs, numFileArgs, usedArgs, numUsedArgs);
    
    // clean-up
    fclose(archive);
    charBufferDelete(filename);
    if(slashedFileArgs) charArrayDelete(slashedFileArgs, numFileArgs);
    return SUCCESS;
}
예제 #19
0
파일: ota_orig.c 프로젝트: pause/chemo
int 
main(int argc ,char **argv)
{

  printf("sizeof(struct entry) = %li\n", sizeof(struct entry));
	signal (2, showPos);
	char *filename ="p";
	int i = 0;

	if (argc < 2) {
		fprintf (stderr,"Usage: %s [-v] [-l] [-e file] _filename_\nWhere: -l: list files in update payload\n       -e _file: extract file from update payload (use \"*\" for all files)\n", argv[0]);
		exit(10);
		}
	
	for (i = 1;
	     i < argc -1;
	     i++)
	    {
		// This is super quick/dirty. You might want to rewrite with getopt, etc..
		if (strcmp (argv[i], "-l") == 0) { g_list++;} 
		if (strcmp (argv[i] , "-v") == 0) { g_verbose++;}
		if (strcmp (argv[i], "-e") == 0) { g_extract = argv[i+1]; i++;}

	    }
	
	filename =argv[argc-1];
	//unsigned char buf[4096];

	int fd = open (filename, O_RDONLY);
	if (fd < 0) { perror (filename); exit(1);}

	// 02/17/2016 - mmap
	
	struct stat stbuf;
	int rc = fstat(fd, &stbuf);

	char *mmapped =  mmap(NULL, // void *addr,
			      stbuf.st_size ,	// size_t len, 
			      PROT_READ,        // int prot,
			      MAP_PRIVATE,                //  int flags,
			      fd,               // int fd, 
			      0);               // off_t offset);


	if (mmapped == MAP_FAILED)  { perror ("mmap"); exit(1);}
	i = 0;

	struct entry *ent = alloca (sizeof(struct entry));

	while(pos + 3*sizeof(struct entry) < stbuf.st_size) {
	
	ent = (struct entry *) (mmapped + pos );
	
	pos += sizeof(struct entry);

	if ((ent->usually_0x210_or_0x110 != 0x210 && ent->usually_0x210_or_0x110 != 0x110 &&
		ent->usually_0x210_or_0x110 != 0x310) || 
		ent->usually_0x00_00)
	{
		fprintf (stderr,"Corrupt entry (0x%x at pos %llu).. skipping\n", ent->usually_0x210_or_0x110,pos);
		int skipping = 1;

		while (skipping)
		{
		   ent = (struct entry *) (mmapped + pos ) ;
		   while (ent->usually_0x210_or_0x110 != 0x210 && ent->usually_0x210_or_0x110 != 0x110)
		   {
		     // #@$#$%$# POS ISN'T ALIGNED!
		     pos ++;
		    ent = (struct entry *) (mmapped + pos ) ;
		   }
		   // read rest of entry
		    int nl = ntohs(ent->nameLen);

		    if (ent->usually_0x00_00 || !nl) {
		//	 fprintf(stderr,"False positive.. skipping %d\n",pos);
			pos+=1;
			

			}
		    else { skipping =0;
			   pos += sizeof(struct entry); }
	 	}

	}

	uint32_t	size = swap32(ent->fileSize);

// fprintf(stdout," Here - ENT at pos %d: %x and 0 marker is %x namelen: %d, fileSize: %d\n", pos, ent->usually_0x210_or_0x110, ent->usually_0x00_00, ntohs(ent->nameLen), size);

	uint32_t	nameLen = ntohs(ent->nameLen);
	// Get Name (immediately after the entry)
	//
	// 02/08/2016: Fixed this from alloca() - the Apple jumbo OTAs have so many files in them (THANKS GUYS!!)
	// that this would exceed the stack limits (could solve with ulimit -s, or also by using
	// a max buf size and reusing same buf, which would be a lot nicer)

	
	// Note to AAPL: Life would have been a lot nicer if the name would have been NULL terminated..
	// What's another byte per every file in a huge file such as this?
	// char *name = (char *) (mmapped+pos);

	char *name = malloc (nameLen+1);

	strncpy(name, mmapped+pos , nameLen);
	name[nameLen] = '\0';
	//printf("NAME IS %s\n", name);

	pos += ntohs(ent->nameLen);
	if (g_list){ 
	if (g_verbose) {
	printf ("Entry @0x%d: UID: %d GID: %d Size: %d (0x%x) Namelen: %d Name: ", i,
							ntohs(ent->uid), ntohs(ent->gid),
						     size, size,
						      ntohs(ent->nameLen));
	}
	printf ("%s\n", name);}

	// Get size (immediately after the name)
	uint32_t	fileSize = swap32(ent->fileSize);
	if (fileSize) 
		{
			if (g_extract) { extractFile(mmapped +pos, name, fileSize, g_extract);}
			pos +=fileSize;
		}



	
	free (name);

	} // Back to loop


	

	close(fd);

}
예제 #20
0
파일: 3dstool.cpp 프로젝트: ajd4096/3dstool
int C3dsTool::Action()
{
	if (m_eAction == kActionExtract)
	{
		if (!extractFile())
		{
			printf("ERROR: extract file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionCreate)
	{
		if (!createFile())
		{
			printf("ERROR: create file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionEncrypt)
	{
		if (!encryptFile())
		{
			printf("ERROR: encrypt file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionUncompress)
	{
		if (!uncompressFile())
		{
			printf("ERROR: uncompress file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionCompress)
	{
		if (!compressFile())
		{
			printf("ERROR: compress file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionTrim)
	{
		if (!trimFile())
		{
			printf("ERROR: trim file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionPad)
	{
		if (!padFile())
		{
			printf("ERROR: pad file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionDiff)
	{
		if (!diffFile())
		{
			printf("ERROR: create patch file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionPatch)
	{
		if (!patchFile())
		{
			printf("ERROR: apply patch file failed\n\n");
			return 1;
		}
	}
	if (m_eAction == kActionSample)
	{
		return sample();
	}
	if (m_eAction == kActionHelp)
	{
		return Help();
	}
	return 0;
}
예제 #21
0
void PackageDialog::extractPackage()
{
  QString s = QFileDialog::getOpenFileName(
     lastDir.isEmpty() ? QString(".") : lastDir,
     tr("Qucs Packages")+" (*.qucs);;"+
     tr("Any File")+" (*)",
     this, 0, tr("Enter a Package File Name"));

  if(s.isEmpty()) {
    reject();
    return;
  }

  QFileInfo Info(s);
  lastDir = Info.dirPath(true);  // remember last directory

  QFile PkgFile(s);
  if(!PkgFile.open(QIODevice::ReadOnly)) {
    if(Info.extension().isEmpty()) s += ".qucs";
    PkgFile.setName(s);
    if(!PkgFile.open(QIODevice::ReadOnly)) {
      MsgText->append(tr("ERROR: Cannot open package!"));
      ButtClose->setDisabled(false);
      return;
    }
  }
  QDataStream Stream(&PkgFile);

  QDir currDir = QucsSettings.QucsHomeDir;
  QString Version;
  Q_UINT16 Checksum;
  Q_UINT32 Code, Length;

  // First read and check header.
  QByteArray Content = PkgFile.readAll();
  if(strncmp(Content.data(), "Qucs package ", 13) != 0) {
    MsgText->append(tr("ERROR: File contains wrong header!"));
    goto ErrorEnd;
  }

  Version = QString(Content.data()+13);
  if(!checkVersion(Version)) {
    MsgText->append(tr("ERROR: Wrong version number!"));
    goto ErrorEnd;
  }

  // checksum correct ?
  PkgFile.at(HEADER_LENGTH-2);
  Stream >> Checksum;
  *((Q_UINT16*)(Content.data()+HEADER_LENGTH-2)) = 0;
  if(Checksum != qChecksum(Content.data(), Content.size())) {
    MsgText->append(tr("ERROR: Checksum mismatch!"));
    goto ErrorEnd;
  }
  Content.resize(0);   // dispose memory


  // work on all files and directories in the package
  for(;;) {
    if(PkgFile.atEnd()) break;
    Stream >> Code >> Length;

    switch(Code) {
      case CODE_DIR:
        if(extractDirectory(PkgFile, Length, currDir) > 0)
          break;
        goto ErrorEnd;
      case CODE_DIR_END:
        MsgText->append(tr("Leave directory \"%1\"").arg(currDir.absPath()));
        currDir.cdUp();
        break;
      case CODE_FILE:
        if(extractFile(PkgFile, Length, currDir) > 0)
          break;
        goto ErrorEnd;
      case CODE_LIBRARY:
        if(extractLibrary(PkgFile, Length) > 0)
          break;
        goto ErrorEnd;
      default:
        MsgText->append(tr("ERROR: Package is corrupt!"));
        goto ErrorEnd;
    }
  }


  MsgText->append(" ");
  MsgText->append(tr("Successfully extracted package!"));
ErrorEnd:
  MsgText->append(" ");
  ButtClose->setDisabled(false);
  PkgFile.close();
}
예제 #22
0
파일: unadf.c 프로젝트: NF6X/ADFlib
void processFile(struct Volume *vol, char* name, char* path, unsigned char *extbuf,
    BOOL pflag, BOOL qflag)
{
	char *sepptr, *cdstr, *fullname, *filename;
	char *bigstr;
    FILE *tfile;

    adfToRootDir(vol);

    sepptr = strchr(name, '/');
    if (sepptr==NULL) {
        extractFile(vol, name, path, extbuf, pflag, qflag);
    }
    else {
        /* the all-in-one string : to call system(), to find the filename, the convert dir sep char ... */
        bigstr=(char*)malloc(strlen(MKDIR)+1+strlen(path)+1+strlen(name)+1);
        if (!bigstr) { fprintf(stderr,"processFile : malloc"); return; }

        /* to build to extract path */
        if (strlen(path)>0) {
            sprintf(bigstr,"%s %s%c%s",MKDIR,path,DIRSEP,name);
            cdstr = bigstr+strlen(MKDIR)+1+strlen(path)+1;
        }
        else {
            sprintf(bigstr,"%s %s",MKDIR,name);
            cdstr = bigstr+strlen(MKDIR)+1;
        }
        /* the directory in which the file will be extracted */
        fullname =  bigstr+strlen(MKDIR)+1;

        /* finds the filename, and separates it from the path */
        filename = strrchr(bigstr,'/')+1;
        filename[-1]='\0';

        sepptr = cdstr;
        /* find the end of the first dir to create */
        while(sepptr[0]!='/' && sepptr[0]!='\0')
            sepptr++;

        while(strlen(cdstr)>0) {
            if (sepptr[0]=='/') { /* not the last one */
                sepptr[0]='\0';
                if (adfChangeDir(vol,cdstr)!=RC_OK)
                    return;
                tfile = fopen(fullname,"r"); /* the only portable way to test if the dir exists */
                if (tfile==NULL) { /* does't exist : create it */
                    if (!pflag) system(bigstr);
                    if (!qflag) printf("x - %s%c\n",fullname,DIRSEP);
                }
                else
                    fclose(tfile);
                sepptr[0] = DIRSEP; /* converts the '/' to '/' or '\' */
                cdstr = sepptr+1; /* next beginning of the next dir to create */
                /* to find the end of the next dir */
                sepptr++;
                while(sepptr[0]!='/' && sepptr[0]!='\0')
                    sepptr++;
            }
            else { /* the last one */
                if (adfChangeDir(vol,cdstr)!=RC_OK)
                    return;
                tfile = fopen(fullname,"r");
                if (tfile==NULL) {
                    if (!pflag) system(bigstr);
                    if (!qflag) printf("x - %s%c\n",fullname,DIRSEP);
                }
                else
                    fclose(tfile);
                cdstr = cdstr+strlen(cdstr); /* at the end, ends the while loop */
            }
        }
        extractFile(vol, filename, fullname, extbuf, pflag, qflag);

        free(bigstr);
    }


}
void KTNEFMain::setupActions()
{
  KStandardAction::quit( this, SLOT(close()), actionCollection() );

  KAction *action =
    KStandardAction::keyBindings( this, SLOT(slotConfigureKeys()), actionCollection() );
  action->setWhatsThis(
    i18nc( "@info:whatsthis",
           "You will be presented with a dialog where you can configure "
           "the application-wide shortcuts." ) );

  KStandardAction::configureToolbars( this, SLOT(slotEditToolbars()), actionCollection() );

  // File menu
  KStandardAction::open( this, SLOT(openFile()), actionCollection() );

  // Action menu
  KAction *openAction = actionCollection()->addAction( "view_file" );
  openAction->setText( i18nc( "@action:inmenu", "View" ) );
  openAction->setIcon( KIcon( "document-open" ) );
  connect( openAction, SIGNAL(triggered()), this, SLOT(viewFile()) );

  KAction *openAsAction = actionCollection()->addAction( "view_file_as" );
  openAsAction->setText( i18nc( "@action:inmenu", "View With..." ) );
  connect( openAsAction, SIGNAL(triggered()), this, SLOT(viewFileAs()) );

  KAction *extractAction = actionCollection()->addAction( "extract_file" );
  extractAction->setText( i18nc( "@action:inmenu", "Extract" ) );
  connect( extractAction, SIGNAL(triggered()), this, SLOT(extractFile()) );

  KAction *extractToAction = actionCollection()->addAction( "extract_file_to" );
  extractToAction->setText( i18nc( "@action:inmenu", "Extract To..." ) );
  extractToAction->setIcon( KIcon( "archive-extract" ) );
  connect( extractToAction, SIGNAL(triggered()), this, SLOT(extractFileTo()) );

  KAction *extractAllToAction = actionCollection()->addAction( "extract_all_files" );
  extractAllToAction->setText( i18nc( "@action:inmenu", "Extract All To..." ) );
  extractAllToAction->setIcon( KIcon( "archive-extract" ) );
  connect( extractAllToAction, SIGNAL(triggered()), this, SLOT(extractAllFiles()) );

  KAction *filePropsAction = actionCollection()->addAction( "properties_file" );
  filePropsAction->setText( i18nc( "@action:inmenu", "Properties" ) );
  filePropsAction->setIcon( KIcon( "document-properties" ) );
  connect( filePropsAction, SIGNAL(triggered()), this, SLOT(propertiesFile()));

  KAction *messPropsAction = actionCollection()->addAction( "msg_properties" );
  messPropsAction->setText( i18nc( "@action:inmenu", "Message Properties" ) );
  connect( messPropsAction, SIGNAL(triggered()), this, SLOT(slotShowMessageProperties()) );

  KAction *messShowAction = actionCollection()->addAction( "msg_text" );
  messShowAction->setText( i18nc( "@action:inmenu", "Show Message Text" ) );
  messShowAction->setIcon( KIcon( "document-preview-archive" ) );
  connect( messShowAction, SIGNAL(triggered()), this, SLOT(slotShowMessageText()) );

  KAction *messSaveAction = actionCollection()->addAction( "msg_save" );
  messSaveAction->setText( i18nc( "@action:inmenu", "Save Message Text As..." ) );
  messSaveAction->setIcon( KIcon( "document-save" ) );
  connect( messSaveAction, SIGNAL(triggered()), this, SLOT(slotSaveMessageText()) );

  actionCollection()->action( "view_file" )->setEnabled( false );
  actionCollection()->action( "view_file_as" )->setEnabled( false );
  actionCollection()->action( "extract_file" )->setEnabled( false );
  actionCollection()->action( "extract_file_to" )->setEnabled( false );
  actionCollection()->action( "extract_all_files" )->setEnabled( false );
  actionCollection()->action( "properties_file" )->setEnabled( false );

  // Options menu
  KAction *defFolderAction = actionCollection()->addAction( "options_default_dir" );
  defFolderAction->setText( i18nc( "@action:inmenu", "Default Folder..." ) );
  defFolderAction->setIcon( KIcon( "folder-open" ) );
  connect( defFolderAction, SIGNAL(triggered()), this, SLOT(optionDefaultDir()) );

}
예제 #24
0
파일: commands.c 프로젝트: eolhing/Parangon
int commandExtract(programOptions po)
{
	// Open archive file
	char* archiveFilename = programOptionsGetArchiveName(po);
	FILE* archiveFile = fopen(archiveFilename, "r+");

	// Check file existence
	if (archiveFile == NULL)
	{
		fprintf(stderr, "No such file or directory : %s\n", archiveFilename);
		return 1;
	}

	// Get file counts
	char** extractFiles = programOptionsGetFilesName(po);
	unsigned int extractFilesCount = programOptionsGetFilesCount(po);

	if (extractFilesCount == 0)
	{
		// Read file count
		unsigned int fileCount = 0;
		if (fread(&fileCount, sizeof(unsigned int), 1, archiveFile) <= 0)
		{
			perror("Error reading.\n");
			return 1;
		}

		// Read headers
		fileHeader header;
		for (int i = 0; i < fileCount; ++i)
		{
			size_t readSize = fread(&header, sizeof(fileHeader), 1, archiveFile);
			if (readSize > 0)
			{
				// Verbose Log
				if (programOptionsGetVerbose(po))
					printf("Extracting file %s from archive %s\n", header.name, archiveFilename);
				if (extractFile(archiveFile, header.name, header.name) != 0)
				{
					fprintf(stderr, "Error extracting %s.\n", header.name);
					return 1;
				}
			}
			else
			{
				// Close archive file
				fclose(archiveFile);
				return 1;
			}
		}
	}
	for (int i = 0; i < extractFilesCount; i++)
	{
		// Verbose Log
		if (programOptionsGetVerbose(po))
			printf("Extracting file %s from archive %s\n", extractFiles[i], archiveFilename);
		if (extractFile(archiveFile, extractFiles[i], extractFiles[i]) != 0)
		{
			fprintf(stderr, "Error extracting %s.\n", extractFiles[i]);
			return 1;
		}
	}

	// Close archive file
	fflush(archiveFile);
	fclose(archiveFile);
	return 0;
}