/**
* Worker for cmdDisplayAll.
*/
static BOOL WINAPI displaySystemStoreCallback(const void *pvSystemStore, DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo,
void *pvReserved, void *pvArg)
{
if (g_cVerbosityLevel > 1)
RTPrintf(" pvSystemStore=%p dwFlags=%#x pStoreInfo=%p pvReserved=%p\n", pvSystemStore, dwFlags, pStoreInfo, pvReserved);
LPCWSTR pwszStoreNm = NULL;
if (dwFlags & CERT_SYSTEM_STORE_RELOCATE_FLAG)
{
const CERT_SYSTEM_STORE_RELOCATE_PARA *pRelPara = (const CERT_SYSTEM_STORE_RELOCATE_PARA *)pvSystemStore;
pwszStoreNm = pRelPara->pwszSystemStore;
RTPrintf(" %#010x '%ls' hKeyBase=%p\n", dwFlags, pwszStoreNm, pRelPara->hKeyBase);
}
else
{
pwszStoreNm = (LPCWSTR)pvSystemStore;
RTPrintf(" %#010x '%ls'\n", dwFlags, pwszStoreNm);
}
/*
* Open the store and list the certificates within.
*/
DWORD dwDst = (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK);
HCERTSTORE hStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_W,
PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
NULL /* hCryptProv = default */,
dwDst | CERT_STORE_OPEN_EXISTING_FLAG,
pwszStoreNm);
if (hStore)
{
PCCERT_CONTEXT pCertCtx = NULL;
while ((pCertCtx = CertEnumCertificatesInStore(hStore, pCertCtx)) != NULL)
{
if (g_cVerbosityLevel > 1)
RTPrintf(" pCertCtx=%p dwCertEncodingType=%#x cbCertEncoded=%#x pCertInfo=%p\n",
pCertCtx, pCertCtx->dwCertEncodingType, pCertCtx->cbCertEncoded, pCertCtx->pCertInfo);
WCHAR wszName[1024];
if (CertGetNameStringW(pCertCtx, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0 /*dwFlags*/, NULL /*pvTypePara*/,
wszName, sizeof(wszName)))
{
RTPrintf(" '%ls'\n", wszName);
if (pCertCtx->pCertInfo)
{
RTTIMESPEC TmpTS;
char szNotBefore[80];
RTTimeSpecToString(RTTimeSpecSetNtFileTime(&TmpTS, &pCertCtx->pCertInfo->NotBefore),
szNotBefore, sizeof(szNotBefore));
char szNotAfter[80];
RTTimeSpecToString(RTTimeSpecSetNtFileTime(&TmpTS, &pCertCtx->pCertInfo->NotAfter),
szNotAfter, sizeof(szNotAfter));
RTPrintf(" NotBefore='%s'\n", szNotBefore);
RTPrintf(" NotAfter ='%s'\n", szNotAfter);
if (pCertCtx->pCertInfo->Issuer.cbData)
{
if (CertGetNameStringW(pCertCtx, CERT_NAME_SIMPLE_DISPLAY_TYPE, CERT_NAME_ISSUER_FLAG, NULL /*pvTypePara*/,
wszName, sizeof(wszName)))
RTPrintf(" Issuer='%ls'\n", wszName);
else
RTMsgError("CertGetNameStringW(Issuer) failed: %s\n", errorToString(GetLastError()));
}
}
}
else
RTMsgError("CertGetNameStringW(Subject) failed: %s\n", errorToString(GetLastError()));
}
CertCloseStore(hStore, CERT_CLOSE_STORE_CHECK_FLAG);
}
else
RTMsgError("CertOpenStore failed opening %#x:'%ls': %s\n", dwDst, pwszStoreNm, errorToString(GetLastError()));
return TRUE;
}
/**
* Handler for the 'display-all' command.
*/
static RTEXITCODE cmdDisplayAll(int argc, char **argv)
{
if (argc != 1)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "the display-all command takes no arguments\n");
if (!CertEnumSystemStoreLocation(0, NULL /*pvArg*/, displaySystemStoreLocation))
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "CertEnumSystemStoreLocation failed: %s\n", errorToString(GetLastError()));
return RTEXITCODE_SUCCESS;
}
/** The verbosity level. */
static unsigned g_cVerbosityLevel = 1;
static const char *errorToString(DWORD dwErr)
{
switch (dwErr)
{
#define MY_CASE(a_uConst) case a_uConst: return #a_uConst;
MY_CASE(CRYPT_E_MSG_ERROR);
MY_CASE(CRYPT_E_UNKNOWN_ALGO);
MY_CASE(CRYPT_E_OID_FORMAT);
MY_CASE(CRYPT_E_INVALID_MSG_TYPE);
MY_CASE(CRYPT_E_UNEXPECTED_ENCODING);
MY_CASE(CRYPT_E_AUTH_ATTR_MISSING);
MY_CASE(CRYPT_E_HASH_VALUE);
MY_CASE(CRYPT_E_INVALID_INDEX);
MY_CASE(CRYPT_E_ALREADY_DECRYPTED);
MY_CASE(CRYPT_E_NOT_DECRYPTED);
MY_CASE(CRYPT_E_RECIPIENT_NOT_FOUND);
MY_CASE(CRYPT_E_CONTROL_TYPE);
MY_CASE(CRYPT_E_ISSUER_SERIALNUMBER);
MY_CASE(CRYPT_E_SIGNER_NOT_FOUND);
MY_CASE(CRYPT_E_ATTRIBUTES_MISSING);
MY_CASE(CRYPT_E_STREAM_MSG_NOT_READY);
MY_CASE(CRYPT_E_STREAM_INSUFFICIENT_DATA);
MY_CASE(CRYPT_I_NEW_PROTECTION_REQUIRED);
MY_CASE(CRYPT_E_BAD_LEN);
MY_CASE(CRYPT_E_BAD_ENCODE);
MY_CASE(CRYPT_E_FILE_ERROR);
MY_CASE(CRYPT_E_NOT_FOUND);
MY_CASE(CRYPT_E_EXISTS);
MY_CASE(CRYPT_E_NO_PROVIDER);
MY_CASE(CRYPT_E_SELF_SIGNED);
MY_CASE(CRYPT_E_DELETED_PREV);
MY_CASE(CRYPT_E_NO_MATCH);
MY_CASE(CRYPT_E_UNEXPECTED_MSG_TYPE);
MY_CASE(CRYPT_E_NO_KEY_PROPERTY);
MY_CASE(CRYPT_E_NO_DECRYPT_CERT);
MY_CASE(CRYPT_E_BAD_MSG);
MY_CASE(CRYPT_E_NO_SIGNER);
MY_CASE(CRYPT_E_PENDING_CLOSE);
MY_CASE(CRYPT_E_REVOKED);
MY_CASE(CRYPT_E_NO_REVOCATION_DLL);
MY_CASE(CRYPT_E_NO_REVOCATION_CHECK);
MY_CASE(CRYPT_E_REVOCATION_OFFLINE);
MY_CASE(CRYPT_E_NOT_IN_REVOCATION_DATABASE);
MY_CASE(CRYPT_E_INVALID_NUMERIC_STRING);
MY_CASE(CRYPT_E_INVALID_PRINTABLE_STRING);
MY_CASE(CRYPT_E_INVALID_IA5_STRING);
MY_CASE(CRYPT_E_INVALID_X500_STRING);
MY_CASE(CRYPT_E_NOT_CHAR_STRING);
MY_CASE(CRYPT_E_FILERESIZED);
MY_CASE(CRYPT_E_SECURITY_SETTINGS);
MY_CASE(CRYPT_E_NO_VERIFY_USAGE_DLL);
MY_CASE(CRYPT_E_NO_VERIFY_USAGE_CHECK);
MY_CASE(CRYPT_E_VERIFY_USAGE_OFFLINE);
MY_CASE(CRYPT_E_NOT_IN_CTL);
MY_CASE(CRYPT_E_NO_TRUSTED_SIGNER);
MY_CASE(CRYPT_E_MISSING_PUBKEY_PARA);
MY_CASE(CRYPT_E_OSS_ERROR);
default:
{
PCRTCOMERRMSG pWinComMsg = RTErrCOMGet(dwErr);
if (pWinComMsg)
return pWinComMsg->pszDefine;
static char s_szErr[32];
RTStrPrintf(s_szErr, sizeof(s_szErr), "%#x (%d)", dwErr, dwErr);
return s_szErr;
}
}
}
#if 0 /* hacking */
static RTEXITCODE addToStore(const char *pszFilename, PCRTUTF16 pwszStore)
{
/*
* Open the source.
*/
void *pvFile;
size_t cbFile;
int rc = RTFileReadAll(pszFilename, &pvFile, &cbFile);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTFileReadAll failed on '%s': %Rrc", pszFilename, rc);
RTEXITCODE rcExit = RTEXITCODE_FAILURE;
PCCERT_CONTEXT pCertCtx = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
(PBYTE)pvFile,
(DWORD)cbFile);
if (pCertCtx)
{
/*
* Open the destination.
*/
HCERTSTORE hDstStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_W,
PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
NULL /* hCryptProv = default */,
/*CERT_SYSTEM_STORE_LOCAL_MACHINE*/ CERT_SYSTEM_STORE_CURRENT_USER | CERT_STORE_OPEN_EXISTING_FLAG,
pwszStore);
if (hDstStore != NULL)
{
#if 0
DWORD dwContextType;
if (CertAddSerializedElementToStore(hDstStore,
pCertCtx->pbCertEncoded,
pCertCtx->cbCertEncoded,
CERT_STORE_ADD_NEW,
0 /* dwFlags (reserved) */,
CERT_STORE_ALL_CONTEXT_FLAG,
&dwContextType,
NULL))
{
RTMsgInfo("Successfully added '%s' to the '%ls' store (ctx type %u)", pszFilename, pwszStore, dwContextType);
rcExit = RTEXITCODE_SUCCESS;
}
else
RTMsgError("CertAddSerializedElementToStore returned %s", errorToString(GetLastError()));
#else
if (CertAddCertificateContextToStore(hDstStore, pCertCtx, CERT_STORE_ADD_NEW, NULL))
{
RTMsgInfo("Successfully added '%s' to the '%ls' store", pszFilename, pwszStore);
rcExit = RTEXITCODE_SUCCESS;
}
else
RTMsgError("CertAddCertificateContextToStore returned %s", errorToString(GetLastError()));
#endif
CertCloseStore(hDstStore, CERT_CLOSE_STORE_CHECK_FLAG);
}
else
RTMsgError("CertOpenStore returned %s", errorToString(GetLastError()));
CertFreeCertificateContext(pCertCtx);
}
else
RTMsgError("CertCreateCertificateContext returned %s", errorToString(GetLastError()));
RTFileReadAllFree(pvFile, cbFile);
return rcExit;
#if 0
CRYPT_DATA_BLOB Blob;
Blob.cbData = (DWORD)cbData;
Blob.pbData = (PBYTE)pvData;
HCERTSTORE hSrcStore = PFXImportCertStore(&Blob, L"", )
#endif
}
/**
* Removes a certificate, given by file, from a store
*
* @returns true on success, false on failure (error message written).
* @param dwDst The destination, like
* CERT_SYSTEM_STORE_LOCAL_MACHINE or
* CERT_SYSTEM_STORE_CURRENT_USER.
* @param pszStoreNm The store name.
* @param pszCertFile The file containing the certificate to add.
*/
static bool removeCertFromStoreByFile(DWORD dwDst, const char *pszStoreNm, const char *pszCertFile)
{
/*
* Read the certificate file first.
*/
PCCERT_CONTEXT pSrcCtx = NULL;
HCERTSTORE hSrcStore = NULL;
if (!readCertFile(pszCertFile, &pSrcCtx, &hSrcStore))
return false;
WCHAR wszName[1024];
if (!CertGetNameStringW(pSrcCtx, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0 /*dwFlags*/, NULL /*pvTypePara*/,
wszName, sizeof(wszName)))
{
RTMsgError("CertGetNameStringW(Subject) failed: %s\n", errorToString(GetLastError()));
wszName[0] = '\0';
}
/*
* Open the destination store.
*/
bool fRc = false;
HCERTSTORE hDstStore = openCertStore(dwDst, pszStoreNm);
if (hDstStore)
{
if (pSrcCtx)
{
fRc = true;
unsigned cDeleted = 0;
PCCERT_CONTEXT pCurCtx = NULL;
while ((pCurCtx = CertEnumCertificatesInStore(hDstStore, pCurCtx)) != NULL)
{
if (CertCompareCertificate(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, pCurCtx->pCertInfo, pSrcCtx->pCertInfo))
{
if (g_cVerbosityLevel > 1)
RTMsgInfo("Removing '%ls'...", wszName);
PCCERT_CONTEXT pDeleteCtx = CertDuplicateCertificateContext(pCurCtx);
if (pDeleteCtx)
{
if (CertDeleteCertificateFromStore(pDeleteCtx))
cDeleted++;
else
RTMsgError("CertDeleteFromStore('%ls') failed: %s\n", wszName, errorToString(GetLastError()));
}
else
RTMsgError("CertDuplicateCertificateContext('%ls') failed: %s\n", wszName, errorToString(GetLastError()));
}
}
if (!cDeleted)
RTMsgInfo("Found no matching certificates to remove.");
}
else
{
RTMsgError("Path not implemented at line %d\n", __LINE__);
}
CertCloseStore(hDstStore, CERT_CLOSE_STORE_CHECK_FLAG);
}
if (pSrcCtx)
CertFreeCertificateContext(pSrcCtx);
if (hSrcStore)
CertCloseStore(hSrcStore, CERT_CLOSE_STORE_CHECK_FLAG);
return fRc;
}
bool
PGRAviFile::appendFrame( const unsigned char* pBuffer, bool bInvert )
{
if( m_pavifile == NULL || m_pstream == NULL )
{
assert( false );
return false;
}
const unsigned char* pWriteBuffer = pBuffer;
if( bInvert )
{
unsigned char* pDest = m_pTempBuffer;
for( int iRow = m_iRows - 1; iRow >= 0; iRow-- )
{
::memcpy( pDest, &pBuffer[ iRow * m_iRowInc ], m_iRowInc );
pDest += m_iRowInc;
}
pWriteBuffer = m_pTempBuffer;
}
LONG lSamplesWritten;
LONG lBytesWritten;
//
// If the AVI file is opened with openSizeLimitedAVI(), split it if necessory.
//
if ( m_bSizeLimited )
{
//
// Split the file if the total size is more than 'AVI_FILE_SPLIT_SIZE' bytes
//
if ( m_liBytesWritten >= (AVI_FILE_SPLIT_SIZE - m_iSize) )
{
char szAVIFile[ _MAX_PATH ];
close();
m_iSplitFile++;
sprintf(szAVIFile, "%s-%04d.avi", m_szAVIDestFile, m_iSplitFile );
if( !open( szAVIFile, m_iCols, m_iRows, m_iBPP, m_frameRate ) )
return false;
}
}
HRESULT hr = ::AVIStreamWrite(
m_pstreamcompressed,
m_iTimeIndex,
1,
(LPVOID)pWriteBuffer,
m_iSize,
AVIIF_KEYFRAME,
&lSamplesWritten,
&lBytesWritten );
m_liBytesWritten += lBytesWritten;
m_iTimeIndex++;
if( hr != AVIERR_OK )
{
errorToString( hr );
close();
assert( false );
return false;
}
return true;
}
QDebug operator<<(QDebug debug, camera_error_t error)
{
debug.nospace() << errorToString(error);
return debug.space();
}
bool MythSocket::readStringList(QStringList &list, uint timeoutMS)
{
list.clear();
if (state() != Connected)
{
VERBOSE(VB_IMPORTANT, LOC +
"readStringList: Error, called with unconnected socket.");
return false;
}
MythTimer timer;
timer.start();
int elapsed = 0;
while (waitForMore(5) < 8)
{
elapsed = timer.elapsed();
if (elapsed >= (int)timeoutMS)
{
VERBOSE(VB_IMPORTANT, LOC + "readStringList: " +
QString("Error, timed out after %1 ms.").arg(timeoutMS));
close();
return false;
}
if (state() != Connected)
{
VERBOSE(VB_IMPORTANT, LOC +
"readStringList: Connection died.");
return false;
}
{
struct timeval tv;
int maxfd;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(socket(), &rfds);
maxfd = socket();
tv.tv_sec = 0;
tv.tv_usec = 0;
int rval = select(maxfd + 1, &rfds, NULL, NULL, &tv);
if (rval)
{
if (bytesAvailable() == 0)
{
VERBOSE(VB_IMPORTANT, LOC +
"readStringList: Connection died (select).");
return false;
}
}
}
}
QByteArray sizestr(8 + 1, '\0');
if (readBlock(sizestr.data(), 8) < 0)
{
VERBOSE(VB_GENERAL, LOC +
QString("readStringList: Error, readBlock return error (%1)")
.arg(errorToString()));
close();
return false;
}
QString sizes = sizestr;
qint64 btr = sizes.trimmed().toInt();
if (btr < 1)
{
int pending = bytesAvailable();
QByteArray dump(pending + 1, 0);
readBlock(dump.data(), pending);
VERBOSE(VB_IMPORTANT, LOC +
QString("Protocol error: '%1' is not a valid size "
"prefix. %2 bytes pending.")
.arg(sizestr.data()).arg(pending));
return false;
}
QByteArray utf8(btr + 1, 0);
qint64 read = 0;
int errmsgtime = 0;
timer.start();
while (btr > 0)
{
qint64 sret = readBlock(utf8.data() + read, btr);
if (sret > 0)
{
read += sret;
btr -= sret;
if (btr > 0)
{
timer.start();
}
}
else if (sret < 0 && error() != MSocketDevice::NoError)
{
VERBOSE(VB_GENERAL, LOC +
QString("readStringList: Error, readBlock %1")
.arg(errorToString()));
close();
return false;
}
else if (!isValid())
{
VERBOSE(VB_IMPORTANT, LOC +
"readStringList: Error, socket went unconnected");
close();
return false;
}
else
{
elapsed = timer.elapsed();
if (elapsed > 10000)
{
if ((elapsed - errmsgtime) > 10000)
{
errmsgtime = elapsed;
VERBOSE(VB_GENERAL, LOC +
QString("readStringList: Waiting for data: %1 %2")
.arg(read).arg(btr));
}
}
if (elapsed > 100000)
{
VERBOSE(VB_GENERAL, LOC +
"Error, readStringList timeout (readBlock)");
return false;
}
usleep(500);
}
}
QString str = QString::fromUtf8(utf8.data());
QByteArray payload;
payload = payload.setNum(str.length());
payload += " ";
payload.truncate(8);
payload += str;
if (VERBOSE_LEVEL_CHECK(VB_NETWORK))
{
QString msg = QString("read <- %1 %2").arg(socket(), 2)
.arg(payload.data());
if (!VERBOSE_LEVEL_CHECK(VB_EXTRA) && msg.length() > 88)
{
msg.truncate(85);
msg += "...";
}
VERBOSE(VB_NETWORK, LOC + msg);
}
list = str.split("[]:[]");
m_notifyread = false;
s_readyread_thread->WakeReadyReadThread();
return true;
}
bool MythSocket::writeStringList(QStringList &list)
{
if (list.size() <= 0)
{
VERBOSE(VB_IMPORTANT, LOC +
"writeStringList: Error, invalid string list.");
return false;
}
if (state() != Connected)
{
VERBOSE(VB_IMPORTANT, LOC +
"writeStringList: Error, called with unconnected socket.");
return false;
}
QString str = list.join("[]:[]");
if (str.isEmpty())
{
VERBOSE(VB_IMPORTANT, LOC +
"writeStringList: Error, joined null string.");
return false;
}
QByteArray utf8 = str.toUtf8();
int size = utf8.length();
int written = 0;
int written_since_timer_restart = 0;
QByteArray payload;
payload = payload.setNum(size);
payload += " ";
payload.truncate(8);
payload += utf8;
size = payload.length();
if (VERBOSE_LEVEL_CHECK(VB_NETWORK))
{
QString msg = QString("write -> %1 %2")
.arg(socket(), 2).arg(payload.data());
if (!VERBOSE_LEVEL_CHECK(VB_EXTRA) && msg.length() > 88)
{
msg.truncate(85);
msg += "...";
}
VERBOSE(VB_NETWORK, LOC + msg);
}
MythTimer timer; timer.start();
unsigned int errorcount = 0;
while (size > 0)
{
if (state() != Connected)
{
VERBOSE(VB_IMPORTANT, LOC +
"writeStringList: Error, socket went unconnected." +
QString("\n\t\t\tWe wrote %1 of %2 bytes with %3 errors")
.arg(written).arg(written+size).arg(errorcount) +
QString("\n\t\t\tstarts with: %1").arg(toSample(payload)));
return false;
}
int temp = writeBlock(payload.data() + written, size);
if (temp > 0)
{
written += temp;
written_since_timer_restart += temp;
size -= temp;
if ((timer.elapsed() > 500) && written_since_timer_restart != 0)
{
timer.restart();
written_since_timer_restart = 0;
}
}
else if (temp < 0 && error() != MSocketDevice::NoError)
{
VERBOSE(VB_IMPORTANT, LOC +
QString("writeStringList: Error, writeBlock failed. (%1)")
.arg(errorToString()));
return false;
}
else if (temp <= 0)
{
errorcount++;
if (timer.elapsed() > 1000)
{
VERBOSE(VB_GENERAL, LOC + "writeStringList: Error, " +
QString("No data written on writeBlock (%1 errors)")
.arg(errorcount) +
QString("\n\t\t\tstarts with: %1")
.arg(toSample(payload)));
return false;
}
usleep(1000);
}
}
flush();
return true;
}
inline void checkCL(cl_int err, std::string msg = "") {
if(CL_SUCCESS != err) {
std::cout << "CL Error: " << err << ", " << errorToString(err) << " " << msg << std::endl;
}
}
