--- /dev/null
+/*
+** 2019 April 12
+**
+** The author disclaims copyright to this source code. In place of
+** a legal notice, here is a blessing:
+**
+** May you do good and not evil.
+** May you find forgiveness for yourself and forgive others.
+** May you share freely, never taking more than you give.
+**
+*************************************************************************
+**
+** A read-only VFS that reads data from a server instead of a file
+** using a custom protocol over a tcp/ip socket. The VFS is named
+** "socket". The filename passed to sqlite3_open() is of the
+** form "host:portnumber". For example, to connect to the server
+** on port 23456 on the localhost:
+**
+** sqlite3_open_v2("localhost:23456", &db, SQLITE_OPEN_READONLY, "socket");
+**
+** Or, if using URIs:
+**
+** sqlite3_open("file:localhost:23456?vfs=socket", &db);
+**
+** The protocol is:
+**
+** * Client connects to tcp/ip server. Server immediately sends the
+** database file-size in bytes as a 64-bit big-endian integer.
+**
+** * To read from the file, client sends the byte offset and amount
+** of data required in bytes, both as 64-bit big-endian integers
+** (i.e. a 16-byte message). Server sends back the requested data.
+**
+** As well as the usual SQLite loadable extension entry point, this file
+** exports one more function:
+**
+** sqlite3_vfs *sqlite3_socketvfs(void);
+**
+** To install the "socket" VFS without loading the extension, link this file
+** into the application and invoke:
+**
+** int bDefault = 0; // Do not make "socket" the default VFS
+** sqlite3_vfs_register(sqlite3_socketvfs(), bDefault);
+**
+*/
+
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+#include <assert.h>
+#include <string.h>
+
+#if defined(_WIN32)
+# if defined(_WIN32_WINNT)
+# undef _WIN32_WINNT
+# endif
+# define _WIN32_WINNT 0x501
+#endif
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1 /* IPv6 won't compile on Solaris without this */
+#endif
+#if defined(_WIN32)
+# include <winsock2.h>
+# include <ws2tcpip.h>
+# include <Windows.h>
+# include <time.h>
+#else
+# include <netinet/in.h>
+# include <arpa/inet.h>
+# include <sys/socket.h>
+# include <netdb.h>
+# include <time.h>
+#endif
+#include <assert.h>
+#include <sys/types.h>
+#include <signal.h>
+
+#if !defined(_WIN32)
+# include <unistd.h>
+#endif
+
+/*
+** When using this VFS, the sqlite3_file* handles that SQLite uses are
+** actually pointers to instances of type SocketFile.
+*/
+typedef struct SocketFile SocketFile;
+struct SocketFile {
+ sqlite3_file base; /* Base class. Must be first. */
+ int iSocket; /* Socket used to talk to server. */
+ sqlite3_int64 szFile; /* Size of file in bytes */
+};
+
+static sqlite3_uint64 socketGetU64(const unsigned char *a){
+ return (((sqlite3_uint64)(a[0])) << 56)
+ + (((sqlite3_uint64)(a[1])) << 48)
+ + (((sqlite3_uint64)(a[2])) << 40)
+ + (((sqlite3_uint64)(a[3])) << 32)
+ + (((sqlite3_uint64)(a[4])) << 24)
+ + (((sqlite3_uint64)(a[5])) << 16)
+ + (((sqlite3_uint64)(a[6])) << 8)
+ + (((sqlite3_uint64)(a[7])) << 0);
+}
+
+static void socketPutU64(unsigned char *a, sqlite3_int64 i){
+ a[0] = ((i >> 56) & 0xFF);
+ a[1] = ((i >> 48) & 0xFF);
+ a[2] = ((i >> 40) & 0xFF);
+ a[3] = ((i >> 32) & 0xFF);
+ a[4] = ((i >> 24) & 0xFF);
+ a[5] = ((i >> 16) & 0xFF);
+ a[6] = ((i >> 8) & 0xFF);
+ a[7] = ((i >> 0) & 0xFF);
+}
+
+static void socket_close(int iSocket){
+ if( iSocket>=0 ){
+#if defined(_WIN32)
+ if( shutdown(iSocket,1)==0 ) shutdown(iSocket,0);
+ closesocket(iSocket);
+#else
+ close(iSocket);
+#endif
+ }
+}
+
+/*
+** Write nData bytes of data from buffer aData to socket iSocket. If
+** successful, return SQLITE_OK. Otherwise, SQLITE_IOERR_WRITE.
+*/
+static int socket_send(int iSocket, const unsigned char *aData, int nData){
+ int nWrite = 0;
+ do{
+ int res = send(iSocket, (const char*)&aData[nWrite], nData-nWrite, 0);
+ if( res<=0 ) return SQLITE_IOERR_WRITE;
+ nWrite += res;
+ }while( nWrite<nData );
+ return SQLITE_OK;
+}
+
+/*
+** Read nData bytes of data from socket iSocket into buffer aData. If
+** successful, return SQLITE_OK. Otherwise, SQLITE_IOERR_READ.
+*/
+static int socket_recv(int iSocket, unsigned char *aData, int nData){
+ int nRead = 0;
+ do{
+ int res = recv(iSocket, (char*)&aData[nRead], nData-nRead, 0);
+ if( res<=0 ) return SQLITE_IOERR_READ;
+ nRead += res;
+ }while( nRead<nData );
+ return SQLITE_OK;
+}
+
+/*
+** Close a SocketFile file.
+*/
+static int socketClose(sqlite3_file *pFile){
+ SocketFile *pSock = (SocketFile*)pFile;
+ socket_close(pSock->iSocket);
+ pSock->iSocket = -1;
+ return SQLITE_OK;
+}
+
+/*
+** Read data from a SocketFile file.
+*/
+static int socketRead(
+ sqlite3_file *pFile,
+ void *zBuf,
+ int iAmt,
+ sqlite3_int64 iOfst
+){
+ SocketFile *pSock = (SocketFile*)pFile;
+ unsigned char aRequest[16];
+ int rc = SQLITE_OK;
+ int nRead = iAmt;
+
+ if( iOfst+nRead>pSock->szFile ){
+ nRead = (int)(pSock->szFile - iOfst);
+ memset(zBuf, 0, iAmt);
+ rc = SQLITE_IOERR_SHORT_READ;
+ }
+
+ if( nRead>0 ){
+ socketPutU64(&aRequest[0], (sqlite3_uint64)iOfst);
+ socketPutU64(&aRequest[8], (sqlite3_uint64)nRead);
+ rc = socket_send(pSock->iSocket, aRequest, sizeof(aRequest));
+ if( rc==SQLITE_OK ){
+ rc = socket_recv(pSock->iSocket, zBuf, nRead);
+ }
+ }
+
+ return rc;
+}
+
+/*
+** Write to a file. This is a no-op, as this VFS is always opens files
+** read-only.
+*/
+static int socketWrite(
+ sqlite3_file *pFile,
+ const void *zBuf,
+ int iAmt,
+ sqlite3_int64 iOfst
+){
+ return SQLITE_IOERR_WRITE;
+}
+
+/*
+** Truncate a file. This is a no-op, as this VFS is always opens files
+** read-only.
+*/
+static int socketTruncate(sqlite3_file *pFile, sqlite3_int64 size){
+ return SQLITE_IOERR_TRUNCATE;
+}
+
+/*
+** Synk a file. This is a no-op, as this VFS is always opens files
+** read-only.
+*/
+static int socketSync(sqlite3_file *pFile, int flags){
+ return SQLITE_IOERR_FSYNC;
+}
+
+/*
+** Write the size of the file in bytes to *pSize.
+*/
+static int socketFileSize(sqlite3_file *pFile, sqlite3_int64 *pSize){
+ SocketFile *pSock = (SocketFile*)pFile;
+ *pSize = pSock->szFile;
+ return SQLITE_OK;
+}
+
+/*
+** Locking functions. All no-ops.
+*/
+static int socketLock(sqlite3_file *pFile, int eLock){
+ return SQLITE_OK;
+}
+static int socketUnlock(sqlite3_file *pFile, int eLock){
+ return SQLITE_OK;
+}
+static int socketCheckReservedLock(sqlite3_file *pFile, int *pResOut){
+ *pResOut = 0;
+ return SQLITE_OK;
+}
+
+/*
+** No xFileControl() verbs are implemented by this VFS.
+*/
+static int socketFileControl(sqlite3_file *pFile, int op, void *pArg){
+ return SQLITE_OK;
+}
+
+/*
+** The xSectorSize() and xDeviceCharacteristics() methods. These two
+** may return special values allowing SQLite to optimize file-system
+** access to some extent. But it is also safe to simply return 0.
+*/
+static int socketSectorSize(sqlite3_file *pFile){
+ return 0;
+}
+static int socketDeviceCharacteristics(sqlite3_file *pFile){
+ return 0;
+}
+
+/*
+** Open a SocketFile file.
+*/
+static int socketOpen(
+ sqlite3_vfs *pVfs, /* VFS */
+ const char *zName, /* File to open, or 0 for a temp file */
+ sqlite3_file *pFile, /* Pointer to SocketFile struct to populate */
+ int flags, /* Input SQLITE_OPEN_XXX flags */
+ int *pOutFlags /* Output SQLITE_OPEN_XXX flags (or NULL) */
+){
+ static const sqlite3_io_methods socketio = {
+ 1, /* iVersion */
+ socketClose, /* xClose */
+ socketRead, /* xRead */
+ socketWrite, /* xWrite */
+ socketTruncate, /* xTruncate */
+ socketSync, /* xSync */
+ socketFileSize, /* xFileSize */
+ socketLock, /* xLock */
+ socketUnlock, /* xUnlock */
+ socketCheckReservedLock, /* xCheckReservedLock */
+ socketFileControl, /* xFileControl */
+ socketSectorSize, /* xSectorSize */
+ socketDeviceCharacteristics /* xDeviceCharacteristics */
+ };
+
+ SocketFile *pSock = (SocketFile*)pFile;
+
+ char zHost[1024];
+ const char *zPort;
+ int i;
+
+ struct addrinfo hints;
+ struct addrinfo *ai = 0;
+ struct addrinfo *pInfo;
+ unsigned char aFileSize[8];
+
+ pSock->iSocket = -1;
+ if( (flags & SQLITE_OPEN_MAIN_DB)==0 ) return SQLITE_CANTOPEN;
+
+ /* Parse the argument and copy the results to zHost and zPort. It should be
+ ** "hostname:port". Anything else is an error. */
+ assert( sizeof(zHost)>=pVfs->mxPathname );
+ if( zName==0 ) return SQLITE_CANTOPEN;
+ for(i=0; zName[i] && zName[i]!=':'; i++);
+ if( zName[i]==0 ) return SQLITE_CANTOPEN;
+ memcpy(zHost, zName, i);
+ zHost[i] = '\0';
+ zPort = &zName[i+1];
+
+ /* Resolve the address */
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+ if( getaddrinfo(zHost, zPort, &hints, &ai) ){
+ return SQLITE_CANTOPEN;
+ }
+
+ /* Connect to the resolved address. Set SocketFile.iSocket to the tcp/ip
+ ** socket and return SQLITE_OK. */
+ for(pInfo=ai; pInfo; pInfo=pInfo->ai_next){
+ int sd = socket(pInfo->ai_family, pInfo->ai_socktype, pInfo->ai_protocol);
+ if( sd<0 ) continue;
+ if( connect(sd, pInfo->ai_addr, pInfo->ai_addrlen)<0 ){
+ socket_close(sd);
+ continue;
+ }
+ pSock->iSocket = sd;
+ break;
+ }
+
+ if( ai ) freeaddrinfo(ai);
+ if( pSock->iSocket<0 ) return SQLITE_CANTOPEN;
+
+ /* The server sends back the file size as a 64-bit big-endian */
+ if( socket_recv(pSock->iSocket, aFileSize, 8) ){
+ socket_close(pSock->iSocket);
+ return SQLITE_CANTOPEN;
+ }
+ pSock->szFile = (sqlite3_int64)socketGetU64(aFileSize);
+
+ *pOutFlags = flags & ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
+ *pOutFlags |= SQLITE_OPEN_READONLY;
+ pSock->base.pMethods = &socketio;
+ return SQLITE_OK;
+}
+
+/*
+** Another no-op. This is a read-only VFS.
+*/
+static int socketDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+ return SQLITE_IOERR_DELETE;
+}
+
+/*
+** This is used by SQLite to detect journal and wal files. Which cannot
+** exist for this VFS. So always set the output to false and return
+** SQLITE_OK.
+*/
+static int socketAccess(
+ sqlite3_vfs *pVfs,
+ const char *zPath,
+ int flags,
+ int *pResOut
+){
+ *pResOut = 0;
+ return SQLITE_OK;
+}
+
+/*
+** A no-op. Copy the input to the output.
+*/
+static int socketFullPathname(
+ sqlite3_vfs *pVfs, /* VFS */
+ const char *zPath, /* Input path (possibly a relative path) */
+ int nPathOut, /* Size of output buffer in bytes */
+ char *zPathOut /* Pointer to output buffer */
+){
+ int nByte = strlen(zPath);
+ if( nByte>=pVfs->mxPathname ) return SQLITE_IOERR;
+ memcpy(zPathOut, zPath, nByte+1);
+ return SQLITE_OK;
+}
+
+/*
+** The following four VFS methods:
+**
+** xDlOpen
+** xDlError
+** xDlSym
+** xDlClose
+**
+** are supposed to implement the functionality needed by SQLite to load
+** extensions compiled as shared objects. This simple VFS does not support
+** this functionality, so the following functions are no-ops.
+*/
+static void *socketDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+ return 0;
+}
+static void socketDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
+ sqlite3_snprintf(nByte, zErrMsg, "Loadable extensions are not supported");
+ zErrMsg[nByte-1] = '\0';
+}
+static void (*socketDlSym(sqlite3_vfs *pVfs, void *pH, const char *z))(void){
+ return 0;
+}
+static void socketDlClose(sqlite3_vfs *pVfs, void *pHandle){
+ return;
+}
+
+/*
+** Parameter zByte points to a buffer nByte bytes in size. Populate this
+** buffer with pseudo-random data.
+*/
+static int socketRandomness(sqlite3_vfs *pVfs, int nByte, char *zByte){
+ memset(zByte, 0, nByte);
+ return SQLITE_OK;
+}
+
+/*
+** Sleep for at least nMicro microseconds. Return the (approximate) number
+** of microseconds slept for.
+*/
+static int socketSleep(sqlite3_vfs *pVfs, int nMicro){
+#ifdef _WIN32
+ Sleep(nMicro/1000);
+#else
+ sleep(nMicro / 1000000);
+ usleep(nMicro % 1000000);
+#endif
+ return nMicro;
+}
+
+/*
+** Set *pTime to the current UTC time expressed as a Julian day. Return
+** SQLITE_OK if successful, or an error code otherwise.
+**
+** http://en.wikipedia.org/wiki/Julian_day
+**
+** This implementation is not very good. The current time is rounded to
+** an integer number of seconds. Also, assuming time_t is a signed 32-bit
+** value, it will stop working some time in the year 2038 AD (the so-called
+** "year 2038" problem that afflicts systems that store time this way).
+*/
+static int socketCurrentTime(sqlite3_vfs *pVfs, double *pTime){
+ time_t t = time(0);
+ *pTime = t/86400.0 + 2440587.5;
+ return SQLITE_OK;
+}
+
+/*
+** This function returns a pointer to the VFS implemented in this file.
+** To make the VFS available to SQLite:
+**
+** sqlite3_vfs_register(sqlite3_socketvfs(), 0);
+*/
+sqlite3_vfs *sqlite3_socketvfs(void){
+ static sqlite3_vfs socketvfs = {
+ 1, /* iVersion */
+ sizeof(SocketFile), /* szOsFile */
+ 512, /* mxPathname */
+ 0, /* pNext */
+ "socket", /* zName */
+ 0, /* pAppData */
+ socketOpen, /* xOpen */
+ socketDelete, /* xDelete */
+ socketAccess, /* xAccess */
+ socketFullPathname, /* xFullPathname */
+ socketDlOpen, /* xDlOpen */
+ socketDlError, /* xDlError */
+ socketDlSym, /* xDlSym */
+ socketDlClose, /* xDlClose */
+ socketRandomness, /* xRandomness */
+ socketSleep, /* xSleep */
+ socketCurrentTime, /* xCurrentTime */
+ };
+ return &socketvfs;
+}
+
+/*
+** Register the amatch virtual table
+*/
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_socketvfs_init(
+ sqlite3 *db,
+ char **pzErrMsg,
+ const sqlite3_api_routines *pApi
+){
+ int rc = SQLITE_OK;
+ SQLITE_EXTENSION_INIT2(pApi);
+ (void)pzErrMsg; /* Not used */
+ sqlite3_vfs_register(sqlite3_socketvfs(), 0);
+ return SQLITE_OK_LOAD_PERMANENTLY;
+}
+
projects / thirdparty / sqlite.git / commitdiff
