OGRDataSource *OGRWalkDriver::Open( const char * pszFilename, int bUpdate )
{
if( EQUALN(pszFilename, "PGEO:", strlen("PGEO:")) )
return NULL;
if( EQUALN(pszFilename, "GEOMEDIA:", strlen("GEOMEDIA:")) )
return NULL;
if( !EQUALN(pszFilename,"WALK:", strlen("WALK:"))
&& !EQUAL(CPLGetExtension(pszFilename), "MDB") )
return NULL;
#ifndef WIN32
// Try to register MDB Tools driver
//
// ODBCINST.INI NOTE:
// This operation requires write access to odbcinst.ini file
// located in directory pointed by ODBCINISYS variable.
// Usually, it points to /etc, so non-root users can overwrite this
// setting ODBCINISYS with location they have write access to, e.g.:
// $ export ODBCINISYS=$HOME/etc
// $ touch $ODBCINISYS/odbcinst.ini
//
// See: http://www.unixodbc.org/internals.html
//
if ( !InstallMdbDriver() )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unable to install MDB driver for ODBC, MDB access may not supported.\n" );
}
else
CPLDebug( "Walk", "MDB Tools driver installed successfully!");
#endif /* ndef WIN32 */
OGRWalkDataSource *poDS = new OGRWalkDataSource();
if( !poDS->Open( pszFilename, bUpdate ) )
{
delete poDS;
return NULL;
}
else
return poDS;
}
int ARGDataset::Identify( GDALOpenInfo *poOpenInfo )
{
json_object * pJSONObject;
if (!EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "arg")) {
return FALSE;
}
pJSONObject = GetJsonObject(poOpenInfo->pszFilename);
if (pJSONObject == NULL) {
return FALSE;
}
json_object_put(pJSONObject);
pJSONObject = NULL;
return TRUE;
}
std::vector<CPLString> GetOutputDriversFor(const char* pszDestFilename,
int nFlagRasterVector)
{
std::vector<CPLString> aoDriverList;
CPLString osExt = CPLGetExtension(pszDestFilename);
const int nDriverCount = GDALGetDriverCount();
for( int i = 0; i < nDriverCount; i++ )
{
GDALDriverH hDriver = GDALGetDriver(i);
if( (GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, nullptr ) != nullptr ||
GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, nullptr ) != nullptr ) &&
(((nFlagRasterVector & GDAL_OF_RASTER) &&
GDALGetMetadataItem( hDriver, GDAL_DCAP_RASTER, nullptr ) != nullptr) ||
((nFlagRasterVector & GDAL_OF_VECTOR) &&
GDALGetMetadataItem( hDriver, GDAL_DCAP_VECTOR, nullptr ) != nullptr)) )
{
if( !osExt.empty() && DoesDriverHandleExtension(hDriver, osExt) )
{
aoDriverList.push_back( GDALGetDriverShortName(hDriver) );
}
else
{
const char* pszPrefix = GDALGetMetadataItem(hDriver,
GDAL_DMD_CONNECTION_PREFIX, nullptr);
if( pszPrefix && STARTS_WITH_CI(pszDestFilename, pszPrefix) )
{
aoDriverList.push_back( GDALGetDriverShortName(hDriver) );
}
}
}
}
// GMT is registered before netCDF for opening reasons, but we want
// netCDF to be used by default for output.
if( EQUAL(osExt, "nc") && aoDriverList.size() == 2 &&
EQUAL(aoDriverList[0], "GMT") && EQUAL(aoDriverList[1], "NETCDF") )
{
aoDriverList.clear();
aoDriverList.push_back("NETCDF");
aoDriverList.push_back("GMT");
}
return aoDriverList;
}
void CheckExtensionConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));
if (pszDestExtension[0] != '\0')
{
int nDriverCount = GDALGetDriverCount();
CPLString osConflictingDriverList;
for(int i=0;i<nDriverCount;i++)
{
GDALDriverH hDriver = GDALGetDriver(i);
const char* pszDriverExtension =
GDALGetMetadataItem( hDriver, GDAL_DMD_EXTENSION, NULL );
if (pszDriverExtension && EQUAL(pszDestExtension, pszDriverExtension))
{
if (GDALGetDriverByName(pszDriverName) != hDriver)
{
if (osConflictingDriverList.size())
osConflictingDriverList += ", ";
osConflictingDriverList += GDALGetDriverShortName(hDriver);
}
else
{
/* If the request driver allows the used extension, then */
/* just stop iterating now */
osConflictingDriverList = "";
break;
}
}
}
if (osConflictingDriverList.size())
{
fprintf(stderr,
"Warning: The target file has a '%s' extension, which is normally used by the %s driver%s,\n"
"but the requested output driver is %s. Is it really what you want ?\n",
pszDestExtension,
osConflictingDriverList.c_str(),
strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",
pszDriverName);
}
}
CPLFree(pszDestExtension);
}
int RDataset::Identify( GDALOpenInfo *poOpenInfo )
{
if( poOpenInfo->nHeaderBytes < 50 )
return FALSE;
// If the extension is .rda and the file type is gzip
// compressed we assume it is a gzipped R binary file.
if( memcmp(poOpenInfo->pabyHeader, "\037\213\b", 3) == 0 &&
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "rda") )
return TRUE;
// Is this an ASCII or XDR binary R file?
if( !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "RDA2\nA\n") &&
!STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "RDX2\nX\n") )
return FALSE;
return TRUE;
}
int ARGDataset::Identify( GDALOpenInfo *poOpenInfo )
{
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (!EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "arg")) {
return FALSE;
}
#endif
json_object *pJSONObject = GetJsonObject(poOpenInfo->pszFilename);
if (pJSONObject == nullptr) {
return FALSE;
}
json_object_put(pJSONObject);
pJSONObject = nullptr;
return TRUE;
}
bool wxGISDataset::Rename(const wxString &sNewName, ITrackCancel* const pTrackCancel)
{
wxCriticalSectionLocker locker(m_CritSect);
Close();
CPLString szDirPath = CPLGetPath(m_sPath);
CPLString szName = CPLGetBasename(m_sPath);
CPLString szNewName(ClearExt(sNewName).mb_str(wxConvUTF8));
char** papszFileList = GetFileList();
papszFileList = CSLAddString( papszFileList, m_sPath );
if(!papszFileList)
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("No files to rename"), wxNOT_FOUND, enumGISMessageErr);
return false;
}
char **papszNewFileList = NULL;
for(int i = 0; papszFileList[i] != NULL; ++i )
{
CPLString szNewPath(CPLFormFilename(szDirPath, szNewName, GetExtension(papszFileList[i], szName)));
papszNewFileList = CSLAddString(papszNewFileList, szNewPath);
if(!RenameFile(papszFileList[i], papszNewFileList[i], pTrackCancel))
{
// Try to put the ones we moved back.
for( --i; i >= 0; i-- )
RenameFile( papszNewFileList[i], papszFileList[i]);
CSLDestroy( papszFileList );
CSLDestroy( papszNewFileList );
return false;
}
}
m_sPath = CPLString(CPLFormFilename(szDirPath, szNewName, CPLGetExtension(m_sPath)));
CSLDestroy( papszFileList );
CSLDestroy( papszNewFileList );
return true;
}
OGRDataSource *OGRDWGDriver::Open( const char * pszFilename, int /*bUpdate*/ )
{
if( !EQUAL(CPLGetExtension(pszFilename),"dwg") )
return NULL;
if( !OGRTEIGHAInitialize() )
return NULL;
OGRDWGDataSource *poDS = new OGRDWGDataSource();
if( !poDS->Open( OGRDWGGetServices(), pszFilename ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
bool wxGxWebConnectionFactory::GetChildren(wxGxObject* pParent, char** &pFileNames, wxArrayLong & pChildrenIds)
{
wxGxCatalogBase* pCatalog = GetGxCatalog();
for(int i = CSLCount(pFileNames) - 1; i >= 0; i-- )
{
CPLString szExt = CPLGetExtension(pFileNames[i]);
if(wxGISEQUAL(szExt, "wconn"))
{
if( m_bHasDriver )
{
wxGxObject* pObj = GetGxObject(pParent, GetConvName(pFileNames[i]), pFileNames[i]);
if(pObj)
pChildrenIds.Add(pObj->GetId());
}
pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );
}
}
return true;
}
int BAGDataset::Identify( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Is it an HDF5 file? */
/* -------------------------------------------------------------------- */
static const char achSignature[] = "\211HDF\r\n\032\n";
if( poOpenInfo->pabyHeader == NULL
|| memcmp(poOpenInfo->pabyHeader,achSignature,8) != 0 )
return FALSE;
/* -------------------------------------------------------------------- */
/* Does it have the extension .bag? */
/* -------------------------------------------------------------------- */
if( !EQUAL(CPLGetExtension(poOpenInfo->pszFilename),"bag") )
return FALSE;
return TRUE;
}
static GDALDataset *OGRAeronavFAADriverOpen( GDALOpenInfo* poOpenInfo )
{
if (poOpenInfo->eAccess == GA_Update ||
poOpenInfo->fpL == NULL ||
!EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "dat") )
{
return NULL;
}
OGRAeronavFAADataSource *poDS = new OGRAeronavFAADataSource();
if( !poDS->Open( poOpenInfo->pszFilename ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
OGRDataSource *OGRPDFDriver::Open( const char * pszFilename, int bUpdate )
{
if( !EQUAL(CPLGetExtension(pszFilename), "pdf") || bUpdate )
return NULL;
/* -------------------------------------------------------------------- */
/* Try to create datasource. */
/* -------------------------------------------------------------------- */
OGRPDFDataSource *poDS;
poDS = new OGRPDFDataSource();
if( !poDS->Open( pszFilename ) )
{
delete poDS;
return NULL;
}
else
return poDS;
}
static int OGRGMLDriverIdentify( GDALOpenInfo* poOpenInfo )
{
if( poOpenInfo->fpL == NULL )
{
if( strstr(poOpenInfo->pszFilename, "xsd=") != NULL )
return -1; /* must be later checked */
return FALSE;
}
/* Might be a OS-Mastermap gzipped GML, so let be nice and try to open */
/* it transparently with /vsigzip/ */
else
if ( poOpenInfo->pabyHeader[0] == 0x1f && poOpenInfo->pabyHeader[1] == 0x8b &&
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "gz") &&
strncmp(poOpenInfo->pszFilename, "/vsigzip/", strlen("/vsigzip/")) != 0 )
{
return -1; /* must be later checked */
}
else
{
const char* szPtr = (const char*)poOpenInfo->pabyHeader;
if( ( (unsigned char)szPtr[0] == 0xEF )
&& ( (unsigned char)szPtr[1] == 0xBB )
&& ( (unsigned char)szPtr[2] == 0xBF) )
{
szPtr += 3;
}
/* -------------------------------------------------------------------- */
/* Here, we expect the opening chevrons of GML tree root element */
/* -------------------------------------------------------------------- */
if( szPtr[0] != '<' )
return FALSE;
if( !poOpenInfo->TryToIngest(4096) )
return FALSE;
return OGRGMLDataSource::CheckHeader((const char*)poOpenInfo->pabyHeader);
}
}
bool wxGxLocalDBFactory::GetChildren(wxGxObject* pParent, char** &pFileNames, wxArrayLong & pChildrenIds)
{
wxGxCatalogBase* pCatalog = GetGxCatalog();
bool bCheckNames = CSLCount(pFileNames) < CHECK_DUBLES_MAX_COUNT;
for(int i = CSLCount(pFileNames) - 1; i >= 0; i-- )
{
VSIStatBufL BufL;
int ret = VSIStatL(pFileNames[i], &BufL);
if(ret == 0)
{
if (VSI_ISDIR(BufL.st_mode) && wxGISEQUAL(CPLGetExtension(pFileNames[i]), "gdb"))
{
wxGxObject* pObj = GetGxObject(pParent, wxString(CPLGetFilename(pFileNames[i]), wxConvUTF8), pFileNames[i], enumContGDBFolder, bCheckNames);
if(pObj)
pChildrenIds.Add(pObj->GetId());
pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );
}
//TODO: mdb, sqlite, db extensions
}
}
return true;
}
void CheckExtensionConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
CPLString osExt = CPLGetExtension(pszDestFilename);
if( !osExt.empty() )
{
GDALDriverH hThisDrv = GDALGetDriverByName(pszDriverName);
if( hThisDrv != NULL && DoesDriverHandleExtension(hThisDrv, osExt) )
return;
const int nDriverCount = GDALGetDriverCount();
CPLString osConflictingDriverList;
for( int i = 0; i < nDriverCount; i++ )
{
GDALDriverH hDriver = GDALGetDriver(i);
if( hDriver != hThisDrv &&
DoesDriverHandleExtension(hDriver, osExt) )
{
if (osConflictingDriverList.size())
osConflictingDriverList += ", ";
osConflictingDriverList += GDALGetDriverShortName(hDriver);
}
}
if (osConflictingDriverList.size())
{
fprintf(
stderr,
"Warning: The target file has a '%s' extension, "
"which is normally used by the %s driver%s, "
"but the requested output driver is %s. "
"Is it really what you want?\n",
osExt.c_str(),
osConflictingDriverList.c_str(),
strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",
pszDriverName);
}
}
}
static
void CheckDestDataSourceNameConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
int i;
char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));
if( EQUAL(pszDriverName, "GMT") )
pszDriverName = "OGR_GMT";
CheckExtensionConsistency(pszDestFilename, pszDriverName);
static const char* apszBeginName[][2] = { { "PG:" , "PostgreSQL" },
{ "MySQL:" , "MySQL" },
{ "CouchDB:" , "CouchDB" },
{ "GFT:" , "GFT" },
{ "MSSQL:" , "MSSQLSpatial" },
{ "ODBC:" , "ODBC" },
{ "OCI:" , "OCI" },
{ "SDE:" , "SDE" },
{ "WFS:" , "WFS" },
{ NULL, NULL }
};
for(i=0; apszBeginName[i][0] != NULL; i++)
{
if (EQUALN(pszDestFilename, apszBeginName[i][0], strlen(apszBeginName[i][0])) &&
!EQUAL(pszDriverName, apszBeginName[i][1]))
{
CPLError(CE_Warning, CPLE_AppDefined,
"The target file has a name which is normally recognized by the %s driver,\n"
"but the requested output driver is %s. Is it really what you want ?\n",
apszBeginName[i][1],
pszDriverName);
break;
}
}
CPLFree(pszDestExtension);
}
static int OGRDXFDriverIdentify( GDALOpenInfo* poOpenInfo )
{
if( poOpenInfo->fpL == NULL || poOpenInfo->nHeaderBytes == 0 )
return FALSE;
if( EQUAL(CPLGetExtension(poOpenInfo->pszFilename),"dxf") )
return TRUE;
const char* pszIter = (const char*)poOpenInfo->pabyHeader;
int bFoundZero = FALSE;
int i = 0;
for(i=0; pszIter[i]; i++)
{
if( pszIter[i] == '0' )
{
int j=i-1;
for(; j>=0; j--)
{
if( pszIter[j] != ' ' )
break;
}
if( j < 0 || pszIter[j] == '\n'|| pszIter[j] == '\r' )
{
bFoundZero = TRUE;
break;
}
}
}
if( !bFoundZero )
return FALSE;
i ++;
while( pszIter[i] == ' ' )
i ++;
while( pszIter[i] == '\n' || pszIter[i] == '\r' )
i ++;
if( !STARTS_WITH_CI(pszIter + i, "SECTION") )
return FALSE;
i += static_cast<int>(strlen("SECTION"));
return pszIter[i] == '\n' || pszIter[i] == '\r';
}
int ROIPACDataset::Identify( GDALOpenInfo *poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Check if: */
/* * 1. The data file extension is known */
/* -------------------------------------------------------------------- */
const char *pszExtension = CPLGetExtension(poOpenInfo->pszFilename);
if ( strcmp( pszExtension, "raw" ) == 0 )
{
/* Since gdal do not read natively CInt8, more work is needed
* to read raw files */
return false;
}
bool bExtensionIsValid = strcmp( pszExtension, "int" ) == 0
|| strcmp( pszExtension, "slc" ) == 0
|| strcmp( pszExtension, "amp" ) == 0
|| strcmp( pszExtension, "cor" ) == 0
|| strcmp( pszExtension, "hgt" ) == 0
|| strcmp( pszExtension, "unw" ) == 0
|| strcmp( pszExtension, "msk" ) == 0
|| strcmp( pszExtension, "trans" ) == 0
|| strcmp( pszExtension, "dem" ) == 0
|| strcmp( pszExtension, "flg" ) == 0;
if ( !bExtensionIsValid )
{
return false;
}
/* -------------------------------------------------------------------- */
/* * 2. there is a .rsc file */
/* -------------------------------------------------------------------- */
CPLString osRscFilename = getRscFilename( poOpenInfo );
if ( osRscFilename.empty() )
{
return false;
}
return true;
}
OGRDataSource *OGRXLSDriver::Open( const char * pszFilename, int bUpdate )
{
if (bUpdate)
{
return NULL;
}
if (!EQUAL(CPLGetExtension(pszFilename), "XLS"))
{
return NULL;
}
OGRXLSDataSource *poDS = new OGRXLSDataSource();
if( !poDS->Open( pszFilename, bUpdate ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
OGRDataSource *OGRXPlaneDriver::Open( const char * pszFilename, int bUpdate )
{
if ( bUpdate )
{
return NULL;
}
if( !EQUAL(CPLGetExtension(pszFilename), "dat") )
return NULL;
OGRXPlaneDataSource *poDS = new OGRXPlaneDataSource();
int bReadWholeFile = CSLTestBoolean(CPLGetConfigOption("OGR_XPLANE_READ_WHOLE_FILE", "TRUE"));
if( !poDS->Open( pszFilename, bReadWholeFile ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
OGRDataSource *OGRODBCDriver::Open( const char * pszFilename,
int bUpdate )
{
OGRODBCDataSource *poDS;
if( !EQUALN(pszFilename,"ODBC:",5)
#ifdef WIN32
&& !EQUAL(CPLGetExtension(pszFilename), "MDB")
#endif
)
return NULL;
poDS = new OGRODBCDataSource();
if( !poDS->Open( pszFilename, bUpdate, TRUE ) )
{
delete poDS;
return NULL;
}
else
return poDS;
}
OGRDataSource *OGRSXFDriver::Open( const char * pszFilename, int bUpdate )
{
/* -------------------------------------------------------------------- */
/* Determine what sort of object this is. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
if (!EQUAL(CPLGetExtension(pszFilename), "sxf") ||
VSIStatL(pszFilename, &sStatBuf) != 0 ||
!VSI_ISREG(sStatBuf.st_mode))
return FALSE;
OGRSXFDataSource *poDS = new OGRSXFDataSource();
if( !poDS->Open( pszFilename, bUpdate ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
int RIKDataset::Identify( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->fpL == NULL || poOpenInfo->nHeaderBytes < 50 )
return FALSE;
if( EQUALN((const char *) poOpenInfo->pabyHeader, "RIK3", 4) )
{
return TRUE;
}
else
{
GUInt16 actLength;
memcpy(&actLength, poOpenInfo->pabyHeader, 2);
#ifdef CPL_MSB
CPL_SWAP16PTR( &actLength );
#endif
if( actLength + 2 > 1024 )
{
return FALSE;
}
if( actLength == 0 )
return -1;
for( int i=0;i<actLength;i++ )
{
if( poOpenInfo->pabyHeader[2+i] == 0 )
return FALSE;
}
if( EQUAL( CPLGetExtension(poOpenInfo->pszFilename), "rik") )
return TRUE;
// We really need Open to be able to conclude
return -1;
}
}
OGRDataSource *OGRGeoconceptDriver::Open( const char* pszFilename,
int bUpdate )
{
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
/* -------------------------------------------------------------------- */
/* We will only consider .gxt and .txt files. */
/* -------------------------------------------------------------------- */
const char* pszExtension = CPLGetExtension(pszFilename);
if( !EQUAL(pszExtension,"gxt") && !EQUAL(pszExtension,"txt") )
{
return nullptr;
}
#endif
OGRGeoconceptDataSource *poDS = new OGRGeoconceptDataSource();
if( !poDS->Open( pszFilename, true, CPL_TO_BOOL(bUpdate) ) )
{
delete poDS;
return nullptr;
}
return poDS;
}
OGRDataSource *OGRIdrisiDriver::Open( const char * pszFilename, int bUpdate )
{
if (bUpdate)
{
return NULL;
}
// --------------------------------------------------------------------
// Does this appear to be a .vct file?
// --------------------------------------------------------------------
if ( !EQUAL(CPLGetExtension(pszFilename), "vct") )
return NULL;
OGRIdrisiDataSource *poDS = new OGRIdrisiDataSource();
if( !poDS->Open( pszFilename ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
OGRDataSource *OGRGeoconceptDriver::Open( const char* pszFilename,
int bUpdate )
{
OGRGeoconceptDataSource *poDS;
/* -------------------------------------------------------------------- */
/* We will only consider .gxt and .txt files. */
/* -------------------------------------------------------------------- */
const char* pszExtension = CPLGetExtension(pszFilename);
if( !EQUAL(pszExtension,"gxt") && !EQUAL(pszExtension,"txt") )
{
return NULL;
}
poDS = new OGRGeoconceptDataSource();
if( !poDS->Open( pszFilename, TRUE, bUpdate ) )
{
delete poDS;
return NULL;
}
return poDS;
}
int OGRTABDataSource::Create( const char * pszName, char **papszOptions )
{
CPLAssert(m_pszName == nullptr);
m_pszName = CPLStrdup(pszName);
m_papszOptions = CSLDuplicate(papszOptions);
m_bUpdate = TRUE;
const char *pszOpt = CSLFetchNameValue(papszOptions, "FORMAT");
if( pszOpt != nullptr && EQUAL(pszOpt, "MIF") )
m_bCreateMIF = TRUE;
else if( EQUAL(CPLGetExtension(pszName),"mif") ||
EQUAL(CPLGetExtension(pszName),"mid") )
m_bCreateMIF = TRUE;
if( (pszOpt = CSLFetchNameValue(papszOptions,"SPATIAL_INDEX_MODE")) != nullptr )
{
if( EQUAL(pszOpt, "QUICK") )
m_bQuickSpatialIndexMode = TRUE;
else if( EQUAL(pszOpt, "OPTIMIZED") )
m_bQuickSpatialIndexMode = FALSE;
}
m_nBlockSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKSIZE", "512"));
// Create a new empty directory.
VSIStatBufL sStat;
if( strlen(CPLGetExtension(pszName)) == 0 )
{
if( VSIStatL( pszName, &sStat ) == 0 )
{
if( !VSI_ISDIR(sStat.st_mode) )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Attempt to create dataset named %s,\n"
"but that is an existing file.",
pszName);
return FALSE;
}
}
else
{
if( VSIMkdir(pszName, 0755) != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unable to create directory %s.",
pszName);
return FALSE;
}
}
m_pszDirectory = CPLStrdup(pszName);
}
// Create a new single file.
else
{
IMapInfoFile *poFile = nullptr;
const char *pszEncoding( CSLFetchNameValue( papszOptions, "ENCODING" ) );
const char *pszCharset( IMapInfoFile::EncodingToCharset( pszEncoding ) );
if( m_bCreateMIF )
{
poFile = new MIFFile;
if( poFile->Open(m_pszName, TABWrite, FALSE, pszCharset) != 0 )
{
delete poFile;
return FALSE;
}
}
else
{
TABFile *poTabFile = new TABFile;
if( poTabFile->Open(m_pszName, TABWrite, FALSE,
m_nBlockSize, pszCharset) != 0 )
{
delete poTabFile;
return FALSE;
}
poFile = poTabFile;
}
m_nLayerCount = 1;
m_papoLayers = static_cast<IMapInfoFile **>(CPLMalloc(sizeof(void *)));
m_papoLayers[0] = poFile;
m_pszDirectory = CPLStrdup(CPLGetPath(pszName));
m_bSingleFile = TRUE;
}
return TRUE;
}
int OGRTABDataSource::Open( GDALOpenInfo *poOpenInfo, int bTestOpen )
{
CPLAssert(m_pszName == nullptr);
m_pszName = CPLStrdup(poOpenInfo->pszFilename);
m_bUpdate = poOpenInfo->eAccess == GA_Update;
// If it is a file, try to open as a Mapinfo file.
if( !poOpenInfo->bIsDirectory )
{
IMapInfoFile *poFile =
IMapInfoFile::SmartOpen(m_pszName, m_bUpdate, bTestOpen);
if( poFile == nullptr )
return FALSE;
poFile->SetDescription(poFile->GetName());
m_nLayerCount = 1;
m_papoLayers = static_cast<IMapInfoFile **>(CPLMalloc(sizeof(void *)));
m_papoLayers[0] = poFile;
m_pszDirectory = CPLStrdup(CPLGetPath(m_pszName));
m_bSingleFile = TRUE;
m_bSingleLayerAlreadyCreated = TRUE;
}
// Otherwise, we need to scan the whole directory for files
// ending in .tab or .mif.
else
{
char **papszFileList = VSIReadDir(m_pszName);
m_pszDirectory = CPLStrdup(m_pszName);
for( int iFile = 0;
papszFileList != nullptr && papszFileList[iFile] != nullptr;
iFile++ )
{
const char *pszExtension = CPLGetExtension(papszFileList[iFile]);
if( !EQUAL(pszExtension, "tab") && !EQUAL(pszExtension, "mif") )
continue;
char *pszSubFilename = CPLStrdup(
CPLFormFilename(m_pszDirectory, papszFileList[iFile], nullptr));
IMapInfoFile *poFile =
IMapInfoFile::SmartOpen(pszSubFilename, m_bUpdate, bTestOpen);
CPLFree(pszSubFilename);
if( poFile == nullptr )
{
CSLDestroy(papszFileList);
return FALSE;
}
poFile->SetDescription( poFile->GetName() );
m_nLayerCount++;
m_papoLayers = static_cast<IMapInfoFile **>(
CPLRealloc(m_papoLayers,sizeof(void *) * m_nLayerCount));
m_papoLayers[m_nLayerCount-1] = poFile;
}
CSLDestroy(papszFileList);
if( m_nLayerCount == 0 )
{
if( !bTestOpen )
CPLError(CE_Failure, CPLE_OpenFailed,
"No mapinfo files found in directory %s.",
m_pszDirectory);
return FALSE;
}
}
return TRUE;
}
static bool OGRGPSBabelDriverIdentifyInternal(
GDALOpenInfo* poOpenInfo,
const char** ppszGSPBabelDriverName )
{
if( STARTS_WITH_CI(poOpenInfo->pszFilename, "GPSBABEL:") )
return true;
const char* pszGPSBabelDriverName = NULL;
if( poOpenInfo->fpL == NULL )
return false;
if (memcmp(poOpenInfo->pabyHeader, "MsRcd", 5) == 0)
pszGPSBabelDriverName = "mapsource";
else if (memcmp(poOpenInfo->pabyHeader, "MsRcf", 5) == 0)
pszGPSBabelDriverName = "gdb";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "<osm") != NULL)
pszGPSBabelDriverName = "osm";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$GPGSA") != NULL ||
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$GPGGA") != NULL)
pszGPSBabelDriverName = "nmea";
else if (STARTS_WITH_CI((const char*)poOpenInfo->pabyHeader, "OziExplorer"))
pszGPSBabelDriverName = "ozi";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Grid") &&
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Datum") &&
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Header"))
pszGPSBabelDriverName = "garmin_txt";
else if (poOpenInfo->pabyHeader[0] == 13 && poOpenInfo->pabyHeader[10] == 'M' && poOpenInfo->pabyHeader[11] == 'S' &&
(poOpenInfo->pabyHeader[12] >= '0' && poOpenInfo->pabyHeader[12] <= '9') &&
(poOpenInfo->pabyHeader[13] >= '0' && poOpenInfo->pabyHeader[13] <= '9') &&
poOpenInfo->pabyHeader[12] * 10 + poOpenInfo->pabyHeader[13] >= 30 &&
(poOpenInfo->pabyHeader[14] == 1 || poOpenInfo->pabyHeader[14] == 2) && poOpenInfo->pabyHeader[15] == 0 &&
poOpenInfo->pabyHeader[16] == 0 && poOpenInfo->pabyHeader[17] == 0)
pszGPSBabelDriverName = "mapsend";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$PMGNWPL") != NULL ||
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$PMGNRTE") != NULL)
pszGPSBabelDriverName = "magellan";
else if (poOpenInfo->pabyHeader[0] == 'A' &&
poOpenInfo->pabyHeader[1] >= 'A' && poOpenInfo->pabyHeader[1] <= 'Z' &&
poOpenInfo->pabyHeader[2] >= 'A' && poOpenInfo->pabyHeader[2] <= 'Z' &&
poOpenInfo->pabyHeader[3] >= 'A' && poOpenInfo->pabyHeader[3] <= 'Z' &&
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "igc") )
pszGPSBabelDriverName = "igc";
static int bGPSBabelFound = -1;
if( pszGPSBabelDriverName != NULL && bGPSBabelFound < 0 )
{
#ifndef WIN32
VSIStatBufL sStat;
bGPSBabelFound = VSIStatL("/usr/bin/gpsbabel", &sStat) == 0;
if( !bGPSBabelFound )
#endif
{
const char* const apszArgs[] = { "gpsbabel", "-V", NULL };
CPLString osTmpFileName("/vsimem/gpsbabel_tmp.tmp");
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName, "wb");
bGPSBabelFound = (CPLSpawn(apszArgs, NULL, tmpfp, FALSE) == 0);
VSIFCloseL(tmpfp);
VSIUnlink(osTmpFileName);
}
}
if( bGPSBabelFound )
*ppszGSPBabelDriverName = pszGPSBabelDriverName;
return *ppszGSPBabelDriverName != NULL;
}
OGRDataSource *OGRGeomediaDriver::Open( const char * pszFilename,
int bUpdate )
{
OGRGeomediaDataSource *poDS;
if( EQUALN(pszFilename, "WALK:", strlen("WALK:")) )
return NULL;
if( EQUALN(pszFilename, "PGEO:", strlen("PGEO:")) )
return NULL;
if( !EQUALN(pszFilename,"GEOMEDIA:",9)
&& !EQUAL(CPLGetExtension(pszFilename),"mdb") )
return NULL;
/* Disabling the attempt to guess if a MDB file is a Geomedia database */
/* or not. See similar fix in PGeo driver for rationale. */
#if 0
if( !EQUALN(pszFilename,"GEOMEDIA:",9) &&
EQUAL(CPLGetExtension(pszFilename),"mdb") )
{
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (!fp)
return NULL;
GByte* pabyHeader = (GByte*) CPLMalloc(100000);
VSIFReadL(pabyHeader, 100000, 1, fp);
VSIFCloseL(fp);
/* Look for GAliasTable table */
const GByte pabyNeedle[] = { 'G', 0, 'A', 0, 'l', 0, 'i', 0, 'a', 0, 's', 0, 'T', 0, 'a', 0, 'b', 0, 'l', 0, 'e'};
int bFound = FALSE;
for(int i=0;i<100000 - (int)sizeof(pabyNeedle);i++)
{
if (memcmp(pabyHeader + i, pabyNeedle, sizeof(pabyNeedle)) == 0)
{
bFound = TRUE;
break;
}
}
CPLFree(pabyHeader);
if (!bFound)
return NULL;
}
#endif
#ifndef WIN32
// Try to register MDB Tools driver
//
// ODBCINST.INI NOTE:
// This operation requires write access to odbcinst.ini file
// located in directory pointed by ODBCINISYS variable.
// Usually, it points to /etc, so non-root users can overwrite this
// setting ODBCINISYS with location they have write access to, e.g.:
// $ export ODBCINISYS=$HOME/etc
// $ touch $ODBCINISYS/odbcinst.ini
//
// See: http://www.unixodbc.org/internals.html
//
if ( !InstallMdbDriver() )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unable to install MDB driver for ODBC, MDB access may not supported.\n" );
}
else
CPLDebug( "Geomedia", "MDB Tools driver installed successfully!");
#endif /* ndef WIN32 */
// Open data source
poDS = new OGRGeomediaDataSource();
if( !poDS->Open( pszFilename, bUpdate, TRUE ) )
{
delete poDS;
return NULL;
}
else
return poDS;
}
