DWORD WINAPI ZipThreadProc(void *) { int size=40*1024*1024; // 40mb big! char *c=new char[size]; for (int i=0; i<size; i+=4) {*(int*)(c+i) = rand();} CreateDirectory("\\z",0); HZIP hz = CreateZip("\\z\\progress.zip",0); ZipAdd(hz,"progress1.zip",c,size); ZipAdd(hz,"progress2.zip",c,size); CloseZip(hz); delete[] c; return 0; }
//----------------------------------------------------------------------------- // Uploads a screenshot to a particular listener //----------------------------------------------------------------------------- void CServerRemoteAccess::UploadScreenshot( const char *pFileName ) { #ifndef SWDS if ( m_nScreenshotListener < 0 ) return; CUtlBuffer buf( 128 * 1024, 0 ); if ( g_pFullFileSystem->ReadFile( pFileName, "MOD", buf ) ) { HZIP hZip = CreateZipZ( 0, 1024 * 1024, ZIP_MEMORY ); void *pMem; unsigned long nLen; ZipAdd( hZip, "screenshot.jpg", buf.Base(), buf.TellMaxPut(), ZIP_MEMORY ); ZipGetMemory( hZip, &pMem, &nLen ); SendResponseToClient( m_nScreenshotListener, SERVERDATA_SCREENSHOT_RESPONSE, pMem, nLen ); CloseZip( hZip ); } else { LogCommand( m_nScreenshotListener, "Failed to read screenshot!\n" ); RespondString( m_nScreenshotListener, 0, "Failed to read screenshot!\n" ); } m_nScreenshotListener = -1; #endif }
bool RecurseDirectory(HZIP hz, QString sDir, QString prevDir = "") { QDir dir(sDir); QFileInfoList list = dir.entryInfoList(); for (int iList=0;iList<list.count();iList++) { QFileInfo info = list[iList]; QString sFilePath = info.filePath(); if (info.isDir()) { // recursive if (info.fileName()!=".." && info.fileName()!=".") { ZRESULT zr; return RecurseDirectory(hz, sFilePath); } } else { // Do something with the file here if(ZipAdd(hz, (/*sDir.right(sDir.size() - sDir.lastIndexOf("/") -1) + "/" + */info.fileName()).toLatin1().data(), info.absoluteFilePath().toLatin1().data()) != ZR_OK) return false; } } return true; };
bool CompressFiles(std::string ZipName, std::vector<std::string>* pFilePaths, std::string* pError) //pointer to a vector of filepath strings to zip into location of ZipName (also a filepath) { #ifdef WIN32 HZIP hz = CreateZip(ZipName.c_str(),0); if (!hz){if (pError) *pError += "Could not create ZIP archive. Aborting\n"; return false;} int NumFiles = pFilePaths->size(); for (int i=0; i<NumFiles; i++){ std::string ThisFilePath = (*pFilePaths)[i]; //extract file name (without path) int StartName = ThisFilePath.find_last_of('/')+1; int EndName = ThisFilePath.size(); std::string Name = ThisFilePath.substr(StartName, EndName-StartName); //remove .tmp from end if it exists... std::string Last4 = Name.substr(Name.size()-4, 4); if (Last4.compare(".tmp")==0) Name = Name.substr(0, Name.size()-4); if(ZipAdd(hz, Name.c_str(), ThisFilePath.c_str()) != ZR_OK){if (pError) *pError += ("Could not add file to ZIP archive. Aborting.\n"); return false;} } if(CloseZip(hz) != ZR_OK){if (pError) *pError += ("Could not close ZIP archive. Aborting.\n"); return false;} return true; #else //Mac/Linux Zip write code remove(ZipName.c_str()); int err; struct zip * hz = zip_open(ZipName.c_str(), ZIP_CREATE, &err); if (!hz){if (pError) *pError += "Could not create ZIP archive. Aborting\n"; return false;} int NumFiles = pFilePaths->size(); for (int i=0; i<NumFiles; i++){ std::string ThisFilePath = (*pFilePaths)[i]; //extract file name (without path) int StartName = ThisFilePath.find_last_of('/')+1; int EndName = ThisFilePath.size(); std::string Name = ThisFilePath.substr(StartName, EndName-StartName); //remove .tmp from end if it exists... std::string Last4 = Name.substr(Name.size()-4, 4); if (Last4.compare(".tmp")==0) Name = Name.substr(0, Name.size()-4); struct zip_source * source = zip_source_file(hz, ThisFilePath.c_str(), 0, 0); if(source == NULL || zip_add(hz, Name.c_str(), source) == -1){if (pError) *pError += ("Could not add file to ZIP archive. Aborting.\n"); return false;} } if (zip_close(hz) != 0) {if(pError) *pError += "Error closing ZIP file.\n"; return false;} return true; #endif }
int main() { HZIP hz; hz = CreateZip("std1.zip",0); ZipAdd(hz,"znsimple.jpg", "std_sample.jpg"); ZipAdd(hz,"znsimple.txt", "std_sample.txt"); CloseZip(hz); hz = OpenZip("std1.zip",0); ZIPENTRY ze; GetZipItem(hz,-1,&ze); int numitems=ze.index; for (int zi=0; zi<numitems; zi++) { GetZipItem(hz,zi,&ze); UnzipItem(hz,zi,ze.name); } CloseZip(hz); return 0; }
bool CZipObj::ZipFile(CString strSrcPath, CString strDstPath, CString strExtName /*= _T(".zip")*/) { USES_CONVERSION; // CString modelName = strSrcPath.Right(strSrcPath.GetLength() - strSrcPath.ReverseFind('\\') - 1); CString zipName = strDstPath + strExtName; std::string strUtf8ZipName = CMyCodeConvert::Gb2312ToUtf8(T2A(zipName)); try { Poco::File p(strUtf8ZipName); //T2A(zipName) if (p.exists()) p.remove(true); } catch (Poco::Exception) { } // std::string strModelPath = T2A(strSrcPath); std::string strUtf8ModelPath = CMyCodeConvert::Gb2312ToUtf8(T2A(strSrcPath)); try { Poco::File p2(strUtf8ModelPath); //T2A(zipName) if (!p2.exists()) { std::string strErr = Poco::format("需要压缩的原文件夹(%s)不存在。", T2A(strSrcPath)); RecordLog(strErr); return false; } } catch (Poco::Exception) { } HZIP hz = CreateZip(zipName, _strPwd.c_str()); Poco::DirectoryIterator it(strUtf8ModelPath); //strModelPath Poco::DirectoryIterator end; while (it != end) { Poco::Path p(it->path()); // std::string strZipFileName = p.getFileName(); std::string strPath = CMyCodeConvert::Utf8ToGb2312(p.toString()); std::string strZipFileName = CMyCodeConvert::Utf8ToGb2312(p.getFileName()); CString strZipPath = A2T(strPath.c_str()); CString strName = A2T(strZipFileName.c_str()); // ZipAdd(hz, A2T(strZipFileName.c_str()), A2T(p.toString().c_str())); ZipAdd(hz, strName, strZipPath); it++; } CloseZip(hz); return true; }
void CMainDlg::AddUserInfoToCrashDescriptorXML(CString sEmail, CString sDesc) { USES_CONVERSION; HZIP hz = CreateZip(m_sZipName, NULL); TStrStrMap::iterator cur = m_pUDFiles.begin(); unsigned int i; for (i = 0; i < m_pUDFiles.size(); i++, cur++) { CString sFileName = cur->first.c_str(); sFileName = sFileName.Mid(sFileName.ReverseFind('\\')+1); if(sFileName.CompareNoCase(_T("crashrpt.xml"))==0) { TiXmlDocument doc; bool bLoad = doc.LoadFile(cur->first.c_str()); if(!bLoad) return; TiXmlNode* root = doc.FirstChild("CrashRpt"); if(!root) return; // Write user e-mail TiXmlElement* email = new TiXmlElement("UserEmail"); root->LinkEndChild(email); LPSTR lpszEmail = T2A(sEmail.GetBuffer(0)); TiXmlText* email_text = new TiXmlText(lpszEmail); email->LinkEndChild(email_text); // Write problem description TiXmlElement* desc = new TiXmlElement("ProblemDescription"); root->LinkEndChild(desc); LPSTR lpszDesc = T2A(sDesc.GetBuffer(0)); TiXmlText* desc_text = new TiXmlText(lpszDesc); desc->LinkEndChild(desc_text); doc.SaveFile(); } LPTSTR lptszFilePath = A2T((char*)cur->first.c_str()); ZRESULT zr = ZipAdd(hz, sFileName, lptszFilePath); ATLASSERT(zr==ZR_OK); zr; } CloseZip(hz); }
// Packages all files in "path" into a .zip file. void CreateArchive(string path, string name, ArchiveInfo& info) { HZIP hz = CreateZip(name.c_str(), 0); HANDLE hFind = INVALID_HANDLE_VALUE; WIN32_FIND_DATA ffd; string spec; stack<string> directories; directories.push(path); while (!directories.empty()) { path = directories.top(); spec = path + "/*"; directories.pop(); hFind = FindFirstFile(spec.c_str(), &ffd); if (hFind == INVALID_HANDLE_VALUE) return; do { if (strcmp(ffd.cFileName, ".") != 0 && strcmp(ffd.cFileName, "..") != 0) { if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // Add folder to archive. ZipAddFolder(hz, string(path + "/" + ffd.cFileName).c_str()); directories.push(path + "/" + ffd.cFileName); } else { // Add file to archive. ZipAdd(hz, string(path + "/" + ffd.cFileName).c_str(), string(path + "/" + ffd.cFileName).c_str()); info.files++; info.size += FileSize(path + "/" + ffd.cFileName); } } } while (FindNextFile(hFind, &ffd) != 0); if (GetLastError() != ERROR_NO_MORE_FILES) { FindClose(hFind); return; } FindClose(hFind); hFind = INVALID_HANDLE_VALUE; } CloseZip(hz); }
/////////////////////////////////////////////////////////////////////////////// // Zip BOOL CXZipTestDlg::Zip(LPCTSTR lpszZipArchive, LPCTSTR lpszSrcFile) { BOOL bResult = TRUE; _ASSERTE(lpszZipArchive); _ASSERTE(lpszZipArchive[0] != _T('\0')); if (!lpszZipArchive || lpszZipArchive[0] == _T('\0')) return FALSE; _ASSERTE(lpszSrcFile); _ASSERTE(lpszSrcFile[0] != _T('\0')); if (!lpszSrcFile || lpszSrcFile[0] == _T('\0')) return FALSE; // does zip source file exist? if (_taccess(lpszSrcFile, 04) != 0) { TRACE(_T("WARNING: zip source file '%s' cannot be found, operation aborted\n"), lpszSrcFile); return FALSE; } // use only the file name for zip file entry TCHAR * cp = (TCHAR *)_tcsrchr(lpszSrcFile, _T('\\')); if (cp == NULL) cp = (TCHAR *) lpszSrcFile; else cp++; HZIP hz = CreateZip((void *)lpszZipArchive, 0, ZIP_FILENAME); if (hz) { ZRESULT zr = ZipAdd(hz, cp, (void *)lpszSrcFile, 0, ZIP_FILENAME); CloseZip(hz); // did add work? if (zr == ZR_OK) { TRACE(_T("added '%s' to zip file '%s'\n"), lpszSrcFile, lpszZipArchive); bResult = TRUE; } else { TRACE(_T("WARNING: failed to add zip source file '%s'\n"), lpszSrcFile); bResult = FALSE; } } else { TRACE(_T("ERROR: failed to create zip file '%s'\n"), lpszZipArchive); bResult = FALSE; } return bResult; }
/////////////////////////////////////////////////////////////////////////////// // OnTest void CXZipTestDlg::OnTest() { #ifdef _UNICODE ZIPENTRYW ze; #else ZIPENTRY ze; #endif memset(&ze, 0, sizeof(ze)); TCHAR * pszArchive1 = _T("_TestZipTmp1.zip"); TCHAR * pszArchive2 = _T("_TestZipTmp2.zip"); // text files TCHAR * pszName1 = _T("_TestZipTmp1.txt"); TCHAR * pszName2 = _T("_TestZipTmp2.txt"); TCHAR * pszName3 = _T("_TestZipTmp3.txt"); // binary files TCHAR * pszName4 = _T("_TestZipTmp4.bin"); TCHAR * pszName5 = _T("_TestZipTmp5.bin"); TCHAR * pszName6 = _T("_TestZipTmp6.bin"); TCHAR * pszName7 = _T("_TestZipTmp7.bin"); TCHAR * pszName8 = _T("_TestZipTmp8.bin"); TCHAR * pszName9 = _T("_TestZipTmp9.bin"); // delete zip files ::DeleteFile(pszArchive1); ::DeleteFile(pszArchive2); // create .txt files CreateTextFile(pszName1, 10000); CreateTextFile(pszName2, 100); CreateTextFile(pszName3, 10); // create .bin files CreateBinaryFile(pszName4, 16384); CreateBinaryFile(pszName5, 3*16384); CreateBinaryFile(pszName6, 8*16384); CreateBinaryFile(pszName7, 123); CreateBinaryFile(pszName8, 17000); CreateBinaryFile(pszName9, 8*16384+1); /////////////////////////////////////////////////////////////////////////// // single-file zip m_List.AddLine(CXListBox::Blue, CXListBox::White, _T("")); m_List.Printf(CXListBox::Navy, CXListBox::White, 0, _T(" === Testing single-file zip ===")); BOOL bRet = Zip(pszArchive1, pszName1); if (bRet) { m_List.Printf(CXListBox::Green, CXListBox::White, 0, _T(" Zip archive created OK")); m_List.Printf(CXListBox::Black, CXListBox::White, 0, _T(" === Testing unzip ===")); HZIP hz = OpenZip(pszArchive1, 0, ZIP_FILENAME); if (hz) { ZRESULT zr = GetZipItem(hz, -1, &ze); if (zr == ZR_OK) { int numitems = ze.index; if (numitems == 1) { m_List.Printf(CXListBox::Green, CXListBox::White, 0, _T(" Zip archive contains 1 file ==> OK")); VerifyZip(hz, pszName1); CloseZip(hz); } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Zip contents bad")); } } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" GetZipItem failed")); } } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Failed to open zip file '%s'"), pszArchive1); } } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Failed to create zip")); } /////////////////////////////////////////////////////////////////////////// // multi-file zip m_List.AddLine(CXListBox::Blue, CXListBox::White, _T("")); m_List.Printf(CXListBox::Navy, CXListBox::White, 0, _T(" === Testing multi-file zip ===")); HZIP hz = CreateZip(pszArchive2, 0, ZIP_FILENAME); if (hz) { m_List.Printf(CXListBox::Green, CXListBox::White, 0, _T(" Zip archive created OK")); if ((ZipAdd(hz, pszName1, pszName1, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName2, pszName2, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName3, pszName3, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName4, pszName4, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName5, pszName5, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName6, pszName6, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName7, pszName7, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName8, pszName8, 0, ZIP_FILENAME) == ZR_OK) && (ZipAdd(hz, pszName9, pszName9, 0, ZIP_FILENAME) == ZR_OK)) { m_List.Printf(CXListBox::Green, CXListBox::White, 0, _T(" Files added to zip archive OK")); CloseZip(hz); hz = OpenZip(pszArchive2, 0, ZIP_FILENAME); if (hz) { m_List.Printf(CXListBox::Green, CXListBox::White, 0, _T(" Zip archive opened OK")); GetZipItem(hz, -1, &ze); int numitems = ze.index; if (numitems == 9) { m_List.Printf(CXListBox::Green, CXListBox::White, 0, _T(" Zip archive contains correct number of entries")); for (int i = 0; i < numitems; i++) { GetZipItem(hz, i, &ze); m_List.Printf(CXListBox::Black, CXListBox::White, 0, _T(" %d: %s"), i, ze.name); } VerifyZip(hz, pszName1); VerifyZip(hz, pszName2); VerifyZip(hz, pszName3); VerifyZip(hz, pszName4); VerifyZip(hz, pszName5); VerifyZip(hz, pszName6); VerifyZip(hz, pszName7); VerifyZip(hz, pszName8); VerifyZip(hz, pszName9); } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Number of entries in zip archive is incorrect")); } } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Failed to open zip archive")); } } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Failed to add file to zip archive")); } } else { m_List.Printf(CXListBox::Red, CXListBox::White, 0, _T(" Failed to create zip archive")); } CloseZip(hz); // the files are not deleted - you can inspect them after running test //::DeleteFile(pszArchive1); //::DeleteFile(pszArchive2); //::DeleteFile(pszName1); //::DeleteFile(pszName2); //::DeleteFile(pszName3); m_List.AddLine(CXListBox::Blue, CXListBox::White, _T("")); }
void tSendInnerErrorReport(HWND hInnerWnd) { //------------------------------------------------------- CHAR szCurrentDir[MAX_PATH] = {0}; ::GetCurrentDirectory(MAX_PATH, szCurrentDir); CHAR szCrashFile[MAX_PATH] = {0}; SYSTEMTIME timeNow; ::GetLocalTime(&timeNow); _snprintf(szCrashFile, MAX_PATH, "crash%02d_%02d_%02d_%02d.zip", timeNow.wMonth, timeNow.wDay, timeNow.wHour, timeNow.wMinute,timeNow.wSecond); //------------------------------------------------------- CHAR szLocalFile[MAX_PATH] = {0}; strncpy(szLocalFile, szCurrentDir, MAX_PATH); PathAppend(szLocalFile, szCrashFile); HZIP hz = CreateZip((void *)szLocalFile, 0, ZIP_FILENAME); if(!hz) { MessageBox(hInnerWnd, "Create Error.zip error!", "ErrorReport", MB_OK | MB_ICONSTOP); return; } ZipAdd(hz, "dump.dmp", (void *)g_strDumpFile.c_str(), 0, ZIP_FILENAME); //CHAR szLogFile[MAX_PATH]; //strncpy(szLogFile, szCurrentDir, MAX_PATH); //PathAppend(szLogFile, "Fairy.log"); //ZipAdd(hz, "Fairy.log", (void *)szLogFile, 0, ZIP_FILENAME); //strncpy(szLogFile, szCurrentDir, MAX_PATH); //PathAppend(szLogFile, "CEGUI.log"); //ZipAdd(hz, "CEGUI.log", (void *)szLogFile, 0, ZIP_FILENAME); CloseZip(hz); //------------------------------------------------------- //BROWSEINFO binfo; ZeroMemory(&binfo, sizeof(BROWSEINFO)); //binfo.hwndOwner = hInnerWnd; //binfo.pidlRoot = NULL; //binfo.ulFlags = BIF_NEWDIALOGSTYLE|BIF_RETURNONLYFSDIRS; //binfo.pszDisplayName = NULL; //binfo.lpszTitle = "选择一个目录用以保存数据文件"; //LPITEMIDLIST pRetFold = ::SHBrowseForFolder(&binfo); //if(!pRetFold) return; //CHAR szReturn[MAX_PATH] = {0}; //::SHGetPathFromIDList(pRetFold, szReturn); ////------------------------------------------------------- //CHAR szSaveAs[MAX_PATH] = {0}; //strncpy(szSaveAs, szReturn, MAX_PATH); //PathAppend(szSaveAs, szCrashFile); //CopyFile(szLocalFile, szSaveAs, FALSE); char szCommand[MAX_PATH] = {0}; PathAppend(szCommand, "upload_dump.bat "); strcat(szCommand, szCrashFile); system(szCommand); }
//----------------------------------------------------------------------------- // Purpose: handles a request //----------------------------------------------------------------------------- void CServerRemoteAccess::WriteDataRequest( CRConServer *pNetworkListener, ra_listener_id listener, const void *buffer, int bufferSize) { m_iBytesReceived += bufferSize; // ConMsg("RemoteAccess: bytes received: %d\n", m_iBytesReceived); if ( bufferSize < 2*sizeof(int) ) // check that the buffer contains at least the id and type { return; } CUtlBuffer cmd(buffer, bufferSize, CUtlBuffer::READ_ONLY); bool invalidRequest = false; while ( invalidRequest == false && (int)cmd.TellGet() < (int)(cmd.Size() - 2 * sizeof(int) ) ) // while there is commands to read { // parse out the buffer int requestID = cmd.GetInt(); pNetworkListener->SetRequestID( listener, requestID ); // tell the rcon server the ID so it can reflect it when the console redirect flushes int requestType = cmd.GetInt(); switch (requestType) { case SERVERDATA_REQUESTVALUE: { if ( IsAuthenticated(listener) ) { char variable[256]; if ( !GetStringHelper( cmd, variable, sizeof(variable) ) ) { invalidRequest = true; break; } RequestValue( listener, requestID, variable); if ( !GetStringHelper( cmd, variable, sizeof(variable) ) ) { invalidRequest = true; break; } } else { char variable[256]; if ( !GetStringHelper( cmd, variable, sizeof(variable) ) ) { invalidRequest = true; break; } if ( !GetStringHelper( cmd, variable, sizeof(variable) ) ) { invalidRequest = true; break; } } } break; case SERVERDATA_SETVALUE: { if ( IsAuthenticated(listener) ) { char variable[256]; char value[256]; if ( !GetStringHelper( cmd, variable, sizeof(variable) ) ) { invalidRequest = true; break; } if ( !GetStringHelper( cmd, value, sizeof(value) ) ) { invalidRequest = true; break; } SetValue(variable, value); } else { char command[512]; if ( !GetStringHelper( cmd, command, sizeof(command) ) ) { invalidRequest = true; break; } if ( !GetStringHelper( cmd, command, sizeof(command) ) ) { invalidRequest = true; break; } } } break; case SERVERDATA_EXECCOMMAND: { if ( IsAuthenticated(listener) ) { char command[512]; if ( !GetStringHelper( cmd, command, sizeof(command) ) ) { invalidRequest = true; break; } ExecCommand(command); if ( listener != m_AdminUIID ) { LogCommand( listener, va( "command \"%s\"", command) ); } if ( !GetStringHelper( cmd, command, sizeof(command) ) ) { invalidRequest = true; break; } } else { char command[512]; if ( !GetStringHelper( cmd, command, sizeof(command) ) ) { invalidRequest = true; break; } if ( !GetStringHelper( cmd, command, sizeof(command) ) ) { invalidRequest = true; break; } LogCommand( listener, "Bad Password" ); } } break; case SERVERDATA_AUTH: { char password[512]; if ( !GetStringHelper( cmd, password, sizeof(password) ) ) { invalidRequest = true; break; } CheckPassword( pNetworkListener, listener, requestID, password ); if ( !GetStringHelper( cmd, password, sizeof(password) ) ) { invalidRequest = true; break; } if ( m_ListenerIDs[ listener ].authenticated ) { // if the second string has a non-zero value, it is a userid. int userID = atoi( password ); const ConCommandBase *var = g_pCVar->GetCommands(); while ( var ) { if ( var->IsCommand() ) { if ( Q_stricmp( var->GetName(), "mp_disable_autokick" ) == 0 ) { Cbuf_AddText( va( "mp_disable_autokick %d\n", userID ) ); Cbuf_Execute(); break; } } var = var->GetNext(); } } } break; case SERVERDATA_TAKE_SCREENSHOT: #ifndef SWDS m_nScreenshotListener = listener; CL_TakeJpeg( ); #endif break; case SERVERDATA_SEND_CONSOLE_LOG: { #ifndef SWDS const char *pLogFile = GetConsoleLogFilename(); CUtlBuffer buf( 1024, 0, CUtlBuffer::TEXT_BUFFER ); if ( g_pFullFileSystem->ReadFile( pLogFile, "GAME", buf ) ) { HZIP hZip = CreateZipZ( 0, 1024 * 1024, ZIP_MEMORY ); void *pMem; unsigned long nLen; ZipAdd( hZip, "console.log", buf.Base(), buf.TellMaxPut(), ZIP_MEMORY ); ZipGetMemory( hZip, &pMem, &nLen ); SendResponseToClient( listener, SERVERDATA_CONSOLE_LOG_RESPONSE, pMem, nLen ); CloseZip( hZip ); } else { LogCommand( listener, "Failed to read console log!\n" ); RespondString( listener, requestID, "Failed to read console log!\n" ); } #endif } break; #ifdef VPROF_ENABLED case SERVERDATA_VPROF: { char password[25]; if ( !GetStringHelper( cmd, password, sizeof(password) ) ) { invalidRequest = true; break; } if ( !GetStringHelper( cmd, password, sizeof(password) ) ) { invalidRequest = true; break; } if ( IsAuthenticated(listener) ) { RegisterVProfDataListener( listener ); LogCommand( listener, "Remote VProf started!\n" ); RespondString( listener, requestID, "Remote VProf started!\n" ); } } break; case SERVERDATA_REMOVE_VPROF: { char password[25]; if ( !GetStringHelper( cmd, password, sizeof(password) ) ) { invalidRequest = true; break; } if ( !GetStringHelper( cmd, password, sizeof(password) ) ) { invalidRequest = true; break; } if ( IsAuthenticated(listener) ) { RemoveVProfDataListener( listener ); LogCommand( listener, "Remote VProf finished!\n" ); RespondString( listener, requestID, "Remote VProf finished!\n" ); } } break; #endif default: Assert(!("Unknown requestType in CServerRemoteAccess::WriteDataRequest()")); cmd.Purge(); invalidRequest = true; break; }; } }
ZIP_API ZRESULT ZipAddData(HZIP zip_handle, const TCHAR* destination_file_name, void* data, unsigned int length){return ZipAdd(zip_handle, destination_file_name, data, length);}
int CMainDialog::ZipFiles() { CCrashReporterApp* pApp = DYNAMIC_DOWNCAST(CCrashReporterApp, AfxGetApp()); ASSERT_VALID(pApp); int nFiles = 0; // generate zip file name m_strZipFile = pApp->m_strAppDataPath; m_strZipFile += pApp->m_strUpdateItExe; int index = m_strZipFile.ReverseFind(_T('.')); if (index > 0) m_strZipFile = m_strZipFile.Left(index); m_strZipFile += _T(".zip"); TRACE(_T("m_strZipPath = <%s>\n"), m_strZipFile); // backup old zip if it exists BackupFile(m_strZipFile); HZIP hZip = NULL; for (int i = 0; i < m_aFileDetails.GetSize(); i++) { FILEDETAILS *fd = (FILEDETAILS *) m_aFileDetails[i]; if (fd) { // make sure file exists if ((_taccess(fd->strFilePath, 00) == 0) && fd->bSend) { // if this is first file, create zip now if (!hZip) { hZip = CreateZip((LPVOID)(LPCTSTR)m_strZipFile, 0, ZIP_FILENAME); if (!hZip) { TRACE(_T("ERROR - failed to create %s\n"), m_strZipFile); break; } } // zip is open, add file CString strName = fd->strFilePath; int index = strName.ReverseFind(_T('\\')); if (index > 0) strName = strName.Right(strName.GetLength()-index-1); TRACE(_T("strName=<%s>\n"), strName); ZRESULT zr = ZipAdd(hZip, strName, (LPVOID)(LPCTSTR)fd->strFilePath, 0, ZIP_FILENAME); if (zr == ZR_OK) { nFiles++; } else { TRACE(_T("ERROR - failed to add '%s' to zip\n"), fd->strFilePath); } } } } if (hZip) CloseZip(hZip); return nFiles; }
ZIP_API ZRESULT ZipAddFile(HZIP zip_handle, const TCHAR* destination_file_name, const TCHAR* source_file_name){return ZipAdd(zip_handle, destination_file_name, source_file_name);}
int ArchiveFileRaw(RecorderProperties *ws, bool sender) { if (CloseFileStream(ws->rawStream) != status_ok) { return status_io_error; } if (CloseFileStream(ws->logStream) != status_ok) { return status_io_error; } time_t now_local = time(NULL); struct tm lt; now_local -= 3600; //prev day localtime_s(<, &now_local); wchar_t szBuf[MAX_PATH]; _snwprintf(szBuf, MAX_PATH, L"%d-%02d-%02d\\", lt.tm_year + 1900, lt.tm_mon + 1, lt.tm_mday); wstring todayFolder = ws->parameters.logDailyPath + szBuf; CreateDirectory(todayFolder.data(), 0); HZIP todayZip; ZRESULT zipResult; //ziping raw if (!sender) { wstring archiveRawFilePath = todayFolder + ws->parameters.rawCurrentFile + L".zip"; todayZip = CreateZip((void*) archiveRawFilePath.data(), 0, ZIP_FILENAME); zipResult = ZipAdd(todayZip, ws->parameters.rawCurrentFile.data(), (void*) (ws->parameters.rawCurrentPath + ws->parameters.rawCurrentFile).data(), 0, ZIP_FILENAME); CloseZip(todayZip); if (zipResult != ZR_OK) { WriteFileLogf(L"Raw zip creation failed"); } } //ziping log wstring archiveLogFilePath = todayFolder + ws->parameters.name + L"log.zip"; todayZip = CreateZip((void*) archiveLogFilePath.data(), 0, ZIP_FILENAME); wstring logFile = wstring(ws->parameters.name + L"rec.log"); zipResult = ZipAdd(todayZip, logFile.data(), (void*) (ws->parameters.rawCurrentPath + logFile).data(), 0, ZIP_FILENAME); CloseZip(todayZip); if (zipResult != ZR_OK) { WriteFileLogf(L"Log zip creation failed"); } if (!sender && OpenFileStream(ws->rawStream, ws->parameters.rawCurrentPath + ws->parameters.rawCurrentFile, true) != status_ok) { return status_io_error; } if (OpenFileStream(ws->logStream, ws->sysLogPath, true) != status_ok) { return status_io_error; } return status_ok; }
void main() { CreateFiles(); HZIP hz; DWORD writ; // EXAMPLE 1 - create a zipfile from existing files hz = CreateZip(_T("\\simple1.zip"),0); ZipAdd(hz,_T("znsimple.bmp"), _T("\\simple.bmp")); ZipAdd(hz,_T("znsimple.txt"), _T("\\simple.txt")); CloseZip(hz); _tprintf(_T("Created '\\simple1.zip'\n")); // EXAMPLE 2 - unzip it with the names suggested in the zip hz = OpenZip(_T("\\simple1.zip"),0); SetUnzipBaseDir(hz,_T("\\")); ZIPENTRY ze; GetZipItem(hz,-1,&ze); int numitems=ze.index; for (int zi=0; zi<numitems; zi++) { GetZipItem(hz,zi,&ze); UnzipItem(hz,zi,ze.name); } CloseZip(hz); _tprintf(_T("Unzipped 'znsimple.bmp' and 'znsimple.txt' from 'simple1.zip'\n")); // EXAMPLE 3 - create an auto-allocated pagefile-based zip file from various sources // the second argument says how much address space to reserve for it. We can // afford to be generous: no address-space is allocated unless it's actually needed. hz = CreateZip(0,100000,"password"); // adding a conventional file... ZipAdd(hz,_T("znsimple.txt"), _T("\\simple.txt")); // adding something from memory... char buf[1000]; for (int zj=0; zj<1000; zj++) buf[zj]=(char)(zj&0x7F); ZipAdd(hz,_T("simple.dat"), buf,1000); // adding something from a pipe... #ifndef UNDER_CE HANDLE hread,hwrite; CreatePipe(&hread,&hwrite,NULL,0); DWORD WINAPI Ex3ThreadFunc(void *dat); HANDLE hthread = CreateThread(0,0,Ex3ThreadFunc,(void*)hwrite,0,0); ZipAddHandle(hz,_T("simple3.dat"), hread,1000); // the '1000' is optional, but it makes for nicer zip files if sizes are known in advance. WaitForSingleObject(hthread,INFINITE); CloseHandle(hthread); CloseHandle(hread); // the thread will close hwrite #endif // // and now that the zip is created in pagefile, let's do something with it: void *zbuf; unsigned long zlen; ZipGetMemory(hz,&zbuf,&zlen); HANDLE hfz = CreateFile(_T("\\simple3 - pwd is 'password'.zip"),GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0); WriteFile(hfz,zbuf,zlen,&writ,NULL); CloseHandle(hfz); CloseZip(hz); _tprintf(_T("Created 'simple3.zip' via pagefile\n")); // EXAMPLE 4 - unzip directly from resource into a file // resource RT_RCDATA/#1 happens to be a zip file... HINSTANCE hInstance=GetModuleHandle(0); HRSRC hrsrc = FindResource(hInstance,MAKEINTRESOURCE(1),RT_RCDATA); HANDLE hglob = LoadResource(hInstance,hrsrc); void *zipbuf=LockResource(hglob); unsigned int ziplen=SizeofResource(hInstance,hrsrc); hz = OpenZip(zipbuf, ziplen, 0); SetUnzipBaseDir(hz,_T("\\")); int i; FindZipItem(hz,_T("simple.jpg"),true,&i,&ze); // - unzip to a file - UnzipItem(hz,i,ze.name); // - unzip to a membuffer - char *ibuf = new char[ze.unc_size]; UnzipItem(hz,i, ibuf, ze.unc_size); delete[] ibuf; // - unzip to a fixed membuff, bit by bit - char fbuf[1024]; ZRESULT zr=ZR_MORE; unsigned long totsize=0; while (zr==ZR_MORE) { zr = UnzipItem(hz,i, fbuf,1024); unsigned long bufsize=1024; if (zr==ZR_OK) bufsize=ze.unc_size-totsize; // now do something with this chunk which we just unzipped... totsize+=bufsize; } // - finished - CloseZip(hz); // note: no need to free resources obtained through Find/Load/LockResource _tprintf(_T("Unzipped 'simple.jpg' from resource zipfile\n")); DeleteFile(_T("\\simple.txt")); DeleteFile(_T("\\simple.bmp")); _tprintf(_T("Deleted 'simple.txt' and 'simple.bmp'\n")); }