sqlcipher/src/test_init.c at Xcode5 · securitykernel/sqlcipher · GitHub

History

292 lines (267 loc) · 8.32 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

** 2009 August 17

** 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.

*************************************************************************

** The code in this file is used for testing SQLite. It is not part of

** the source code used in production systems.

** Specifically, this file tests the effect of errors while initializing

** the various pluggable sub-systems from within sqlite3_initialize().

** If an error occurs in sqlite3_initialize() the following should be

** true:

** 1) An error code is returned to the user, and

** 2) A subsequent call to sqlite3_shutdown() calls the shutdown method

** of those subsystems that were initialized, and

** 3) A subsequent call to sqlite3_initialize() attempts to initialize

** the remaining, uninitialized, subsystems.

#include "sqliteInt.h"

#include <string.h>

#include <tcl.h>

static struct Wrapped {

sqlite3_pcache_methods2 pcache;

sqlite3_mem_methods mem;

sqlite3_mutex_methods mutex;

int mem_init; /* True if mem subsystem is initalized */

int mem_fail; /* True to fail mem subsystem inialization */

int mutex_init; /* True if mutex subsystem is initalized */

int mutex_fail; /* True to fail mutex subsystem inialization */

int pcache_init; /* True if pcache subsystem is initalized */

int pcache_fail; /* True to fail pcache subsystem inialization */

} wrapped;

static int wrMemInit(void *pAppData){

int rc;

if( wrapped.mem_fail ){

rc = SQLITE_ERROR;

}else{

rc = wrapped.mem.xInit(wrapped.mem.pAppData);

}

if( rc==SQLITE_OK ){

wrapped.mem_init = 1;

}

return rc;

}

static void wrMemShutdown(void *pAppData){

wrapped.mem.xShutdown(wrapped.mem.pAppData);

wrapped.mem_init = 0;

}

static void *wrMemMalloc(int n) {return wrapped.mem.xMalloc(n);}

static void wrMemFree(void *p) {wrapped.mem.xFree(p);}

static void *wrMemRealloc(void *p, int n) {return wrapped.mem.xRealloc(p, n);}

static int wrMemSize(void *p) {return wrapped.mem.xSize(p);}

static int wrMemRoundup(int n) {return wrapped.mem.xRoundup(n);}

static int wrMutexInit(void){

int rc;

if( wrapped.mutex_fail ){

rc = SQLITE_ERROR;

}else{

rc = wrapped.mutex.xMutexInit();

}

if( rc==SQLITE_OK ){

wrapped.mutex_init = 1;

}

return rc;

}

static int wrMutexEnd(void){

wrapped.mutex.xMutexEnd();

wrapped.mutex_init = 0;

return SQLITE_OK;

}

static sqlite3_mutex *wrMutexAlloc(int e){

return wrapped.mutex.xMutexAlloc(e);

}

static void wrMutexFree(sqlite3_mutex *p){

wrapped.mutex.xMutexFree(p);

}

static void wrMutexEnter(sqlite3_mutex *p){

wrapped.mutex.xMutexEnter(p);

}

static int wrMutexTry(sqlite3_mutex *p){

return wrapped.mutex.xMutexTry(p);

}

static void wrMutexLeave(sqlite3_mutex *p){

wrapped.mutex.xMutexLeave(p);

}

static int wrMutexHeld(sqlite3_mutex *p){

return wrapped.mutex.xMutexHeld(p);

}

static int wrMutexNotheld(sqlite3_mutex *p){

return wrapped.mutex.xMutexNotheld(p);

}

static int wrPCacheInit(void *pArg){

int rc;

if( wrapped.pcache_fail ){

rc = SQLITE_ERROR;

}else{

rc = wrapped.pcache.xInit(wrapped.pcache.pArg);

}

if( rc==SQLITE_OK ){

wrapped.pcache_init = 1;

}

return rc;

}

static void wrPCacheShutdown(void *pArg){

wrapped.pcache.xShutdown(wrapped.pcache.pArg);

wrapped.pcache_init = 0;

}

static sqlite3_pcache *wrPCacheCreate(int a, int b, int c){

return wrapped.pcache.xCreate(a, b, c);

}

static void wrPCacheCachesize(sqlite3_pcache *p, int n){

wrapped.pcache.xCachesize(p, n);

}

static int wrPCachePagecount(sqlite3_pcache *p){

return wrapped.pcache.xPagecount(p);

}

static sqlite3_pcache_page *wrPCacheFetch(sqlite3_pcache *p, unsigned a, int b){

return wrapped.pcache.xFetch(p, a, b);

}

static void wrPCacheUnpin(sqlite3_pcache *p, sqlite3_pcache_page *a, int b){

wrapped.pcache.xUnpin(p, a, b);

}

static void wrPCacheRekey(

sqlite3_pcache *p,

sqlite3_pcache_page *a,

unsigned b,

unsigned c

){

wrapped.pcache.xRekey(p, a, b, c);

}

