int GetPattern(struct sockaddr_in ServerID, char *patternbuf, int pattern_max, struct htx_data * stats)
{
SOCKET ToServerSock;
int rc;
int i;
struct CoordMsg CMsg;
int pflength;
char msg_text[1024];
ToServerSock = SetUpConnect(&ServerID, stats, 0);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_REQ_PATTERN);
CMsg.ID.Wsize.size = htonl((uint32_t)pattern_max);
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
sprintf(msg_text, "GetPattern: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT1,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT1);
}
rc = StreamRead(ToServerSock, (char *) &CMsg, sizeof(CMsg));
CMsg.msg_type = ntohl(CMsg.msg_type);
if(CMsg.msg_type != CM_PATTERN) {
sprintf(msg_text, "GetPattern: Unable to obtain pattern file - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT2,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT2);
}
pflength = ntohl(CMsg.ID.Wsize.size);
if(pflength > pattern_max || pflength <= 0) {
sprintf(msg_text, "GetPattern: Server wrote too many characters - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT3,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT3);
}
rc = StreamRead(ToServerSock, (char *) patternbuf, pflength);
if(rc != pflength) {
sprintf(msg_text, "GetPattern: Unable to receive pattern file - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT4,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT4);
}
closesocket(ToServerSock);
/********************************************************************/
/* Fill remainder of patternbuf. */
/********************************************************************/
for(i=pflength; i<pattern_max; i++)
patternbuf[i] = patternbuf[i%pflength];
return pattern_max;
}
bool PNG_Pico_Loader::decode(ResourceLoadOptions& options)
{
std::vector<byte> data;
StreamRead((Stream*) &stream, data);
if( data.empty() ) return false;
uint32 width, height;
std::vector<byte> buffer;
decodePNG(buffer, width, height, &data[0], data.size());
//flip( buffer, width, height );
// Build our image with the data. The pixel format returned by picoPNG
// is always the same, 32bits per pixel, RGBA 8 bits per component.
Image* image = static_cast<Image*>( res );
image->setPixelFormat( PixelFormat::R8G8B8A8 );
image->setWidth( width );
image->setHeight( height );
image->setBuffer( buffer );
return true;
}
void ntlm_read_ntlm_v2_client_challenge(PStream s, NTLMv2_CLIENT_CHALLENGE* challenge)
{
size_t size;
StreamRead_UINT8(s, challenge->RespType);
StreamRead_UINT8(s, challenge->HiRespType);
StreamRead_UINT16(s, challenge->Reserved1);
StreamRead_UINT32(s, challenge->Reserved2);
StreamRead(s, challenge->Timestamp, 8);
StreamRead(s, challenge->ClientChallenge, 8);
StreamRead_UINT32(s, challenge->Reserved3);
size = StreamRemainingSize(s);
challenge->AvPairs = (NTLM_AV_PAIR*) malloc(size);
StreamRead(s, challenge->AvPairs, size);
}
char* CBuffer::readchars(int len)
{
if(len < 0)return NULL;
StreamRead(&retval, len);
retval[len] = '\0';
return retval;
}
void ntlm_read_version_info(PStream s, NTLM_VERSION_INFO* versionInfo)
{
StreamRead_UINT8(s, versionInfo->ProductMajorVersion); /* ProductMajorVersion (1 byte) */
StreamRead_UINT8(s, versionInfo->ProductMinorVersion); /* ProductMinorVersion (1 byte) */
StreamRead_UINT16(s, versionInfo->ProductBuild); /* ProductBuild (2 bytes) */
StreamRead(s, versionInfo->Reserved, sizeof(versionInfo->Reserved)); /* Reserved (3 bytes) */
StreamRead_UINT8(s, versionInfo->NTLMRevisionCurrent); /* NTLMRevisionCurrent (1 byte) */
}
bool STB_Image_Loader::decode(ResourceLoadOptions& options)
{
std::vector<uint8> data;
StreamRead(options.stream, data);
if( data.empty() ) return false;
int width, height, comp;
byte* pixelData = stbi_load_from_memory(
&data[0], data.size(), &width, &height,
&comp, 0 /* 0=auto-detect, 3=RGB, 4=RGBA */ );
if( !pixelData )
{
const char* error = stbi_failure_reason();
LogError("STB image error: %s", error);
return false;
}
// Build our image with the pixel data returned by stb_image.
PixelFormat pf = PixelFormat::Unknown;
switch( comp )
{
case 0:
case 1: break;
case 3: pf = PixelFormat::R8G8B8; break;
case 4: pf = PixelFormat::R8G8B8A8; break;
}
if( pf == PixelFormat::Unknown )
{
LogError( "Implement support for more pixel formats" );
return false;
}
std::vector<byte> buffer;
uint32 size = width*height*comp;
buffer.resize(size);
memcpy(&buffer[0], pixelData, size);
free(pixelData);
Image* image = static_cast<Image*>( options.resource );
image->setWidth( width );
image->setHeight( height );
image->setPixelFormat( pf );
image->setBuffer( buffer );
return true;
}
char* CBuffer::readstring()
{
int i;
for(i = readpos; i < count; i++)
{
if(data[i] == '\0')
break;
}
if(i == count)return NULL;
i-=readpos;
i = min(20000, i);
StreamRead(&retval, i+1);
return retval;
}
void CXMLObject::read ( RCFile f ) {
int i;
FreeMemory();
f.CreateRead ( objTag );
f.CreateRead ( objData );
f.ReadInt ( &nObjects );
nAlloc = nObjects;
if (nObjects>0) {
object = new PCXMLObject[nObjects];
for (i=0;i<nObjects;i++) {
object[i] = NULL;
StreamRead ( f,object[i] );
}
}
}
void CSSGraph::read ( RCFile f ) {
int i,Version;
FreeMemory();
f.ReadInt ( &Version );
f.CreateRead ( name );
f.ReadTerLine ( devChain,False );
f.ReadInt ( &nVertices );
if (nVertices>0) {
nVAlloc = nVertices;
Vertex = new PCSSVertex[nVertices];
for (i=0;i<nVertices;i++) {
Vertex[i] = NULL;
StreamRead ( f,Vertex[i] );
}
}
}
int GetblkCallback(xd3_stream *stream, xd3_source *source, xoff_t blkno) {
bindiff_p in = (bindiff_p)source->ioh;
stream_p istream = ((bindiff_p)(in))->in1;
diffdata_p data = (diffdata_p)(((bindiff_p)(in))->userdata);
int retcode;
int offset = data->org_cur - data->org_last;
if(offset > 0) offset -= BIN_DIFF_NUM_ORGBUFS;
int shift = offset + (int)source->getblkno - (int)source->curblkno;
if(shift <= 0) {
if(shift < 1-BIN_DIFF_NUM_ORGBUFS) return XD3_TOOFARBACK;
data->org_cur = data->org_last+shift;
if(data->org_cur < 0) data->org_cur += BIN_DIFF_NUM_ORGBUFS;
source->curblkno += (shift-offset);
source->curblk = (uint8_t*)data->orgbufs[data->org_cur];
source->onblk = data->orgsizes[data->org_cur];
return 0;
} else {
source->curblkno -= offset;
while(shift--) {
data->org_last++;
if(data->org_last >= BIN_DIFF_NUM_ORGBUFS) data->org_last = 0;
data->org_cur = data->org_last;
retcode = StreamRead(istream, data->orgbufs[data->org_last], BIN_DIFF_WINDOW_SIZE);
if(retcode != STREAM_EOF) {
source->curblkno++;
data->orgsizes[data->org_last] = retcode;
source->onblk = retcode;
source->curblk = (uint8_t*)data->orgbufs[data->org_last];
} else {
data->org_last--;
if(data->org_last < 0) data->org_last += BIN_DIFF_NUM_ORGBUFS;
data->org_cur = data->org_last;
return 0;
}
}
return 0;
}
}
wxBitmap* ConvertImageToBitmap( Image* image, const Path& fullPath )
{
if( !image || !image->isLoaded() )
return nullptr;
PixelFormat pf = image->getPixelFormat();
if( pf != PixelFormat::R8G8B8A8 )
{
LogDebug("Invalid image format: %s", EnumGetValueName(ReflectionGetType(PixelFormat), (int32)pf));
return nullptr;
}
//wxBitmap* bmp = new wxBitmap;
//bmp->Create(&image->getBuffer(), wxBITMAP_TYPE_ANY, image->getWidth(), image->getHeight(), 4);
Stream* stream = StreamCreateFromFile(AllocatorGetHeap(), fullPath, StreamOpenMode::Read);
if( !stream ) return nullptr;
std::vector<byte> data;
StreamRead(stream, data);
wxMemoryInputStream mem(&data[0], data.size());
wxImage img(mem);
img.Rescale(32, 32);
StreamDestroy(stream);
#if 0
const wxSize& size = GetSize();
if( img.GetWidth() > size.GetWidth() || img.GetHeight() > size.GetHeight() )
{
img.Rescale( size.GetWidth(), size.GetHeight() );
}
#endif
wxBitmap* bmp = new wxBitmap(img);
return bmp;
}
void Body::Serialize(ISerializer& stream)
{
StreamRead(stream,Mass);
StreamRead(stream,Friction);
StreamRead(stream,Restitution);
std::string shapeName;
StreamRead(stream,shapeName);
if( shapeName == "Circle" )
{
ShapeCircle * shape = new ShapeCircle();
StreamRead(stream,shape->Radius);
this->BodyShape = shape;
}
if( shapeName == "Box" )
{
ShapeAAB * shape = new ShapeAAB();
StreamRead(stream,shape->Extents);
this->BodyShape = shape;
}
}
int CBuffer::readint()
{
int b;
StreamRead(&b, 4);
return b;
}
void ntlm_read_ntlm_v2_response(PStream s, NTLMv2_RESPONSE* response)
{
StreamRead(s, response->Response, 16);
ntlm_read_ntlm_v2_client_challenge(s, &(response->Challenge));
}
int GetRules(struct sockaddr_in ServerID, struct rule_format rule[], int max_rules, struct htx_data * stats)
{
SOCKET ToServerSock;
struct CoordMsg CMsg;
int rc;
int i;
int NoStanzas;
char msg[1024];
errno = 0;
ToServerSock = SetUpConnect(&ServerID, stats, 0);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_REQ_RULES);
CMsg.ID.Wsize.size = htonl((uint32_t)sizeof(struct rule_format));
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
sprintf(msg, "GetRules: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_RULE1,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE1);
}
StreamRead(ToServerSock, (char *) &CMsg, sizeof(CMsg));
CMsg.msg_type = ntohl(CMsg.msg_type);
CMsg.ID.Wsize.size = ntohl(CMsg.ID.Wsize.size);
if(CMsg.msg_type != CM_RULES_STANZA) {
sprintf(msg, "GetRules: Illegal Packet recvd.\n");
hxfmsg(stats, HTXERROR(EX_RULE3,0), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE3);
}
#ifdef __DEBUG__
sprintf(msg, "GetRules: Sock = %d, Recvd msg = %x of size = %#x, rule_format size = %x, pid = %d \n", ToServerSock, CMsg.msg_type, sizeof(CMsg), (uint32_t)sizeof(struct rule_format), getpid());
hxfmsg(stats, 0, 7, msg);
#endif
memset(rule, '\0', sizeof(struct rule_format) * max_rules);
memset(&CMsg, '\0', sizeof(CMsg));
for(i=0; i < max_rules; i++) {
rc = StreamRead(ToServerSock, (char *) &CMsg.msg_type, sizeof(CMsg.msg_type));
CMsg.msg_type = ntohl(CMsg.msg_type);
#ifdef __DEBUG__
sprintf(msg, "i = %#x, GetRules: Recvd msg = %x, of size = %x \n", i, CMsg.msg_type, sizeof(CMsg.msg_type));
hxfmsg(stats, 0, 7, msg);
#endif
if(CMsg.msg_type == CM_RULES_FINISHED)
break;
if(CMsg.msg_type != CM_RULES_STANZA) {
sprintf(msg, "GetRules: Unable to obtain rules - type %x\n", (int)CMsg.msg_type);
hxfmsg(stats, HTXERROR(EX_RULE2,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE2);
}
rc = StreamRead(ToServerSock, (char*) &rule[i], sizeof(struct rule_format));
if(rc != sizeof(struct rule_format)) {
sprintf(msg, "GetRules: Unable to read rules from server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_RULE4,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE3);
}
NetToHostRules(&rule[i]);
}
NoStanzas = i;
closesocket(ToServerSock);
return NoStanzas;
}
void ntlm_input_av_pairs(NTLM_CONTEXT* context, PStream s)
{
AV_ID AvId;
UINT16 AvLen;
BYTE* value;
AV_PAIRS* av_pairs = context->av_pairs;
#ifdef WITH_DEBUG_NTLM
printf("AV_PAIRS = {\n");
#endif
do
{
value = NULL;
StreamRead_UINT16(s, AvId);
StreamRead_UINT16(s, AvLen);
if (AvLen > 0)
{
if (AvId != MsvAvFlags)
{
value = malloc(AvLen);
StreamRead(s, value, AvLen);
}
else
{
StreamRead_UINT32(s, av_pairs->Flags);
}
}
switch (AvId)
{
case MsvAvNbComputerName:
av_pairs->NbComputerName.length = AvLen;
av_pairs->NbComputerName.value = value;
break;
case MsvAvNbDomainName:
av_pairs->NbDomainName.length = AvLen;
av_pairs->NbDomainName.value = value;
break;
case MsvAvDnsComputerName:
av_pairs->DnsComputerName.length = AvLen;
av_pairs->DnsComputerName.value = value;
break;
case MsvAvDnsDomainName:
av_pairs->DnsDomainName.length = AvLen;
av_pairs->DnsDomainName.value = value;
break;
case MsvAvDnsTreeName:
av_pairs->DnsTreeName.length = AvLen;
av_pairs->DnsTreeName.value = value;
break;
case MsvAvTimestamp:
av_pairs->Timestamp.length = AvLen;
av_pairs->Timestamp.value = value;
break;
case MsvAvRestrictions:
av_pairs->Restrictions.length = AvLen;
av_pairs->Restrictions.value = value;
break;
case MsvAvTargetName:
av_pairs->TargetName.length = AvLen;
av_pairs->TargetName.value = value;
break;
case MsvChannelBindings:
av_pairs->ChannelBindings.length = AvLen;
av_pairs->ChannelBindings.value = value;
break;
default:
if (value != NULL)
free(value);
break;
}
#ifdef WITH_DEBUG_NTLM
if (AvId < 10)
printf("\tAvId: %s, AvLen: %d\n", AV_PAIRS_STRINGS[AvId], AvLen);
else
printf("\tAvId: %s, AvLen: %d\n", "Unknown", AvLen);
winpr_HexDump(value, AvLen);
#endif
}
while (AvId != MsvAvEOL);
#ifdef WITH_DEBUG_NTLM
printf("}\n");
#endif
}
unsigned char CBuffer::readbyte()
{
unsigned char b;
StreamRead(&b, 1);
return b;
}
short CBuffer::readshort()
{
short b;
StreamRead(&b, 2);
return b;
}
HRESULT LegacySyncSetProduct(
__in CFGDB_STRUCT *pcdb,
__inout LEGACY_SYNC_SESSION *pSyncSession,
__in LPCWSTR wzName
)
{
HRESULT hr = S_OK;
LEGACY_SYNC_PRODUCT_SESSION *pSyncProductSession = &pSyncSession->syncProductSession;
LEGACY_FILE *pFile = NULL;
LEGACY_FILE_SPECIAL *pFileSpecial = NULL;
LEGACY_INI_FILE *pIniFile = NULL;
CONFIG_VALUE cvManifestContents = { };
CONFIG_VALUE cvManifestConvertedToBlob = { };
SCE_ROW_HANDLE sceManifestValueRow = NULL;
LPWSTR sczManifestValueName = NULL;
BOOL fWasRegistered = FALSE;
BYTE *pbManifestBuffer = NULL;
SIZE_T iManifestBuffer = 0;
LPWSTR sczBlobManifestAsString = NULL;
if (pSyncSession->fInSceTransaction)
{
SceRollbackTransaction(pcdb->psceDb);
pSyncSession->fInSceTransaction = FALSE;
}
hr = ProductGetLegacyManifestValueName(wzName, &sczManifestValueName);
ExitOnFailure(hr, "Failed to get legacy manifest value name");
ManifestFreeProductStruct(&pSyncProductSession->product);
ZeroMemory(&pSyncProductSession->product, sizeof(pSyncProductSession->product));
for (DWORD i = 0; i < pSyncProductSession->cIniFiles; ++i)
{
IniFree(pSyncProductSession->rgIniFiles + i);
}
ReleaseNullMem(pSyncProductSession->rgIniFiles);
pSyncProductSession->cIniFiles = 0;
ReleaseNullDict(pSyncProductSession->shDictValuesSeen);
ReleaseNullDict(pSyncProductSession->shIniFilesByNamespace);
hr = DictCreateStringList(&pSyncProductSession->shDictValuesSeen, 0, DICT_FLAG_CASEINSENSITIVE);
ExitOnFailure(hr, "Failed to create dictionary of values seen");
hr = DictCreateWithEmbeddedKey(&pSyncProductSession->shIniFilesByNamespace, 0, reinterpret_cast<void **>(&pSyncProductSession->rgIniFiles), offsetof(LEGACY_INI_FILE, sczNamespace), DICT_FLAG_CASEINSENSITIVE);
ExitOnFailure(hr, "Failed to create ini file dictionary");
hr = DictCreateWithEmbeddedKey(&pSyncProductSession->product.detect.shCachedDetectionPropertyValues, offsetof(LEGACY_CACHED_DETECTION_RESULT, sczPropertyName), reinterpret_cast<void **>(&pSyncProductSession->product.detect.rgCachedDetectionProperties), 0, DICT_FLAG_CASEINSENSITIVE);
ExitOnFailure(hr, "Failed to create cached detection property values dictionary");
hr = ValueFindRow(pcdb, pcdb->dwCfgAppID, sczManifestValueName, &sceManifestValueRow);
ExitOnFailure(hr, "Failed to find config value for legacy manifest (AppID: %u, Config Value named: %ls)", pcdb->dwCfgAppID, sczManifestValueName);
hr = ValueRead(pcdb, sceManifestValueRow, &cvManifestContents);
ExitOnFailure(hr, "Failed to read manifest contents");
// TODO: someday remove this temporary conversion code when we feel confident nobody has old databases with old manifests laying around
if (VALUE_STRING == cvManifestContents.cvType)
{
LogStringLine(REPORT_STANDARD, "Converting manifest value named %ls from string to blob value", sczManifestValueName);
hr = ValueSetBlob(reinterpret_cast<BYTE *>(cvManifestContents.string.sczValue), lstrlenW(cvManifestContents.string.sczValue) * sizeof(WCHAR), FALSE, NULL, pcdb->sczGuid, &cvManifestConvertedToBlob);
ExitOnFailure(hr, "Failed to set converted manifest value in memory");
hr = ValueWrite(pcdb, pcdb->dwCfgAppID, sczManifestValueName, &cvManifestConvertedToBlob, TRUE, NULL);
ExitOnFailure(hr, "Failed to set converted manifest blob: %ls", sczManifestValueName);
ReleaseNullSceRow(sceManifestValueRow);
ReleaseNullCfgValue(cvManifestContents);
hr = ValueFindRow(pcdb, pcdb->dwCfgAppID, sczManifestValueName, &sceManifestValueRow);
ExitOnFailure(hr, "Failed to find config value for legacy manifest after conversion (AppID: %u, Config Value named: %ls)", pcdb->dwCfgAppID, sczManifestValueName);
hr = ValueRead(pcdb, sceManifestValueRow, &cvManifestContents);
ExitOnFailure(hr, "Failed to read converted manifest contents");
}
if (VALUE_BLOB != cvManifestContents.cvType)
{
hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
ExitOnFailure(hr, "Stored manifest value was not of type blob");
}
if (CFG_BLOB_DB_STREAM != cvManifestContents.blob.cbType)
{
hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
ExitOnFailure(hr, "Stored manifest blob was not a database stream");
}
hr = StreamRead(pcdb, cvManifestContents.blob.dbstream.dwContentID, NULL, &pbManifestBuffer, &iManifestBuffer);
ExitOnFailure(hr, "Failed to get binary content of blob named: %ls, with content ID: %u", sczManifestValueName, pcdb->dwCfgAppID);
hr = StrAllocString(&sczBlobManifestAsString, reinterpret_cast<LPWSTR>(pbManifestBuffer), iManifestBuffer / sizeof(WCHAR));
ExitOnFailure(hr, "Failed to add null terminator to manifest blob");
hr = ParseManifest(sczBlobManifestAsString, &pSyncProductSession->product);
ExitOnFailure(hr, "Failed to parse manifest");
hr = ProductSet(pcdb, wzName, wzLegacyVersion, wzLegacyPublicKey, FALSE, NULL);
ExitOnFailure(hr, "Failed to set product");
hr = ProductIsRegistered(pcdb, pcdb->sczProductName, wzLegacyVersion, wzLegacyPublicKey, &fWasRegistered);
ExitOnFailure(hr, "Failed to check if product is registered");
hr = DetectProduct(pcdb, !pSyncSession->fDetect, &pSyncSession->arpProducts, &pSyncSession->exeProducts, pSyncProductSession);
ExitOnFailure(hr, "Failed to detect product with AppID: %u", pcdb->dwAppID);
// Don't bother writing new registration state data to the database if detect is disabled
if (pSyncSession->fDetect)
{
hr = UpdateProductRegistrationState(pcdb, pSyncProductSession, pcdb->sczProductName, wzLegacyVersion, wzLegacyPublicKey);
ExitOnFailure(hr, "Failed to update product registration state");
}
hr = ProductIsRegistered(pcdb, pcdb->sczProductName, wzLegacyVersion, wzLegacyPublicKey, &pSyncProductSession->fRegistered);
ExitOnFailure(hr, "Failed to check if product is registered");
pSyncProductSession->fNewlyRegistered = (!fWasRegistered && pSyncProductSession->fRegistered);
for (DWORD i = 0; i < pSyncProductSession->product.cFiles; ++i)
{
pFile = pSyncProductSession->product.rgFiles + i;
hr = UtilExpandLegacyPath(pFile->sczLocation, &pSyncProductSession->product.detect, &pFile->sczExpandedPath);
if (E_NOTFOUND == hr)
{
hr = S_OK;
}
if (NULL != pFile->sczExpandedPath)
{
for (DWORD j = 0; j < pFile->cFileSpecials; ++j)
{
pFileSpecial = pFile->rgFileSpecials + j;
if (0 < pFileSpecial->cIniInfo)
{
hr = MemEnsureArraySize(reinterpret_cast<void **>(&pSyncProductSession->rgIniFiles), pSyncProductSession->cIniFiles + 1, sizeof(LEGACY_INI_FILE), 5);
ExitOnFailure(hr, "Failed to grow active IniFiles array");
pIniFile = pSyncProductSession->rgIniFiles + pSyncProductSession->cIniFiles;
hr = IniFileOpen(pFile, pFileSpecial, pFileSpecial->rgIniInfo, pIniFile);
ExitOnFailure(hr, "Failed to parse INI file");
hr = DictAddValue(pSyncProductSession->shIniFilesByNamespace, pIniFile);
ExitOnFailure(hr, "Failed to add INI file to dict for namespace: %ls", pIniFile->sczNamespace);
++pSyncProductSession->cIniFiles;
}
}
}
}
// IMPORTANT: Put all legacy database actions into a separate transaction
// for each product. In the case of any kind of failure, it's OK to leave
// changes written to local machine registry / file system, but not the
// legacy database - they'll just appear as local machine changes on next
// sync, and everything will be happy. The other way around is NOT happy,
// because every sync would create another history entry, ad infinitum!
hr = SceBeginTransaction(pcdb->psceDb);
ExitOnFailure(hr, "Failed to begin transaction");
pSyncSession->fInSceTransaction = TRUE;
LExit:
ReleaseSceRow(sceManifestValueRow);
ReleaseCfgValue(cvManifestContents);
ReleaseCfgValue(cvManifestConvertedToBlob);
ReleaseStr(sczManifestValueName);
ReleaseMem(pbManifestBuffer);
ReleaseStr(sczBlobManifestAsString);
return hr;
}
int BinDiff(void *in, void *buffer, size_t size) {
stream_p modified = ((bindiff_p)(in))->in2;
diffdata_p data = (diffdata_p)(((bindiff_p)(in))->userdata);
int retcode;
int len_done = 0;
// Alloc resources if needed
if(data == NULL)
{
data = malloc(sizeof(diffdata_t));
xd3_init_config(&data->config, 0);
data->config.winsize = BIN_DIFF_WINDOW_SIZE;
data->config.getblk = &GetblkCallback;
retcode = xd3_config_stream(&data->stream, &data->config);
if (retcode != 0) return STREAM_EOF;
data->source.ioh = in;
data->source.curblkno = (xoff_t) -1;
data->source.curblk = NULL;
data->source.blksize = BIN_DIFF_WINDOW_SIZE;
retcode = xd3_set_source(&data->stream, &data->source);
if (retcode != 0) return STREAM_EOF;
data->haveData = 0;
data->reachedEOF = 0;
data->org_cur = data->org_last = 0;
((bindiff_p)(in))->userdata = data;
}
if(data->haveData) {
if((size_t)data->haveData >= size) {
memcpy (buffer, &data->stream.next_out[data->stream.avail_out-data->haveData], size);
data->haveData = data->haveData - size;
return size;
} else {
memcpy (buffer, &data->stream.next_out[data->stream.avail_out-data->haveData], data->haveData);
len_done = data->haveData;
data->stream.avail_out = 0;
data->haveData = 0;
}
}
do {
if(((bindiff_p)(in))->isPatch) retcode = xd3_decode_input(&data->stream);
else retcode = xd3_encode_input(&data->stream);
switch (retcode) {
case XD3_INPUT:
if(data->reachedEOF) return len_done ? len_done : STREAM_EOF;
retcode = StreamRead(modified, data->inbuf, BIN_DIFF_WINDOW_SIZE);
//fprintf(stderr,"\tXD3_INPUT (%i)\n", retcode);
if (retcode == STREAM_EOF) {
xd3_set_flags (&data->stream, XD3_FLUSH);
data->reachedEOF = 1;
retcode = 0;
}
xd3_avail_input(&data->stream, (uint8_t*)data->inbuf, retcode);
continue;
case XD3_OUTPUT:
//fprintf(stderr,"\tXD3_OUTPUT (%i)\n", data->stream.avail_out);
if(data->stream.avail_out >= (size-len_done)) {
memcpy (((char *)buffer)+len_done, data->stream.next_out, size-len_done);
data->haveData = data->stream.avail_out - size+len_done;
return size;
} else {
memcpy (((char *)buffer)+len_done, data->stream.next_out, data->stream.avail_out);
len_done += data->stream.avail_out;
data->stream.avail_out = 0;
data->haveData = 0;
continue;
}
case XD3_GETSRCBLK:
case XD3_GOTHEADER:
case XD3_WINSTART:
case XD3_WINFINISH:
continue;
default:
//fprintf(stderr,"\terror: %s\n", data->stream.msg);
return STREAM_EOF;
}
} while (1);
}
double CBuffer::readdouble()
{
double b;
StreamRead(&b, 8);
return b;
}
float CBuffer::readfloat()
{
float b;
StreamRead(&b, 4);
return b;
}
unsigned int CBuffer::readuint()
{
unsigned int b;
StreamRead(&b, 4);
return b;
}
extern "C" HRESULT RegDefaultWriteValue(
__in LEGACY_PRODUCT *pProduct,
__in_z LPCWSTR wzName,
__in const CONFIG_VALUE *pcvValue,
__out BOOL *pfHandled
)
{
HRESULT hr = S_OK;
LPWSTR sczValue = NULL;
LPWSTR sczRegKey = NULL;
LPWSTR sczRegValueName = NULL;
BYTE *pbBuffer = NULL;
SIZE_T cbBuffer = 0;
BOOL fReleaseBuffer = FALSE;
DWORD dwRoot = DWORD_MAX;
HKEY hk = NULL;
hr = MapCfgNameToRegValue(pProduct, wzName, &dwRoot, &sczRegKey, &sczRegValueName);
if (E_INVALIDARG == hr)
{
*pfHandled = FALSE;
// Not a regkey, so just ignore
ExitFunction1(hr = S_OK);
}
ExitOnFailure(hr, "Failed to convert value name to registry information");
*pfHandled = TRUE;
hr = RegOpen(ManifestConvertToRootKey(dwRoot), sczRegKey, KEY_SET_VALUE, &hk);
if (E_FILENOTFOUND == hr)
{
hr = S_OK;
// The key doesn't exist, so no need to proceed with deleting the value
if (VALUE_DELETED == pcvValue->cvType)
{
ExitFunction1(hr = S_OK);
}
hr = RegCreate(ManifestConvertToRootKey(dwRoot), sczRegKey, KEY_SET_VALUE, &hk);
ExitOnFailure(hr, "Failed to create regkey: %ls", sczRegKey);
}
ExitOnFailure(hr, "Failed to open regkey: %ls", sczRegKey);
switch (pcvValue->cvType)
{
case VALUE_DELETED:
hr = RegWriteString(hk, sczRegValueName, NULL);
ExitOnFailure(hr, "Failed to delete existing value");
break;
case VALUE_BLOB:
switch (pcvValue->blob.cbType)
{
case CFG_BLOB_POINTER:
pbBuffer = const_cast<BYTE *>(pcvValue->blob.pointer.pbValue);
cbBuffer = pcvValue->blob.cbValue;
break;
case CFG_BLOB_DB_STREAM:
fReleaseBuffer = TRUE;
hr = StreamRead(pcvValue->blob.dbstream.pcdb, pcvValue->blob.dbstream.dwContentID, NULL, &pbBuffer, &cbBuffer);
ExitOnFailure(hr, "Failed to read stream from database while writing binary to the registry");
break;
default:
hr = E_INVALIDARG;
ExitOnFailure(hr, "Invalid blob type encountered");
break;
}
hr = RegWriteBinary(hk, sczRegValueName, pbBuffer, cbBuffer);
ExitOnFailure(hr, "Failed to write binary value to registry");
break;
case VALUE_STRING:
hr = RegWriteString(hk, sczRegValueName, pcvValue->string.sczValue);
ExitOnFailure(hr, "Failed to write string to registry");
break;
case VALUE_DWORD:
hr = RegWriteNumber(hk, sczRegValueName, pcvValue->dword.dwValue);
ExitOnFailure(hr, "Failed to write dword to registry");
break;
case VALUE_QWORD:
hr = RegWriteQword(hk, sczRegValueName, pcvValue->qword.qwValue);
ExitOnFailure(hr, "Failed to write qword to registry");
break;
default:
ExitFunction1(hr = E_INVALIDARG);
}
LExit:
ReleaseRegKey(hk);
ReleaseStr(sczValue);
ReleaseStr(sczRegKey);
ReleaseStr(sczRegValueName);
if (fReleaseBuffer)
{
ReleaseMem(pbBuffer);
}
return hr;
}
unsigned short CBuffer::readushort()
{
unsigned short b;
StreamRead(&b, 2);
return b;
}
