GDALDataset *GRASSDataset::Open( GDALOpenInfo * poOpenInfo ) { char *pszGisdb = NULL, *pszLoc = NULL; char *pszMapset = NULL, *pszElem = NULL, *pszName = NULL; char **papszCells = NULL; char **papszMapsets = NULL; /* -------------------------------------------------------------------- */ /* Does this even look like a grass file path? */ /* -------------------------------------------------------------------- */ if( strstr(poOpenInfo->pszFilename,"/cellhd/") == NULL && strstr(poOpenInfo->pszFilename,"/group/") == NULL ) return NULL; /* Always init, if no rasters are opened G_no_gisinit resets the projection and * rasters in different projection may be then opened */ // Don't use GISRC file and read/write GRASS variables (from location G_VAR_GISRC) to memory only. G_set_gisrc_mode ( G_GISRC_MODE_MEMORY ); // Init GRASS libraries (required) G_no_gisinit(); // Doesn't check write permissions for mapset compare to G_gisinit // Set error function G_set_error_routine ( (GrassErrorHandler) Grass2CPLErrorHook ); // GISBASE is path to the directory where GRASS is installed, if ( !getenv( "GISBASE" ) ) { static char* gisbaseEnv = NULL; const char *gisbase = GRASS_GISBASE; CPLError( CE_Warning, CPLE_AppDefined, "GRASS warning: GISBASE " "enviroment variable was not set, using:\n%s", gisbase ); char buf[2000]; snprintf ( buf, sizeof(buf), "GISBASE=%s", gisbase ); buf[sizeof(buf)-1] = '\0'; CPLFree(gisbaseEnv); gisbaseEnv = CPLStrdup ( buf ); putenv( gisbaseEnv ); } if ( !SplitPath( poOpenInfo->pszFilename, &pszGisdb, &pszLoc, &pszMapset, &pszElem, &pszName) ) { return NULL; } /* -------------------------------------------------------------------- */ /* Check element name */ /* -------------------------------------------------------------------- */ if ( strcmp(pszElem,"cellhd") != 0 && strcmp(pszElem,"group") != 0 ) { G_free(pszGisdb); G_free(pszLoc); G_free(pszMapset); G_free(pszElem); G_free(pszName); return NULL; } /* -------------------------------------------------------------------- */ /* Set GRASS variables */ /* -------------------------------------------------------------------- */ G__setenv( "GISDBASE", pszGisdb ); G__setenv( "LOCATION_NAME", pszLoc ); G__setenv( "MAPSET", pszMapset); // group is searched only in current mapset G_reset_mapsets(); G_add_mapset_to_search_path ( pszMapset ); /* -------------------------------------------------------------------- */ /* Check if this is a valid grass cell. */ /* -------------------------------------------------------------------- */ if ( strcmp(pszElem,"cellhd") == 0 ) { if ( G_find_file2("cell", pszName, pszMapset) == NULL ) { G_free(pszGisdb); G_free(pszLoc); G_free(pszMapset); G_free(pszElem); G_free(pszName); return NULL; } papszMapsets = CSLAddString( papszMapsets, pszMapset ); papszCells = CSLAddString( papszCells, pszName ); } /* -------------------------------------------------------------------- */ /* Check if this is a valid GRASS imagery group. */ /* -------------------------------------------------------------------- */ else { struct Ref ref; I_init_group_ref( &ref ); if ( I_get_group_ref( pszName, &ref ) == 0 ) { G_free(pszGisdb); G_free(pszLoc); G_free(pszMapset); G_free(pszElem); G_free(pszName); return NULL; } for( int iRef = 0; iRef < ref.nfiles; iRef++ ) { papszCells = CSLAddString( papszCells, ref.file[iRef].name ); papszMapsets = CSLAddString( papszMapsets, ref.file[iRef].mapset ); G_add_mapset_to_search_path ( ref.file[iRef].mapset ); } I_free_group_ref( &ref ); } G_free( pszMapset ); G_free( pszName ); /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ GRASSDataset *poDS; poDS = new GRASSDataset(); /* notdef: should only allow read access to an existing cell, right? */ poDS->eAccess = poOpenInfo->eAccess; poDS->pszGisdbase = pszGisdb; poDS->pszLocation = pszLoc; poDS->pszElement = pszElem; /* -------------------------------------------------------------------- */ /* Capture some information from the file that is of interest. */ /* -------------------------------------------------------------------- */ #if GRASS_VERSION_MAJOR >= 7 Rast_get_cellhd( papszCells[0], papszMapsets[0], &(poDS->sCellInfo) ); #else if( G_get_cellhd( papszCells[0], papszMapsets[0], &(poDS->sCellInfo) ) != 0 ) { CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster header"); delete poDS; return NULL; } #endif poDS->nRasterXSize = poDS->sCellInfo.cols; poDS->nRasterYSize = poDS->sCellInfo.rows; poDS->adfGeoTransform[0] = poDS->sCellInfo.west; poDS->adfGeoTransform[1] = poDS->sCellInfo.ew_res; poDS->adfGeoTransform[2] = 0.0; poDS->adfGeoTransform[3] = poDS->sCellInfo.north; poDS->adfGeoTransform[4] = 0.0; poDS->adfGeoTransform[5] = -1 * poDS->sCellInfo.ns_res; /* -------------------------------------------------------------------- */ /* Try to get a projection definition. */ /* -------------------------------------------------------------------- */ struct Key_Value *projinfo, *projunits; projinfo = G_get_projinfo(); projunits = G_get_projunits(); poDS->pszProjection = GPJ_grass_to_wkt ( projinfo, projunits, 0, 0); if (projinfo) G_free_key_value(projinfo); if (projunits) G_free_key_value(projunits); /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ for( int iBand = 0; papszCells[iBand] != NULL; iBand++ ) { GRASSRasterBand *rb = new GRASSRasterBand( poDS, iBand+1, papszMapsets[iBand], papszCells[iBand] ); if ( !rb->valid ) { CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster band %d", iBand); delete rb; delete poDS; return NULL; } poDS->SetBand( iBand+1, rb ); } CSLDestroy(papszCells); CSLDestroy(papszMapsets); /* -------------------------------------------------------------------- */ /* Confirm the requested access is supported. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) { delete poDS; CPLError( CE_Failure, CPLE_NotSupported, "The GRASS driver does not support update access to existing" " datasets.\n" ); return NULL; } return poDS; }
int GRASS_LIB_EXPORT QgsGrassGisLib::G__gisinit( const char * version, const char * programName ) { Q_UNUSED( version ); // We use this function also to init our fake lib QgsDebugMsg( QString( "version = %1 programName = %2" ).arg( version ).arg( programName ) ); // Init providers path int argc = 1; char **argv = new char*[1]; argv[0] = qstrdup( programName ); // unfortunately it seems impossible to get QGIS prefix // QCoreApplication::applicationDirPath() returns $GISBASE/lib on Linux #if 0 QDir dir( QCoreApplication::applicationDirPath() ); dir.cdUp(); QString prefixPath = dir.absolutePath(); #endif //QCoreApplication app( argc, argv ); // to init paths QgsApplication app( argc, argv, false ); // to init paths // TODO: WCS (network) fails with: "QTimer can only be used with threads started // with QThread" because QCoreApplication::exec() was not called, but // QCoreApplication::exec() goes to loop. We need to start QThread somehow. // QGIS_PREFIX_PATH should be loaded by QgsApplication //QString prefixPath = getenv( "QGIS_PREFIX_PATH" ); //if ( prefixPath.isEmpty() ) //{ // fatal( "Cannot get QGIS_PREFIX_PATH" ); //} //QgsApplication::setPrefixPath( prefixPath, true ); QgsDebugMsg( "Plugin path: " + QgsApplication::pluginPath() ); QgsProviderRegistry::instance( QgsApplication::pluginPath() ); QgsDebugMsg( "qgisSettingsDirPath = " + app.qgisSettingsDirPath() ); G_set_error_routine( &errorRoutine ); G_set_gisrc_mode( G_GISRC_MODE_MEMORY ); G_setenv( "OVERWRITE", "1" ); // avoid checking if map exists G_suppress_masking(); #if GRASS_VERSION_MAJOR<6 || (GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR <= 4) G__init_null_patterns(); #endif // Read projection if set //mCrs.createFromOgcWmsCrs( "EPSG:900913" ); QString crsStr = getenv( "QGIS_GRASS_CRS" ); QgsDebugMsg( "Setting CRS to " + crsStr ); if ( !crsStr.isEmpty() ) { if ( !mCrs.createFromProj4( crsStr ) ) { fatal( "Cannot create CRS from QGIS_GRASS_CRS: " + crsStr ); } //TODO: createFromProj4 used to save to the user database any new CRS // this behavior was changed in order to separate creation and saving. // Not sure if it necessary to save it here, should be checked by someone // familiar with the code (should also give a more descriptive name to the generated CRS) if ( mCrs.srsid() == 0 ) { QString myName = QString( " * %1 (%2)" ) .arg( QObject::tr( "Generated CRS", "A CRS automatically generated from layer info get this prefix for description" ) ) .arg( mCrs.toProj4() ); mCrs.saveAsUserCRS( myName ); } } mDistanceArea.setSourceCrs( mCrs.srsid() ); // Read region fron environment variable // QGIS_GRASS_REGION=west,south,east,north,cols,rows #if 0 QString regionStr = getenv( "QGIS_GRASS_REGION" ); QStringList regionList = regionStr.split( "," ); if ( regionList.size() != 6 ) { fatal( "Cannot read region from QGIS_GRASS_REGION environment variable" ); } double xMin, yMin, xMax, yMax; int cols, rows; bool xMinOk, yMinOk, xMaxOk, yMaxOk, colsOk, rowsOk; xMin = regionList.value( 0 ).toDouble( &xMinOk ); yMin = regionList.value( 1 ).toDouble( &yMinOk ); xMax = regionList.value( 2 ).toDouble( &xMaxOk ); yMax = regionList.value( 3 ).toDouble( &yMaxOk ); cols = regionList.value( 4 ).toInt( &colsOk ); rows = regionList.value( 5 ).toInt( &rowsOk ); if ( !xMinOk || !yMinOk || !xMaxOk || !yMaxOk || !colsOk || !rowsOk ) { fatal( "Cannot parse QGIS_GRASS_REGION" ); } struct Cell_head window; window.west = xMin; window.south = yMin; window.east = xMax; window.north = yMax; window.rows = rows; window.cols = cols; char* err = G_adjust_Cell_head( &window, 1, 1 ); if ( err ) { fatal( QString( err ) ); } G_set_window( &window ); #endif QString regionStr = getenv( "GRASS_REGION" ); if ( regionStr.isEmpty() ) { fatal( "GRASS_REGION environment variable not set" ); } QgsDebugMsg( "Getting region via true lib from GRASS_REGION: " + regionStr ); // GRASS true lib reads GRASS_REGION environment variable G_get_window( &mWindow ); mExtent = QgsRectangle( mWindow.west, mWindow.south, mWindow.east, mWindow.north ); mRows = mWindow.rows; mColumns = mWindow.cols; mXRes = mExtent.width() / mColumns; mYRes = mExtent.height() / mColumns; QgsDebugMsg( "End" ); return 0; }
int OGRGRASSDataSource::Open( const char * pszNewName, int /*bUpdate*/, int bTestOpen, int /*bSingleNewFileIn*/ ) { VSIStatBuf stat; CPLAssert( nLayers == 0 ); pszName = CPLStrdup( pszNewName ); // Released by destructor /* -------------------------------------------------------------------- */ /* Do the given path contains 'vector' and 'head'? */ /* -------------------------------------------------------------------- */ if ( strstr(pszName,"vector") == NULL || strstr(pszName,"head") == NULL ) { if( !bTestOpen ) { CPLError( CE_Failure, CPLE_AppDefined, "%s is not GRASS vector, access failed.\n", pszName ); } return FALSE; } /* -------------------------------------------------------------------- */ /* Is the given a regular file? */ /* -------------------------------------------------------------------- */ if( CPLStat( pszName, &stat ) != 0 || !VSI_ISREG(stat.st_mode) ) { if( !bTestOpen ) { CPLError( CE_Failure, CPLE_AppDefined, "%s is not GRASS vector, access failed.\n", pszName ); } return FALSE; } /* -------------------------------------------------------------------- */ /* Parse datasource name */ /* -------------------------------------------------------------------- */ if ( !SplitPath(pszName, &pszGisdbase, &pszLocation, &pszMapset, &pszMap) ) { if( !bTestOpen ) { CPLError( CE_Failure, CPLE_AppDefined, "%s is not GRASS datasource name, access failed.\n", pszName ); } return FALSE; } CPLDebug ( "GRASS", "Gisdbase: %s", pszGisdbase ); CPLDebug ( "GRASS", "Location: %s", pszLocation ); CPLDebug ( "GRASS", "Mapset: %s", pszMapset ); CPLDebug ( "GRASS", "Map: %s", pszMap ); /* -------------------------------------------------------------------- */ /* Init GRASS library */ /* -------------------------------------------------------------------- */ // GISBASE is path to the directory where GRASS is installed, // it is necessary because there are database drivers. if ( !getenv( "GISBASE" ) ) { static char* gisbaseEnv = NULL; const char *gisbase = GRASS_GISBASE; CPLError( CE_Warning, CPLE_AppDefined, "GRASS warning: GISBASE " "environment variable was not set, using:\n%s", gisbase ); char buf[2000]; snprintf ( buf, sizeof(buf), "GISBASE=%s", gisbase ); buf[sizeof(buf)-1] = '\0'; CPLFree(gisbaseEnv); gisbaseEnv = CPLStrdup ( buf ); putenv( gisbaseEnv ); } // Don't use GISRC file and read/write GRASS variables // (from location G_VAR_GISRC) to memory only. G_set_gisrc_mode ( G_GISRC_MODE_MEMORY ); // Init GRASS libraries (required). G_no_gisinit() doesn't check // write permissions for mapset compare to G_gisinit() G_no_gisinit(); // Set error function G_set_error_routine ( (GrassErrorHandler) Grass2OGRErrorHook ); /* -------------------------------------------------------------------- */ /* Set GRASS variables */ /* -------------------------------------------------------------------- */ G__setenv( "GISDBASE", pszGisdbase ); G__setenv( "LOCATION_NAME", pszLocation ); G__setenv( "MAPSET", pszMapset); G_reset_mapsets(); G_add_mapset_to_search_path ( pszMapset ); /* -------------------------------------------------------------------- */ /* Open GRASS vector map */ /* -------------------------------------------------------------------- */ #if GRASS_VERSION_MAJOR < 7 Vect_set_fatal_error ( GV_FATAL_PRINT ); // Print error and continue #endif Vect_set_open_level (2); int level = Vect_open_old ( &map, pszMap, pszMapset); if ( level < 2 ) { CPLError( CE_Failure, CPLE_AppDefined, "Cannot open GRASS vector %s on level 2.\n", pszName ); return FALSE; } CPLDebug ( "GRASS", "Num lines = %d", Vect_get_num_lines(&map) ); /* -------------------------------------------------------------------- */ /* Build a list of layers. */ /* -------------------------------------------------------------------- */ int ncidx = Vect_cidx_get_num_fields ( &map ); CPLDebug ( "GRASS", "Num layers = %d", ncidx ); for ( int i = 0; i < ncidx; i++ ) { // Create the layer object OGRGRASSLayer *poLayer = new OGRGRASSLayer( i, &map ); // Add layer to data source layer list papoLayers = (OGRGRASSLayer **) CPLRealloc( papoLayers, sizeof(OGRGRASSLayer *) * (nLayers+1) ); papoLayers[nLayers++] = poLayer; } bOpened = TRUE; return TRUE; }
void GRASS_EXPORT QgsGrass::init( void ) { // Warning!!! // G_set_error_routine() once called from plugin // is not valid in provider -> call it always // Set error function G_set_error_routine( &error_routine ); if ( initialized ) return; QSettings settings; // Is it active mode ? if ( getenv( "GISRC" ) ) { active = true; // Store default values defaultGisdbase = G_gisdbase(); defaultLocation = G_location(); defaultMapset = G_mapset(); } else { active = false; } // Don't use GISRC file and read/write GRASS variables (from location G_VAR_GISRC) to memory only. G_set_gisrc_mode( G_GISRC_MODE_MEMORY ); // Init GRASS libraries (required) G_no_gisinit(); // Doesn't check write permissions for mapset compare to G_gisinit("libgrass++"); // I think that mask should not be used in QGIS as it can only confuses people, // anyway, I don't think anybody is using MASK G_suppress_masking(); // Set program name G_set_program_name( "QGIS" ); // Require GISBASE to be set. This should point to the location of // the GRASS installation. The GRASS libraries use it to know // where to look for things. // Look first to see if GISBASE env var is already set. // This is set when QGIS is run from within GRASS // or when set explicitly by the user. // This value should always take precedence. #if WIN32 QString gisBase = getenv( "WINGISBASE" ) ? getenv( "WINGISBASE" ) : getenv( "GISBASE" ); gisBase = shortPath( gisBase ); #else QString gisBase = getenv( "GISBASE" ); #endif QgsDebugMsg( QString( "GRASS gisBase from GISBASE env var is: %1" ).arg( gisBase ) ); if ( !isValidGrassBaseDir( gisBase ) ) { // Look for gisbase in QSettings gisBase = settings.value( "/GRASS/gisbase", "" ).toString(); QgsDebugMsg( QString( "GRASS gisBase from QSettings is: %1" ).arg( gisBase ) ); } if ( !isValidGrassBaseDir( gisBase ) ) { // Erase gisbase from settings because it does not exists settings.setValue( "/GRASS/gisbase", "" ); #ifdef WIN32 // Use the applicationDirPath()/grass gisBase = shortPath( QCoreApplication::applicationDirPath() + "/grass" ); QgsDebugMsg( QString( "GRASS gisBase = %1" ).arg( gisBase ) ); #else // Use the location specified --with-grass during configure gisBase = GRASS_BASE; QgsDebugMsg( QString( "GRASS gisBase from configure is: %1" ).arg( gisBase ) ); #endif } bool userGisbase = false; bool valid = false; while ( !( valid = isValidGrassBaseDir( gisBase ) ) ) { // ask user if he wants to specify GISBASE QMessageBox::StandardButton res = QMessageBox::warning( 0, QObject::tr( "GRASS plugin" ), QObject::tr( "QGIS couldn't find your GRASS installation.\n" "Would you like to specify path (GISBASE) to your GRASS installation?" ), QMessageBox::Ok | QMessageBox::Cancel ); if ( res != QMessageBox::Ok ) { userGisbase = false; break; } // XXX Need to subclass this and add explantory message above to left side userGisbase = true; // For Mac, GISBASE folder may be inside GRASS bundle. Use Qt file dialog // since Mac native dialog doesn't allow user to browse inside bundles. gisBase = QFileDialog::getExistingDirectory( 0, QObject::tr( "Choose GRASS installation path (GISBASE)" ), gisBase, QFileDialog::DontUseNativeDialog ); if ( gisBase == QString::null ) { // User pressed cancel. No GRASS for you! userGisbase = false; break; } #if defined(WIN32) gisBase = shortPath( gisBase ); #endif } if ( !valid ) { // warn user QMessageBox::information( 0, QObject::tr( "GRASS plugin" ), QObject::tr( "GRASS data won't be available if GISBASE is not specified." ) ); } if ( userGisbase ) { settings.setValue( "/GRASS/gisbase", gisBase ); } QgsDebugMsg( QString( "Valid GRASS gisBase is: %1" ).arg( gisBase ) ); putEnv( "GISBASE", gisBase ); // Add path to GRASS modules #ifdef WIN32 QString sep = ";"; #else QString sep = ":"; #endif QString path = gisBase + "/bin"; path.append( sep + gisBase + "/scripts" ); path.append( sep + QgsApplication::pkgDataPath() + "/grass/scripts/" ); // On windows the GRASS libraries are in // QgsApplication::prefixPath(), we have to add them // to PATH to enable running of GRASS modules // and database drivers #ifdef WIN32 // It seems that QgsApplication::prefixPath() // is not initialized at this point path.append( sep + shortPath( QCoreApplication::applicationDirPath() ) ); // Add path to MSYS bin // Warning: MSYS sh.exe will translate this path to '/bin' if ( QFileInfo( QCoreApplication::applicationDirPath() + "/msys/bin/" ).isDir() ) path.append( sep + shortPath( QCoreApplication::applicationDirPath() + "/msys/bin/" ) ); #endif QString p = getenv( "PATH" ); path.append( sep + p ); QgsDebugMsg( QString( "set PATH: %1" ).arg( path ) ); putEnv( "PATH", path ); // Set PYTHONPATH QString pythonpath = gisBase + "/etc/python"; QString pp = getenv( "PYTHONPATH" ); pythonpath.append( sep + pp ); QgsDebugMsg( QString( "set PYTHONPATH: %1" ).arg( pythonpath ) ); putEnv( "PYTHONPATH", pythonpath ); // Set GRASS_PAGER if not set, it is necessary for some // modules printing to terminal, e.g. g.list // We use 'cat' because 'more' is not present in MSYS (Win) // and it doesn't work well in built in shell (Unix/Mac) // and 'less' is not user friendly (for example user must press // 'q' to quit which is definitely difficult for normal user) // Also scroling can be don in scrollable window in both // MSYS terminal and built in shell. if ( !getenv( "GRASS_PAGER" ) ) { QString pager; QStringList pagers; //pagers << "more" << "less" << "cat"; // se notes above pagers << "cat"; for ( int i = 0; i < pagers.size(); i++ ) { int state; QProcess p; p.start( pagers.at( i ) ); p.waitForStarted(); state = p.state(); p.write( "\004" ); // Ctrl-D p.closeWriteChannel(); p.waitForFinished( 1000 ); p.kill(); if ( state == QProcess::Running ) { pager = pagers.at( i ); break; } } if ( pager.length() > 0 ) { putEnv( "GRASS_PAGER", pager ); } } initialized = 1; }
int main(int argc, char *argv[]) { struct Flag *tostdout, *overwrite; struct Option *extradirs; struct GModule *module; FILE *outstream; char *fontcapfile; struct stat status; int i; G_set_program_name(argv[0]); G_no_gisinit(); G_set_gisrc_mode(G_GISRC_MODE_MEMORY); module = G_define_module(); module->keywords = "general"; module->description = "Generates the font configuration file by scanning various directories " "for fonts"; overwrite = G_define_flag(); overwrite->key = 'o'; overwrite->description = "Overwrite font configuration file if already existing"; tostdout = G_define_flag(); tostdout->key = 's'; tostdout->description = "Write font configuration file to standard output instead of " "$GISBASE/etc"; extradirs = G_define_option(); extradirs->key = "extradirs"; extradirs->type = TYPE_STRING; extradirs->required = NO; extradirs->description = "Comma-separated list of extra directories to scan for " "Freetype-compatible fonts as well as the defaults (see documentation)"; if (argc > 1 && G_parser(argc, argv)) exit(EXIT_FAILURE); if (!tostdout->answer) { const char *gisbase = G_gisbase(); const char *alt_file = getenv("GRASS_FONT_CAP"); if (alt_file) fontcapfile = G_store(alt_file); else G_asprintf(&fontcapfile, "%s/etc/fontcap", gisbase); if (!stat(fontcapfile, &status)) { /* File exists? */ if (!overwrite->answer) G_fatal_error ("Fontcap file %s already exists; use -%c flag if you " "wish to overwrite it", fontcapfile, overwrite->key); } } searchdirs = NULL; numsearchdirs = 0; /* Prepare list of directories to search */ if (extradirs->answer) { #ifndef HAVE_FT2BUILD_H G_warning("This GRASS installation was compiled without Freetype support, extradirs parameter ignored"); #endif char *str = G_store(extradirs->answer); while ((str = strtok(str, ","))) { add_search_dir(str); str = NULL; } } i = -1; while (standarddirs[++i]) add_search_dir(standarddirs[i]); totalfonts = maxfonts = 0; fontcap = NULL; find_stroke_fonts(); find_freetype_fonts(); qsort(fontcap, totalfonts, sizeof(struct GFONT_CAP), compare_fonts); if (tostdout->answer) outstream = stdout; else { outstream = fopen(fontcapfile, "w"); if (outstream == NULL) G_fatal_error("Cannot open %s for writing: %s", fontcapfile, strerror(errno)); } for (i = 0; i < totalfonts; i++) fprintf(outstream, "%s|%s|%d|%s|%d|%s|\n", fontcap[i].name, fontcap[i].longname, fontcap[i].type, fontcap[i].path, fontcap[i].index, fontcap[i].encoding); fclose(outstream); exit(EXIT_SUCCESS); }
/*! \brief Get driver (?) \param argc, argv arguments \return 0 on success \return 1 on failure */ int db_driver(int argc, char *argv[]) { int stat; int procnum; int i; int rfd, wfd; FILE *send, *recv; char *modestr; /* Read and set environment variables, see dbmi_client/start.c */ if ((modestr = getenv("GRASS_DB_DRIVER_GISRC_MODE"))) { int mode; mode = atoi(modestr); if (mode == G_GISRC_MODE_MEMORY) { G_set_gisrc_mode(G_GISRC_MODE_MEMORY); G__setenv("DEBUG", getenv("DEBUG")); G__setenv("GISDBASE", getenv("GISDBASE")); G__setenv("LOCATION_NAME", getenv("LOCATION_NAME")); G__setenv("MAPSET", getenv("MAPSET")); G_debug(3, "Driver GISDBASE set to '%s'", G_getenv("GISDBASE")); } } #ifdef __MINGW32__ /* TODO: */ /* We should close everything except stdin, stdout but _fcloseall() * closes open streams not file descriptors. _getmaxstdio too big number. * * Because the pipes were created just before this driver was started * the file descriptors should not be above a closed descriptor * until it was run from a multithread application and some descriptors * were closed in the mean time. * Also Windows documentation does not say that new file descriptor is * the lowest available. */ { int err_count = 0; int cfd = 3; while (1) { if (close(cfd) == -1) err_count++; /* no good reason for 10 */ if (err_count > 10) break; cfd++; } } #endif send = stdout; recv = stdin; /* THIS CODE IS FOR DEBUGGING WITH CODECENTER */ /**********************************************/ if (argc == 3) { rfd = wfd = -1; sscanf(argv[1], "%d", &rfd); sscanf(argv[2], "%d", &wfd); send = fdopen(wfd, "w"); if (send == NULL) { db_syserror(argv[1]); exit(1); } recv = fdopen(rfd, "r"); if (recv == NULL) { db_syserror(argv[2]); exit(1); } } /**********************************************/ db_clear_error(); db_auto_print_errors(0); db_auto_print_protocol_errors(1); db__init_driver_state(); #ifndef USE_BUFFERED_IO setbuf(recv, NULL); setbuf(send, NULL); #endif db__set_protocol_fds(send, recv); if (db_driver_init(argc, argv) == DB_OK) db__send_success(); else { db__send_failure(); exit(1); } stat = DB_OK; /* get the procedure number */ while (db__recv_procnum(&procnum) == DB_OK) { #ifdef __MINGW32__ if (procnum == DB_PROC_SHUTDOWN_DRIVER) { db__send_procedure_ok(procnum); break; } #endif db_clear_error(); /* find this procedure */ for (i = 0; procedure[i].routine; i++) if (procedure[i].procnum == procnum) break; /* if found, call it */ if (procedure[i].routine) { if ((stat = db__send_procedure_ok(procnum)) != DB_OK) break; /* while loop */ if ((stat = (*procedure[i].routine) ()) != DB_OK) break; } else if ((stat = db__send_procedure_not_implemented(procnum)) != DB_OK) break; } db_driver_finish(); exit(stat == DB_OK ? 0 : 1); }