static void wrPCacheTruncate(sqlite3_pcache *p, unsigned a){

wrapped.pcache.xTruncate(p, a);

}

static void wrPCacheDestroy(sqlite3_pcache *p){

wrapped.pcache.xDestroy(p);

}

static void installInitWrappers(void){

sqlite3_mutex_methods mutexmethods = {

wrMutexInit, wrMutexEnd, wrMutexAlloc,

wrMutexFree, wrMutexEnter, wrMutexTry,

wrMutexLeave, wrMutexHeld, wrMutexNotheld

};

sqlite3_pcache_methods2 pcachemethods = {

1, 0,

wrPCacheInit, wrPCacheShutdown, wrPCacheCreate,

wrPCacheCachesize, wrPCachePagecount, wrPCacheFetch,

wrPCacheUnpin, wrPCacheRekey, wrPCacheTruncate,

wrPCacheDestroy

};

sqlite3_mem_methods memmethods = {

wrMemMalloc, wrMemFree, wrMemRealloc,

wrMemSize, wrMemRoundup, wrMemInit,

wrMemShutdown,

};

memset(&wrapped, 0, sizeof(wrapped));

sqlite3_shutdown();

sqlite3_config(SQLITE_CONFIG_GETMUTEX, &wrapped.mutex);

sqlite3_config(SQLITE_CONFIG_GETMALLOC, &wrapped.mem);

sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &wrapped.pcache);

sqlite3_config(SQLITE_CONFIG_MUTEX, &mutexmethods);

sqlite3_config(SQLITE_CONFIG_MALLOC, &memmethods);

sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcachemethods);

}

static int init_wrapper_install(

ClientData clientData, /* Unused */

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int objc, /* Number of arguments */

Tcl_Obj *CONST objv[] /* Command arguments */

){

int i;

installInitWrappers();

for(i=1; i<objc; i++){

char *z = Tcl_GetString(objv[i]);

if( strcmp(z, "mem")==0 ){

wrapped.mem_fail = 1;

}else if( strcmp(z, "mutex")==0 ){

wrapped.mutex_fail = 1;

}else if( strcmp(z, "pcache")==0 ){

wrapped.pcache_fail = 1;

}else{

Tcl_AppendResult(interp, "Unknown argument: \"", z, "\"");

return TCL_ERROR;

}

return TCL_OK;

}

static int init_wrapper_uninstall(

ClientData clientData, /* Unused */

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int objc, /* Number of arguments */

Tcl_Obj *CONST objv[] /* Command arguments */

){

if( objc!=1 ){

Tcl_WrongNumArgs(interp, 1, objv, "");

return TCL_ERROR;

}

memset(&wrapped, 0, sizeof(&wrapped));

sqlite3_shutdown();

sqlite3_config(SQLITE_CONFIG_MUTEX, &wrapped.mutex);

sqlite3_config(SQLITE_CONFIG_MALLOC, &wrapped.mem);

sqlite3_config(SQLITE_CONFIG_PCACHE2, &wrapped.pcache);

return TCL_OK;

}

static int init_wrapper_clear(

ClientData clientData, /* Unused */

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int objc, /* Number of arguments */

Tcl_Obj *CONST objv[] /* Command arguments */

){

if( objc!=1 ){

Tcl_WrongNumArgs(interp, 1, objv, "");

return TCL_ERROR;

}

wrapped.mem_fail = 0;

wrapped.mutex_fail = 0;

wrapped.pcache_fail = 0;

return TCL_OK;

}

static int init_wrapper_query(

ClientData clientData, /* Unused */

Tcl_Interp *interp, /* The TCL interpreter that invoked this command */

int objc, /* Number of arguments */

Tcl_Obj *CONST objv[] /* Command arguments */

){

Tcl_Obj *pRet;

if( objc!=1 ){

Tcl_WrongNumArgs(interp, 1, objv, "");

return TCL_ERROR;

}

pRet = Tcl_NewObj();

if( wrapped.mutex_init ){

Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("mutex", -1));

}

if( wrapped.mem_init ){

Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("mem", -1));

}

if( wrapped.pcache_init ){

Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("pcache", -1));

}

Tcl_SetObjResult(interp, pRet);

return TCL_OK;

}

int Sqlitetest_init_Init(Tcl_Interp *interp){

static struct {

char *zName;

Tcl_ObjCmdProc *xProc;

} aObjCmd[] = {

{"init_wrapper_install", init_wrapper_install},

{"init_wrapper_query", init_wrapper_query },

{"init_wrapper_uninstall", init_wrapper_uninstall},

{"init_wrapper_clear", init_wrapper_clear}

};

int i;

for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){

Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);

}

return TCL_OK;

}

sqlcipher/src/test_init.c at Xcode5 · securitykernel/sqlcipher · GitHub

Expand file tree

Breadcrumbs

test_init.c

Latest commit

History

Breadcrumbs

test_init.c

File metadata and controls