CSemaphoreImpl::CSemaphoreImpl(int n, int max): _n(n), _max(max) { poco_assert (n >= 0 && max > 0 && n <= max); if (pthread_mutex_init(&_mutex, NULL)) throw CSystemException("cannot create semaphore (mutex)"); if (pthread_cond_init(&_cond, NULL)) throw CSystemException("cannot create semaphore (condition)"); }
CRWLockImpl::CRWLockImpl(): _readers(0), _writers(0) { _mutex = CreateMutexW(NULL, FALSE, NULL); if (_mutex == NULL) throw CSystemException("cannot create reader/writer lock"); _readEvent = CreateEventW(NULL, TRUE, TRUE, NULL); if (_readEvent == NULL) throw CSystemException("cannot create reader/writer lock"); _writeEvent = CreateEventW(NULL, TRUE, TRUE, NULL); if (_writeEvent == NULL) throw CSystemException("cannot create reader/writer lock"); }
void CSemaphoreImpl::waitImpl() { if (pthread_mutex_lock(&_mutex)) throw CSystemException("wait for semaphore failed (lock)"); while (_n < 1) { if (pthread_cond_wait(&_cond, &_mutex)) { pthread_mutex_unlock(&_mutex); throw CSystemException("wait for semaphore failed"); } } --_n; pthread_mutex_unlock(&_mutex); }
tstring CRegConfig::GetStringValue(TCHAR* Name, const TCHAR* strDefaultValue) { DWORD err, type, size; TCHAR *pbuffer; size = 0; err = RegQueryValueEx(m_hKey, Name, NULL, &type, NULL, &size); if(ERROR_SUCCESS != err) { //throw CSystemException(err, "Failed to query configuration value."); return tstring(strDefaultValue); } if(type != REG_SZ) { throw std::exception("Failed to query configuration value (type mismatch)."); } pbuffer = new TCHAR[(size - 1) / sizeof(TCHAR)]; err = RegQueryValueEx(m_hKey, Name, NULL, &type, reinterpret_cast<LPBYTE>(pbuffer), &size); if(ERROR_SUCCESS != err) { throw CSystemException(err, "Failed to query configuration value."); } return tstring(pbuffer); }
CSemaphoreImpl::CSemaphoreImpl(int n, int max) { poco_assert (n >= 0 && max > 0 && n <= max); _sema = CreateSemaphoreW(NULL, n, max, NULL); if (!_sema) { throw CSystemException("cannot create semaphore"); } }
void CSemaphoreImpl::waitImpl() { switch (WaitForSingleObject(_sema, INFINITE)) { case WAIT_OBJECT_0: return; default: throw CSystemException("wait for semaphore failed"); } }
void CRegConfig::SetValue(TCHAR* Name, float fValue) { DWORD err; err = RegSetValueEx(m_hKey, Name, NULL, REG_DWORD, reinterpret_cast<LPBYTE>(&fValue), sizeof(fValue)); if(ERROR_SUCCESS != err) { throw CSystemException(err, "Failed to set configuration value."); } }
void CRegConfig::SetValue(TCHAR* Name, const TCHAR* strValue) { DWORD err; err = RegSetValueEx(m_hKey, Name, NULL, REG_SZ, reinterpret_cast<const BYTE*>(strValue), (_tcslen(strValue) + 1) * sizeof(TCHAR)); if(ERROR_SUCCESS != err) { throw CSystemException(err, "Failed to set configuration value."); } }
bool CSemaphoreImpl::waitImpl(long milliseconds) { switch (WaitForSingleObject(_sema, milliseconds + 1)) { case WAIT_TIMEOUT: return false; case WAIT_OBJECT_0: return true; default: throw CSystemException("wait for semaphore failed"); } }
inline void CRWLockImpl::addWriter() { switch (WaitForSingleObject(_mutex, INFINITE)) { case WAIT_OBJECT_0: if (++_writers == 1) ResetEvent(_readEvent); ReleaseMutex(_mutex); break; default: throw CSystemException("cannot lock reader/writer lock"); } }
void CRWLockImpl::unlockImpl() { switch (WaitForSingleObject(_mutex, INFINITE)) { case WAIT_OBJECT_0: if (_writers == 0) SetEvent(_readEvent); if (--_readers == 0) SetEvent(_writeEvent); ReleaseMutex(_mutex); break; default: throw CSystemException("cannot unlock reader/writer lock"); } }
bool CSemaphoreImpl::waitImpl(long milliseconds) { int rc = 0; struct timespec abstime; #if defined(__VMS) struct timespec delta; delta.tv_sec = milliseconds / 1000; delta.tv_nsec = (milliseconds % 1000)*1000000; pthread_get_expiration_np(&delta, &abstime); #else struct timeval tv; gettimeofday(&tv, NULL); abstime.tv_sec = tv.tv_sec + milliseconds / 1000; abstime.tv_nsec = tv.tv_usec*1000 + (milliseconds % 1000)*1000000; if (abstime.tv_nsec >= 1000000000) { abstime.tv_nsec -= 1000000000; abstime.tv_sec++; } #endif if (pthread_mutex_lock(&_mutex) != 0) throw CSystemException("wait for semaphore failed (lock)"); while (_n < 1) { if ((rc = pthread_cond_timedwait(&_cond, &_mutex, &abstime))) { if (rc == ETIMEDOUT) break; pthread_mutex_unlock(&_mutex); throw CSystemException("cannot wait for semaphore"); } } if (rc == 0) --_n; pthread_mutex_unlock(&_mutex); return rc == 0; }
void COutArchive::WriteLocalHeader(const CLocalItem &item) { SeekTo(m_BasePosition); bool isZip64 = m_IsZip64 || item.PackSize >= 0xFFFFFFFF || item.UnPackSize >= 0xFFFFFFFF; WriteUInt32(NSignature::kLocalFileHeader); { Byte ver = item.ExtractVersion.Version; if (isZip64 && ver < NFileHeader::NCompressionMethod::kExtractVersion_Zip64) ver = NFileHeader::NCompressionMethod::kExtractVersion_Zip64; WriteByte(ver); } WriteByte(item.ExtractVersion.HostOS); WriteUInt16(item.Flags); WriteUInt16(item.CompressionMethod); WriteUInt32(item.Time); WriteUInt32(item.FileCRC); WriteUInt32(isZip64 ? 0xFFFFFFFF: (UInt32)item.PackSize); WriteUInt32(isZip64 ? 0xFFFFFFFF: (UInt32)item.UnPackSize); WriteUInt16((UInt16)item.Name.Length()); { UInt16 localExtraSize = (UInt16)((isZip64 ? (4 + 16): 0) + item.LocalExtra.GetSize()); if (localExtraSize > m_ExtraSize) throw CSystemException(E_FAIL); } WriteUInt16((UInt16)m_ExtraSize); // test it; WriteBytes((const char *)item.Name, item.Name.Length()); UInt32 extraPos = 0; if (isZip64) { extraPos += 4 + 16; WriteUInt16(NFileHeader::NExtraID::kZip64); WriteUInt16(16); WriteUInt64(item.UnPackSize); WriteUInt64(item.PackSize); } WriteExtra(item.LocalExtra); extraPos += (UInt32)item.LocalExtra.GetSize(); for (; extraPos < m_ExtraSize; extraPos++) WriteByte(0); m_OutBuffer.FlushWithCheck(); MoveBasePosition(item.PackSize); SeekTo(m_BasePosition); }
void CRegConfig::SetPlugin(TCHAR *pszName) { TCHAR path[512]; DWORD err, disp; CloseKey(); _tcscpy(path, REGCONFIG_PLUGINSPATH); _tcscat(path, pszName); err = RegCreateKeyEx( HKEY_CURRENT_USER, path, 0, _T(""), REG_OPTION_NON_VOLATILE, 0, NULL, &m_hKey, &disp); if(ERROR_SUCCESS != err) { throw CSystemException(err, "Failed to create plugin's registry key."); } }
void CRWLockImpl::readLockImpl() { HANDLE h[2]; h[0] = _mutex; h[1] = _readEvent; switch (WaitForMultipleObjects(2, h, TRUE, INFINITE)) { case WAIT_OBJECT_0: case WAIT_OBJECT_0 + 1: ++_readers; ResetEvent(_writeEvent); ReleaseMutex(_mutex); break; default: throw CSystemException("cannot lock reader/writer lock"); } }
static HRESULT ExtractGroupCommand(const UStringVector &arcPaths, bool showDialog, const UString &outFolder, bool testMode) { HRESULT result; MY_TRY_BEGIN CREATE_CODECS CExtractOptions eo; eo.OutputDir = outFolder; eo.TestMode = testMode; CExtractCallbackImp *ecs = new CExtractCallbackImp; CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs; ecs->Init(); // eo.CalcCrc = options.CalcCrc; UStringVector arcPathsSorted; UStringVector arcFullPathsSorted; { NWildcard::CCensor acrCensor; for (int i = 0; i < arcPaths.Size(); i++) acrCensor.AddItem(true, arcPaths[i], false); EnumerateDirItemsAndSort(acrCensor, arcPathsSorted, arcFullPathsSorted); } CIntVector formatIndices; NWildcard::CCensor censor; censor.AddItem(true, L"*", false); bool messageWasDisplayed = false; result = ExtractGUI(codecs, formatIndices, arcPathsSorted, arcFullPathsSorted, censor.Pairs.Front().Head, eo, showDialog, messageWasDisplayed, ecs, g_HWND); if (result != S_OK) { if (result != E_ABORT && messageWasDisplayed) return E_FAIL; throw CSystemException(result); } return ecs->IsOK() ? S_OK : E_FAIL; MY_TRY_FINISH return result; }
void CInArchive::SafeReadBytes(void *data, unsigned size) { size_t processed = size; if (_inBufMode) { processed = _inBuffer.ReadBytes((Byte *)data, size); m_Position += processed; } else { HRESULT result = ReadStream(Stream, data, &processed); m_Position += processed; if (result != S_OK) throw CSystemException(result); } if (processed != size) throw CUnexpectEnd(); }
bool CRWLockImpl::tryReadLockImpl() { HANDLE h[2]; h[0] = _mutex; h[1] = _readEvent; switch (WaitForMultipleObjects(2, h, TRUE, 1)) { case WAIT_OBJECT_0: case WAIT_OBJECT_0 + 1: ++_readers; ResetEvent(_writeEvent); ReleaseMutex(_mutex); return true; case WAIT_TIMEOUT: return false; default: throw CSystemException("cannot lock reader/writer lock"); } }
HRESULT CompressFiles( const UString &arcPathPrefix, const UString &arcName, const UString &arcType, const UStringVector &names, bool email, bool showDialog, bool /* waitFinish */) { //::MessageBoxW(NULL, (LPCWSTR)L"CompressCall2::CompressFiles", (LPCWSTR)L"mooo", MB_OK); HRESULT result; MY_TRY_BEGIN CREATE_CODECS CUpdateCallbackGUI callback; callback.Init(); CUpdateOptions uo; uo.EMailMode = email; uo.SetAddActionCommand(); CIntVector formatIndices; if (!codecs->FindFormatForArchiveType(arcType, formatIndices)) { ErrorLangMessage(IDS_UNSUPPORTED_ARCHIVE_TYPE, 0x0200060D); return E_FAIL; } if (!uo.Init(codecs, formatIndices, arcPathPrefix + arcName)) { ErrorLangMessage(IDS_UPDATE_NOT_SUPPORTED, 0x02000601); return E_FAIL; } NWildcard::CCensor censor; for (int i = 0; i < names.Size(); i++) censor.AddItem(true, names[i], false); //::MessageBoxW(NULL, (LPCWSTR)L"CompressCall2::CompressFiles2", (LPCWSTR)L"mooo", MB_OK); bool messageWasDisplayed = false; result = UpdateGUI(codecs, censor, uo, showDialog, messageWasDisplayed, &callback, g_HWND); //::MessageBoxW(NULL, (LPCWSTR)L"CompressCall2::CompressFiles3", (LPCWSTR)L"mooo", MB_OK); if (result != S_OK) { if (result != E_ABORT && messageWasDisplayed) return E_FAIL; throw CSystemException(result); } if (callback.FailedFiles.Size() > 0) { if (!messageWasDisplayed) throw CSystemException(E_FAIL); return E_FAIL; } MY_TRY_FINISH return S_OK; }
void COutArchive::SeekTo(UInt64 offset) { HRESULT res = m_Stream->Seek(offset, STREAM_SEEK_SET, NULL); if (res != S_OK) throw CSystemException(res); }