bool Decrypt(const wxString &sText, wxString &sDecryptText)
{
GByte *pabyKey = GetKey();
GByte *pabyIV = GetIV();
EVP_CIPHER_CTX* ctx = CreateCTX(pabyKey, pabyIV, true);
if(!ctx)
{
wxLogError(_("Decrypt: Failed EVP_DecryptInit!"));
CPLFree( pabyKey );
CPLFree( pabyIV );
return false;
}
int nTextBytes;
GByte *pabyText = CPLHexToBinary( sText.mb_str(wxConvUTF8), &nTextBytes );
int outlen;
unsigned char outbuf[BUFSIZE];
bool bResult = EVP_DecryptUpdate(ctx, outbuf, &outlen, pabyText, nTextBytes);
if(!bResult)
{
wxLogError(_("Decrypt: Failed EVP_DecryptUpdate!"));
CPLFree( pabyKey );
CPLFree( pabyIV );
CPLFree( pabyText );
return bResult;
}
int nLen = outlen;
bResult = EVP_DecryptFinal(ctx, &outbuf[outlen], &outlen);
nLen += outlen;
outbuf[nLen] = 0;
CPLString szCryptText((const char*)outbuf);
sDecryptText = wxString(szCryptText, wxConvUTF8);
CPLFree( pabyKey );
CPLFree( pabyIV );
CPLFree( pabyText );
EVP_CIPHER_CTX_cleanup(ctx);
//EVP_CIPHER_CTX_free(ctx);
return bResult;
}
GByte *GetKey(void)
{
wxGISAppConfig oConfig = GetConfig();
if(!oConfig.IsOk())
return NULL;
//try get key data from config
wxString sKey = oConfig.Read(enumGISHKCU, wxString(wxT("wxGISCommon/crypt/key")), wxString(ERR));
if(sKey.CmpNoCase(wxString(ERR)) == 0)
{
if(!CreateRandomData())//create random key data
return NULL;
//second try get key data from config
sKey = oConfig.Read(enumGISHKCU, wxString(wxT("wxGISCommon/crypt/key")), wxString(ERR));
if(sKey.CmpNoCase(wxString(ERR)) == 0)
return NULL;
}
int nKeyBytes;
GByte *pabyKey = CPLHexToBinary( sKey.mb_str(wxConvUTF8), &nKeyBytes );
return pabyKey;
}
/*****************************************************
* \brief Read a natural block of raster band data
*****************************************************/
CPLErr PostGISRasterRasterBand::IReadBlock(int nBlockXOff,
int nBlockYOff, void * pImage)
{
PGresult * poResult = NULL;
CPLString osCommand;
int nXOff = 0;
int nYOff = 0;
int nNaturalBlockXSize = 0;
int nNaturalBlockYSize = 0;
double adfProjWin[8];
PostGISRasterDataset * poRDS = (PostGISRasterDataset *)poDS;
int nPixelSize = GDALGetDataTypeSize(eDataType) / 8;
// Construct a polygon to intersect with
GetBlockSize(&nNaturalBlockXSize, &nNaturalBlockYSize);
nXOff = nBlockXOff * nNaturalBlockXSize;
nYOff = nBlockYOff * nNaturalBlockYSize;
poRDS->PolygonFromCoords(nXOff, nYOff, nXOff + nNaturalBlockXSize, nYOff + nNaturalBlockYSize, adfProjWin);
// Raise the query
if (poRDS->pszWhere == NULL) {
osCommand.Printf("SELECT st_band(%s, %d) FROM %s.%s "
"WHERE st_intersects(%s, ST_PolygonFromText"
"('POLYGON((%.17f %.17f, %.17f %.17f, %.17f %.17f, %.17f "
"%.17f, %.17f %.17f))', %d))", pszColumn, nBand, pszSchema,
pszTable, pszColumn, adfProjWin[0], adfProjWin[1],
adfProjWin[2], adfProjWin[3], adfProjWin[4], adfProjWin[5],
adfProjWin[6], adfProjWin[7], adfProjWin[0], adfProjWin[1],
poRDS->nSrid);
}
else {
osCommand.Printf("SELECT st_band(%s, %d) FROM %s.%s WHERE (%s) "
"AND st_intersects(%s, ST_PolygonFromText"
"('POLYGON((%.17f %.17f, %.17f %.17f, %.17f %.17f, %.17f "
"%.17f, %.17f %.17f))', %d))", pszColumn, nBand, pszSchema,
pszTable, poRDS->pszWhere, pszColumn, adfProjWin[0],
adfProjWin[1], adfProjWin[2], adfProjWin[3], adfProjWin[4],
adfProjWin[5], adfProjWin[6], adfProjWin[7], adfProjWin[0],
adfProjWin[1], poRDS->nSrid);
}
#ifdef DEBUG_QUERY
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IReadBlock(): Query = %s",
osCommand.c_str());
#endif
poResult = PQexec(poRDS->poConn, osCommand.c_str());
if (poResult == NULL ||
PQresultStatus(poResult) != PGRES_TUPLES_OK ||
PQntuples(poResult) < 0) {
if (poResult)
PQclear(poResult);
ReportError(CE_Failure, CPLE_AppDefined,
"Error retrieving raster data FROM database");
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IRasterIO(): %s",
PQerrorMessage(poRDS->poConn));
return CE_Failure;
}
/**
* No data. Return the buffer filled with nodata values
**/
else if (PQntuples(poResult) == 0) {
PQclear(poResult);
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IRasterIO(): Null block");
NullBlock(pImage);
return CE_None;
}
/**
* Ok, we get the data. Only data size, without payload
*
* TODO: Check byte order
**/
int nExpectedDataSize = nNaturalBlockXSize * nNaturalBlockYSize *
nPixelSize;
int nWKBLength = 0;
GByte * pbyData = CPLHexToBinary(PQgetvalue(poResult, 0, 0),
&nWKBLength);
char * pbyDataToRead = (char*)GET_BAND_DATA(pbyData,nBand,
nPixelSize, nExpectedDataSize);
memcpy(pImage, pbyDataToRead, nExpectedDataSize * sizeof(char));
CPLDebug("PostGIS_Raster", "IReadBlock: Copied %d bytes FROM block "
"(%d, %d) to %p", nExpectedDataSize, nBlockXOff,
nBlockYOff, pImage);
CPLFree(pbyData);
PQclear(poResult);
return CE_None;
}
CPLErr GDALPamRasterBand::XMLInit( CPLXMLNode *psTree, const char *pszUnused )
{
PamInitialize();
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Collect various other items of metadata. */
/* -------------------------------------------------------------------- */
GDALMajorObject::SetDescription( CPLGetXMLValue( psTree, "Description", "" ) );
if( CPLGetXMLValue( psTree, "NoDataValue", NULL ) != NULL )
{
const char *pszLEHex =
CPLGetXMLValue( psTree, "NoDataValue.le_hex_equiv", NULL );
if( pszLEHex != NULL )
{
int nBytes;
GByte *pabyBin = CPLHexToBinary( pszLEHex, &nBytes );
if( nBytes == 8 )
{
CPL_LSBPTR64( pabyBin );
GDALPamRasterBand::SetNoDataValue( *((double *) pabyBin) );
}
else
{
GDALPamRasterBand::SetNoDataValue(
atof(CPLGetXMLValue( psTree, "NoDataValue", "0" )) );
}
CPLFree( pabyBin );
}
else
{
GDALPamRasterBand::SetNoDataValue(
atof(CPLGetXMLValue( psTree, "NoDataValue", "0" )) );
}
}
GDALPamRasterBand::SetOffset(
atof(CPLGetXMLValue( psTree, "Offset", "0.0" )) );
GDALPamRasterBand::SetScale(
atof(CPLGetXMLValue( psTree, "Scale", "1.0" )) );
GDALPamRasterBand::SetUnitType( CPLGetXMLValue( psTree, "UnitType", NULL));
if( CPLGetXMLValue( psTree, "ColorInterp", NULL ) != NULL )
{
const char *pszInterp = CPLGetXMLValue( psTree, "ColorInterp", NULL );
GDALPamRasterBand::SetColorInterpretation(
GDALGetColorInterpretationByName(pszInterp));
}
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "CategoryNames" ) != NULL )
{
CPLXMLNode *psEntry;
char **papszCategoryNames = NULL;
for( psEntry = CPLGetXMLNode( psTree, "CategoryNames" )->psChild;
psEntry != NULL; psEntry = psEntry->psNext )
{
/* Don't skeep <Category> tag with empty content */
if( psEntry->eType != CXT_Element
|| !EQUAL(psEntry->pszValue,"Category")
|| (psEntry->psChild != NULL && psEntry->psChild->eType != CXT_Text) )
continue;
papszCategoryNames = CSLAddString( papszCategoryNames,
(psEntry->psChild) ? psEntry->psChild->pszValue : "" );
}
GDALPamRasterBand::SetCategoryNames( papszCategoryNames );
}
/* -------------------------------------------------------------------- */
/* Collect a color table. */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "ColorTable" ) != NULL )
{
CPLXMLNode *psEntry;
GDALColorTable oTable;
int iEntry = 0;
for( psEntry = CPLGetXMLNode( psTree, "ColorTable" )->psChild;
psEntry != NULL; psEntry = psEntry->psNext )
{
GDALColorEntry sCEntry;
sCEntry.c1 = (short) atoi(CPLGetXMLValue( psEntry, "c1", "0" ));
sCEntry.c2 = (short) atoi(CPLGetXMLValue( psEntry, "c2", "0" ));
sCEntry.c3 = (short) atoi(CPLGetXMLValue( psEntry, "c3", "0" ));
sCEntry.c4 = (short) atoi(CPLGetXMLValue( psEntry, "c4", "255" ));
oTable.SetColorEntry( iEntry++, &sCEntry );
}
GDALPamRasterBand::SetColorTable( &oTable );
}
/* -------------------------------------------------------------------- */
/* Do we have a complete set of stats? */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "Minimum" ) != NULL
&& CPLGetXMLNode( psTree, "Maximum" ) != NULL )
{
psPam->bHaveMinMax = TRUE;
psPam->dfMin = atof(CPLGetXMLValue(psTree, "Minimum","0"));
psPam->dfMax = atof(CPLGetXMLValue(psTree, "Maximum","0"));
}
if( CPLGetXMLNode( psTree, "Mean" ) != NULL
&& CPLGetXMLNode( psTree, "StandardDeviation" ) != NULL )
{
psPam->bHaveStats = TRUE;
psPam->dfMean = atof(CPLGetXMLValue(psTree, "Mean","0"));
psPam->dfStdDev = atof(CPLGetXMLValue(psTree,"StandardDeviation","0"));
}
/* -------------------------------------------------------------------- */
/* Histograms */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHist = CPLGetXMLNode( psTree, "Histograms" );
if( psHist != NULL )
{
CPLXMLNode *psNext = psHist->psNext;
psHist->psNext = NULL;
psPam->psSavedHistograms = CPLCloneXMLTree( psHist );
psHist->psNext = psNext;
}
/* -------------------------------------------------------------------- */
/* Raster Attribute Table */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRAT = CPLGetXMLNode( psTree, "GDALRasterAttributeTable" );
if( psRAT != NULL )
{
psPam->poDefaultRAT = new GDALRasterAttributeTable();
psPam->poDefaultRAT->XMLInit( psRAT, "" );
}
return CE_None;
}
/**
* Fill all the raster properties with the string
* hexwkb representation given as input.
* This method swaps words if the raster endianess is distinct from
* the machine endianess
* Properties:
* const char *: the string hexwkb representation of the raster
*/
int WKTRasterWrapper::Initialize(const char* pszHex) {
int nBufferDataWithoutHeaderLen = 0;
int nRasterHeaderLen = 0;
int nRasterBandHeaderLen = 0;
int nRasterDataLen = 0;
GByte * pbyAuxPtr;
GByte byMachineEndianess = NDR; // by default
// Check machine endianess
#ifdef CPL_LSB
byMachineEndianess = NDR;
#else
byMachineEndianess = XDR;
#endif
/*************************************************************************
* Check parameters
*************************************************************************/
if (pszHex == NULL || strlen(pszHex) % 2) {
CPLError(CE_Failure, CPLE_NotSupported,
"Couldn't create raster wrapper, invalid raster hexwkb string");
return FALSE;
}
/*************************************************************************
* Check if raster has enough data
*************************************************************************/
nRasterHeaderLen =
sizeof (GByte) +
4 * sizeof (GUInt16) +
sizeof (GInt32) +
6 * sizeof (double);
nBufferDataWithoutHeaderLen =
strlen(pszHex +2*nRasterHeaderLen) / 2;
pbyHexWkb = CPLHexToBinary(pszHex, &nLengthByWkbString);
if (nRasterHeaderLen > nLengthByWkbString ||
nLengthByWkbString != nRasterHeaderLen + nBufferDataWithoutHeaderLen)
{
CPLError(CE_Failure, CPLE_ObjectNull,
"Raster object is corrupted, not enough data");
return FALSE;
}
/*************************************************************************
* Copy raster as class attribute, and transform it to binary
*************************************************************************/
nLengthHexWkbString = strlen(pszHex);
pszHexWkb = (char *) VSIMalloc(nLengthHexWkbString);
if (pszHexWkb == NULL) {
CPLError(CE_Failure, CPLE_ObjectNull,
"Couldn't allocate memory for raster wrapper, aborting");
return FALSE;
}
memcpy(pszHexWkb, pszHex, nLengthHexWkbString * sizeof (GByte));
/***********************************************************************
* Get endianess. This is important, because we could need to swap
* words if the data endianess is distinct from machine endianess
***********************************************************************/
memcpy(&byEndianess, pbyHexWkb, sizeof(GByte));
// We are going to use this pointer to move over the string
pbyAuxPtr = pbyHexWkb + sizeof (GByte);
/*************************************************************************
* Parse HexWkb string in binary format and fill the rest of class fields
*************************************************************************/
memcpy(&nVersion, pbyAuxPtr, sizeof (GUInt16));
if (byEndianess != byMachineEndianess)
GDALSwapWords(&nVersion, sizeof (GUInt16), 1, sizeof (GUInt16));
pbyAuxPtr += sizeof (GUInt16);
/**
* Check WKT Raster version
*/
if (nVersion != WKT_RASTER_VERSION) {
CPLError(CE_Failure, CPLE_NotSupported,
"WKT Raster version not supported (%d). Supported raster\
version is %d\n", nVersion, WKT_RASTER_VERSION);
return FALSE;
}
/*****************************************************
* \brief Read a natural block of raster band data
*****************************************************/
CPLErr PostGISRasterTileRasterBand::IReadBlock(CPL_UNUSED int nBlockXOff,
CPL_UNUSED int nBlockYOff,
void * pImage)
{
CPLString osCommand;
PGresult * poResult = NULL;
int nWKBLength = 0;
int nPixelSize = GDALGetDataTypeSize(eDataType)/8;
PostGISRasterTileDataset * poRTDS =
(PostGISRasterTileDataset *)poDS;
// Get by PKID
if (poRTDS->poRDS->pszPrimaryKeyName) {
osCommand.Printf("select st_band(%s, %d) from %s.%s where "
"%s = '%s'", poRTDS->poRDS->pszColumn, nBand, poRTDS->poRDS->pszSchema, poRTDS->poRDS->pszTable,
poRTDS->poRDS->pszPrimaryKeyName, poRTDS->pszPKID);
}
// Get by upperleft
else {
osCommand.Printf("select st_band(%s, %d) from %s.%s where "
"abs(ST_UpperLeftX(%s) - %.8f) < 1e-8 and abs(ST_UpperLeftY(%s) - %.8f) < 1e-8",
poRTDS->poRDS->pszColumn, nBand, poRTDS->poRDS->pszSchema, poRTDS->poRDS->pszTable, poRTDS->poRDS->pszColumn,
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_X], poRTDS->poRDS->pszColumn,
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_Y]);
}
poResult = PQexec(poRTDS->poRDS->poConn, osCommand.c_str());
#ifdef DEBUG_QUERY
CPLDebug("PostGIS_Raster", "PostGISRasterTileRasterBand::IReadBlock(): "
"Query = \"%s\" --> number of rows = %d",
osCommand.c_str(), poResult ? PQntuples(poResult) : 0 );
#endif
if (poResult == NULL ||
PQresultStatus(poResult) != PGRES_TUPLES_OK ||
PQntuples(poResult) <= 0) {
if (poResult)
PQclear(poResult);
ReportError(CE_Failure, CPLE_AppDefined,
"Error getting block of data (upperpixel = %f, %f)",
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_X],
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_Y]);
return CE_Failure;
}
// TODO: Check this
if (bIsOffline) {
CPLError(CE_Failure, CPLE_AppDefined, "This raster has outdb "
"storage. This feature isn't still available");
PQclear(poResult);
return CE_Failure;
}
/* Copy only data size, without payload */
int nExpectedDataSize =
nBlockXSize * nBlockYSize * nPixelSize;
GByte * pbyData = CPLHexToBinary(PQgetvalue(poResult, 0, 0),
&nWKBLength);
int nExpectedWKBLength = RASTER_HEADER_SIZE + BAND_SIZE(nPixelSize, nExpectedDataSize);
CPLErr eRet = CE_None;
if( nWKBLength != nExpectedWKBLength )
{
CPLDebug("PostGIS_Raster", "nWKBLength=%d, nExpectedWKBLength=%d", nWKBLength, nExpectedWKBLength );
eRet = CE_Failure;
}
else
{
GByte * pbyDataToRead =
(GByte*)GET_BAND_DATA(pbyData,1, nPixelSize,
nExpectedDataSize);
// Do byte-swapping if necessary */
int bIsLittleEndian = (pbyData[0] == 1);
#ifdef CPL_LSB
int bSwap = !bIsLittleEndian;
#else
int bSwap = bIsLittleEndian;
#endif
if( bSwap && nPixelSize > 1 )
{
GDALSwapWords( pbyDataToRead, nPixelSize,
nBlockXSize * nBlockYSize,
nPixelSize );
}
memcpy(pImage, pbyDataToRead, nExpectedDataSize);
}
CPLFree(pbyData);
PQclear(poResult);
return eRet;
}
/*****************************************************
* \brief Read a natural block of raster band data
*****************************************************/
CPLErr PostGISRasterTileRasterBand::IReadBlock(int /*nBlockXOff*/,
int /*nBlockYOff*/,
void * pImage)
{
CPLString osCommand;
PGresult * poResult = nullptr;
int nWKBLength = 0;
const int nPixelSize = GDALGetDataTypeSizeBytes(eDataType);
PostGISRasterTileDataset * poRTDS =
cpl::down_cast<PostGISRasterTileDataset *>(poDS);
const double dfTileUpperLeftX = poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_X];
const double dfTileUpperLeftY = poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_Y];
const double dfTileResX = poRTDS->adfGeoTransform[1];
const double dfTileResY = poRTDS->adfGeoTransform[5];
const int nTileXSize = nBlockXSize;
const int nTileYSize = nBlockYSize;
CPLString osRasterToFetch;
osRasterToFetch.Printf("ST_Band(%s, %d)",
poRTDS->poRDS->pszColumn, nBand);
// We don't honour CLIENT_SIDE_IF_POSSIBLE since it would be likely too
// costly in that context.
if( poRTDS->poRDS->eOutDBResolution != OutDBResolution::CLIENT_SIDE )
{
osRasterToFetch = "encode(ST_AsBinary(" + osRasterToFetch + ",TRUE),'hex')";
}
osCommand.Printf("SELECT %s FROM %s.%s WHERE ",
osRasterToFetch.c_str(), poRTDS->poRDS->pszSchema, poRTDS->poRDS->pszTable);
// Get by PKID
if (poRTDS->poRDS->pszPrimaryKeyName)
{
osCommand += CPLSPrintf("%s = '%s'",
poRTDS->poRDS->pszPrimaryKeyName, poRTDS->pszPKID);
}
// Get by upperleft
else {
osCommand += CPLSPrintf(
"abs(ST_UpperLeftX(%s) - %.8f) < 1e-8 and abs(ST_UpperLeftY(%s) - %.8f) < 1e-8",
poRTDS->poRDS->pszColumn,
dfTileUpperLeftX,
poRTDS->poRDS->pszColumn,
dfTileUpperLeftY);
}
poResult = PQexec(poRTDS->poRDS->poConn, osCommand.c_str());
#ifdef DEBUG_QUERY
CPLDebug("PostGIS_Raster", "PostGISRasterTileRasterBand::IReadBlock(): "
"Query = \"%s\" --> number of rows = %d",
osCommand.c_str(), poResult ? PQntuples(poResult) : 0 );
#endif
if (poResult == nullptr ||
PQresultStatus(poResult) != PGRES_TUPLES_OK ||
PQntuples(poResult) <= 0) {
CPLString osError;
if( PQresultStatus(poResult) == PGRES_FATAL_ERROR )
{
const char *pszError = PQerrorMessage( poRTDS->poRDS->poConn );
if( pszError )
osError = pszError;
}
if (poResult)
PQclear(poResult);
ReportError(CE_Failure, CPLE_AppDefined,
"Error getting block of data (upperpixel = %f, %f): %s",
dfTileUpperLeftX,
dfTileUpperLeftY,
osError.c_str());
return CE_Failure;
}
/* Copy only data size, without payload */
int nExpectedDataSize =
nBlockXSize * nBlockYSize * nPixelSize;
struct CPLFreer { void operator() (GByte* x) const { CPLFree(x); } };
std::unique_ptr<GByte, CPLFreer> pbyDataAutoFreed(
CPLHexToBinary(PQgetvalue(poResult, 0, 0), &nWKBLength));
GByte* pbyData = pbyDataAutoFreed.get();
PQclear(poResult);
const int nMinimumWKBLength = RASTER_HEADER_SIZE + BAND_SIZE(1, nPixelSize);
if( nWKBLength < nMinimumWKBLength )
{
CPLDebug("PostGIS_Raster", "nWKBLength=%d. too short. Expected at least %d",
nWKBLength, nMinimumWKBLength );
return CE_Failure;
}
// Is it indb-raster ?
if( (pbyData[RASTER_HEADER_SIZE] & 0x80) == 0 )
{
int nExpectedWKBLength = RASTER_HEADER_SIZE +
BAND_SIZE(nPixelSize, nExpectedDataSize);
if( nWKBLength != nExpectedWKBLength )
{
CPLDebug("PostGIS_Raster",
"nWKBLength=%d, nExpectedWKBLength=%d",
nWKBLength, nExpectedWKBLength );
return CE_Failure;
}
GByte * pbyDataToRead = GET_BAND_DATA(pbyData,1,
nPixelSize,nExpectedDataSize);
// Do byte-swapping if necessary */
const bool bIsLittleEndian = (pbyData[0] == 1);
#ifdef CPL_LSB
const bool bSwap = !bIsLittleEndian;
#else
const bool bSwap = bIsLittleEndian;
#endif
if( bSwap && nPixelSize > 1 )
{
GDALSwapWords( pbyDataToRead, nPixelSize,
nBlockXSize * nBlockYSize,
nPixelSize );
}
memcpy(pImage, pbyDataToRead, nExpectedDataSize);
}
else
{
int nCurOffset = RASTER_HEADER_SIZE;
if( !poRTDS->poRDS->LoadOutdbRaster(nCurOffset, eDataType, nBand,
pbyData,
nWKBLength,
pImage,
dfTileUpperLeftX,
dfTileUpperLeftY,
dfTileResX,
dfTileResY,
nTileXSize,
nTileYSize) )
{
return CE_Failure;
}
}
return CE_None;
}
