Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: GDAL Core
4 : * Purpose: Implementation of GDALDriverManager class.
5 : * Author: Frank Warmerdam, warmerdam@pobox.com
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 1998, Frank Warmerdam
9 : * Copyright (c) 2009-2013, Even Rouault <even dot rouault at spatialys.com>
10 : *
11 : * SPDX-License-Identifier: MIT
12 : ****************************************************************************/
13 :
14 : #include "cpl_port.h"
15 : #include "gdal_priv.h"
16 :
17 : #include <algorithm>
18 : #include <cstring>
19 : #include <map>
20 : #include <set>
21 :
22 : #include "cpl_conv.h"
23 : #include "cpl_error.h"
24 : #include "cpl_http.h"
25 : #include "cpl_multiproc.h"
26 : #include "cpl_port.h"
27 : #include "cpl_string.h"
28 : #include "cpl_vsi.h"
29 : #include "cpl_compressor.h"
30 : #include "gdal_alg.h"
31 : #include "gdal_alg_priv.h"
32 : #include "gdal.h"
33 : #include "gdal_pam.h"
34 : #include "gdalplugindriverproxy.h"
35 : #include "gdal_version_full/gdal_version.h"
36 : #include "gdal_thread_pool.h"
37 : #include "ogr_srs_api.h"
38 : #include "ograpispy.h"
39 : #ifdef HAVE_XERCES
40 : #include "ogr_xerces.h"
41 : #endif // HAVE_XERCES
42 :
43 : #ifdef _MSC_VER
44 : #ifdef MSVC_USE_VLD
45 : #include <wchar.h>
46 : #include <vld.h>
47 : #endif
48 : #endif
49 :
50 : // FIXME: Disabled following code as it crashed on OSX CI test.
51 : // #include <mutex>
52 :
53 : /************************************************************************/
54 : /* ==================================================================== */
55 : /* GDALDriverManager */
56 : /* ==================================================================== */
57 : /************************************************************************/
58 :
59 : static volatile GDALDriverManager *poDM = nullptr;
60 : static CPLMutex *hDMMutex = nullptr;
61 :
62 : // FIXME: Disabled following code as it crashed on OSX CI test.
63 : // static std::mutex oDeleteMutex;
64 :
65 57 : CPLMutex **GDALGetphDMMutex()
66 : {
67 57 : return &hDMMutex;
68 : }
69 :
70 : /************************************************************************/
71 : /* GetGDALDriverManager() */
72 : /* */
73 : /* A freestanding function to get the only instance of the */
74 : /* GDALDriverManager. */
75 : /************************************************************************/
76 :
77 : /**
78 : * \brief Fetch the global GDAL driver manager.
79 : *
80 : * This function fetches the pointer to the singleton global driver manager.
81 : * If the driver manager doesn't exist it is automatically created.
82 : *
83 : * @return pointer to the global driver manager. This should not be able
84 : * to fail.
85 : */
86 :
87 1177050 : GDALDriverManager *GetGDALDriverManager()
88 :
89 : {
90 1177050 : if (poDM == nullptr)
91 : {
92 3514 : CPLMutexHolderD(&hDMMutex);
93 : // cppcheck-suppress identicalInnerCondition
94 1757 : if (poDM == nullptr)
95 1757 : poDM = new GDALDriverManager();
96 : }
97 :
98 1177050 : CPLAssert(nullptr != poDM);
99 :
100 1177050 : return const_cast<GDALDriverManager *>(poDM);
101 : }
102 :
103 : /************************************************************************/
104 : /* GDALDriverManager() */
105 : /************************************************************************/
106 :
107 : #define XSTRINGIFY(x) #x
108 : #define STRINGIFY(x) XSTRINGIFY(x)
109 :
110 1757 : GDALDriverManager::GDALDriverManager()
111 : {
112 1757 : CPLAssert(poDM == nullptr);
113 :
114 1757 : CPLLoadConfigOptionsFromPredefinedFiles();
115 :
116 1757 : CPLHTTPSetDefaultUserAgent(
117 : "GDAL/" STRINGIFY(GDAL_VERSION_MAJOR) "." STRINGIFY(
118 : GDAL_VERSION_MINOR) "." STRINGIFY(GDAL_VERSION_REV));
119 :
120 : /* -------------------------------------------------------------------- */
121 : /* We want to push a location to search for data files */
122 : /* supporting GDAL/OGR such as EPSG csv files, S-57 definition */
123 : /* files, and so forth. Use the INST_DATA macro (setup at */
124 : /* configure time) if available. Otherwise we don't push anything */
125 : /* and we hope other mechanisms such as environment variables will */
126 : /* have been employed. */
127 : /* -------------------------------------------------------------------- */
128 : #ifdef INST_DATA
129 1757 : if (CPLGetConfigOption("GDAL_DATA", nullptr) != nullptr)
130 : {
131 : // This one is picked up automatically by finder initialization.
132 : }
133 : else
134 : {
135 2 : CPLPushFinderLocation(INST_DATA);
136 : }
137 : #endif
138 1757 : }
139 :
140 : /************************************************************************/
141 : /* ~GDALDriverManager() */
142 : /************************************************************************/
143 :
144 : // Keep these two in sync with gdalproxypool.cpp.
145 : void GDALDatasetPoolPreventDestroy();
146 : void GDALDatasetPoolForceDestroy();
147 :
148 2246 : GDALDriverManager::~GDALDriverManager()
149 :
150 : {
151 : /* -------------------------------------------------------------------- */
152 : /* Cleanup any open datasets. */
153 : /* -------------------------------------------------------------------- */
154 :
155 : // We have to prevent the destroying of the dataset pool during this first
156 : // phase, otherwise it cause crashes with a VRT B referencing a VRT A, and
157 : // if CloseDependentDatasets() is called first on VRT A.
158 : // If we didn't do this nasty trick, due to the refCountOfDisableRefCount
159 : // mechanism that cheats the real refcount of the dataset pool, we might
160 : // destroy the dataset pool too early, leading the VRT A to
161 : // destroy itself indirectly ... Ok, I am aware this explanation does
162 : // not make any sense unless you try it under a debugger ...
163 : // When people just manipulate "top-level" dataset handles, we luckily
164 : // don't need this horrible hack, but GetOpenDatasets() expose "low-level"
165 : // datasets, which defeat some "design" of the proxy pool.
166 1123 : GDALDatasetPoolPreventDestroy();
167 :
168 : // First begin by requesting each remaining dataset to drop any reference
169 : // to other datasets.
170 1123 : bool bHasDroppedRef = false;
171 :
172 1138 : do
173 : {
174 1138 : int nDSCount = 0;
175 1138 : GDALDataset **papoDSList = GDALDataset::GetOpenDatasets(&nDSCount);
176 :
177 : // If a dataset has dropped a reference, the list might have become
178 : // invalid, so go out of the loop and try again with the new valid
179 : // list.
180 1138 : bHasDroppedRef = false;
181 1363 : for (int i = 0; i < nDSCount && !bHasDroppedRef; ++i)
182 : {
183 : #if DEBUG_VERBOSE
184 : CPLDebug("GDAL", "Call CloseDependentDatasets() on %s",
185 : papoDSList[i]->GetDescription());
186 : #endif // DEBUG_VERBOSE
187 : bHasDroppedRef =
188 225 : CPL_TO_BOOL(papoDSList[i]->CloseDependentDatasets());
189 : }
190 : } while (bHasDroppedRef);
191 :
192 : // Now let's destroy the dataset pool. Nobody should use it afterwards
193 : // if people have well released their dependent datasets above.
194 1123 : GDALDatasetPoolForceDestroy();
195 :
196 : // Now close the stand-alone datasets.
197 1123 : int nDSCount = 0;
198 1123 : GDALDataset **papoDSList = GDALDataset::GetOpenDatasets(&nDSCount);
199 1182 : for (int i = 0; i < nDSCount; ++i)
200 : {
201 59 : CPLDebug("GDAL", "Force close of %s (%p) in GDALDriverManager cleanup.",
202 59 : papoDSList[i]->GetDescription(), papoDSList[i]);
203 : // Destroy with delete operator rather than GDALClose() to force
204 : // deletion of datasets with multiple reference count.
205 : // We could also iterate while GetOpenDatasets() returns a non NULL
206 : // list.
207 59 : delete papoDSList[i];
208 : }
209 :
210 : /* -------------------------------------------------------------------- */
211 : /* Destroy the existing drivers. */
212 : /* -------------------------------------------------------------------- */
213 251548 : while (GetDriverCount() > 0)
214 : {
215 250425 : GDALDriver *poDriver = GetDriver(0);
216 :
217 250425 : DeregisterDriver(poDriver);
218 250425 : delete poDriver;
219 : }
220 :
221 : {
222 1123 : auto oIter = oMapNameToDrivers.find("MEMORY");
223 1123 : if (oIter != oMapNameToDrivers.end())
224 1123 : delete oIter->second;
225 : }
226 :
227 1123 : CleanupPythonDrivers();
228 :
229 1123 : GDALDestroyGlobalThreadPool();
230 :
231 : /* -------------------------------------------------------------------- */
232 : /* Cleanup local memory. */
233 : /* -------------------------------------------------------------------- */
234 1123 : VSIFree(papoDrivers);
235 :
236 : /* -------------------------------------------------------------------- */
237 : /* Cleanup any Proxy related memory. */
238 : /* -------------------------------------------------------------------- */
239 1123 : PamCleanProxyDB();
240 :
241 : /* -------------------------------------------------------------------- */
242 : /* Cleanup any memory allocated by the OGRSpatialReference */
243 : /* related subsystem. */
244 : /* -------------------------------------------------------------------- */
245 1123 : OSRCleanup();
246 :
247 : /* -------------------------------------------------------------------- */
248 : /* Blow away all the finder hints paths. We really should not */
249 : /* be doing all of them, but it is currently hard to keep track */
250 : /* of those that actually belong to us. */
251 : /* -------------------------------------------------------------------- */
252 1123 : CPLFinderClean();
253 1123 : CPLFreeConfig();
254 1123 : CPLCleanupSharedFileMutex();
255 :
256 : #ifdef HAVE_XERCES
257 1123 : OGRCleanupXercesMutex();
258 : #endif
259 :
260 : #ifdef OGRAPISPY_ENABLED
261 1123 : OGRAPISpyDestroyMutex();
262 : #endif
263 :
264 : /* -------------------------------------------------------------------- */
265 : /* Cleanup VSIFileManager. */
266 : /* -------------------------------------------------------------------- */
267 1123 : VSICleanupFileManager();
268 1123 : CPLDestroyCompressorRegistry();
269 :
270 : /* -------------------------------------------------------------------- */
271 : /* Cleanup thread local storage ... I hope the program is all */
272 : /* done with GDAL/OGR! */
273 : /* -------------------------------------------------------------------- */
274 1123 : CPLCleanupTLS();
275 :
276 : /* -------------------------------------------------------------------- */
277 : /* Cleanup our mutex. */
278 : /* -------------------------------------------------------------------- */
279 1123 : if (hDMMutex)
280 : {
281 1123 : CPLDestroyMutex(hDMMutex);
282 1123 : hDMMutex = nullptr;
283 : }
284 :
285 : /* -------------------------------------------------------------------- */
286 : /* Cleanup dataset list mutex. */
287 : /* -------------------------------------------------------------------- */
288 1123 : if (*GDALGetphDLMutex() != nullptr)
289 : {
290 1123 : CPLDestroyMutex(*GDALGetphDLMutex());
291 1123 : *GDALGetphDLMutex() = nullptr;
292 : }
293 :
294 : /* -------------------------------------------------------------------- */
295 : /* Cleanup raster block mutex. */
296 : /* -------------------------------------------------------------------- */
297 1123 : GDALRasterBlock::DestroyRBMutex();
298 :
299 : /* -------------------------------------------------------------------- */
300 : /* Cleanup gdaltransformer.cpp mutex. */
301 : /* -------------------------------------------------------------------- */
302 1123 : GDALCleanupTransformDeserializerMutex();
303 :
304 : /* -------------------------------------------------------------------- */
305 : /* Cleanup cpl_error.cpp mutex. */
306 : /* -------------------------------------------------------------------- */
307 1123 : CPLCleanupErrorMutex();
308 :
309 : /* -------------------------------------------------------------------- */
310 : /* Cleanup CPLsetlocale mutex. */
311 : /* -------------------------------------------------------------------- */
312 1123 : CPLCleanupSetlocaleMutex();
313 :
314 : /* -------------------------------------------------------------------- */
315 : /* Cleanup curl related stuff. */
316 : /* -------------------------------------------------------------------- */
317 1123 : CPLHTTPCleanup();
318 :
319 : /* -------------------------------------------------------------------- */
320 : /* Cleanup the master CPL mutex, which governs the creation */
321 : /* of all other mutexes. */
322 : /* -------------------------------------------------------------------- */
323 1123 : CPLCleanupMasterMutex();
324 :
325 : /* -------------------------------------------------------------------- */
326 : /* Ensure the global driver manager pointer is NULLed out. */
327 : /* -------------------------------------------------------------------- */
328 1123 : if (poDM == this)
329 1123 : poDM = nullptr;
330 2246 : }
331 :
332 : /************************************************************************/
333 : /* GetDriverCount() */
334 : /************************************************************************/
335 :
336 : /**
337 : * \brief Fetch the number of registered drivers.
338 : *
339 : * This C analog to this is GDALGetDriverCount().
340 : *
341 : * @return the number of registered drivers.
342 : */
343 :
344 286418 : int GDALDriverManager::GetDriverCount() const
345 :
346 : {
347 286418 : return nDrivers;
348 : }
349 :
350 : //! @cond Doxygen_Suppress
351 79048 : int GDALDriverManager::GetDriverCount(bool bIncludeHidden) const
352 :
353 : {
354 79048 : if (!bIncludeHidden)
355 0 : return nDrivers;
356 79048 : return nDrivers + static_cast<int>(m_aoHiddenDrivers.size());
357 : }
358 :
359 : //! @endcond
360 :
361 : /************************************************************************/
362 : /* IsKnownDriver() */
363 : /************************************************************************/
364 :
365 : //! @cond Doxygen_Suppress
366 0 : bool GDALDriverManager::IsKnownDriver(const char *pszDriverName) const
367 : {
368 0 : CPLMutexHolderD(&hDMMutex);
369 0 : if (cpl::contains(oMapNameToDrivers, CPLString(pszDriverName).toupper()))
370 0 : return true;
371 0 : for (const auto &poDriver : m_aoHiddenDrivers)
372 : {
373 0 : if (EQUAL(poDriver->GetDescription(), pszDriverName))
374 0 : return true;
375 : }
376 0 : return false;
377 : }
378 :
379 : //! @endcond
380 :
381 : /************************************************************************/
382 : /* GetHiddenDriverByName() */
383 : /************************************************************************/
384 :
385 : //! @cond Doxygen_Suppress
386 4 : GDALDriver *GDALDriverManager::GetHiddenDriverByName(const char *pszName)
387 : {
388 8 : CPLMutexHolderD(&hDMMutex);
389 4 : for (const auto &poDriver : m_aoHiddenDrivers)
390 : {
391 0 : if (EQUAL(poDriver->GetDescription(), pszName))
392 0 : return poDriver.get();
393 : }
394 4 : return nullptr;
395 : }
396 :
397 : //! @endcond
398 :
399 : /************************************************************************/
400 : /* GDALGetDriverCount() */
401 : /************************************************************************/
402 :
403 : /**
404 : * \brief Fetch the number of registered drivers.
405 : *
406 : * @see GDALDriverManager::GetDriverCount()
407 : */
408 :
409 1452 : int CPL_STDCALL GDALGetDriverCount()
410 :
411 : {
412 1452 : return GetGDALDriverManager()->GetDriverCount();
413 : }
414 :
415 : /************************************************************************/
416 : /* GetDriver() */
417 : /************************************************************************/
418 :
419 : /**
420 : * \brief Fetch driver by index.
421 : *
422 : * This C analog to this is GDALGetDriver().
423 : *
424 : * @param iDriver the driver index from 0 to GetDriverCount()-1.
425 : *
426 : * @return the driver identified by the index or NULL if the index is invalid
427 : */
428 :
429 12043400 : GDALDriver *GDALDriverManager::GetDriver(int iDriver)
430 :
431 : {
432 24086900 : CPLMutexHolderD(&hDMMutex);
433 :
434 24086900 : return GetDriver_unlocked(iDriver);
435 : }
436 :
437 : //! @cond Doxygen_Suppress
438 8435660 : GDALDriver *GDALDriverManager::GetDriver(int iDriver, bool bIncludeHidden)
439 :
440 : {
441 16876700 : CPLMutexHolderD(&hDMMutex);
442 8441050 : if (!bIncludeHidden || iDriver < nDrivers)
443 8441050 : return GetDriver_unlocked(iDriver);
444 0 : if (iDriver - nDrivers < static_cast<int>(m_aoHiddenDrivers.size()))
445 0 : return m_aoHiddenDrivers[iDriver - nDrivers].get();
446 0 : return nullptr;
447 : }
448 :
449 : //! @endcond
450 :
451 : /************************************************************************/
452 : /* GDALGetDriver() */
453 : /************************************************************************/
454 :
455 : /**
456 : * \brief Fetch driver by index.
457 : *
458 : * @see GDALDriverManager::GetDriver()
459 : */
460 :
461 83120 : GDALDriverH CPL_STDCALL GDALGetDriver(int iDriver)
462 :
463 : {
464 83120 : return /* (GDALDriverH) */ GetGDALDriverManager()->GetDriver(iDriver);
465 : }
466 :
467 : /************************************************************************/
468 : /* RegisterDriver() */
469 : /************************************************************************/
470 :
471 : /**
472 : * \brief Register a driver for use.
473 : *
474 : * The C analog is GDALRegisterDriver().
475 : *
476 : * Normally this method is used by format specific C callable registration
477 : * entry points such as GDALRegister_GTiff() rather than being called
478 : * directly by application level code.
479 : *
480 : * If this driver (based on the object pointer, not short name) is already
481 : * registered, then no change is made, and the index of the existing driver
482 : * is returned. Otherwise the driver list is extended, and the new driver
483 : * is added at the end.
484 : *
485 : * @param poDriver the driver to register.
486 : *
487 : * @return the index of the new installed driver.
488 : */
489 :
490 398200 : int GDALDriverManager::RegisterDriver(GDALDriver *poDriver)
491 : {
492 398200 : return RegisterDriver(poDriver, /*bHidden=*/false);
493 : }
494 :
495 398200 : int GDALDriverManager::RegisterDriver(GDALDriver *poDriver, bool bHidden)
496 : {
497 796400 : CPLMutexHolderD(&hDMMutex);
498 :
499 : /* -------------------------------------------------------------------- */
500 : /* If it is already registered, just return the existing */
501 : /* index. */
502 : /* -------------------------------------------------------------------- */
503 789893 : if (!m_bInDeferredDriverLoading &&
504 391693 : GetDriverByName_unlocked(poDriver->GetDescription()) != nullptr)
505 : {
506 223 : for (int i = 0; i < nDrivers; ++i)
507 : {
508 223 : if (papoDrivers[i] == poDriver)
509 : {
510 1 : return i;
511 : }
512 : }
513 :
514 0 : CPLAssert(false);
515 : }
516 :
517 398199 : if (poDriver->pfnOpen != nullptr ||
518 80738 : poDriver->pfnOpenWithDriverArg != nullptr)
519 317464 : poDriver->SetMetadataItem(GDAL_DCAP_OPEN, "YES");
520 :
521 398199 : if (poDriver->pfnCreate != nullptr || poDriver->pfnCreateEx != nullptr)
522 120368 : poDriver->SetMetadataItem(GDAL_DCAP_CREATE, "YES");
523 :
524 398199 : if (poDriver->pfnCreateCopy != nullptr)
525 64179 : poDriver->SetMetadataItem(GDAL_DCAP_CREATECOPY, "YES");
526 :
527 398199 : if (poDriver->pfnCreateMultiDimensional != nullptr)
528 5313 : poDriver->SetMetadataItem(GDAL_DCAP_CREATE_MULTIDIMENSIONAL, "YES");
529 :
530 : // Backward compatibility for GDAL raster out-of-tree drivers:
531 : // If a driver hasn't explicitly set a vector capability, assume it is
532 : // a raster-only driver (legacy OGR drivers will have DCAP_VECTOR set before
533 : // calling RegisterDriver()).
534 398199 : if (poDriver->GetMetadataItem(GDAL_DCAP_RASTER) == nullptr &&
535 401712 : poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr &&
536 3513 : poDriver->GetMetadataItem(GDAL_DCAP_GNM) == nullptr)
537 : {
538 3 : CPLDebug("GDAL", "Assuming DCAP_RASTER for driver %s. Please fix it.",
539 3 : poDriver->GetDescription());
540 3 : poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
541 : }
542 :
543 398199 : if (poDriver->GetMetadataItem(GDAL_DMD_OPENOPTIONLIST) != nullptr &&
544 151590 : poDriver->pfnIdentify == nullptr &&
545 553299 : poDriver->pfnIdentifyEx == nullptr &&
546 3510 : !STARTS_WITH_CI(poDriver->GetDescription(), "Interlis"))
547 : {
548 0 : CPLDebug("GDAL",
549 : "Driver %s that defines GDAL_DMD_OPENOPTIONLIST must also "
550 : "implement Identify(), so that it can be used",
551 0 : poDriver->GetDescription());
552 : }
553 :
554 398199 : if (poDriver->pfnVectorTranslateFrom != nullptr)
555 3510 : poDriver->SetMetadataItem(GDAL_DCAP_VECTOR_TRANSLATE_FROM, "YES");
556 :
557 404706 : if (m_bInDeferredDriverLoading &&
558 6507 : cpl::contains(oMapNameToDrivers,
559 404706 : CPLString(poDriver->GetDescription()).toupper()))
560 : {
561 6506 : if (cpl::contains(m_oMapRealDrivers, poDriver->GetDescription()))
562 : {
563 0 : CPLError(
564 : CE_Failure, CPLE_AppDefined,
565 : "RegisterDriver() in m_bInDeferredDriverLoading: %s already "
566 : "registered!",
567 0 : poDriver->GetDescription());
568 0 : delete poDriver;
569 0 : return -1;
570 : }
571 13012 : m_oMapRealDrivers[poDriver->GetDescription()] =
572 19518 : std::unique_ptr<GDALDriver>(poDriver);
573 6506 : return -1;
574 : }
575 :
576 : /* -------------------------------------------------------------------- */
577 : /* Otherwise grow the list to hold the new entry. */
578 : /* -------------------------------------------------------------------- */
579 391693 : if (bHidden)
580 : {
581 0 : m_aoHiddenDrivers.push_back(std::unique_ptr<GDALDriver>(poDriver));
582 0 : return -1;
583 : }
584 :
585 : GDALDriver **papoNewDrivers =
586 391693 : static_cast<GDALDriver **>(VSI_REALLOC_VERBOSE(
587 : papoDrivers, sizeof(GDALDriver *) * (nDrivers + 1)));
588 391693 : if (papoNewDrivers == nullptr)
589 0 : return -1;
590 391693 : papoDrivers = papoNewDrivers;
591 :
592 391693 : papoDrivers[nDrivers] = poDriver;
593 391693 : ++nDrivers;
594 :
595 391693 : oMapNameToDrivers[CPLString(poDriver->GetDescription()).toupper()] =
596 : poDriver;
597 :
598 393449 : if (EQUAL(poDriver->GetDescription(), "MEM") &&
599 393449 : oMapNameToDrivers.find("MEMORY") == oMapNameToDrivers.end())
600 : {
601 : // Instantiate a Memory driver, that is the same as the MEM one,
602 : // for legacy purposes. It can be queried through GetDriverByName()
603 : // but doesn't appear in the driver list.
604 1755 : auto poMemoryDriver = new GDALDriver();
605 1755 : poMemoryDriver->SetDescription("Memory");
606 1755 : poMemoryDriver->SetMetadata(poDriver->GetMetadata());
607 1755 : poMemoryDriver->pfnOpen = poDriver->pfnOpen;
608 1755 : poMemoryDriver->pfnIdentify = poDriver->pfnIdentify;
609 1755 : poMemoryDriver->pfnCreate = poDriver->pfnCreate;
610 1755 : poMemoryDriver->pfnCreateMultiDimensional =
611 1755 : poDriver->pfnCreateMultiDimensional;
612 1755 : poMemoryDriver->pfnDelete = poDriver->pfnDelete;
613 3510 : oMapNameToDrivers[CPLString(poMemoryDriver->GetDescription())
614 3510 : .toupper()] = poMemoryDriver;
615 : }
616 :
617 391693 : int iResult = nDrivers - 1;
618 :
619 391693 : return iResult;
620 : }
621 :
622 : /************************************************************************/
623 : /* GetDriverByName_unlocked() */
624 : /************************************************************************/
625 :
626 : GDALDriver *
627 971954 : GDALDriverManager::GetDriverByName_unlocked(const char *pszName) const
628 : {
629 971954 : const CPLString osName = CPLString(pszName).toupper();
630 971954 : if (osName == "MEMORY")
631 : {
632 47 : CPLErrorOnce(CE_Warning, CPLE_AppDefined,
633 : "DeprecationWarning: 'Memory' driver is deprecated since "
634 : "GDAL 3.11. Use 'MEM' onwards");
635 : }
636 971954 : auto oIter = oMapNameToDrivers.find(osName);
637 1943910 : return oIter == oMapNameToDrivers.end() ? nullptr : oIter->second;
638 : }
639 :
640 : /************************************************************************/
641 : /* GDALRegisterDriver() */
642 : /************************************************************************/
643 :
644 : /**
645 : * \brief Register a driver for use.
646 : *
647 : * @see GDALDriverManager::GetRegisterDriver()
648 : */
649 :
650 95 : int CPL_STDCALL GDALRegisterDriver(GDALDriverH hDriver)
651 :
652 : {
653 95 : VALIDATE_POINTER1(hDriver, "GDALRegisterDriver", 0);
654 :
655 95 : return GetGDALDriverManager()->RegisterDriver(
656 95 : static_cast<GDALDriver *>(hDriver));
657 : }
658 :
659 : /************************************************************************/
660 : /* DeregisterDriver() */
661 : /************************************************************************/
662 :
663 : /**
664 : * \brief Deregister the passed driver.
665 : *
666 : * If the driver isn't found no change is made.
667 : *
668 : * The C analog is GDALDeregisterDriver().
669 : *
670 : * @param poDriver the driver to deregister.
671 : */
672 :
673 250534 : void GDALDriverManager::DeregisterDriver(GDALDriver *poDriver)
674 :
675 : {
676 250534 : CPLMutexHolderD(&hDMMutex);
677 :
678 250534 : int i = 0; // Used after for.
679 270951 : for (; i < nDrivers; ++i)
680 : {
681 270950 : if (papoDrivers[i] == poDriver)
682 250533 : break;
683 : }
684 :
685 250534 : if (i == nDrivers)
686 1 : return;
687 :
688 250533 : oMapNameToDrivers.erase(CPLString(poDriver->GetDescription()).toupper());
689 250533 : --nDrivers;
690 : // Move all following drivers down by one to pack the list.
691 28051100 : while (i < nDrivers)
692 : {
693 27800600 : papoDrivers[i] = papoDrivers[i + 1];
694 27800600 : ++i;
695 : }
696 : }
697 :
698 : /************************************************************************/
699 : /* GDALDeregisterDriver() */
700 : /************************************************************************/
701 :
702 : /**
703 : * \brief Deregister the passed driver.
704 : *
705 : * @see GDALDriverManager::GetDeregisterDriver()
706 : */
707 :
708 95 : void CPL_STDCALL GDALDeregisterDriver(GDALDriverH hDriver)
709 :
710 : {
711 95 : VALIDATE_POINTER0(hDriver, "GDALDeregisterDriver");
712 :
713 95 : GetGDALDriverManager()->DeregisterDriver(
714 : static_cast<GDALDriver *>(hDriver));
715 : }
716 :
717 : /************************************************************************/
718 : /* GetDriverByName() */
719 : /************************************************************************/
720 :
721 : /**
722 : * \brief Fetch a driver based on the short name.
723 : *
724 : * The C analog is the GDALGetDriverByName() function.
725 : *
726 : * @param pszName the short name, such as GTiff, being searched for.
727 : *
728 : * @return the identified driver, or NULL if no match is found.
729 : */
730 :
731 586768 : GDALDriver *GDALDriverManager::GetDriverByName(const char *pszName)
732 :
733 : {
734 1173540 : CPLMutexHolderD(&hDMMutex);
735 :
736 586768 : if (m_bInDeferredDriverLoading)
737 : {
738 6507 : return nullptr;
739 : }
740 :
741 : // Alias old name to new name
742 580261 : if (EQUAL(pszName, "CartoDB"))
743 0 : pszName = "Carto";
744 :
745 580261 : return GetDriverByName_unlocked(pszName);
746 : }
747 :
748 : /************************************************************************/
749 : /* GDALGetDriverByName() */
750 : /************************************************************************/
751 :
752 : /**
753 : * \brief Fetch a driver based on the short name.
754 : *
755 : * @see GDALDriverManager::GetDriverByName()
756 : */
757 :
758 563771 : GDALDriverH CPL_STDCALL GDALGetDriverByName(const char *pszName)
759 :
760 : {
761 563771 : VALIDATE_POINTER1(pszName, "GDALGetDriverByName", nullptr);
762 :
763 563771 : return GetGDALDriverManager()->GetDriverByName(pszName);
764 : }
765 :
766 : /************************************************************************/
767 : /* AutoSkipDrivers() */
768 : /************************************************************************/
769 :
770 : /**
771 : * \brief This method unload undesirable drivers.
772 : *
773 : * All drivers specified in the comma delimited list in the GDAL_SKIP
774 : * environment variable) will be deregistered and destroyed. This method
775 : * should normally be called after registration of standard drivers to allow
776 : * the user a way of unloading undesired drivers. The GDALAllRegister()
777 : * function already invokes AutoSkipDrivers() at the end, so if that functions
778 : * is called, it should not be necessary to call this method from application
779 : * code.
780 : *
781 : * Note: space separator is also accepted for backward compatibility, but some
782 : * vector formats have spaces in their names, so it is encouraged to use comma
783 : * to avoid issues.
784 : */
785 :
786 2039 : void GDALDriverManager::AutoSkipDrivers()
787 :
788 : {
789 2039 : char **apapszList[2] = {nullptr, nullptr};
790 2039 : const char *pszGDAL_SKIP = CPLGetConfigOption("GDAL_SKIP", nullptr);
791 2039 : if (pszGDAL_SKIP != nullptr)
792 : {
793 : // Favor comma as a separator. If not found, then use space.
794 5 : const char *pszSep = (strchr(pszGDAL_SKIP, ',') != nullptr) ? "," : " ";
795 5 : apapszList[0] =
796 5 : CSLTokenizeStringComplex(pszGDAL_SKIP, pszSep, FALSE, FALSE);
797 : }
798 2039 : const char *pszOGR_SKIP = CPLGetConfigOption("OGR_SKIP", nullptr);
799 2039 : if (pszOGR_SKIP != nullptr)
800 : {
801 : // OGR has always used comma as a separator.
802 4 : apapszList[1] =
803 4 : CSLTokenizeStringComplex(pszOGR_SKIP, ",", FALSE, FALSE);
804 : }
805 :
806 6117 : for (auto j : {0, 1})
807 : {
808 4087 : for (int i = 0; apapszList[j] != nullptr && apapszList[j][i] != nullptr;
809 : ++i)
810 : {
811 9 : GDALDriver *const poDriver = GetDriverByName(apapszList[j][i]);
812 :
813 9 : if (poDriver == nullptr)
814 : {
815 0 : CPLError(CE_Warning, CPLE_AppDefined,
816 : "Unable to find driver %s to unload from GDAL_SKIP "
817 : "environment variable.",
818 0 : apapszList[j][i]);
819 : }
820 : else
821 : {
822 9 : CPLDebug("GDAL", "AutoSkipDriver(%s)", apapszList[j][i]);
823 9 : DeregisterDriver(poDriver);
824 9 : delete poDriver;
825 : }
826 : }
827 : }
828 :
829 2039 : CSLDestroy(apapszList[0]);
830 2039 : CSLDestroy(apapszList[1]);
831 2039 : }
832 :
833 : /************************************************************************/
834 : /* GetSearchPaths() */
835 : /************************************************************************/
836 :
837 : //! @cond Doxygen_Suppress
838 5834 : char **GDALDriverManager::GetSearchPaths(const char *pszGDAL_DRIVER_PATH)
839 : {
840 5834 : char **papszSearchPaths = nullptr;
841 5834 : CPL_IGNORE_RET_VAL(pszGDAL_DRIVER_PATH);
842 : #ifndef GDAL_NO_AUTOLOAD
843 5834 : if (pszGDAL_DRIVER_PATH != nullptr)
844 : {
845 : #ifdef _WIN32
846 : papszSearchPaths =
847 : CSLTokenizeStringComplex(pszGDAL_DRIVER_PATH, ";", TRUE, FALSE);
848 : #else
849 : papszSearchPaths =
850 5834 : CSLTokenizeStringComplex(pszGDAL_DRIVER_PATH, ":", TRUE, FALSE);
851 : #endif
852 : }
853 : else
854 : {
855 : #ifdef INSTALL_PLUGIN_FULL_DIR
856 : // CMake way
857 : papszSearchPaths =
858 0 : CSLAddString(papszSearchPaths, INSTALL_PLUGIN_FULL_DIR);
859 : #elif defined(GDAL_PREFIX)
860 : papszSearchPaths = CSLAddString(papszSearchPaths,
861 : #ifdef MACOSX_FRAMEWORK
862 : GDAL_PREFIX "/PlugIns");
863 : #else
864 : GDAL_PREFIX "/lib/gdalplugins");
865 : #endif
866 : #else
867 : char szExecPath[1024];
868 :
869 : if (CPLGetExecPath(szExecPath, sizeof(szExecPath)))
870 : {
871 : papszSearchPaths = CSLAddString(
872 : papszSearchPaths,
873 : (CPLGetDirnameSafe(szExecPath) + "\\gdalplugins").c_str());
874 : }
875 : else
876 : {
877 : papszSearchPaths =
878 : CSLAddString(papszSearchPaths, "/usr/local/lib/gdalplugins");
879 : }
880 : #endif
881 :
882 : #ifdef MACOSX_FRAMEWORK
883 : #define num2str(x) str(x)
884 : #define str(x) #x
885 : papszSearchPaths = CSLAddString(
886 : papszSearchPaths,
887 : "/Library/Application Support/GDAL/" num2str(
888 : GDAL_VERSION_MAJOR) "." num2str(GDAL_VERSION_MINOR) "/PlugIns");
889 : #endif
890 : }
891 : #endif // GDAL_NO_AUTOLOAD
892 5834 : return papszSearchPaths;
893 : }
894 :
895 : //! @endcond
896 :
897 : /************************************************************************/
898 : /* LoadPlugin() */
899 : /************************************************************************/
900 :
901 : /**
902 : * \brief Load a single GDAL driver/plugin from shared libraries.
903 : *
904 : * This function will load a single named driver/plugin from shared libraries.
905 : * It searches the "driver path" for .so (or .dll) files named
906 : * "gdal_{name}.[so|dll|dylib]" or "ogr_{name}.[so|dll|dylib]", then tries to
907 : * call a function within them called GDALRegister_{name}(), or failing that
908 : * called GDALRegisterMe().
909 : *
910 : * \see GDALDriverManager::AutoLoadDrivers() for the rules used to determine
911 : * which paths are searched for plugin library files.
912 : */
913 :
914 1 : CPLErr GDALDriverManager::LoadPlugin(const char *name)
915 : {
916 : #ifdef GDAL_NO_AUTOLOAD
917 : CPLDebug("GDAL", "GDALDriverManager::LoadPlugin() not compiled in.");
918 : return CE_Failure;
919 : #else
920 : const char *pszGDAL_DRIVER_PATH =
921 1 : CPLGetConfigOption("GDAL_DRIVER_PATH", nullptr);
922 1 : if (pszGDAL_DRIVER_PATH == nullptr)
923 0 : pszGDAL_DRIVER_PATH = CPLGetConfigOption("OGR_DRIVER_PATH", nullptr);
924 :
925 : /* -------------------------------------------------------------------- */
926 : /* Where should we look for stuff? */
927 : /* -------------------------------------------------------------------- */
928 2 : const CPLStringList aosSearchPaths(GetSearchPaths(pszGDAL_DRIVER_PATH));
929 :
930 : /* -------------------------------------------------------------------- */
931 : /* Format the ABI version specific subdirectory to look in. */
932 : /* -------------------------------------------------------------------- */
933 2 : CPLString osABIVersion;
934 :
935 1 : osABIVersion.Printf("%d.%d", GDAL_VERSION_MAJOR, GDAL_VERSION_MINOR);
936 :
937 : /* -------------------------------------------------------------------- */
938 : /* Scan each directory looking for files matching */
939 : /* gdal_{name}.[so|dll|dylib] or ogr_{name}.[so|dll|dylib] */
940 : /* -------------------------------------------------------------------- */
941 1 : const int nSearchPaths = aosSearchPaths.size();
942 2 : for (int iDir = 0; iDir < nSearchPaths; ++iDir)
943 : {
944 : std::string osABISpecificDir =
945 1 : CPLFormFilenameSafe(aosSearchPaths[iDir], osABIVersion, nullptr);
946 :
947 : VSIStatBufL sStatBuf;
948 1 : if (VSIStatL(osABISpecificDir.c_str(), &sStatBuf) != 0)
949 1 : osABISpecificDir = aosSearchPaths[iDir];
950 :
951 3 : CPLString gdal_or_ogr[2] = {"gdal_", "ogr_"};
952 4 : CPLString platformExtensions[3] = {"so", "dll", "dylib"};
953 :
954 3 : for (const CPLString &prefix : gdal_or_ogr)
955 : {
956 8 : for (const CPLString &extension : platformExtensions)
957 : {
958 : const std::string osFilename = CPLFormFilenameSafe(
959 : osABISpecificDir.c_str(),
960 6 : CPLSPrintf("%s%s", prefix.c_str(), name), extension);
961 6 : if (VSIStatL(osFilename.c_str(), &sStatBuf) != 0)
962 6 : continue;
963 :
964 0 : CPLString osFuncName;
965 0 : if (EQUAL(prefix, "gdal_"))
966 : {
967 0 : osFuncName.Printf("GDALRegister_%s", name);
968 : }
969 : else
970 : {
971 0 : osFuncName.Printf("RegisterOGR%s", name);
972 : }
973 0 : CPLErrorReset();
974 0 : CPLPushErrorHandler(CPLQuietErrorHandler);
975 0 : void *pRegister = CPLGetSymbol(osFilename.c_str(), osFuncName);
976 0 : CPLPopErrorHandler();
977 0 : if (pRegister == nullptr)
978 : {
979 0 : CPLString osLastErrorMsg(CPLGetLastErrorMsg());
980 0 : osFuncName = "GDALRegisterMe";
981 0 : pRegister = CPLGetSymbol(osFilename.c_str(), osFuncName);
982 0 : if (pRegister == nullptr)
983 : {
984 0 : CPLError(CE_Failure, CPLE_AppDefined, "%s",
985 : osLastErrorMsg.c_str());
986 0 : return CE_Failure;
987 : }
988 : }
989 0 : CPLDebug("GDAL", "Registering %s using %s in %s", name,
990 : osFuncName.c_str(), osFilename.c_str());
991 0 : CPLErrorReset();
992 0 : reinterpret_cast<void (*)()>(pRegister)();
993 0 : if (CPLGetErrorCounter() > 0)
994 : {
995 0 : return CE_Failure;
996 : }
997 0 : return CE_None;
998 : }
999 : }
1000 : }
1001 1 : CPLError(CE_Failure, CPLE_AppDefined,
1002 : "Failed to find driver %s in configured driver paths.", name);
1003 1 : return CE_Failure;
1004 : #endif // GDAL_NO_AUTOLOAD
1005 : }
1006 :
1007 : /************************************************************************/
1008 : /* AutoLoadDrivers() */
1009 : /************************************************************************/
1010 :
1011 : /**
1012 : * \brief Auto-load GDAL drivers from shared libraries.
1013 : *
1014 : * This function will automatically load drivers from shared libraries. It
1015 : * searches the "driver path" for .so (or .dll) files that start with the
1016 : * prefix "gdal_X.so". It then tries to load them and then tries to call a
1017 : * function within them called GDALRegister_X() where the 'X' is the same as
1018 : * the remainder of the shared library basename ('X' is case sensitive), or
1019 : * failing that to call GDALRegisterMe().
1020 : *
1021 : * There are a few rules for the driver path. If the GDAL_DRIVER_PATH
1022 : * environment variable it set, it is taken to be a list of directories to
1023 : * search separated by colons on UNIX, or semi-colons on Windows. Otherwise
1024 : * the /usr/local/lib/gdalplugins directory, and (if known) the
1025 : * lib/gdalplugins subdirectory of the gdal home directory are searched on
1026 : * UNIX and \$(BINDIR)\\gdalplugins on Windows.
1027 : *
1028 : * Auto loading can be completely disabled by setting the GDAL_DRIVER_PATH
1029 : * config option to "disable".
1030 : *
1031 : * Starting with gdal 3.5, the default search path \$(prefix)/lib/gdalplugins
1032 : * can be overridden at compile time by passing
1033 : * -DINSTALL_PLUGIN_DIR=/another/path to cmake.
1034 : */
1035 :
1036 2039 : void GDALDriverManager::AutoLoadDrivers()
1037 :
1038 : {
1039 : #ifdef GDAL_NO_AUTOLOAD
1040 : CPLDebug("GDAL", "GDALDriverManager::AutoLoadDrivers() not compiled in.");
1041 : #else
1042 : const char *pszGDAL_DRIVER_PATH =
1043 2039 : CPLGetConfigOption("GDAL_DRIVER_PATH", nullptr);
1044 2039 : if (pszGDAL_DRIVER_PATH == nullptr)
1045 0 : pszGDAL_DRIVER_PATH = CPLGetConfigOption("OGR_DRIVER_PATH", nullptr);
1046 :
1047 : /* -------------------------------------------------------------------- */
1048 : /* Allow applications to completely disable this search by */
1049 : /* setting the driver path to the special string "disable". */
1050 : /* -------------------------------------------------------------------- */
1051 2039 : if (pszGDAL_DRIVER_PATH != nullptr && EQUAL(pszGDAL_DRIVER_PATH, "disable"))
1052 : {
1053 0 : CPLDebug("GDAL", "GDALDriverManager::AutoLoadDrivers() disabled.");
1054 0 : return;
1055 : }
1056 :
1057 : /* -------------------------------------------------------------------- */
1058 : /* Where should we look for stuff? */
1059 : /* -------------------------------------------------------------------- */
1060 2039 : char **papszSearchPaths = GetSearchPaths(pszGDAL_DRIVER_PATH);
1061 :
1062 : /* -------------------------------------------------------------------- */
1063 : /* Format the ABI version specific subdirectory to look in. */
1064 : /* -------------------------------------------------------------------- */
1065 4078 : CPLString osABIVersion;
1066 :
1067 2039 : osABIVersion.Printf("%d.%d", GDAL_VERSION_MAJOR, GDAL_VERSION_MINOR);
1068 :
1069 : /* -------------------------------------------------------------------- */
1070 : /* Scan each directory looking for files starting with gdal_ */
1071 : /* -------------------------------------------------------------------- */
1072 2039 : const int nSearchPaths = CSLCount(papszSearchPaths);
1073 2039 : bool bFoundOnePlugin = false;
1074 4078 : for (int iDir = 0; iDir < nSearchPaths; ++iDir)
1075 : {
1076 : std::string osABISpecificDir =
1077 4078 : CPLFormFilenameSafe(papszSearchPaths[iDir], osABIVersion, nullptr);
1078 :
1079 : VSIStatBufL sStatBuf;
1080 2039 : if (VSIStatL(osABISpecificDir.c_str(), &sStatBuf) != 0)
1081 2039 : osABISpecificDir = papszSearchPaths[iDir];
1082 :
1083 2039 : char **papszFiles = VSIReadDir(osABISpecificDir.c_str());
1084 2039 : const int nFileCount = CSLCount(papszFiles);
1085 :
1086 81560 : for (int iFile = 0; iFile < nFileCount; ++iFile)
1087 : {
1088 : const CPLString osExtension =
1089 79521 : CPLGetExtensionSafe(papszFiles[iFile]);
1090 :
1091 85638 : if (!EQUAL(osExtension, "dll") && !EQUAL(osExtension, "so") &&
1092 6117 : !EQUAL(osExtension, "dylib"))
1093 : {
1094 6117 : if (strcmp(papszFiles[iFile], "drivers.ini") == 0)
1095 : {
1096 4078 : m_osDriversIniPath = CPLFormFilenameSafe(
1097 4078 : osABISpecificDir.c_str(), papszFiles[iFile], nullptr);
1098 : }
1099 6117 : continue;
1100 : }
1101 :
1102 73404 : if (cpl::contains(m_oSetPluginFileNames, papszFiles[iFile]))
1103 : {
1104 71365 : continue;
1105 : }
1106 :
1107 2039 : CPLString osFuncName;
1108 2039 : if (STARTS_WITH_CI(papszFiles[iFile], "gdal_"))
1109 : {
1110 : osFuncName.Printf(
1111 : "GDALRegister_%s",
1112 0 : CPLGetBasenameSafe(papszFiles[iFile]).c_str() +
1113 0 : strlen("gdal_"));
1114 : }
1115 2039 : else if (STARTS_WITH_CI(papszFiles[iFile], "ogr_"))
1116 : {
1117 : osFuncName.Printf(
1118 : "RegisterOGR%s",
1119 0 : CPLGetBasenameSafe(papszFiles[iFile]).c_str() +
1120 0 : strlen("ogr_"));
1121 : }
1122 : else
1123 2039 : continue;
1124 :
1125 : const std::string osFilename = CPLFormFilenameSafe(
1126 0 : osABISpecificDir.c_str(), papszFiles[iFile], nullptr);
1127 :
1128 0 : CPLErrorReset();
1129 0 : CPLPushErrorHandler(CPLQuietErrorHandler);
1130 0 : void *pRegister = CPLGetSymbol(osFilename.c_str(), osFuncName);
1131 0 : CPLPopErrorHandler();
1132 0 : if (pRegister == nullptr)
1133 : {
1134 0 : CPLString osLastErrorMsg(CPLGetLastErrorMsg());
1135 0 : osFuncName = "GDALRegisterMe";
1136 0 : pRegister = CPLGetSymbol(osFilename.c_str(), osFuncName);
1137 0 : if (pRegister == nullptr)
1138 : {
1139 0 : CPLError(CE_Failure, CPLE_AppDefined, "%s",
1140 : osLastErrorMsg.c_str());
1141 : }
1142 : }
1143 :
1144 0 : if (pRegister != nullptr)
1145 : {
1146 0 : bFoundOnePlugin = true;
1147 0 : CPLDebug("GDAL", "Auto register %s using %s.",
1148 : osFilename.c_str(), osFuncName.c_str());
1149 :
1150 0 : reinterpret_cast<void (*)()>(pRegister)();
1151 : }
1152 : }
1153 :
1154 2039 : CSLDestroy(papszFiles);
1155 : }
1156 :
1157 2039 : CSLDestroy(papszSearchPaths);
1158 :
1159 : // No need to reorder drivers if there are no plugins
1160 2039 : if (!bFoundOnePlugin)
1161 2039 : m_osDriversIniPath.clear();
1162 :
1163 : #endif // GDAL_NO_AUTOLOAD
1164 : }
1165 :
1166 : /************************************************************************/
1167 : /* ReorderDrivers() */
1168 : /************************************************************************/
1169 :
1170 : /**
1171 : * \brief Reorder drivers according to the order of the drivers.ini file.
1172 : *
1173 : * This function is called by GDALAllRegister(), at the end of driver loading,
1174 : * in particular after plugin loading.
1175 : * It will load the drivers.ini configuration file located next to plugins and
1176 : * will use it to reorder the registration order of drivers. This can be
1177 : * important in some situations where multiple drivers could open the same
1178 : * dataset.
1179 : */
1180 :
1181 2039 : void GDALDriverManager::ReorderDrivers()
1182 : {
1183 : #ifndef GDAL_NO_AUTOLOAD
1184 2039 : if (m_osDriversIniPath.empty())
1185 : {
1186 2039 : if (m_oSetPluginFileNames.empty())
1187 0 : return;
1188 :
1189 2039 : m_osDriversIniPath = GetPluginFullPath("drivers.ini");
1190 2039 : if (m_osDriversIniPath.empty())
1191 0 : return;
1192 : }
1193 :
1194 2039 : CPLMutexHolderD(&hDMMutex);
1195 :
1196 2039 : VSILFILE *fp = VSIFOpenL(m_osDriversIniPath.c_str(), "rb");
1197 2039 : if (fp == nullptr)
1198 0 : return;
1199 :
1200 : // Parse drivers.ini
1201 2039 : bool bInOrderSection = false;
1202 4078 : std::vector<std::string> aosOrderedDrivers;
1203 4078 : std::set<std::string> oSetOrderedDrivers;
1204 572959 : while (const char *pszLine = CPLReadLine2L(fp, 1024, nullptr))
1205 : {
1206 570920 : if (pszLine[0] == '#')
1207 67287 : continue;
1208 521984 : int i = 0;
1209 521984 : while (pszLine[i] != 0 &&
1210 503633 : isspace(static_cast<unsigned char>(pszLine[i])))
1211 0 : i++;
1212 521984 : if (pszLine[i] == 0)
1213 18351 : continue;
1214 503633 : if (strcmp(pszLine, "[order]") == 0)
1215 : {
1216 2039 : bInOrderSection = true;
1217 : }
1218 501594 : else if (pszLine[0] == '[')
1219 : {
1220 0 : bInOrderSection = false;
1221 : }
1222 501594 : else if (bInOrderSection)
1223 : {
1224 1003190 : CPLString osUCDriverName(pszLine);
1225 501594 : osUCDriverName.toupper();
1226 501594 : if (osUCDriverName != "MEMORY")
1227 : {
1228 501594 : if (cpl::contains(oSetOrderedDrivers, osUCDriverName))
1229 : {
1230 0 : CPLError(CE_Warning, CPLE_AppDefined,
1231 : "Duplicated name %s in [order] section", pszLine);
1232 : }
1233 501594 : else if (cpl::contains(oMapNameToDrivers, osUCDriverName))
1234 : {
1235 454968 : aosOrderedDrivers.emplace_back(pszLine);
1236 454968 : oSetOrderedDrivers.insert(std::move(osUCDriverName));
1237 : }
1238 : #ifdef DEBUG_VERBOSE
1239 : else
1240 : {
1241 : // Completely expected situation for "non-maximal" builds,
1242 : // but can help diagnose bad entries in drivers.ini
1243 : CPLDebug("GDAL",
1244 : "Driver %s is listed in %s but not registered.",
1245 : pszLine, m_osDriversIniPath.c_str());
1246 : }
1247 : #endif
1248 : }
1249 : }
1250 570920 : }
1251 2039 : VSIFCloseL(fp);
1252 :
1253 : // Find potential registered drivers not in drivers.ini, and put them in
1254 : // their registration order in aosUnorderedDrivers
1255 4078 : std::vector<std::string> aosUnorderedDrivers;
1256 457016 : for (int i = 0; i < nDrivers; ++i)
1257 : {
1258 454977 : const char *pszName = papoDrivers[i]->GetDescription();
1259 454977 : if (!cpl::contains(oSetOrderedDrivers, CPLString(pszName).toupper()))
1260 : {
1261 : // Could happen for a private plugin
1262 9 : CPLDebug("GDAL",
1263 : "Driver %s is registered but not listed in %s. "
1264 : "It will be registered before other drivers.",
1265 : pszName, m_osDriversIniPath.c_str());
1266 9 : aosUnorderedDrivers.emplace_back(pszName);
1267 : }
1268 : }
1269 :
1270 : // Put aosUnorderedDrivers in front of existing aosOrderedDrivers
1271 2039 : if (!aosUnorderedDrivers.empty())
1272 : {
1273 7 : aosUnorderedDrivers.insert(aosUnorderedDrivers.end(),
1274 : aosOrderedDrivers.begin(),
1275 14 : aosOrderedDrivers.end());
1276 7 : std::swap(aosOrderedDrivers, aosUnorderedDrivers);
1277 : }
1278 :
1279 : // Update papoDrivers[] to reflect aosOrderedDrivers order.
1280 2039 : CPLAssert(static_cast<int>(aosOrderedDrivers.size()) == nDrivers);
1281 457016 : for (int i = 0; i < nDrivers; ++i)
1282 : {
1283 : const auto oIter =
1284 454977 : oMapNameToDrivers.find(CPLString(aosOrderedDrivers[i]).toupper());
1285 454977 : CPLAssert(oIter != oMapNameToDrivers.end());
1286 454977 : papoDrivers[i] = oIter->second;
1287 : }
1288 : #endif
1289 : }
1290 :
1291 : /************************************************************************/
1292 : /* GDALPluginDriverProxy */
1293 : /************************************************************************/
1294 :
1295 : /** Constructor for a plugin driver proxy.
1296 : *
1297 : * @param osPluginFileName Plugin filename. e.g "ogr_Parquet.so"
1298 : */
1299 77220 : GDALPluginDriverProxy::GDALPluginDriverProxy(
1300 77220 : const std::string &osPluginFileName)
1301 77220 : : m_osPluginFileName(osPluginFileName)
1302 : {
1303 77220 : }
1304 :
1305 : //! @cond Doxygen_Suppress
1306 : #define DEFINE_DRIVER_METHOD_GET_CALLBACK(method_name, output_type) \
1307 : GDALDriver::output_type GDALPluginDriverProxy::method_name() \
1308 : { \
1309 : auto poRealDriver = GetRealDriver(); \
1310 : if (!poRealDriver) \
1311 : return nullptr; \
1312 : return poRealDriver->method_name(); \
1313 : }
1314 :
1315 11585 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetOpenCallback, OpenCallback)
1316 1489 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetCreateCallback, CreateCallback)
1317 132 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetCreateMultiDimensionalCallback,
1318 : CreateMultiDimensionalCallback)
1319 5626 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetCreateCopyCallback, CreateCopyCallback)
1320 596 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetDeleteCallback, DeleteCallback)
1321 3 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetRenameCallback, RenameCallback)
1322 0 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetCopyFilesCallback, CopyFilesCallback)
1323 13 : DEFINE_DRIVER_METHOD_GET_CALLBACK(GetInstantiateAlgorithmCallback,
1324 : InstantiateAlgorithmCallback)
1325 :
1326 : //! @endcond
1327 :
1328 1846 : char **GDALPluginDriverProxy::GetMetadata(const char *pszDomain)
1329 : {
1330 1846 : auto poRealDriver = GetRealDriver();
1331 1846 : if (!poRealDriver)
1332 0 : return nullptr;
1333 1846 : return poRealDriver->GetMetadata(pszDomain);
1334 : }
1335 :
1336 1033790 : CPLErr GDALPluginDriverProxy::SetMetadataItem(const char *pszName,
1337 : const char *pszValue,
1338 : const char *pszDomain)
1339 : {
1340 1033790 : if (!pszDomain || pszDomain[0] == 0)
1341 : {
1342 1033790 : if (!EQUAL(pszName, GDAL_DMD_PLUGIN_INSTALLATION_MESSAGE))
1343 : {
1344 1033790 : m_oSetMetadataItems.insert(pszName);
1345 : }
1346 : }
1347 1033790 : return GDALDriver::SetMetadataItem(pszName, pszValue, pszDomain);
1348 : }
1349 :
1350 : static const char *const apszProxyMetadataItems[] = {
1351 : GDAL_DMD_LONGNAME,
1352 : GDAL_DMD_EXTENSIONS,
1353 : GDAL_DMD_EXTENSION,
1354 : GDAL_DCAP_RASTER,
1355 : GDAL_DCAP_MULTIDIM_RASTER,
1356 : GDAL_DCAP_VECTOR,
1357 : GDAL_DCAP_GNM,
1358 : GDAL_DMD_OPENOPTIONLIST,
1359 : GDAL_DCAP_OPEN,
1360 : GDAL_DCAP_CREATE,
1361 : GDAL_DCAP_CREATE_MULTIDIMENSIONAL,
1362 : GDAL_DCAP_CREATECOPY,
1363 : GDAL_DMD_SUBDATASETS,
1364 : GDAL_DCAP_MULTIPLE_VECTOR_LAYERS,
1365 : GDAL_DCAP_NONSPATIAL,
1366 : GDAL_DMD_CONNECTION_PREFIX,
1367 : GDAL_DCAP_VECTOR_TRANSLATE_FROM,
1368 : GDAL_DMD_PLUGIN_INSTALLATION_MESSAGE,
1369 : };
1370 :
1371 2364360 : const char *GDALPluginDriverProxy::GetMetadataItem(const char *pszName,
1372 : const char *pszDomain)
1373 : {
1374 2364100 : const auto IsListedProxyMetadataItem = [](const char *pszItem)
1375 : {
1376 18776700 : for (const char *pszListedItem : apszProxyMetadataItems)
1377 : {
1378 18703400 : if (EQUAL(pszItem, pszListedItem))
1379 2290810 : return true;
1380 : }
1381 73294 : return false;
1382 : };
1383 :
1384 2364360 : if (!pszDomain || pszDomain[0] == 0)
1385 : {
1386 2364220 : if (EQUAL(pszName, "IS_NON_LOADED_PLUGIN"))
1387 : {
1388 363 : return !m_poRealDriver ? "YES" : nullptr;
1389 : }
1390 2363860 : else if (EQUAL(pszName, "MISSING_PLUGIN_FILENAME"))
1391 : {
1392 161 : return m_osPluginFullPath.empty() ? m_osPluginFileName.c_str()
1393 161 : : nullptr;
1394 : }
1395 2363700 : else if (IsListedProxyMetadataItem(pszName))
1396 : {
1397 : const char *pszValue =
1398 2290810 : GDALDriver::GetMetadataItem(pszName, pszDomain);
1399 2289790 : if (!pszValue && EQUAL(pszName, GDAL_DMD_EXTENSION))
1400 : {
1401 : const char *pszOtherValue =
1402 51 : GDALDriver::GetMetadataItem(GDAL_DMD_EXTENSIONS, pszDomain);
1403 51 : if (pszOtherValue && strchr(pszOtherValue, ' '))
1404 51 : return pszOtherValue;
1405 : }
1406 2289740 : else if (!pszValue && EQUAL(pszName, GDAL_DMD_EXTENSIONS))
1407 : {
1408 10995 : return GDALDriver::GetMetadataItem(GDAL_DMD_EXTENSION,
1409 10995 : pszDomain);
1410 : }
1411 2278760 : return pszValue;
1412 : }
1413 73275 : else if (cpl::contains(m_oSetMetadataItems, pszName))
1414 : {
1415 34152 : return GDALDriver::GetMetadataItem(pszName, pszDomain);
1416 : }
1417 : }
1418 :
1419 39281 : auto poRealDriver = GetRealDriver();
1420 39176 : if (!poRealDriver)
1421 0 : return nullptr;
1422 39176 : return poRealDriver->GetMetadataItem(pszName, pszDomain);
1423 : }
1424 :
1425 : /************************************************************************/
1426 : /* GetRealDriver() */
1427 : /************************************************************************/
1428 :
1429 60466 : GDALDriver *GDALPluginDriverProxy::GetRealDriver()
1430 : {
1431 : // No need to take the mutex has this member variable is not modified
1432 : // under the mutex.
1433 60466 : if (m_osPluginFullPath.empty())
1434 0 : return nullptr;
1435 :
1436 120932 : CPLMutexHolderD(&hDMMutex);
1437 :
1438 60466 : if (m_poRealDriver)
1439 55018 : return m_poRealDriver.get();
1440 :
1441 5448 : auto poDriverManager = GetGDALDriverManager();
1442 5448 : auto oIter = poDriverManager->m_oMapRealDrivers.find(GetDescription());
1443 5448 : if (oIter != poDriverManager->m_oMapRealDrivers.end())
1444 : {
1445 1457 : m_poRealDriver = std::move(oIter->second);
1446 1457 : poDriverManager->m_oMapRealDrivers.erase(oIter);
1447 : }
1448 : else
1449 : {
1450 : #ifdef GDAL_NO_AUTOLOAD
1451 : return nullptr;
1452 : #else
1453 7982 : CPLString osFuncName;
1454 3991 : if (STARTS_WITH(m_osPluginFileName.c_str(), "gdal_"))
1455 : {
1456 1351 : osFuncName = "GDALRegister_";
1457 2702 : osFuncName += m_osPluginFileName.substr(
1458 : strlen("gdal_"),
1459 2702 : m_osPluginFileName.find('.') - strlen("gdal_"));
1460 : }
1461 : else
1462 : {
1463 2640 : CPLAssert(STARTS_WITH(m_osPluginFileName.c_str(), "ogr_"));
1464 2640 : osFuncName = "RegisterOGR";
1465 5280 : osFuncName += m_osPluginFileName.substr(
1466 5280 : strlen("ogr_"), m_osPluginFileName.find('.') - strlen("ogr_"));
1467 : }
1468 :
1469 3991 : CPLErrorReset();
1470 3991 : CPLPushErrorHandler(CPLQuietErrorHandler);
1471 3991 : void *pRegister = CPLGetSymbol(m_osPluginFullPath.c_str(), osFuncName);
1472 3991 : CPLPopErrorHandler();
1473 3991 : if (pRegister == nullptr)
1474 : {
1475 0 : CPLString osLastErrorMsg(CPLGetLastErrorMsg());
1476 0 : osFuncName = "GDALRegisterMe";
1477 0 : pRegister = CPLGetSymbol(m_osPluginFullPath.c_str(), osFuncName);
1478 0 : if (pRegister == nullptr)
1479 : {
1480 0 : CPLError(CE_Failure, CPLE_AppDefined, "%s",
1481 : osLastErrorMsg.c_str());
1482 : }
1483 : }
1484 :
1485 3991 : if (pRegister != nullptr)
1486 : {
1487 3991 : CPLDebug("GDAL", "On-demand registering %s using %s.",
1488 : m_osPluginFullPath.c_str(), osFuncName.c_str());
1489 :
1490 3991 : poDriverManager->m_bInDeferredDriverLoading = true;
1491 : try
1492 : {
1493 3991 : reinterpret_cast<void (*)()>(pRegister)();
1494 : }
1495 0 : catch (...)
1496 : {
1497 0 : CPLError(CE_Failure, CPLE_AppDefined, "%s threw an exception",
1498 : osFuncName.c_str());
1499 : }
1500 3991 : poDriverManager->m_bInDeferredDriverLoading = false;
1501 :
1502 3991 : oIter = poDriverManager->m_oMapRealDrivers.find(GetDescription());
1503 3991 : if (oIter == poDriverManager->m_oMapRealDrivers.end())
1504 : {
1505 0 : CPLError(CE_Failure, CPLE_AppDefined,
1506 : "Function %s of %s did not register a driver %s",
1507 : osFuncName.c_str(), m_osPluginFullPath.c_str(),
1508 0 : GetDescription());
1509 : }
1510 : else
1511 : {
1512 3991 : m_poRealDriver = std::move(oIter->second);
1513 3991 : poDriverManager->m_oMapRealDrivers.erase(oIter);
1514 : }
1515 : }
1516 : #endif // GDAL_NO_AUTOLOAD
1517 : }
1518 :
1519 5448 : if (m_poRealDriver)
1520 : {
1521 5448 : pfnDelete = m_poRealDriver->pfnDelete;
1522 5448 : pfnRename = m_poRealDriver->pfnRename;
1523 5448 : pfnCopyFiles = m_poRealDriver->pfnCopyFiles;
1524 :
1525 5448 : if (strcmp(GetDescription(), m_poRealDriver->GetDescription()) != 0)
1526 : {
1527 0 : CPLError(
1528 : CE_Warning, CPLE_AppDefined,
1529 : "Driver %s has not the same name as its underlying driver (%s)",
1530 0 : GetDescription(), m_poRealDriver->GetDescription());
1531 : }
1532 :
1533 54396 : for (const auto &osItem : m_oSetMetadataItems)
1534 : {
1535 48948 : const char *pszProxyValue = GetMetadataItem(osItem.c_str());
1536 : const char *pszRealValue =
1537 48948 : m_poRealDriver->GetMetadataItem(osItem.c_str());
1538 48948 : if (pszProxyValue &&
1539 48948 : (!pszRealValue || strcmp(pszProxyValue, pszRealValue) != 0))
1540 : {
1541 0 : CPLError(CE_Warning, CPLE_AppDefined,
1542 : "Proxy driver %s declares %s whereas its real driver "
1543 : "doesn't declare it or with a different value",
1544 0 : GetDescription(), osItem.c_str());
1545 : }
1546 : }
1547 103512 : for (const char *pszListedItem : apszProxyMetadataItems)
1548 : {
1549 : const char *pszRealValue =
1550 98064 : m_poRealDriver->GetMetadataItem(pszListedItem);
1551 98064 : if (pszRealValue)
1552 : {
1553 34640 : const char *pszProxyValue = GetMetadataItem(pszListedItem);
1554 34640 : if (!pszProxyValue || strcmp(pszProxyValue, pszRealValue) != 0)
1555 : {
1556 0 : CPLError(CE_Warning, CPLE_AppDefined,
1557 : "Driver %s declares %s whereas its proxy "
1558 : "doesn't declare it or with a different value",
1559 0 : GetDescription(), pszListedItem);
1560 : }
1561 : }
1562 : }
1563 :
1564 : const auto CheckFunctionPointer =
1565 10896 : [this](void *pfnFuncProxy, void *pfnFuncReal, const char *pszFunc)
1566 : {
1567 10896 : if (pfnFuncReal && !pfnFuncProxy)
1568 : {
1569 0 : CPLError(CE_Warning, CPLE_AppDefined,
1570 : "Driver %s declares a %s callback whereas its proxy "
1571 : "does not declare it",
1572 0 : GetDescription(), pszFunc);
1573 : }
1574 10896 : else if (!pfnFuncReal && pfnFuncProxy)
1575 : {
1576 0 : CPLError(CE_Warning, CPLE_AppDefined,
1577 : "Proxy driver %s declares a %s callback whereas the "
1578 : "real driver does not.",
1579 0 : GetDescription(), pszFunc);
1580 : }
1581 16344 : };
1582 :
1583 5448 : CheckFunctionPointer(
1584 5448 : reinterpret_cast<void *>(m_poRealDriver->pfnIdentify),
1585 5448 : reinterpret_cast<void *>(pfnIdentify), "pfnIdentify");
1586 :
1587 : // The real driver might provide a more accurate identification method
1588 5448 : if (m_poRealDriver->pfnIdentify)
1589 5448 : pfnIdentify = m_poRealDriver->pfnIdentify;
1590 :
1591 5448 : CheckFunctionPointer(
1592 5448 : reinterpret_cast<void *>(m_poRealDriver->pfnGetSubdatasetInfoFunc),
1593 5448 : reinterpret_cast<void *>(pfnGetSubdatasetInfoFunc),
1594 : "pfnGetSubdatasetInfoFunc");
1595 :
1596 : const auto CheckFunctionPointerVersusCap =
1597 43584 : [this](void *pfnFunc, const char *pszFunc, const char *pszItemName)
1598 : {
1599 21792 : if (pfnFunc && !GetMetadataItem(pszItemName))
1600 : {
1601 0 : CPLError(CE_Warning, CPLE_AppDefined,
1602 : "Driver %s declares a %s callback whereas its proxy "
1603 : "doest not declare %s",
1604 0 : GetDescription(), pszFunc, pszItemName);
1605 : }
1606 21792 : else if (!pfnFunc && GetMetadataItem(pszItemName))
1607 : {
1608 0 : CPLError(CE_Warning, CPLE_AppDefined,
1609 : "Proxy driver %s declares %s whereas the real "
1610 : "driver does not declare a %s callback",
1611 0 : GetDescription(), pszItemName, pszFunc);
1612 : }
1613 27240 : };
1614 :
1615 5448 : CheckFunctionPointerVersusCap(
1616 5448 : reinterpret_cast<void *>(m_poRealDriver->pfnOpen), "pfnOpen",
1617 : GDAL_DCAP_OPEN);
1618 5448 : CheckFunctionPointerVersusCap(
1619 5448 : reinterpret_cast<void *>(m_poRealDriver->pfnCreate), "pfnCreate",
1620 : GDAL_DCAP_CREATE);
1621 5448 : CheckFunctionPointerVersusCap(
1622 5448 : reinterpret_cast<void *>(m_poRealDriver->pfnCreateCopy),
1623 : "pfnCreateCopy", GDAL_DCAP_CREATECOPY);
1624 5448 : CheckFunctionPointerVersusCap(
1625 5448 : reinterpret_cast<void *>(m_poRealDriver->pfnCreateMultiDimensional),
1626 : "pfnCreateMultiDimensional", GDAL_DCAP_CREATE_MULTIDIMENSIONAL);
1627 : }
1628 :
1629 5448 : return m_poRealDriver.get();
1630 : }
1631 :
1632 : /************************************************************************/
1633 : /* GetPluginFullPath() */
1634 : /************************************************************************/
1635 :
1636 79259 : std::string GDALDriverManager::GetPluginFullPath(const char *pszFilename) const
1637 : {
1638 79259 : if (!m_osLastTriedDirectory.empty())
1639 : {
1640 : std::string osFullFilename = CPLFormFilenameSafe(
1641 77504 : m_osLastTriedDirectory.c_str(), pszFilename, nullptr);
1642 : VSIStatBufL sStatBuf;
1643 77504 : if (VSIStatL(osFullFilename.c_str(), &sStatBuf) == 0)
1644 : {
1645 77504 : return osFullFilename;
1646 : }
1647 : }
1648 :
1649 : const char *pszGDAL_DRIVER_PATH =
1650 1755 : CPLGetConfigOption("GDAL_DRIVER_PATH", nullptr);
1651 1755 : if (pszGDAL_DRIVER_PATH == nullptr)
1652 0 : pszGDAL_DRIVER_PATH = CPLGetConfigOption("OGR_DRIVER_PATH", nullptr);
1653 :
1654 : /* ---------------------------------------------------------------- */
1655 : /* Allow applications to completely disable this search by */
1656 : /* setting the driver path to the special string "disable". */
1657 : /* ---------------------------------------------------------------- */
1658 1755 : if (pszGDAL_DRIVER_PATH != nullptr && EQUAL(pszGDAL_DRIVER_PATH, "disable"))
1659 : {
1660 0 : CPLDebug("GDAL", "GDALDriverManager::GetPluginFullPath() disabled.");
1661 0 : return std::string();
1662 : }
1663 :
1664 : /* ---------------------------------------------------------------- */
1665 : /* Where should we look for stuff? */
1666 : /* ---------------------------------------------------------------- */
1667 : const CPLStringList aosSearchPaths(
1668 3510 : GDALDriverManager::GetSearchPaths(pszGDAL_DRIVER_PATH));
1669 :
1670 : /* ---------------------------------------------------------------- */
1671 : /* Format the ABI version specific subdirectory to look in. */
1672 : /* ---------------------------------------------------------------- */
1673 3510 : CPLString osABIVersion;
1674 :
1675 1755 : osABIVersion.Printf("%d.%d", GDAL_VERSION_MAJOR, GDAL_VERSION_MINOR);
1676 :
1677 : /* ---------------------------------------------------------------- */
1678 : /* Scan each directory looking for the file of interest. */
1679 : /* ---------------------------------------------------------------- */
1680 1755 : const int nSearchPaths = aosSearchPaths.size();
1681 1755 : for (int iDir = 0; iDir < nSearchPaths; ++iDir)
1682 : {
1683 : std::string osABISpecificDir =
1684 1755 : CPLFormFilenameSafe(aosSearchPaths[iDir], osABIVersion, nullptr);
1685 :
1686 : VSIStatBufL sStatBuf;
1687 1755 : if (VSIStatL(osABISpecificDir.c_str(), &sStatBuf) != 0)
1688 1755 : osABISpecificDir = aosSearchPaths[iDir];
1689 :
1690 : std::string osFullFilename =
1691 1755 : CPLFormFilenameSafe(osABISpecificDir.c_str(), pszFilename, nullptr);
1692 1755 : if (VSIStatL(osFullFilename.c_str(), &sStatBuf) == 0)
1693 : {
1694 1755 : m_osLastTriedDirectory = std::move(osABISpecificDir);
1695 1755 : return osFullFilename;
1696 : }
1697 : }
1698 :
1699 0 : return std::string();
1700 : }
1701 :
1702 : /************************************************************************/
1703 : /* DeclareDeferredPluginDriver() */
1704 : /************************************************************************/
1705 :
1706 : /** Declare a driver that will be loaded as a plugin, when actually needed.
1707 : *
1708 : * @param poProxyDriver Plugin driver proxy
1709 : *
1710 : * @since 3.9
1711 : */
1712 77220 : void GDALDriverManager::DeclareDeferredPluginDriver(
1713 : GDALPluginDriverProxy *poProxyDriver)
1714 : {
1715 77220 : CPLMutexHolderD(&hDMMutex);
1716 :
1717 77220 : const auto &osPluginFileName = poProxyDriver->GetPluginFileName();
1718 77220 : const char *pszPluginFileName = osPluginFileName.c_str();
1719 77220 : if ((!STARTS_WITH(pszPluginFileName, "gdal_") &&
1720 26325 : !STARTS_WITH(pszPluginFileName, "ogr_")) ||
1721 77220 : !strchr(pszPluginFileName, '.'))
1722 : {
1723 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid plugin filename: %s",
1724 : pszPluginFileName);
1725 0 : return;
1726 : }
1727 :
1728 77220 : if (GDALGetDriverByName(poProxyDriver->GetDescription()))
1729 : {
1730 0 : CPLError(CE_Failure, CPLE_AppDefined,
1731 : "DeclarePluginDriver(): trying to register %s several times",
1732 0 : poProxyDriver->GetDescription());
1733 0 : delete poProxyDriver;
1734 0 : return;
1735 : }
1736 :
1737 77220 : const std::string osFullPath = GetPluginFullPath(pszPluginFileName);
1738 77220 : poProxyDriver->SetPluginFullPath(osFullPath);
1739 :
1740 77220 : if (osFullPath.empty())
1741 : {
1742 : // Do not try to re-register a non-existent deferred plugin
1743 : // This would cause memory leaks in case of repeated calls to GDALAllRegister()
1744 : // Cf https://github.com/rasterio/rasterio/issues/3250
1745 0 : for (const auto &poDriver : m_aoHiddenDrivers)
1746 : {
1747 0 : if (EQUAL(poDriver->GetDescription(),
1748 : poProxyDriver->GetDescription()))
1749 : {
1750 0 : delete poProxyDriver;
1751 0 : return;
1752 : }
1753 : }
1754 :
1755 0 : CPLDebug("GDAL",
1756 : "Proxy driver %s *not* registered due to %s not being found",
1757 0 : poProxyDriver->GetDescription(), pszPluginFileName);
1758 0 : RegisterDriver(poProxyDriver, /*bHidden=*/true);
1759 : }
1760 : else
1761 : {
1762 : //CPLDebugOnly("GDAL", "Registering proxy driver %s",
1763 : // poProxyDriver->GetDescription());
1764 77220 : RegisterDriver(poProxyDriver);
1765 77220 : m_oSetPluginFileNames.insert(pszPluginFileName);
1766 : }
1767 : }
1768 :
1769 : /************************************************************************/
1770 : /* GDALDestroyDriverManager() */
1771 : /************************************************************************/
1772 :
1773 : /**
1774 : * \brief Destroy the driver manager.
1775 : *
1776 : * Incidentally unloads all managed drivers.
1777 : *
1778 : * NOTE: This function is not thread safe. It should not be called while
1779 : * other threads are actively using GDAL.
1780 : *
1781 : * \see GDALDestroy()
1782 : * \deprecated Use GDALDestroy() instead
1783 : */
1784 :
1785 1790 : void CPL_STDCALL GDALDestroyDriverManager(void)
1786 :
1787 : {
1788 : // THREADSAFETY: We would like to lock the mutex here, but it
1789 : // needs to be reacquired within the destructor during driver
1790 : // deregistration.
1791 :
1792 : // FIXME: Disable following code as it crashed on OSX CI test.
1793 : // std::lock_guard<std::mutex> oLock(oDeleteMutex);
1794 :
1795 1790 : if (poDM != nullptr)
1796 : {
1797 1123 : delete poDM;
1798 1123 : poDM = nullptr;
1799 : }
1800 1790 : }
|
