rtpg_assignHookGDALEnabledDrivers()

static void rtpg_assignHookGDALEnabledDrivers ( const char *  enabled_drivers, void *  extra  )

static

Definition at line 278 of file rtpostgis.c.

                                                                            {
        int enable_all = 0;
        int disable_all = 0;
 
        char **enabled_drivers_array = NULL;
        uint32_t enabled_drivers_count = 0;
        bool *enabled_drivers_found = NULL;
        char *gdal_skip = NULL;
 
        uint32_t i;
        uint32_t j;
 
        POSTGIS_RT_DEBUGF(4, "GDAL_SKIP = %s", CPLGetConfigOption("GDAL_SKIP", ""));
        POSTGIS_RT_DEBUGF(4, "enabled_drivers = %s", enabled_drivers);
 
        /* if NULL, nothing to do */
        if (enabled_drivers == NULL)
                return;
 
        /* destroy the driver manager */
        /* this is the only way to ensure GDAL_SKIP is recognized */
        GDALDestroyDriverManager();
        CPLSetConfigOption("GDAL_SKIP", NULL);
 
        /* force wrapper function to call GDALAllRegister() */
        rt_util_gdal_register_all(1);
 
        enabled_drivers_array = rtpg_strsplit(enabled_drivers, " ", &enabled_drivers_count);
        enabled_drivers_found = palloc(sizeof(bool) * enabled_drivers_count);
        memset(enabled_drivers_found, FALSE, sizeof(bool) * enabled_drivers_count);
 
        /* scan for keywords DISABLE_ALL and ENABLE_ALL */
        disable_all = 0;
        enable_all = 0;
        if (strstr(enabled_drivers, GDAL_DISABLE_ALL) != NULL) {
                for (i = 0; i < enabled_drivers_count; i++) {
                        if (strstr(enabled_drivers_array[i], GDAL_DISABLE_ALL) != NULL) {
                                enabled_drivers_found[i] = TRUE;
                                disable_all = 1;
                        }
                }
        }
        else if (strstr(enabled_drivers, GDAL_ENABLE_ALL) != NULL) {
                for (i = 0; i < enabled_drivers_count; i++) {
                        if (strstr(enabled_drivers_array[i], GDAL_ENABLE_ALL) != NULL) {
                                enabled_drivers_found[i] = TRUE;
                                enable_all = 1;
                        }
                }
        }
 
        if (!enable_all) {
                int found = 0;
                uint32_t drv_count = 0;
                rt_gdaldriver drv_set = rt_raster_gdal_drivers(&drv_count, 0);
 
                POSTGIS_RT_DEBUGF(4, "driver count = %d", drv_count);
 
                /* all other drivers than those in new drivers are added to GDAL_SKIP */
                for (i = 0; i < drv_count; i++) {
                        found = 0;
 
                        if (!disable_all) {
                                /* gdal driver found in enabled_drivers, continue to thorough search */
                                if (strstr(enabled_drivers, drv_set[i].short_name) != NULL) {
                                        /* thorough search of enabled_drivers */
                                        for (j = 0; j < enabled_drivers_count; j++) {
                                                /* driver found */
                                                if (strcmp(enabled_drivers_array[j], drv_set[i].short_name) == 0) {
                                                        enabled_drivers_found[j] = TRUE;
                                                        found = 1;
                                                }
                                        }
                                }
                        }
 
                        /* driver found, continue */
                        if (found)
                                continue;
 
                        /* driver not found, add to gdal_skip */
                        if (gdal_skip == NULL) {
                                gdal_skip = palloc(sizeof(char) * (strlen(drv_set[i].short_name) + 1));
                                gdal_skip[0] = '\0';
                        }
                        else {
                                gdal_skip = repalloc(
                                        gdal_skip,
                                        sizeof(char) * (
                                                strlen(gdal_skip) + 1 + strlen(drv_set[i].short_name) + 1
                                        )
                                );
                                strcat(gdal_skip, " ");
                        }
                        strcat(gdal_skip, drv_set[i].short_name);
                }
 
                for (i = 0; i < drv_count; i++) {
                        pfree(drv_set[i].short_name);
                        pfree(drv_set[i].long_name);
                        pfree(drv_set[i].create_options);
                }
                if (drv_count) pfree(drv_set);
 
        }
 
        for (i = 0; i < enabled_drivers_count; i++) {
                if (enabled_drivers_found[i])
                        continue;
 
                if (disable_all)
                        elog(WARNING, "%s set. Ignoring GDAL driver: %s", GDAL_DISABLE_ALL, enabled_drivers_array[i]);
                else if (enable_all)
                        elog(WARNING, "%s set. Ignoring GDAL driver: %s", GDAL_ENABLE_ALL, enabled_drivers_array[i]);
                else
                        elog(WARNING, "Unknown GDAL driver: %s", enabled_drivers_array[i]);
        }
 
        /* destroy the driver manager */
        /* this is the only way to ensure GDAL_SKIP is recognized */
        GDALDestroyDriverManager();
 
        /* set GDAL_SKIP */
        POSTGIS_RT_DEBUGF(4, "gdal_skip = %s", gdal_skip);
        CPLSetConfigOption("GDAL_SKIP", gdal_skip);
        if (gdal_skip != NULL) pfree(gdal_skip);
 
        /* force wrapper function to call GDALAllRegister() */
        rt_util_gdal_register_all(1);
 
        pfree(enabled_drivers_array);
        pfree(enabled_drivers_found);
        POSTGIS_RT_DEBUGF(4, "GDAL_SKIP = %s", CPLGetConfigOption("GDAL_SKIP", ""));
}

References FALSE, GDAL_DISABLE_ALL, GDAL_ENABLE_ALL, POSTGIS_RT_DEBUGF, rt_raster_gdal_drivers(), rt_util_gdal_register_all(), rtpg_strsplit(), and TRUE.

Referenced by _PG_init().

Here is the call graph for this function:

Here is the caller graph for this function: