ERMsg COGRBaseOption::ParseOption(int argc, char* argv[])
{
ERMsg msg;
// Must process GDAL_SKIP before GDALAllRegister(), but we can't call
// GDALGeneralCmdLineProcessor before it needs the drivers to be registered
// for the --format or --formats options
for (int i = 1; i < argc; i++)
{
if (IsEqual(argv[i], "--config") && i + 2 < argc && IsEqual(argv[i + 1], "GDAL_SKIP"))
{
CPLSetConfigOption(argv[i + 1], argv[i + 2]);
i += 2;
}
}
// --------------------------------------------------------------------
// Register standard GDAL drivers, and process generic GDAL
// command options.
// --------------------------------------------------------------------
OGRRegisterAll();
argc = OGRGeneralCmdLineProcessor(argc, &argv, 0);
if (argc < 1)
exit(-argc);
// --------------------------------------------------------------------
// Parse arguments.
// --------------------------------------------------------------------
for (int i = 1; i < argc; i++)
{
msg += ProcessOption(i, argc, argv);
}
if (m_bVersion)
{
string error = Format("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
msg.ajoute(error);
//return msg;
}
if (m_bNeedHelp)
{
msg.ajoute(GetUsage());
msg.ajoute(GetHelp());
//return msg;
}
return msg;
}
int main( int nArgc, char ** papszArgv )
{
const char *pszWHERE = NULL;
const char *pszDataSource = NULL;
char **papszLayers = NULL;
OGRGeometry *poSpatialFilter = NULL;
int nRepeatCount = 1, bAllLayers = FALSE;
const char *pszSQLStatement = NULL;
const char *pszDialect = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-fid") && iArg < nArgc-1 )
nFetchFID = atoi(papszArgv[++iArg]);
else if( EQUAL(papszArgv[iArg],"-spat")
&& papszArgv[iArg+1] != NULL
&& papszArgv[iArg+2] != NULL
&& papszArgv[iArg+3] != NULL
&& papszArgv[iArg+4] != NULL )
{
OGRLinearRing oRing;
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
poSpatialFilter = new OGRPolygon();
((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
iArg += 4;
}
else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL )
{
pszWHERE = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-sql") && papszArgv[iArg+1] != NULL )
{
pszSQLStatement = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dialect")
&& papszArgv[iArg+1] != NULL )
{
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-rc") && papszArgv[iArg+1] != NULL )
{
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"-al") )
{
bAllLayers = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-so")
|| EQUAL(papszArgv[iArg],"-summary") )
{
bSummaryOnly = TRUE;
}
else if( EQUALN(papszArgv[iArg],"-fields=", strlen("-fields=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUALN(papszArgv[iArg],"-geom=", strlen("-geom=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
else
{
papszLayers = CSLAddString( papszLayers, papszArgv[iArg] );
bAllLayers = FALSE;
}
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS = NULL;
OGRSFDriver *poDriver = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
CPLAssert( poDriver != NULL);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
if( pszSQLStatement != NULL )
{
OGRLayer *poResultSet = NULL;
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf( "layer names ignored in combination with -sql.\n" );
poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter,
pszDialect );
if( poResultSet != NULL )
{
if( pszWHERE != NULL )
poResultSet->SetAttributeFilter( pszWHERE );
ReportOnLayer( poResultSet, NULL, NULL );
poDS->ReleaseResultSet( poResultSet );
}
}
CPLDebug( "OGR", "GetLayerCount() = %d\n", poDS->GetLayerCount() );
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if ( CSLCount(papszLayers) == 0 )
{
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
if (!bAllLayers)
{
printf( "%d: %s",
iLayer+1,
poLayer->GetLayerDefn()->GetName() );
if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown )
printf( " (%s)",
OGRGeometryTypeToName(
poLayer->GetLayerDefn()->GetGeomType() ) );
printf( "\n" );
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
char** papszIter = papszLayers;
for( ; *papszIter != NULL; papszIter++ )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter );
exit( 1 );
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszArgv );
CSLDestroy( papszLayers );
CSLDestroy( papszOptions );
OGRDataSource::DestroyDataSource( poDS );
if (poSpatialFilter)
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
OGRCleanupAll();
return 0;
}
int main( int nArgc, char ** papszArgv )
{
OGRSpatialReference oSRS;
int i;
int bReportXML = FALSE;
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 2 )
Usage();
for( i = 1; i < nArgc; i++ )
{
if( EQUAL(papszArgv[i],"-xml") )
bReportXML = TRUE;
else if( EQUAL(papszArgv[i],"-t") && i < nArgc - 4 )
{
OGRSpatialReference oSourceSRS, oTargetSRS;
OGRCoordinateTransformation *poCT;
double x, y, z_orig, z;
int nArgsUsed = 4;
if( oSourceSRS.SetFromUserInput(papszArgv[i+1]) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SetFromUserInput(%s) failed.",
papszArgv[i+1] );
continue;
}
if( oTargetSRS.SetFromUserInput(papszArgv[i+2]) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SetFromUserInput(%s) failed.",
papszArgv[i+2] );
continue;
}
poCT = OGRCreateCoordinateTransformation( &oSourceSRS,
&oTargetSRS );
x = CPLAtof( papszArgv[i+3] );
y = CPLAtof( papszArgv[i+4] );
if( i < nArgc - 5
&& (CPLAtof(papszArgv[i+5]) > 0.0 || papszArgv[i+5][0] == '0') )
{
z_orig = z = CPLAtof(papszArgv[i+5]);
nArgsUsed++;
}
else
z_orig = z = 0;
if( poCT == NULL || !poCT->Transform( 1, &x, &y, &z ) )
printf( "Transformation failed.\n" );
else
printf( "(%f,%f,%f) -> (%f,%f,%f)\n",
CPLAtof( papszArgv[i+3] ),
CPLAtof( papszArgv[i+4] ),
z_orig,
x, y, z );
i += nArgsUsed;
}
else
{
/* coverity[tainted_data] */
if( oSRS.SetFromUserInput(papszArgv[i]) != OGRERR_NONE )
CPLError( CE_Failure, CPLE_AppDefined,
"Error occurred translating %s.\n",
papszArgv[i] );
else
{
char *pszWKT = NULL;
if( oSRS.Validate() != OGRERR_NONE )
printf( "Validate Fails.\n" );
else
printf( "Validate Succeeds.\n" );
oSRS.exportToPrettyWkt( &pszWKT, FALSE );
printf( "WKT[%s] =\n%s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
printf( "\n" );
oSRS.exportToPrettyWkt( &pszWKT, TRUE );
printf( "Simplified WKT[%s] =\n%s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
printf( "\n" );
OGRSpatialReference *poSRS2;
poSRS2 = oSRS.Clone();
poSRS2->StripCTParms();
poSRS2->exportToWkt( &pszWKT );
printf( "Old Style WKT[%s] = %s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
OGRSpatialReference::DestroySpatialReference( poSRS2 );
poSRS2 = oSRS.Clone();
poSRS2->morphToESRI();
poSRS2->exportToPrettyWkt( &pszWKT, FALSE );
printf( "ESRI'ified WKT[%s] = \n%s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
OGRSpatialReference::DestroySpatialReference( poSRS2 );
oSRS.exportToProj4( &pszWKT );
printf( "PROJ.4 rendering of [%s] = %s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
if( bReportXML )
{
char *pszRawXML;
if( oSRS.exportToXML(&pszRawXML) == OGRERR_NONE )
{
printf( "XML[%s] =\n%s\n",
papszArgv[i], pszRawXML );
CPLFree( pszRawXML );
}
else
{
printf( "XML translation failed\n" );
}
}
printf( "\n" );
}
}
}
CSLDestroy( papszArgv );
OSRCleanup();
CPLFinderClean();
CPLCleanupTLS();
return 0;
}
int main( int nArgc, char ** papszArgv )
{
const char *pszDataSource = NULL;
char** papszLayers = NULL;
const char *pszSQLStatement = NULL;
int bRet = TRUE;
/* Must process OGR_SKIP before OGRRegisterAll(), but we can't call */
/* OGRGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--config") && iArg + 2 < nArgc &&
EQUAL(papszArgv[iArg+1], "OGR_SKIP") )
{
CPLSetConfigOption(papszArgv[iArg+1], papszArgv[iArg+2]);
break;
}
}
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-sql") && iArg + 1 < nArgc)
pszSQLStatement = papszArgv[++iArg];
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if (pszDataSource == NULL)
pszDataSource = papszArgv[iArg];
else
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS;
OGRSFDriver *poDriver;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s' using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Process optionnal SQL request. */
/* -------------------------------------------------------------------- */
if (pszSQLStatement != NULL)
{
OGRLayer *poResultSet = poDS->ExecuteSQL(pszSQLStatement, NULL, NULL);
if (poResultSet == NULL)
exit(1);
printf( "INFO: Testing layer %s.\n",
poResultSet->GetName() );
bRet = TestOGRLayer( poDS, poResultSet, TRUE );
poDS->ReleaseResultSet(poResultSet);
}
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
else if (papszLayers == NULL)
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
}
}
else
{
/* -------------------------------------------------------------------- */
/* Or process layers specified by the user */
/* -------------------------------------------------------------------- */
char** papszLayerIter = papszLayers;
while (*papszLayerIter)
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszLayerIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszLayerIter );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
papszLayerIter ++;
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
OGRDataSource::DestroyDataSource(poDS);
OGRCleanupAll();
CSLDestroy(papszLayers);
CSLDestroy(papszArgv);
#ifdef DBMALLOC
malloc_dump(1);
#endif
return (bRet) ? 0 : 1;
}
MAIN_START(nArgc, papszArgv)
{
// Check strict compilation and runtime library version as we use C++ API.
if( !GDAL_CHECK_VERSION(papszArgv[0]) )
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor(nArgc, &papszArgv, 0);
if( nArgc < 1 )
exit(-nArgc);
char *pszWHERE = nullptr;
const char *pszDataSource = nullptr;
char **papszLayers = nullptr;
OGRGeometry *poSpatialFilter = nullptr;
int nRepeatCount = 1;
bool bAllLayers = false;
char *pszSQLStatement = nullptr;
const char *pszDialect = nullptr;
int nRet = 0;
const char* pszGeomField = nullptr;
char **papszOpenOptions = nullptr;
char **papszExtraMDDomains = nullptr;
bool bListMDD = false;
bool bShowMetadata = true;
bool bFeatureCount = true;
bool bExtent = true;
bool bDatasetGetNextFeature = false;
bool bReadOnly = false;
bool bUpdate = false;
const char* pszWKTFormat = "WKT2";
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and "
"is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME,
GDALVersionInfo("RELEASE_NAME"));
CSLDestroy(papszArgv);
return 0;
}
else if( EQUAL(papszArgv[iArg], "--help") )
{
Usage();
}
else if( EQUAL(papszArgv[iArg], "-ro") )
{
bReadOnly = true;
}
else if( EQUAL(papszArgv[iArg], "-update") )
{
bUpdate = true;
}
else if( EQUAL(papszArgv[iArg], "-q") ||
EQUAL(papszArgv[iArg], "-quiet"))
{
bVerbose = false;
}
else if( EQUAL(papszArgv[iArg], "-qq") )
{
/* Undocumented: mainly only useful for AFL testing */
bVerbose = false;
bSuperQuiet = true;
}
else if( EQUAL(papszArgv[iArg], "-fid") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nFetchFID = CPLAtoGIntBig(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-spat") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
OGRLinearRing oRing;
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
poSpatialFilter = new OGRPolygon();
static_cast<OGRPolygon *>(poSpatialFilter)->addRing(&oRing);
iArg += 4;
}
else if( EQUAL(papszArgv[iArg], "-geomfield") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszGeomField = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-where") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszWHERE);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszWHERE = reinterpret_cast<char *>(pabyRet);
}
else
{
pszWHERE = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-sql") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszSQLStatement);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszSQLStatement = reinterpret_cast<char *>(pabyRet);
RemoveSQLComments(pszSQLStatement);
}
else
{
pszSQLStatement = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-dialect") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-rc") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-al") )
{
bAllLayers = true;
}
else if( EQUAL(papszArgv[iArg], "-so") ||
EQUAL(papszArgv[iArg], "-summary") )
{
bSummaryOnly = true;
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-fields=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-geom=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUAL(papszArgv[iArg], "-oo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszOpenOptions = CSLAddString(papszOpenOptions,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nomd") )
{
bShowMetadata = false;
}
else if( EQUAL(papszArgv[iArg], "-listmdd") )
{
bListMDD = true;
}
else if( EQUAL(papszArgv[iArg], "-mdd") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszExtraMDDomains = CSLAddString(papszExtraMDDomains,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nocount") )
{
bFeatureCount = false;
}
else if( EQUAL(papszArgv[iArg], "-noextent") )
{
bExtent = false;
}
else if( EQUAL(papszArgv[iArg], "-rl"))
{
bDatasetGetNextFeature = true;
}
else if( EQUAL(papszArgv[iArg], "-wkt_format") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszWKTFormat = papszArgv[++iArg];
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == nullptr )
{
pszDataSource = papszArgv[iArg];
}
else
{
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
bAllLayers = false;
}
}
if( pszDataSource == nullptr )
Usage("No datasource specified.");
if( pszDialect != nullptr && pszWHERE != nullptr &&
pszSQLStatement == nullptr )
printf("Warning: -dialect is ignored with -where. Use -sql instead");
if( bDatasetGetNextFeature && pszSQLStatement )
{
Usage("-rl is incompatible with -sql");
}
#ifdef __AFL_HAVE_MANUAL_CONTROL
while (__AFL_LOOP(1000)) {
#endif
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
GDALDataset *poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
((bReadOnly || pszSQLStatement == nullptr) &&
!bUpdate ? GDAL_OF_READONLY : GDAL_OF_UPDATE) | GDAL_OF_VECTOR,
nullptr, papszOpenOptions, nullptr));
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement == nullptr )
{
// In some cases (empty geopackage for example), opening in read-only
// mode fails, so retry in update mode
if( GDALIdentifyDriverEx(pszDataSource, GDAL_OF_VECTOR,
nullptr, nullptr) )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
}
}
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement != nullptr )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_READONLY | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
if( poDS != nullptr && bVerbose )
{
printf("Had to open data source read-only.\n");
#ifdef __AFL_HAVE_MANUAL_CONTROL
bReadOnly = true;
#endif
}
}
GDALDriver *poDriver = nullptr;
if( poDS != nullptr )
poDriver = poDS->GetDriver();
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == nullptr )
{
printf("FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource);
#ifdef __AFL_HAVE_MANUAL_CONTROL
continue;
#else
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf(" -> %s\n", poR->GetDriver(iDriver)->GetDescription());
}
nRet = 1;
goto end;
#endif
}
CPLAssert(poDriver != nullptr);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf("INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetDescription());
if( bVerbose && !EQUAL(pszDataSource,poDS->GetDescription()) )
{
printf("INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetDescription(), pszDataSource);
}
GDALInfoReportMetadata(static_cast<GDALMajorObjectH>(poDS),
bListMDD,
bShowMetadata,
papszExtraMDDomains);
if( bDatasetGetNextFeature )
{
nRepeatCount = 0; // skip layer reporting.
/* -------------------------------------------------------------------- */
/* Set filters if provided. */
/* -------------------------------------------------------------------- */
if( pszWHERE != nullptr || poSpatialFilter != nullptr )
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( pszWHERE != nullptr )
{
if( poLayer->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("WARNING: SetAttributeFilter(%s) "
"failed on layer %s.\n",
pszWHERE, poLayer->GetName());
}
}
if( poSpatialFilter != nullptr )
{
if( pszGeomField != nullptr )
{
OGRFeatureDefn *poDefn = poLayer->GetLayerDefn();
const int iGeomField =
poDefn->GetGeomFieldIndex(pszGeomField);
if( iGeomField >= 0 )
poLayer->SetSpatialFilter(iGeomField,
poSpatialFilter);
else
printf("WARNING: Cannot find geometry field %s.\n",
pszGeomField);
}
else
{
poLayer->SetSpatialFilter(poSpatialFilter);
}
}
}
}
std::set<OGRLayer*> oSetLayers;
while( true )
{
OGRLayer* poLayer = nullptr;
OGRFeature* poFeature = poDS->GetNextFeature(&poLayer, nullptr,
nullptr, nullptr);
if( poFeature == nullptr )
break;
if( papszLayers == nullptr || poLayer == nullptr ||
CSLFindString(papszLayers, poLayer->GetName()) >= 0 )
{
if( bVerbose && poLayer != nullptr &&
oSetLayers.find(poLayer) == oSetLayers.end() )
{
oSetLayers.insert(poLayer);
const bool bSummaryOnlyBackup = bSummaryOnly;
bSummaryOnly = true;
ReportOnLayer(poLayer, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata,
papszExtraMDDomains,
bFeatureCount,
bExtent,
pszWKTFormat);
bSummaryOnly = bSummaryOnlyBackup;
}
if( !bSuperQuiet && !bSummaryOnly )
poFeature->DumpReadable(nullptr, papszOptions);
}
OGRFeature::DestroyFeature(poFeature);
}
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
else if( pszSQLStatement != nullptr )
{
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf("layer names ignored in combination with -sql.\n");
OGRLayer *poResultSet =
poDS->ExecuteSQL(
pszSQLStatement,
pszGeomField == nullptr ? poSpatialFilter : nullptr,
pszDialect);
if( poResultSet != nullptr )
{
if( pszWHERE != nullptr )
{
if( poResultSet->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("FAILURE: SetAttributeFilter(%s) failed.\n",
pszWHERE);
exit(1);
}
}
if( pszGeomField != nullptr )
ReportOnLayer(poResultSet, nullptr,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
else
ReportOnLayer(poResultSet, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
poDS->ReleaseResultSet(poResultSet);
}
}
// coverity[tainted_data]
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if( papszLayers == nullptr || *papszLayers == nullptr )
{
if( iRepeat == 0 )
CPLDebug("OGR", "GetLayerCount() = %d\n",
poDS->GetLayerCount());
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( !bAllLayers )
{
printf("%d: %s", iLayer + 1, poLayer->GetName());
const int nGeomFieldCount =
poLayer->GetLayerDefn()->GetGeomFieldCount();
if( nGeomFieldCount > 1 )
{
printf(" (");
for( int iGeom = 0; iGeom < nGeomFieldCount; iGeom++ )
{
if( iGeom > 0 )
printf(", ");
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->
GetGeomFieldDefn(iGeom);
printf(
"%s",
OGRGeometryTypeToName(
poGFldDefn->GetType()));
}
printf(")");
}
else if( poLayer->GetGeomType() != wkbUnknown )
printf(" (%s)",
OGRGeometryTypeToName(
poLayer->GetGeomType()));
printf("\n");
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
for( char** papszIter = papszLayers;
*papszIter != nullptr;
++papszIter )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter);
exit(1);
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE, pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
GDALClose(poDS);
#ifdef __AFL_HAVE_MANUAL_CONTROL
}
#else
end:
#endif
CSLDestroy(papszArgv);
CSLDestroy(papszLayers);
CSLDestroy(papszOptions);
CSLDestroy(papszOpenOptions);
CSLDestroy(papszExtraMDDomains);
if( poSpatialFilter )
OGRGeometryFactory::destroyGeometry(poSpatialFilter);
CPLFree(pszSQLStatement);
CPLFree(pszWHERE);
OGRCleanupAll();
return nRet;
}
int main( int nArgc, char ** papszArgv )
{
GDALDatasetH hDS = NULL;
GDALDatasetH hODS = NULL;
int bCloseODS = TRUE;
int bUsageError = FALSE;
GDALDatasetH hDstDS;
int nRetCode = 1;
GDALVectorTranslateOptionsForBinary* psOptionsForBinary;
GDALVectorTranslateOptions *psOptions;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
{
papszArgv = NULL;
nRetCode = -nArgc;
goto exit;
}
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
nRetCode = 0;
goto exit;
}
else if( EQUAL(papszArgv[iArg],"--help") )
{
Usage();
goto exit;
}
else if ( EQUAL(papszArgv[iArg], "--long-usage") )
{
Usage(FALSE);
goto exit;
}
}
psOptionsForBinary = GDALVectorTranslateOptionsForBinaryNew();
psOptions = GDALVectorTranslateOptionsNew(papszArgv + 1, psOptionsForBinary);
if( psOptions == NULL )
{
Usage();
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( psOptionsForBinary->pszDataSource == NULL ||
psOptionsForBinary->pszDestDataSource == NULL )
{
if( psOptionsForBinary->pszDestDataSource == NULL )
Usage("no target datasource provided");
else
Usage("no source datasource provided");
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( strcmp(psOptionsForBinary->pszDestDataSource, "/vsistdout/") == 0 )
psOptionsForBinary->bQuiet = TRUE;
if (!psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet &&
psOptionsForBinary->eAccessMode == ACCESS_CREATION)
{
CheckDestDataSourceNameConsistency(psOptionsForBinary->pszDestDataSource,
psOptionsForBinary->pszFormat);
}
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
/* Avoid opening twice the same datasource if it is both the input and output */
/* Known to cause problems with at least FGdb, SQlite and GPKG drivers. See #4270 */
if (psOptionsForBinary->eAccessMode != ACCESS_CREATION &&
strcmp(psOptionsForBinary->pszDestDataSource, psOptionsForBinary->pszDataSource) == 0)
{
hODS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
GDALDriverH hDriver = NULL;
if( hODS != NULL )
hDriver = GDALGetDatasetDriver(hODS);
/* Restrict to those 3 drivers. For example it is known to break with */
/* the PG driver due to the way it manages transactions... */
if (hDriver && !(EQUAL(GDALGetDescription(hDriver), "FileGDB") ||
EQUAL(GDALGetDescription(hDriver), "SQLite") ||
EQUAL(GDALGetDescription(hDriver), "GPKG")))
{
hDS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
}
else
{
hDS = hODS;
bCloseODS = FALSE;
}
}
else
{
hDS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( hDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
fprintf( stderr, "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
psOptionsForBinary->pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
}
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALVectorTranslateOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
hDstDS = GDALVectorTranslate(psOptionsForBinary->pszDestDataSource, hODS,
1, &hDS, psOptions, &bUsageError);
if( bUsageError )
Usage();
else
nRetCode = (hDstDS) ? 0 : 1;
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
if(hDS)
GDALClose(hDS);
if(bCloseODS)
GDALClose(hDstDS);
exit:
CSLDestroy( papszArgv );
OGRCleanupAll();
return nRetCode;
}
