mirror of
https://github.com/mdbtools/mdbtools.git
synced 2025-04-05 20:31:00 +08:00
Merge branch 'dev' into no-sql
This commit is contained in:
Evan Miller
commit
8692586205
3
.github/workflows/build.yml
vendored
3
.github/workflows/build.yml
vendored
@ -6,7 +6,7 @@ jobs:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
compiler: [ clang, gcc, gcc-8, gcc-9, gcc-10 ]
|
||||
compiler: [ clang, gcc, gcc-9, gcc-10 ]
|
||||
glib: [ enable-glib, disable-glib ]
|
||||
steps:
|
||||
- name: Install packages
|
||||
@ -79,6 +79,7 @@ jobs:
|
||||
macos-iodbc:
|
||||
runs-on: macos-latest
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
compiler: [ clang, gcc ]
|
||||
glib: [ enable-glib, disable-glib ]
|
||||
|
||||
@ -97,6 +97,9 @@ Offset 0x14 contains the Jet version of this database:
|
||||
- 0x01 for 4
|
||||
- 0x02 for 5
|
||||
- 0x03 for Access 2010
|
||||
- 0x04 for Access 2013
|
||||
- 0x05 for Access 2016
|
||||
- 0x06 for Access 2019
|
||||
|
||||
This is used by the `mdb-ver` utility to determine the Jet version.
|
||||
|
||||
|
||||
@ -6,4 +6,7 @@ DEFDIR = $(prefix)
|
||||
EXTRA_DIST = HACKING HACKING.md libmdb.pc.in libmdbsql.pc.in README.md
|
||||
|
||||
pkgconfigdir = $(libdir)/pkgconfig
|
||||
pkgconfig_DATA = libmdb.pc libmdbsql.pc
|
||||
pkgconfig_DATA = libmdb.pc
|
||||
if SQL
|
||||
pkgconfig_DATA += libmdbsql.pc
|
||||
endif
|
||||
|
||||
25
NEWS
25
NEWS
@ -1,3 +1,28 @@
|
||||
Version 0.9.3
|
||||
=============
|
||||
|
||||
libmdb:
|
||||
* Support files created with Access 2019 #260 #277
|
||||
* Fix a warning when reading in binary property values #262
|
||||
* Fix signed-unsigned comparison warning #269
|
||||
* Migrate to `g_memdup2` #287 #288
|
||||
* Fix build when `_XOPEN_SOURCE` was already defined on the platform #298
|
||||
* Fix build failure with emscripten #299
|
||||
|
||||
libmdbsql:
|
||||
* Support negative floating point literals #274 #279
|
||||
* Improved support for file paths in `CONNECT TO` statements #275 #280 #282
|
||||
* Comparison operators behaved incorrectly when the constant was on the left #283 #285
|
||||
* Allow double quoted (") database names #291
|
||||
* Allow spaces in database names #292 #293
|
||||
|
||||
ODBC:
|
||||
* unixODBC now uses the `--libdir` passed at configure-time #261
|
||||
* Fix a segfault in PyODBC when `SQLGetTypeInfo` is called on an unsupported data type #278
|
||||
|
||||
Docs:
|
||||
* Add JET version for access 2013/2016/2019 to docs #286
|
||||
|
||||
Version 0.9.2
|
||||
=============
|
||||
|
||||
|
||||
12
configure.ac
12
configure.ac
@ -1,5 +1,5 @@
|
||||
dnl Process this file with autoconf to produce a configure script.
|
||||
AC_INIT([mdbtools],[0.9.2],[https://github.com/mdbtools/mdbtools/issues],[],[https://github.com/mdbtools/mdbtools])
|
||||
AC_INIT([mdbtools],[0.9.4-beta1],[https://github.com/mdbtools/mdbtools/issues],[],[https://github.com/mdbtools/mdbtools])
|
||||
AC_CONFIG_MACRO_DIR([m4])
|
||||
AC_CONFIG_AUX_DIR([build-aux])
|
||||
AC_CONFIG_SRCDIR(src/extras/mdb-dump.c)
|
||||
@ -7,11 +7,11 @@ AM_INIT_AUTOMAKE([foreign dist-zip])
|
||||
|
||||
MDBTOOLS_VERSION_MAJOR=0
|
||||
MDBTOOLS_VERSION_MINOR=9
|
||||
MDBTOOLS_VERSION_MICRO=2
|
||||
MDBTOOLS_VERSION_MICRO=4
|
||||
|
||||
# Update these numbers with every release
|
||||
# See https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
|
||||
VERSION_INFO=3:2:0
|
||||
VERSION_INFO=3:4:0
|
||||
AC_SUBST(VERSION_INFO)
|
||||
AC_SUBST(MDBTOOLS_CFLAGS)
|
||||
|
||||
@ -28,9 +28,7 @@ AC_PROG_LEX
|
||||
AC_PROG_YACC
|
||||
|
||||
dnl Checks for header files.
|
||||
AC_HEADER_STDC
|
||||
AC_CHECK_HEADERS(fcntl.h limits.h unistd.h xlocale.h)
|
||||
AC_CHECK_HEADERS(wordexp.h)
|
||||
AC_CHECK_LIB(mswstr, DBLCMapStringW)
|
||||
AC_CHECK_DECLS([program_invocation_short_name], [], [], [[
|
||||
#define _GNU_SOURCE
|
||||
@ -91,8 +89,6 @@ AC_SUBST(LFLAGS)
|
||||
CFLAGS="$CFLAGS -Wall -Werror"
|
||||
AS_CASE([$host],
|
||||
[*mingw*|*cygwin*], [LDFLAGS="$LDFLAGS -no-undefined"], [])
|
||||
AS_CASE([$host],
|
||||
[*mingw*], [LDFLAGS="$LDFLAGS -lWs2_32"], [])
|
||||
|
||||
dnl Fuzz testing
|
||||
|
||||
@ -216,8 +212,8 @@ if test "$enable_glib" = "yes"; then
|
||||
GLIB_PACKAGE=glib-2.0
|
||||
PKG_CHECK_MODULES([GLIB], [$GLIB_PACKAGE], HAVE_GLIB=true, HAVE_GLIB=false)
|
||||
if test "x$HAVE_GLIB" = "xtrue"; then
|
||||
MDBTOOLS_CFLAGS="$MDBTOOLS_CFLAGS -DHAVE_GLIB=1"
|
||||
GLIB_CFLAGS="$GLIB_CFLAGS -DHAVE_GLIB=1"
|
||||
AC_CHECK_LIB($GLIB_PACKAGE, g_memdup2, [GLIB_CFLAGS="$GLIB_CFLAGS -DHAVE_G_MEMDUP2=1"])
|
||||
AC_SUBST(GLIB_PACKAGE)
|
||||
else
|
||||
enable_glib=no
|
||||
|
||||
@ -26,13 +26,6 @@
|
||||
#include <inttypes.h>
|
||||
#include <strings.h>
|
||||
|
||||
// for ntohl
|
||||
#ifdef _WIN32
|
||||
#include <winsock.h>
|
||||
#else
|
||||
#include <arpa/inet.h>
|
||||
#endif
|
||||
|
||||
typedef uint16_t guint16;
|
||||
typedef uint32_t guint32;
|
||||
typedef uint64_t guint64;
|
||||
@ -132,14 +125,7 @@ typedef struct GOptionContext {
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
|
||||
#define GUINT16_FROM_LE(l) (uint16_t)l
|
||||
#define GUINT32_FROM_LE(l) (uint32_t)l
|
||||
#define GUINT64_FROM_LE(l) (uint64_t)l
|
||||
#define GINT32_FROM_LE(l) (uint32_t)l
|
||||
#define GINT32_FROM_BE(l) (int32_t)ntohl(l)
|
||||
#define GUINT32_SWAP_LE_BE(l) (uint32_t)ntohl(l)
|
||||
#define GINT32_TO_LE(l) (int32_t)l
|
||||
#define GINT32_TO_BE(l) (int32_t)ntohl(l)
|
||||
#define GUINT32_SWAP_LE_BE(l) __builtin_bswap32((uint32_t)(l))
|
||||
|
||||
/* string functions */
|
||||
void *g_memdup(const void *src, size_t len);
|
||||
|
||||
@ -16,17 +16,28 @@
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef _mdbprivate_h_
|
||||
#define _mdbprivate_h_
|
||||
#ifndef MDBPRIVATE_H
|
||||
#define MDBPRIVATE_H
|
||||
|
||||
#include "mdbtools.h"
|
||||
|
||||
/*
|
||||
* This header is for stuff lacking a MDB_ or mdb_ something, so they won't be
|
||||
* exported to calling programs.
|
||||
* This header is for stuff lacking a MDB_ or mdb_ something, or functions only
|
||||
* used within mdbtools so they won't be exported to calling programs.
|
||||
*/
|
||||
|
||||
#define _(String) (String)
|
||||
#define N_(String) String
|
||||
#define textdomain(Domain)
|
||||
#define bindtextdomain(Package, Directory)
|
||||
#ifndef HAVE_G_MEMDUP2
|
||||
#define g_memdup2 g_memdup
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void mdbi_rc4(unsigned char *key, guint32 key_len, unsigned char *buf, guint32 buf_len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -81,7 +81,8 @@ enum {
|
||||
MDB_VER_ACCDB_2007 = 0x02,
|
||||
MDB_VER_ACCDB_2010 = 0x03,
|
||||
MDB_VER_ACCDB_2013 = 0x04,
|
||||
MDB_VER_ACCDB_2016 = 0x05
|
||||
MDB_VER_ACCDB_2016 = 0x05,
|
||||
MDB_VER_ACCDB_2019 = 0x06
|
||||
};
|
||||
enum {
|
||||
MDB_FORM = 0,
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
lib_LTLIBRARIES = libmdb.la
|
||||
libmdb_la_SOURCES= catalog.c file.c table.c data.c dump.c backend.c money.c sargs.c index.c like.c write.c stats.c map.c props.c worktable.c options.c iconv.c version.c
|
||||
libmdb_la_SOURCES= catalog.c file.c table.c data.c dump.c backend.c money.c sargs.c index.c like.c write.c stats.c map.c props.c worktable.c options.c iconv.c version.c rc4.c
|
||||
libmdb_la_LDFLAGS = -version-info $(VERSION_INFO)
|
||||
if FAKE_GLIB
|
||||
libmdb_la_SOURCES += fakeglib.c
|
||||
|
||||
@ -463,10 +463,8 @@ int mdb_set_default_backend(MdbHandle *mdb, const char *backend_name)
|
||||
} else {
|
||||
mdb_set_shortdate_fmt(mdb, "%x");
|
||||
}
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
return (backend != NULL);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -18,7 +18,6 @@
|
||||
|
||||
#include "mdbtools.h"
|
||||
|
||||
#define _XOPEN_SOURCE
|
||||
#include <time.h>
|
||||
|
||||
#define OFFSET_MASK 0x1fff
|
||||
@ -464,6 +463,8 @@ mdb_fetch_row(MdbTableDef *table)
|
||||
do {
|
||||
if (table->is_temp_table) {
|
||||
GPtrArray *pages = table->temp_table_pages;
|
||||
if (pages->len == 0)
|
||||
return 0;
|
||||
rows = mdb_get_int16(
|
||||
g_ptr_array_index(pages, table->cur_pg_num-1),
|
||||
fmt->row_count_offset);
|
||||
|
||||
@ -20,6 +20,7 @@
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <inttypes.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
void mdb_buffer_dump(const void* buf, off_t start, size_t len)
|
||||
{
|
||||
|
||||
@ -19,6 +19,7 @@
|
||||
#include <inttypes.h>
|
||||
#include <stddef.h>
|
||||
#include "mdbtools.h"
|
||||
#include "mdbprivate.h"
|
||||
|
||||
MdbFormatConstants MdbJet4Constants = {
|
||||
.pg_size = 4096,
|
||||
@ -65,69 +66,8 @@ MdbFormatConstants MdbJet3Constants = {
|
||||
.tab_row_col_num_offset = 5
|
||||
};
|
||||
|
||||
typedef struct _RC4_KEY
|
||||
{
|
||||
unsigned char state[256];
|
||||
unsigned char x;
|
||||
unsigned char y;
|
||||
} RC4_KEY;
|
||||
|
||||
#define swap_byte(x,y) t = *(x); *(x) = *(y); *(y) = t
|
||||
|
||||
static ssize_t _mdb_read_pg(MdbHandle *mdb, void *pg_buf, unsigned long pg);
|
||||
|
||||
static void RC4_set_key(RC4_KEY *key, int key_data_len, unsigned char *key_data_ptr)
|
||||
{
|
||||
unsigned char t;
|
||||
unsigned char index1;
|
||||
unsigned char index2;
|
||||
unsigned char* state;
|
||||
short counter;
|
||||
|
||||
state = &key->state[0];
|
||||
for(counter = 0; counter < 256; counter++)
|
||||
state[counter] = counter;
|
||||
key->x = 0;
|
||||
key->y = 0;
|
||||
index1 = 0;
|
||||
index2 = 0;
|
||||
for(counter = 0; counter < 256; counter++) {
|
||||
index2 = (key_data_ptr[index1] + state[counter] + index2) % 256;
|
||||
swap_byte(&state[counter], &state[index2]);
|
||||
index1 = (index1 + 1) % key_data_len;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* this algorithm does 'encrypt in place' instead of inbuff/outbuff
|
||||
* note also: encryption and decryption use same routine
|
||||
* implementation supplied by (Adam Back) at <adam at cypherspace dot org>
|
||||
*/
|
||||
|
||||
static void RC4(RC4_KEY *key, int buffer_len, unsigned char * buff)
|
||||
{
|
||||
unsigned char t;
|
||||
unsigned char x;
|
||||
unsigned char y;
|
||||
unsigned char* state;
|
||||
unsigned char xorIndex;
|
||||
short counter;
|
||||
|
||||
x = key->x;
|
||||
y = key->y;
|
||||
state = &key->state[0];
|
||||
for(counter = 0; counter < buffer_len; counter++) {
|
||||
x = (x + 1) % 256;
|
||||
y = (state[x] + y) % 256;
|
||||
swap_byte(&state[x], &state[y]);
|
||||
xorIndex = (state[x] + state[y]) % 256;
|
||||
buff[counter] ^= state[xorIndex];
|
||||
}
|
||||
key->x = x;
|
||||
key->y = y;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* mdb_find_file:
|
||||
* @filename: path to MDB (database) file
|
||||
@ -222,6 +162,7 @@ static MdbHandle *mdb_handle_from_stream(FILE *stream, MdbFileFlags flags) {
|
||||
case MDB_VER_ACCDB_2010:
|
||||
case MDB_VER_ACCDB_2013:
|
||||
case MDB_VER_ACCDB_2016:
|
||||
case MDB_VER_ACCDB_2019:
|
||||
mdb->fmt = &MdbJet4Constants;
|
||||
break;
|
||||
default:
|
||||
@ -230,10 +171,11 @@ static MdbHandle *mdb_handle_from_stream(FILE *stream, MdbFileFlags flags) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
RC4_KEY rc4_key;
|
||||
unsigned int tmp_key = 0x6b39dac7;
|
||||
RC4_set_key(&rc4_key, 4, (unsigned char *)&tmp_key);
|
||||
RC4(&rc4_key, mdb->f->jet_version == MDB_VER_JET3 ? 126 : 128, mdb->pg_buf + 0x18);
|
||||
unsigned char tmp_key[4] = { 0xC7, 0xDA, 0x39, 0x6B };
|
||||
mdbi_rc4(tmp_key, sizeof(tmp_key),
|
||||
mdb->pg_buf + 0x18,
|
||||
mdb->f->jet_version == MDB_VER_JET3 ? 126 : 128
|
||||
);
|
||||
|
||||
if (mdb->f->jet_version == MDB_VER_JET3) {
|
||||
mdb->f->lang_id = mdb_get_int16(mdb->pg_buf, 0x3a);
|
||||
@ -247,8 +189,6 @@ static MdbHandle *mdb_handle_from_stream(FILE *stream, MdbFileFlags flags) {
|
||||
/* Bug - JET3 supports 20 byte passwords, this is currently just 14 bytes */
|
||||
memcpy(mdb->f->db_passwd, mdb->pg_buf + 0x42, sizeof(mdb->f->db_passwd));
|
||||
}
|
||||
/* write is not supported for encrypted files yet */
|
||||
mdb->f->writable = mdb->f->writable && !mdb->f->db_key;
|
||||
|
||||
mdb_iconv_init(mdb);
|
||||
|
||||
@ -359,14 +299,14 @@ MdbHandle *mdb_clone_handle(MdbHandle *mdb)
|
||||
MdbCatalogEntry *entry, *data;
|
||||
unsigned int i;
|
||||
|
||||
newmdb = (MdbHandle *) g_memdup(mdb, sizeof(MdbHandle));
|
||||
newmdb = (MdbHandle *) g_memdup2(mdb, sizeof(MdbHandle));
|
||||
|
||||
memset(&newmdb->catalog, 0, sizeof(MdbHandle) - offsetof(MdbHandle, catalog));
|
||||
|
||||
newmdb->catalog = g_ptr_array_new();
|
||||
for (i=0;i<mdb->num_catalog;i++) {
|
||||
entry = g_ptr_array_index(mdb->catalog,i);
|
||||
data = g_memdup(entry,sizeof(MdbCatalogEntry));
|
||||
data = g_memdup2(entry,sizeof(MdbCatalogEntry));
|
||||
data->mdb = newmdb;
|
||||
data->props = NULL;
|
||||
g_ptr_array_add(newmdb->catalog, data);
|
||||
@ -434,10 +374,11 @@ static ssize_t _mdb_read_pg(MdbHandle *mdb, void *pg_buf, unsigned long pg)
|
||||
*/
|
||||
if (pg != 0 && mdb->f->db_key != 0)
|
||||
{
|
||||
RC4_KEY rc4_key;
|
||||
unsigned int tmp_key = mdb->f->db_key ^ pg;
|
||||
RC4_set_key(&rc4_key, 4, (unsigned char *)&tmp_key);
|
||||
RC4(&rc4_key, mdb->fmt->pg_size, pg_buf);
|
||||
guint32 tmp_key_i = mdb->f->db_key ^ pg;
|
||||
unsigned char tmp_key[4] = {
|
||||
tmp_key_i & 0xFF, (tmp_key_i >> 8) & 0xFF,
|
||||
(tmp_key_i >> 16) & 0xFF, (tmp_key_i >> 24) & 0xFF };
|
||||
mdbi_rc4(tmp_key, sizeof(tmp_key), pg_buf, mdb->fmt->pg_size);
|
||||
}
|
||||
|
||||
return mdb->fmt->pg_size;
|
||||
@ -465,9 +406,8 @@ unsigned char mdb_pg_get_byte(MdbHandle *mdb, int offset)
|
||||
|
||||
int mdb_get_int16(void *buf, int offset)
|
||||
{
|
||||
guint16 l;
|
||||
memcpy(&l, (char*)buf + offset, 2);
|
||||
return (int)GUINT16_FROM_LE(l);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
return u8_buf[0] + (u8_buf[1] << 8);
|
||||
}
|
||||
int mdb_pg_get_int16(MdbHandle *mdb, int offset)
|
||||
{
|
||||
@ -478,15 +418,13 @@ int mdb_pg_get_int16(MdbHandle *mdb, int offset)
|
||||
|
||||
long mdb_get_int32_msb(void *buf, int offset)
|
||||
{
|
||||
gint32 l;
|
||||
memcpy(&l, (char*)buf + offset, 4);
|
||||
return (long)GINT32_FROM_BE(l);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
return (u8_buf[0] << 24) + (u8_buf[1] << 16) + (u8_buf[2] << 8) + u8_buf[3];
|
||||
}
|
||||
long mdb_get_int32(void *buf, int offset)
|
||||
{
|
||||
gint32 l;
|
||||
memcpy(&l, (char*)buf + offset, 4);
|
||||
return (long)GINT32_FROM_LE(l);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
return u8_buf[0] + (u8_buf[1] << 8) + (u8_buf[2] << 16) + (u8_buf[3] << 24);
|
||||
}
|
||||
long mdb_pg_get_int32(MdbHandle *mdb, int offset)
|
||||
{
|
||||
@ -498,8 +436,8 @@ long mdb_pg_get_int32(MdbHandle *mdb, int offset)
|
||||
float mdb_get_single(void *buf, int offset)
|
||||
{
|
||||
union {guint32 g; float f;} f;
|
||||
memcpy(&f, (char*)buf + offset, 4);
|
||||
f.g = GUINT32_FROM_LE(f.g);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
f.g = u8_buf[0] + (u8_buf[1] << 8) + (u8_buf[2] << 16) + (u8_buf[3] << 24);
|
||||
return f.f;
|
||||
}
|
||||
float mdb_pg_get_single(MdbHandle *mdb, int offset)
|
||||
@ -512,8 +450,10 @@ float mdb_pg_get_single(MdbHandle *mdb, int offset)
|
||||
double mdb_get_double(void *buf, int offset)
|
||||
{
|
||||
union {guint64 g; double d;} d;
|
||||
memcpy(&d, (char*)buf + offset, 8);
|
||||
d.g = GUINT64_FROM_LE(d.g);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
d.g = u8_buf[0] + (u8_buf[1] << 8) + (u8_buf[2] << 16) + (u8_buf[3] << 24) +
|
||||
((guint64)u8_buf[4] << 32) + ((guint64)u8_buf[5] << 40) +
|
||||
((guint64)u8_buf[6] << 48) + ((guint64)u8_buf[7] << 56);
|
||||
return d.d;
|
||||
}
|
||||
double mdb_pg_get_double(MdbHandle *mdb, int offset)
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
*/
|
||||
|
||||
#include "mdbtools.h"
|
||||
#include "mdbprivate.h"
|
||||
#ifdef HAVE_LIBMSWSTR
|
||||
#include <mswstr/mswstr.h>
|
||||
#endif
|
||||
@ -524,7 +525,7 @@ mdb_index_test_sargs(MdbHandle *mdb, MdbIndex *idx, char *buf, int len)
|
||||
col->idx_sarg_cache = g_ptr_array_new();
|
||||
for (j=0;j<col->num_sargs;j++) {
|
||||
sarg = g_ptr_array_index (col->sargs, j);
|
||||
idx_sarg = g_memdup(sarg,sizeof(MdbSarg));
|
||||
idx_sarg = g_memdup2(sarg,sizeof(MdbSarg));
|
||||
//printf("calling mdb_index_cache_sarg\n");
|
||||
mdb_index_cache_sarg(col, sarg, idx_sarg);
|
||||
g_ptr_array_add(col->idx_sarg_cache, idx_sarg);
|
||||
|
||||
@ -50,12 +50,11 @@ mdb_read_props_list(MdbHandle *mdb, gchar *kkd, int len)
|
||||
}
|
||||
return names;
|
||||
}
|
||||
static gboolean
|
||||
static void
|
||||
free_hash_entry(gpointer key, gpointer value, gpointer user_data)
|
||||
{
|
||||
g_free(key);
|
||||
g_free(value);
|
||||
return TRUE;
|
||||
}
|
||||
void
|
||||
mdb_free_props(MdbProperties *props)
|
||||
@ -64,15 +63,20 @@ mdb_free_props(MdbProperties *props)
|
||||
|
||||
if (props->name) g_free(props->name);
|
||||
if (props->hash) {
|
||||
g_hash_table_foreach(props->hash, (GHFunc)free_hash_entry, 0);
|
||||
g_hash_table_foreach(props->hash, free_hash_entry, 0);
|
||||
g_hash_table_destroy(props->hash);
|
||||
}
|
||||
g_free(props);
|
||||
}
|
||||
|
||||
static void
|
||||
do_g_free(gpointer ptr, gpointer user_data) {
|
||||
g_free(ptr);
|
||||
}
|
||||
|
||||
static void
|
||||
free_names(GPtrArray *names) {
|
||||
g_ptr_array_foreach(names, (GFunc)g_free, NULL);
|
||||
g_ptr_array_foreach(names, do_g_free, NULL);
|
||||
g_ptr_array_free(names, TRUE);
|
||||
}
|
||||
MdbProperties *
|
||||
@ -118,7 +122,7 @@ mdb_read_props(MdbHandle *mdb, GPtrArray *names, gchar *kkd, int len)
|
||||
record_len = mdb_get_int16(kkd, pos);
|
||||
dtype = kkd[pos + 3];
|
||||
elem = mdb_get_int16(kkd, pos + 4);
|
||||
if (elem < 0 || elem >= names->len)
|
||||
if (elem >= names->len)
|
||||
break;
|
||||
dsize = mdb_get_int16(kkd, pos + 6);
|
||||
if (dsize < 0 || pos + 8 + dsize > len)
|
||||
|
||||
85
src/libmdb/rc4.c
Normal file
85
src/libmdb/rc4.c
Normal file
@ -0,0 +1,85 @@
|
||||
/* MDB Tools - A library for reading MS Access database files
|
||||
* Copyright (C) 2000 Brian Bruns
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include "mdbprivate.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned char state[256];
|
||||
unsigned char x;
|
||||
unsigned char y;
|
||||
} RC4_KEY;
|
||||
|
||||
#define swap_byte(x,y) t = *(x); *(x) = *(y); *(y) = t
|
||||
|
||||
|
||||
static void RC4_set_key(RC4_KEY *key, int key_data_len, unsigned char *key_data_ptr)
|
||||
{
|
||||
unsigned char t;
|
||||
unsigned char index1;
|
||||
unsigned char index2;
|
||||
unsigned char* state;
|
||||
short counter;
|
||||
|
||||
state = &key->state[0];
|
||||
for(counter = 0; counter < 256; counter++)
|
||||
state[counter] = counter;
|
||||
key->x = 0;
|
||||
key->y = 0;
|
||||
index1 = 0;
|
||||
index2 = 0;
|
||||
for(counter = 0; counter < 256; counter++) {
|
||||
index2 = (key_data_ptr[index1] + state[counter] + index2) % 256;
|
||||
swap_byte(&state[counter], &state[index2]);
|
||||
index1 = (index1 + 1) % key_data_len;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* this algorithm does 'encrypt in place' instead of inbuff/outbuff
|
||||
* note also: encryption and decryption use same routine
|
||||
* implementation supplied by (Adam Back) at <adam at cypherspace dot org>
|
||||
*/
|
||||
static void RC4(RC4_KEY *key, int buffer_len, unsigned char * buff)
|
||||
{
|
||||
unsigned char t;
|
||||
unsigned char x;
|
||||
unsigned char y;
|
||||
unsigned char* state;
|
||||
unsigned char xorIndex;
|
||||
short counter;
|
||||
|
||||
x = key->x;
|
||||
y = key->y;
|
||||
state = &key->state[0];
|
||||
for(counter = 0; counter < buffer_len; counter++) {
|
||||
x = (x + 1) % 256;
|
||||
y = (state[x] + y) % 256;
|
||||
swap_byte(&state[x], &state[y]);
|
||||
xorIndex = (state[x] + state[y]) % 256;
|
||||
buff[counter] ^= state[xorIndex];
|
||||
}
|
||||
key->x = x;
|
||||
key->y = y;
|
||||
}
|
||||
|
||||
void mdbi_rc4(unsigned char *key, guint32 key_len, unsigned char *buf, guint32 buf_len) {
|
||||
RC4_KEY rc4_key;
|
||||
RC4_set_key(&rc4_key, key_len, key);
|
||||
RC4(&rc4_key, buf_len, buf);
|
||||
}
|
||||
@ -29,6 +29,7 @@
|
||||
|
||||
#include <time.h>
|
||||
#include "mdbtools.h"
|
||||
#include "mdbprivate.h"
|
||||
|
||||
void
|
||||
mdb_sql_walk_tree(MdbSargNode *node, MdbSargTreeFunc func, gpointer data)
|
||||
@ -338,7 +339,7 @@ MdbSarg *sarg;
|
||||
if (!col->sargs) {
|
||||
col->sargs = g_ptr_array_new();
|
||||
}
|
||||
sarg = g_memdup(in_sarg,sizeof(MdbSarg));
|
||||
sarg = g_memdup2(in_sarg,sizeof(MdbSarg));
|
||||
g_ptr_array_add(col->sargs, sarg);
|
||||
col->num_sargs++;
|
||||
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
*/
|
||||
|
||||
#include "mdbtools.h"
|
||||
#include "mdbprivate.h"
|
||||
|
||||
static gint mdb_col_comparer(MdbColumn **a, MdbColumn **b)
|
||||
{
|
||||
@ -91,7 +92,7 @@ MdbTableDef *mdb_read_table(MdbCatalogEntry *entry)
|
||||
mdb_free_tabledef(table);
|
||||
return NULL;
|
||||
}
|
||||
table->usage_map = g_memdup((char*)buf + row_start, table->map_sz);
|
||||
table->usage_map = g_memdup2((char*)buf + row_start, table->map_sz);
|
||||
if (mdb_get_option(MDB_DEBUG_USAGE))
|
||||
mdb_buffer_dump(buf, row_start, table->map_sz);
|
||||
mdb_debug(MDB_DEBUG_USAGE,"usage map found on page %ld row %d start %d len %d",
|
||||
@ -104,7 +105,7 @@ MdbTableDef *mdb_read_table(MdbCatalogEntry *entry)
|
||||
mdb_free_tabledef(table);
|
||||
return NULL;
|
||||
}
|
||||
table->free_usage_map = g_memdup((char*)buf + row_start, table->freemap_sz);
|
||||
table->free_usage_map = g_memdup2((char*)buf + row_start, table->freemap_sz);
|
||||
mdb_debug(MDB_DEBUG_USAGE,"free map found on page %ld row %d start %d len %d\n",
|
||||
pg_row >> 8, pg_row & 0xff, row_start, table->freemap_sz);
|
||||
|
||||
@ -207,7 +208,7 @@ read_pg_if_n(MdbHandle *mdb, void *buf, int *cur_pos, size_t len)
|
||||
|
||||
void mdb_append_column(GPtrArray *columns, MdbColumn *in_col)
|
||||
{
|
||||
g_ptr_array_add(columns, g_memdup(in_col,sizeof(MdbColumn)));
|
||||
g_ptr_array_add(columns, g_memdup2(in_col,sizeof(MdbColumn)));
|
||||
}
|
||||
void mdb_free_columns(GPtrArray *columns)
|
||||
{
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
*/
|
||||
|
||||
#include "mdbtools.h"
|
||||
#include "mdbprivate.h"
|
||||
|
||||
/*
|
||||
* Temp table routines. These are currently used to generate mock results for
|
||||
@ -73,7 +74,7 @@ mdb_temp_table_add_col(MdbTableDef *table, MdbColumn *col)
|
||||
col->col_num = table->num_cols;
|
||||
if (!col->is_fixed)
|
||||
col->var_col_num = table->num_var_cols++;
|
||||
g_ptr_array_add(table->columns, g_memdup(col, sizeof(MdbColumn)));
|
||||
g_ptr_array_add(table->columns, g_memdup2(col, sizeof(MdbColumn)));
|
||||
table->num_cols++;
|
||||
}
|
||||
/*
|
||||
|
||||
@ -18,7 +18,7 @@
|
||||
|
||||
#include <time.h>
|
||||
#include <inttypes.h>
|
||||
#include "mdbtools.h"
|
||||
#include "mdbprivate.h"
|
||||
|
||||
//static int mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg);
|
||||
static int mdb_add_row_to_leaf_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg, MdbField *idx_fields, guint32 pgnum, guint16 rownum);
|
||||
@ -26,8 +26,9 @@ static int mdb_add_row_to_leaf_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPag
|
||||
void
|
||||
mdb_put_int16(void *buf, guint32 offset, guint32 value)
|
||||
{
|
||||
value = GINT32_TO_LE(value);
|
||||
memcpy((char*)buf + offset, &value, 2);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
u8_buf[0] = (value & 0xFF);
|
||||
u8_buf[1] = (value >> 8) & 0xFF;
|
||||
}
|
||||
void
|
||||
_mdb_put_int16(void *buf, guint32 offset, guint32 value)
|
||||
@ -40,8 +41,11 @@ __attribute__((alias("mdb_put_int16")));
|
||||
void
|
||||
mdb_put_int32(void *buf, guint32 offset, guint32 value)
|
||||
{
|
||||
value = GINT32_TO_LE(value);
|
||||
memcpy((char*)buf + offset, &value, 4);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
u8_buf[0] = (value & 0xFF);
|
||||
u8_buf[1] = (value >> 8) & 0xFF;
|
||||
u8_buf[2] = (value >> 16) & 0xFF;
|
||||
u8_buf[3] = (value >> 24) & 0xFF;
|
||||
}
|
||||
void
|
||||
_mdb_put_int32(void *buf, guint32 offset, guint32 value)
|
||||
@ -54,8 +58,11 @@ __attribute__((alias("mdb_put_int32")));
|
||||
void
|
||||
mdb_put_int32_msb(void *buf, guint32 offset, guint32 value)
|
||||
{
|
||||
value = GINT32_TO_BE(value);
|
||||
memcpy((char*)buf + offset, &value, 4);
|
||||
unsigned char *u8_buf = (unsigned char *)buf + offset;
|
||||
u8_buf[3] = (value & 0xFF);
|
||||
u8_buf[2] = (value >> 8) & 0xFF;
|
||||
u8_buf[1] = (value >> 16) & 0xFF;
|
||||
u8_buf[0] = (value >> 24) & 0xFF;
|
||||
}
|
||||
void
|
||||
_mdb_put_int32_mdb(void *buf, guint32 offset, guint32 value)
|
||||
@ -70,6 +77,7 @@ mdb_write_pg(MdbHandle *mdb, unsigned long pg)
|
||||
{
|
||||
ssize_t len;
|
||||
off_t offset = pg * mdb->fmt->pg_size;
|
||||
unsigned char *buf = mdb->pg_buf;
|
||||
|
||||
fseeko(mdb->f->stream, 0, SEEK_END);
|
||||
/* is page beyond current size + 1 ? */
|
||||
@ -78,7 +86,20 @@ mdb_write_pg(MdbHandle *mdb, unsigned long pg)
|
||||
return 0;
|
||||
}
|
||||
fseeko(mdb->f->stream, offset, SEEK_SET);
|
||||
len = fwrite(mdb->pg_buf, 1, mdb->fmt->pg_size, mdb->f->stream);
|
||||
|
||||
if (pg != 0 && mdb->f->db_key != 0)
|
||||
{
|
||||
buf = g_memdup2(mdb->pg_buf, mdb->fmt->pg_size);
|
||||
unsigned int tmp_key = mdb->f->db_key ^ pg;
|
||||
mdbi_rc4((unsigned char*)&tmp_key, 4, buf, mdb->fmt->pg_size);
|
||||
}
|
||||
|
||||
len = fwrite(buf, 1, mdb->fmt->pg_size, mdb->f->stream);
|
||||
|
||||
if (buf != mdb->pg_buf) {
|
||||
g_free(buf);
|
||||
}
|
||||
|
||||
if (ferror(mdb->f->stream)) {
|
||||
perror("write");
|
||||
return 0;
|
||||
|
||||
@ -979,12 +979,13 @@ SQLRETURN SQL_API SQLErrorW(
|
||||
result = SQLError(henv, hdbc, hstmt, szSqlState8, pfNativeError, szErrorMsg8, 3*cbErrorMsgMax+1, &pcbErrorMsg8);
|
||||
if (result == SQL_SUCCESS) {
|
||||
struct _hdbc *dbc = hstmt ? ((struct _hstmt *)hstmt)->hdbc : hdbc;
|
||||
size_t l=6, z=6*sizeof(SQLWCHAR);
|
||||
ascii2unicode(dbc, (char*)szSqlState8, &l, (char*)szSqlState, &z);
|
||||
l = cbErrorMsgMax;
|
||||
ascii2unicode(dbc, (char*)szErrorMsg8, (size_t*)&pcbErrorMsg8, (char*)szErrorMsg, &l);
|
||||
size_t lin=6, lout=6*sizeof(SQLWCHAR);
|
||||
ascii2unicode(dbc, (char*)szSqlState8, &lin, (char*)szSqlState, &lout);
|
||||
lin = pcbErrorMsg8;
|
||||
lout = cbErrorMsgMax;
|
||||
ascii2unicode(dbc, (char*)szErrorMsg8, &lin, (char*)szErrorMsg, &lout);
|
||||
if (pcbErrorMsg)
|
||||
*pcbErrorMsg = l;
|
||||
*pcbErrorMsg = lout;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -74,8 +74,8 @@ like { return LIKE; }
|
||||
limit { return LIMIT; }
|
||||
top { return TOP; }
|
||||
percent { return PERCENT; }
|
||||
count { return COUNT; }
|
||||
strptime { return STRPTIME; }
|
||||
count\( { return COUNT; }
|
||||
strptime\( { return STRPTIME; }
|
||||
[ \t\r] ;
|
||||
|
||||
\"[^"]*\"\" {
|
||||
@ -98,6 +98,8 @@ strptime { return STRPTIME; }
|
||||
return IDENT;
|
||||
}
|
||||
|
||||
\[[^\]]+\] { yylval->name = g_strndup(yytext+1, yyleng-2); return NAME; }
|
||||
|
||||
[a-z\xa0-\xff][a-z0-9_#@\xa0-\xff]* { yylval->name = g_strdup(yytext); return NAME; }
|
||||
|
||||
'[^']*'' {
|
||||
@ -109,10 +111,17 @@ strptime { return STRPTIME; }
|
||||
return STRING;
|
||||
}
|
||||
|
||||
(-*[0-9]+|([0-9]*\.[0-9]+)(e[-+]?[0-9]+)?) {
|
||||
(-?[0-9]+|(-?[0-9]*\.[0-9]+)(e[-+]?[0-9]+)?) {
|
||||
yylval->name = g_strdup(yytext); return NUMBER;
|
||||
}
|
||||
~?(\/?[a-z0-9\.\xa0-\xff]+)+ {
|
||||
~?(\/?[a-z0-9\.\-\_\!\~\'\(\)\%\xa0-\xff]+)+ {
|
||||
if (yytext[0] == ')' && strlen(yytext) == 1) {
|
||||
return CLOSING;
|
||||
}
|
||||
|
||||
if (yytext[0] == '(' && strlen(yytext) == 1) {
|
||||
return OPENING;
|
||||
}
|
||||
yylval->name = g_strdup(yytext); return PATH;
|
||||
}
|
||||
|
||||
|
||||
@ -17,13 +17,10 @@
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
#define _XOPEN_SOURCE
|
||||
#include "mdbsql.h"
|
||||
|
||||
#ifdef HAVE_WORDEXP_H
|
||||
#define HAVE_WORDEXP
|
||||
#include <wordexp.h>
|
||||
#ifndef _XOPEN_SOURCE
|
||||
#define _XOPEN_SOURCE 600
|
||||
#endif
|
||||
#include "mdbsql.h"
|
||||
|
||||
#ifdef HAVE_STRPTIME
|
||||
#include <time.h>
|
||||
@ -191,35 +188,9 @@ mdb_sql_close(MdbSQL *sql)
|
||||
|
||||
MdbHandle *mdb_sql_open(MdbSQL *sql, char *db_name)
|
||||
{
|
||||
char *db_namep = db_name;
|
||||
|
||||
#ifdef HAVE_WORDEXP
|
||||
wordexp_t words;
|
||||
int need_free_words = 0;
|
||||
|
||||
switch (wordexp(db_name, &words, 0))
|
||||
{
|
||||
case 0:
|
||||
if (words.we_wordc>0)
|
||||
{
|
||||
db_namep = words.we_wordv[0];
|
||||
}
|
||||
need_free_words = 1;
|
||||
break;
|
||||
case WRDE_NOSPACE:
|
||||
// If the error was WRDE_NOSPACE, then perhaps part of the result was allocated.
|
||||
need_free_words = 1;
|
||||
break;
|
||||
default:
|
||||
// Some other error
|
||||
need_free_words = 0;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
sql->mdb = mdb_open(db_namep, MDB_NOFLAGS);
|
||||
if ((!sql->mdb) && (!strstr(db_namep, ".mdb"))) {
|
||||
char *tmpstr = (char *) g_strconcat(db_namep, ".mdb", NULL);
|
||||
sql->mdb = mdb_open(db_name, MDB_NOFLAGS);
|
||||
if ((!sql->mdb) && (!strstr(db_name, ".mdb"))) {
|
||||
char *tmpstr = g_strconcat(db_name, ".mdb", NULL);
|
||||
sql->mdb = mdb_open(tmpstr, MDB_NOFLAGS);
|
||||
g_free(tmpstr);
|
||||
}
|
||||
@ -227,13 +198,6 @@ MdbHandle *mdb_sql_open(MdbSQL *sql, char *db_name)
|
||||
mdb_sql_error(sql, "Unable to locate database %s", db_name);
|
||||
}
|
||||
|
||||
#ifdef HAVE_WORDEXP
|
||||
if ( need_free_words )
|
||||
{
|
||||
wordfree(&words);
|
||||
}
|
||||
#endif
|
||||
|
||||
return sql->mdb;
|
||||
}
|
||||
static MdbSargNode *
|
||||
|
||||
@ -60,7 +60,7 @@ typedef struct sql_context
|
||||
|
||||
%start stmt
|
||||
|
||||
%token <name> IDENT NAME PATH STRING NUMBER
|
||||
%token <name> IDENT NAME PATH STRING NUMBER OPENING CLOSING
|
||||
%token SELECT FROM WHERE CONNECT DISCONNECT TO LIST TABLES AND OR NOT LIMIT COUNT STRPTIME
|
||||
%token DESCRIBE TABLE TOP PERCENT
|
||||
%token LTEQ GTEQ LIKE IS NUL
|
||||
@ -138,7 +138,7 @@ limit_clause:
|
||||
|
||||
sarg_list:
|
||||
sarg
|
||||
| '(' sarg_list ')'
|
||||
| OPENING sarg_list CLOSING
|
||||
| NOT sarg_list { mdb_sql_add_not(parser_ctx->mdb); }
|
||||
| sarg_list OR sarg_list { mdb_sql_add_or(parser_ctx->mdb); }
|
||||
| sarg_list AND sarg_list { mdb_sql_add_and(parser_ctx->mdb); }
|
||||
@ -151,6 +151,21 @@ sarg:
|
||||
free($3);
|
||||
}
|
||||
| constant operator identifier {
|
||||
switch($2) {
|
||||
case MDB_GT:
|
||||
$2 = MDB_LT;
|
||||
break;
|
||||
case MDB_LT:
|
||||
$2 = MDB_GT;
|
||||
break;
|
||||
case MDB_GTEQ:
|
||||
$2 = MDB_LTEQ;
|
||||
break;
|
||||
case MDB_LTEQ:
|
||||
$2 = MDB_GTEQ;
|
||||
break;
|
||||
}
|
||||
|
||||
mdb_sql_add_sarg(parser_ctx->mdb, $3, $2, $1);
|
||||
free($1);
|
||||
free($3);
|
||||
@ -186,10 +201,10 @@ nulloperator:
|
||||
;
|
||||
|
||||
constant:
|
||||
STRPTIME '(' constant ',' constant ')' {
|
||||
$$ = mdb_sql_strptime(parser_ctx->mdb, $3, $5);
|
||||
free($3);
|
||||
free($5);
|
||||
STRPTIME constant ',' constant CLOSING {
|
||||
$$ = mdb_sql_strptime(parser_ctx->mdb, $2, $4);
|
||||
free($2);
|
||||
free($4);
|
||||
}
|
||||
| NUMBER { $$ = $1; }
|
||||
| STRING { $$ = $1; }
|
||||
@ -197,7 +212,8 @@ constant:
|
||||
|
||||
database:
|
||||
PATH
|
||||
| NAME
|
||||
| NAME
|
||||
| IDENT
|
||||
;
|
||||
|
||||
table:
|
||||
@ -205,7 +221,7 @@ table:
|
||||
;
|
||||
|
||||
column_list:
|
||||
COUNT '(' '*' ')' { mdb_sql_sel_count(parser_ctx->mdb); }
|
||||
COUNT '*' CLOSING { mdb_sql_sel_count(parser_ctx->mdb); }
|
||||
| '*' { mdb_sql_all_columns(parser_ctx->mdb); }
|
||||
| column
|
||||
| column ',' column_list
|
||||
|
||||
@ -182,12 +182,10 @@ int main (int argc, char **argv) {
|
||||
}
|
||||
break;
|
||||
case 5: // table name
|
||||
if(strcmp(sql_tables,"") == 0) {
|
||||
strcpy(sql_tables,name1);
|
||||
} else {
|
||||
if(strcmp(sql_tables,"") != 0) {
|
||||
strcat(sql_tables,",");
|
||||
strcat(sql_tables,name1);
|
||||
}
|
||||
sprintf(sql_tables+strlen(sql_tables),"[%s]",name1);
|
||||
break;
|
||||
case 6: // column name
|
||||
if(strcmp(sql_columns,"") == 0) {
|
||||
|
||||
@ -18,7 +18,6 @@
|
||||
|
||||
#include "mdbtools.h"
|
||||
#include "mdbver.h"
|
||||
#include "mdbprivate.h"
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
@ -58,7 +57,7 @@ main(int argc, char **argv)
|
||||
}
|
||||
|
||||
if (!(mdb = mdb_open(argv[1], MDB_NOFLAGS))) {
|
||||
fprintf(stderr,_("Error: unable to open file %s\n"), argv[1]);
|
||||
fprintf(stderr,"Error: unable to open file %s\n", argv[1]);
|
||||
exit(1);
|
||||
}
|
||||
switch(mdb->f->jet_version) {
|
||||
@ -80,8 +79,11 @@ main(int argc, char **argv)
|
||||
case MDB_VER_ACCDB_2016:
|
||||
printf("ACE16\n");
|
||||
break;
|
||||
case MDB_VER_ACCDB_2019:
|
||||
printf("ACE17\n");
|
||||
break;
|
||||
default:
|
||||
printf(_("unknown database version\n"));
|
||||
printf("unknown database version\n");
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user