/src/gdal/ogr/ogrsf_frmts/shape/shp_vsi.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  IO Redirection via VSI services for shp/dbf io.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2007,  Frank Warmerdam
 * Copyright (c) 2009-2013, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "shp_vsi.h"
#include "cpl_error.h"
#include "cpl_conv.h"
#include "cpl_vsi_error.h"
#include <limits.h>

#include "shapefil_private.h"

typedef struct
{
    VSILFILE *fp;
    char *pszFilename;
    int bEnforce2GBLimit;
    int bHasWarned2GB;
    SAOffset nCurOffset;
} OGRSHPDBFFile;

/************************************************************************/
/*                         VSI_SHP_OpenInternal()                       */
/************************************************************************/

static SAFile VSI_SHP_OpenInternal(const char *pszFilename,
                                   const char *pszAccess, int bEnforce2GBLimit)

{
    OGRSHPDBFFile *pFile;
    VSILFILE *fp = VSIFOpenExL(pszFilename, pszAccess, TRUE);
    if (fp == SHPLIB_NULLPTR)
        return SHPLIB_NULLPTR;
    pFile = (OGRSHPDBFFile *)CPLCalloc(1, sizeof(OGRSHPDBFFile));
    pFile->fp = fp;
    pFile->pszFilename = CPLStrdup(pszFilename);
    pFile->bEnforce2GBLimit = bEnforce2GBLimit;
    pFile->nCurOffset = 0;
    return (SAFile)pFile;
}

/************************************************************************/
/*                            VSI_SHP_Open()                            */
/************************************************************************/

static SAFile VSI_SHP_Open(const char *pszFilename, const char *pszAccess,
                           void *userData)

{
    (void)userData;
    return VSI_SHP_OpenInternal(pszFilename, pszAccess, FALSE);
}

/************************************************************************/
/*                            VSI_SHP_Read()                            */
/************************************************************************/

static SAOffset VSI_SHP_Read(void *p, SAOffset size, SAOffset nmemb,
                             SAFile file)

{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    SAOffset ret =
        (SAOffset)VSIFReadL(p, (size_t)size, (size_t)nmemb, pFile->fp);
    pFile->nCurOffset += ret * size;
    return ret;
}

/************************************************************************/
/*                      VSI_SHP_WriteMoreDataOK()                       */
/************************************************************************/

int VSI_SHP_WriteMoreDataOK(SAFile file, SAOffset nExtraBytes)
{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    if (pFile->nCurOffset + nExtraBytes > INT_MAX)
    {
        if (pFile->bEnforce2GBLimit)
        {
            CPLError(CE_Failure, CPLE_AppDefined,
                     "2GB file size limit reached for %s", pFile->pszFilename);
            return FALSE;
        }
        else if (!pFile->bHasWarned2GB)
        {
            pFile->bHasWarned2GB = TRUE;
            CPLError(CE_Warning, CPLE_AppDefined,
                     "2GB file size limit reached for %s. "
                     "Going on, but might cause compatibility issues with "
                     "third party software",
                     pFile->pszFilename);
        }
    }

    return TRUE;
}

/************************************************************************/
/*                           VSI_SHP_Write()                            */
/************************************************************************/

static SAOffset VSI_SHP_Write(const void *p, SAOffset size, SAOffset nmemb,
                              SAFile file)

{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    SAOffset ret;
    if (!VSI_SHP_WriteMoreDataOK(file, size * nmemb))
        return 0;
    ret = (SAOffset)VSIFWriteL(p, (size_t)size, (size_t)nmemb, pFile->fp);
    pFile->nCurOffset += ret * size;
    return ret;
}

/************************************************************************/
/*                            VSI_SHP_Seek()                            */
/************************************************************************/

static SAOffset VSI_SHP_Seek(SAFile file, SAOffset offset, int whence)

{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    SAOffset ret = (SAOffset)VSIFSeekL(pFile->fp, (vsi_l_offset)offset, whence);
    if (whence == 0 && ret == 0)
        pFile->nCurOffset = offset;
    else
        pFile->nCurOffset = (SAOffset)VSIFTellL(pFile->fp);
    return ret;
}

/************************************************************************/
/*                            VSI_SHP_Tell()                            */
/************************************************************************/

static SAOffset VSI_SHP_Tell(SAFile file)

{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    return (SAOffset)pFile->nCurOffset;
}

/************************************************************************/
/*                           VSI_SHP_Flush()                            */
/************************************************************************/

static int VSI_SHP_Flush(SAFile file)

{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    return VSIFFlushL(pFile->fp);
}

/************************************************************************/
/*                           VSI_SHP_Close()                            */
/************************************************************************/

static int VSI_SHP_Close(SAFile file)

{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    int ret = VSIFCloseL(pFile->fp);
    CPLFree(pFile->pszFilename);
    CPLFree(pFile);
    return ret;
}

/************************************************************************/
/*                              SADError()                              */
/************************************************************************/

static void VSI_SHP_Error(const char *message)

{
    CPLError(CE_Failure, CPLE_AppDefined, "%s", message);
}

/************************************************************************/
/*                           VSI_SHP_Remove()                           */
/************************************************************************/

static int VSI_SHP_Remove(const char *pszFilename, void *userData)

{
    (void)userData;
    return VSIUnlink(pszFilename);
}

/************************************************************************/
/*                        SASetupDefaultHooks()                         */
/************************************************************************/

void SASetupDefaultHooks(SAHooks *psHooks)

{
    psHooks->FOpen = VSI_SHP_Open;
    psHooks->FRead = VSI_SHP_Read;
    psHooks->FWrite = VSI_SHP_Write;
    psHooks->FSeek = VSI_SHP_Seek;
    psHooks->FTell = VSI_SHP_Tell;
    psHooks->FFlush = VSI_SHP_Flush;
    psHooks->FClose = VSI_SHP_Close;
    psHooks->Remove = VSI_SHP_Remove;

    psHooks->Error = VSI_SHP_Error;
    psHooks->Atof = CPLAtof;
    psHooks->pvUserData = SHPLIB_NULLPTR;
}

#ifndef SHP_VSI_ONLY_SETUP_HOOKS

/************************************************************************/
/*                         VSI_SHP_GetVSIL()                            */
/************************************************************************/

VSILFILE *VSI_SHP_GetVSIL(SAFile file)
{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    return pFile->fp;
}

/************************************************************************/
/*                        VSI_SHP_GetFilename()                         */
/************************************************************************/

const char *VSI_SHP_GetFilename(SAFile file)
{
    OGRSHPDBFFile *pFile = (OGRSHPDBFFile *)file;
    return pFile->pszFilename;
}

/************************************************************************/
/*                        VSI_SHP_Open2GBLimit()                        */
/************************************************************************/

static SAFile VSI_SHP_Open2GBLimit(const char *pszFilename,
                                   const char *pszAccess, void *userData)

{
    (void)userData;
    return VSI_SHP_OpenInternal(pszFilename, pszAccess, TRUE);
}

/************************************************************************/
/*                         VSI_SHP_GetHook()                            */
/************************************************************************/

static const SAHooks sOGRHook = {
    VSI_SHP_Open,  VSI_SHP_Read,  VSI_SHP_Write, VSI_SHP_Seek,
    VSI_SHP_Tell,  VSI_SHP_Flush, VSI_SHP_Close, VSI_SHP_Remove,
    VSI_SHP_Error, CPLAtof,       NULL};

static const SAHooks sOGRHook2GBLimit = {
    VSI_SHP_Open2GBLimit, VSI_SHP_Read,  VSI_SHP_Write, VSI_SHP_Seek,
    VSI_SHP_Tell,         VSI_SHP_Flush, VSI_SHP_Close, VSI_SHP_Remove,
    VSI_SHP_Error,        CPLAtof,       NULL};

const SAHooks *VSI_SHP_GetHook(int b2GBLimit)
{
    return (b2GBLimit) ? &sOGRHook2GBLimit : &sOGRHook;
}

#endif

Coverage Report

Created: 2025-06-09 08:44

Line	Count	Source (jump to first uncovered line)
1		/******************************************************************************
2		*
3		* Project: OpenGIS Simple Features Reference Implementation
4		* Purpose: IO Redirection via VSI services for shp/dbf io.
5		* Author: Frank Warmerdam, warmerdam@pobox.com
6		*
7		******************************************************************************
8		* Copyright (c) 2007, 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 "shp_vsi.h"
15		#include "cpl_error.h"
16		#include "cpl_conv.h"
17		#include "cpl_vsi_error.h"
18		#include <limits.h>
19
20		#include "shapefil_private.h"
21
22		typedef struct
23		{
24		VSILFILE *fp;
25		char *pszFilename;
26		int bEnforce2GBLimit;
27		int bHasWarned2GB;
28		SAOffset nCurOffset;
29		} OGRSHPDBFFile;
30
31		/************************************************************************/
32		/* VSI_SHP_OpenInternal() */
33		/************************************************************************/
34
35		static SAFile VSI_SHP_OpenInternal(const char *pszFilename,
36		const char *pszAccess, int bEnforce2GBLimit)
37
38	95.8k	{
39	95.8k	OGRSHPDBFFile *pFile;
40	95.8k	VSILFILE *fp = VSIFOpenExL(pszFilename, pszAccess, TRUE);
41	95.8k	if (fp == SHPLIB_NULLPTR)
42	73.7k	return SHPLIB_NULLPTR;
43	22.0k	pFile = (OGRSHPDBFFile *)CPLCalloc(1, sizeof(OGRSHPDBFFile));
44	22.0k	pFile->fp = fp;
45	22.0k	pFile->pszFilename = CPLStrdup(pszFilename);
46	22.0k	pFile->bEnforce2GBLimit = bEnforce2GBLimit;
47	22.0k	pFile->nCurOffset = 0;
48	22.0k	return (SAFile)pFile;
49	95.8k	}
50
51		/************************************************************************/
52		/* VSI_SHP_Open() */
53		/************************************************************************/
54
55		static SAFile VSI_SHP_Open(const char pszFilename, const char pszAccess,
56		void *userData)
57
58	95.8k	{
59	95.8k	(void)userData;
60	95.8k	return VSI_SHP_OpenInternal(pszFilename, pszAccess, FALSE);
61	95.8k	}
62
63		/************************************************************************/
64		/* VSI_SHP_Read() */
65		/************************************************************************/
66
67		static SAOffset VSI_SHP_Read(void *p, SAOffset size, SAOffset nmemb,
68		SAFile file)
69
70	12.3M	{
71	12.3M	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
72	12.3M	SAOffset ret =
73	12.3M	(SAOffset)VSIFReadL(p, (size_t)size, (size_t)nmemb, pFile->fp);
74	12.3M	pFile->nCurOffset += ret * size;
75	12.3M	return ret;
76	12.3M	}
77
78		/************************************************************************/
79		/* VSI_SHP_WriteMoreDataOK() */
80		/************************************************************************/
81
82		int VSI_SHP_WriteMoreDataOK(SAFile file, SAOffset nExtraBytes)
83	20.0M	{
84	20.0M	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
85	20.0M	if (pFile->nCurOffset + nExtraBytes > INT_MAX)
86	0	{
87	0	if (pFile->bEnforce2GBLimit)
88	0	{
89	0	CPLError(CE_Failure, CPLE_AppDefined,
90	0	"2GB file size limit reached for %s", pFile->pszFilename);
91	0	return FALSE;
92	0	}
93	0	else if (!pFile->bHasWarned2GB)
94	0	{
95	0	pFile->bHasWarned2GB = TRUE;
96	0	CPLError(CE_Warning, CPLE_AppDefined,
97	0	"2GB file size limit reached for %s. "
98	0	"Going on, but might cause compatibility issues with "
99	0	"third party software",
100	0	pFile->pszFilename);
101	0	}
102	0	}
103
104	20.0M	return TRUE;
105	20.0M	}
106
107		/************************************************************************/
108		/* VSI_SHP_Write() */
109		/************************************************************************/
110
111		static SAOffset VSI_SHP_Write(const void *p, SAOffset size, SAOffset nmemb,
112		SAFile file)
113
114	18.0M	{
115	18.0M	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
116	18.0M	SAOffset ret;
117	18.0M	if (!VSI_SHP_WriteMoreDataOK(file, size * nmemb))
118	0	return 0;
119	18.0M	ret = (SAOffset)VSIFWriteL(p, (size_t)size, (size_t)nmemb, pFile->fp);
120	18.0M	pFile->nCurOffset += ret * size;
121	18.0M	return ret;
122	18.0M	}
123
124		/************************************************************************/
125		/* VSI_SHP_Seek() */
126		/************************************************************************/
127
128		static SAOffset VSI_SHP_Seek(SAFile file, SAOffset offset, int whence)
129
130	26.6M	{
131	26.6M	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
132	26.6M	SAOffset ret = (SAOffset)VSIFSeekL(pFile->fp, (vsi_l_offset)offset, whence);
133	26.6M	if (whence == 0 && ret == 0)
134	26.6M	pFile->nCurOffset = offset;
135	10.0k	else
136	10.0k	pFile->nCurOffset = (SAOffset)VSIFTellL(pFile->fp);
137	26.6M	return ret;
138	26.6M	}
139
140		/************************************************************************/
141		/* VSI_SHP_Tell() */
142		/************************************************************************/
143
144		static SAOffset VSI_SHP_Tell(SAFile file)
145
146	3.73M	{
147	3.73M	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
148	3.73M	return (SAOffset)pFile->nCurOffset;
149	3.73M	}
150
151		/************************************************************************/
152		/* VSI_SHP_Flush() */
153		/************************************************************************/
154
155		static int VSI_SHP_Flush(SAFile file)
156
157	15.3k	{
158	15.3k	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
159	15.3k	return VSIFFlushL(pFile->fp);
160	15.3k	}
161
162		/************************************************************************/
163		/* VSI_SHP_Close() */
164		/************************************************************************/
165
166		static int VSI_SHP_Close(SAFile file)
167
168	22.0k	{
169	22.0k	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
170	22.0k	int ret = VSIFCloseL(pFile->fp);
171	22.0k	CPLFree(pFile->pszFilename);
172	22.0k	CPLFree(pFile);
173	22.0k	return ret;
174	22.0k	}
175
176		/************************************************************************/
177		/* SADError() */
178		/************************************************************************/
179
180		static void VSI_SHP_Error(const char *message)
181
182	59.6k	{
183	59.6k	CPLError(CE_Failure, CPLE_AppDefined, "%s", message);
184	59.6k	}
185
186		/************************************************************************/
187		/* VSI_SHP_Remove() */
188		/************************************************************************/
189
190		static int VSI_SHP_Remove(const char pszFilename, void userData)
191
192	1.78k	{
193	1.78k	(void)userData;
194	1.78k	return VSIUnlink(pszFilename);
195	1.78k	}
196
197		/************************************************************************/
198		/* SASetupDefaultHooks() */
199		/************************************************************************/
200
201		void SASetupDefaultHooks(SAHooks *psHooks)
202
203	3.54k	{
204	3.54k	psHooks->FOpen = VSI_SHP_Open;
205	3.54k	psHooks->FRead = VSI_SHP_Read;
206	3.54k	psHooks->FWrite = VSI_SHP_Write;
207	3.54k	psHooks->FSeek = VSI_SHP_Seek;
208	3.54k	psHooks->FTell = VSI_SHP_Tell;
209	3.54k	psHooks->FFlush = VSI_SHP_Flush;
210	3.54k	psHooks->FClose = VSI_SHP_Close;
211	3.54k	psHooks->Remove = VSI_SHP_Remove;
212
213	3.54k	psHooks->Error = VSI_SHP_Error;
214	3.54k	psHooks->Atof = CPLAtof;
215	3.54k	psHooks->pvUserData = SHPLIB_NULLPTR;
216	3.54k	}
217
218		#ifndef SHP_VSI_ONLY_SETUP_HOOKS
219
220		/************************************************************************/
221		/* VSI_SHP_GetVSIL() */
222		/************************************************************************/
223
224		VSILFILE *VSI_SHP_GetVSIL(SAFile file)
225	204k	{
226	204k	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
227	204k	return pFile->fp;
228	204k	}
229
230		/************************************************************************/
231		/* VSI_SHP_GetFilename() */
232		/************************************************************************/
233
234		const char *VSI_SHP_GetFilename(SAFile file)
235	0	{
236	0	OGRSHPDBFFile pFile = (OGRSHPDBFFile )file;
237	0	return pFile->pszFilename;
238	0	}
239
240		/************************************************************************/
241		/* VSI_SHP_Open2GBLimit() */
242		/************************************************************************/
243
244		static SAFile VSI_SHP_Open2GBLimit(const char *pszFilename,
245		const char pszAccess, void userData)
246
247	0	{
248	0	(void)userData;
249	0	return VSI_SHP_OpenInternal(pszFilename, pszAccess, TRUE);
250	0	}
251
252		/************************************************************************/
253		/* VSI_SHP_GetHook() */
254		/************************************************************************/
255
256		static const SAHooks sOGRHook = {
257		VSI_SHP_Open, VSI_SHP_Read, VSI_SHP_Write, VSI_SHP_Seek,
258		VSI_SHP_Tell, VSI_SHP_Flush, VSI_SHP_Close, VSI_SHP_Remove,
259		VSI_SHP_Error, CPLAtof, NULL};
260
261		static const SAHooks sOGRHook2GBLimit = {
262		VSI_SHP_Open2GBLimit, VSI_SHP_Read, VSI_SHP_Write, VSI_SHP_Seek,
263		VSI_SHP_Tell, VSI_SHP_Flush, VSI_SHP_Close, VSI_SHP_Remove,
264		VSI_SHP_Error, CPLAtof, NULL};
265
266		const SAHooks *VSI_SHP_GetHook(int b2GBLimit)
267	36.6k	{
268	36.6k	return (b2GBLimit) ? &sOGRHook2GBLimit : &sOGRHook;
269	36.6k	}
270
271		#endif