sqlcipher/src/test_devsym.c at sqlite-release · sqlcipher/sqlcipher · GitHub

History

525 lines (478 loc) · 15 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

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

** 2008 Jan 22

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

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

** This file contains code that modified the OS layer in order to simulate

** different device types (by overriding the return values of the

** xDeviceCharacteristics() and xSectorSize() methods).

#if SQLITE_TEST /* This file is used for testing only */

#include "sqlite3.h"

#include "sqliteInt.h"

** Maximum pathname length supported by the devsym backend.

#define DEVSYM_MAX_PATHNAME 512

** Name used to identify this VFS.

#define DEVSYM_VFS_NAME "devsym"

#define WRITECRASH_NAME "writecrash"

typedef struct devsym_file devsym_file;

struct devsym_file {

sqlite3_file base;

sqlite3_file *pReal;

};

** Method declarations for devsym_file.

static int devsymClose(sqlite3_file*);

static int devsymRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);

static int devsymWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);

static int devsymTruncate(sqlite3_file*, sqlite3_int64 size);

static int devsymSync(sqlite3_file*, int flags);

static int devsymFileSize(sqlite3_file*, sqlite3_int64 *pSize);

static int devsymLock(sqlite3_file*, int);

static int devsymUnlock(sqlite3_file*, int);

static int devsymCheckReservedLock(sqlite3_file*, int *);

static int devsymFileControl(sqlite3_file*, int op, void *pArg);

static int devsymSectorSize(sqlite3_file*);

static int devsymDeviceCharacteristics(sqlite3_file*);

static int devsymShmLock(sqlite3_file*,int,int,int);

static int devsymShmMap(sqlite3_file*,int,int,int, void volatile **);

static void devsymShmBarrier(sqlite3_file*);

static int devsymShmUnmap(sqlite3_file*,int);

** Method declarations for devsym_vfs.

static int devsymOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);

static int devsymDelete(sqlite3_vfs*, const char *zName, int syncDir);

static int devsymAccess(sqlite3_vfs*, const char *zName, int flags, int *);

static int devsymFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);

#ifndef SQLITE_OMIT_LOAD_EXTENSION

static void *devsymDlOpen(sqlite3_vfs*, const char *zFilename);

static void devsymDlError(sqlite3_vfs*, int nByte, char *zErrMsg);

static void (*devsymDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);

static void devsymDlClose(sqlite3_vfs*, void*);

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

static int devsymRandomness(sqlite3_vfs*, int nByte, char *zOut);

static int devsymSleep(sqlite3_vfs*, int microseconds);

static int devsymCurrentTime(sqlite3_vfs*, double*);

struct DevsymGlobal {

sqlite3_vfs *pVfs;

int iDeviceChar;

int iSectorSize;

int nWriteCrash;

};

struct DevsymGlobal g = {0, 0, 512, 0};

** Close an devsym-file.

static int devsymClose(sqlite3_file *pFile){

devsym_file *p = (devsym_file *)pFile;

sqlite3OsClose(p->pReal);

return SQLITE_OK;

}

** Read data from an devsym-file.

static int devsymRead(

sqlite3_file *pFile,

void *zBuf,

int iAmt,

sqlite_int64 iOfst

){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);

}

** Write data to an devsym-file.

static int devsymWrite(

sqlite3_file *pFile,

const void *zBuf,

int iAmt,

sqlite_int64 iOfst

){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);

}

** Truncate an devsym-file.

static int devsymTruncate(sqlite3_file *pFile, sqlite_int64 size){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsTruncate(p->pReal, size);

}

** Sync an devsym-file.

static int devsymSync(sqlite3_file *pFile, int flags){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsSync(p->pReal, flags);

}

** Return the current file-size of an devsym-file.

static int devsymFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsFileSize(p->pReal, pSize);

}

** Lock an devsym-file.

static int devsymLock(sqlite3_file *pFile, int eLock){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsLock(p->pReal, eLock);

}

** Unlock an devsym-file.

static int devsymUnlock(sqlite3_file *pFile, int eLock){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsUnlock(p->pReal, eLock);

}

** Check if another file-handle holds a RESERVED lock on an devsym-file.

static int devsymCheckReservedLock(sqlite3_file *pFile, int *pResOut){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsCheckReservedLock(p->pReal, pResOut);

}

** File control method. For custom operations on an devsym-file.

static int devsymFileControl(sqlite3_file *pFile, int op, void *pArg){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsFileControl(p->pReal, op, pArg);

}

** Return the sector-size in bytes for an devsym-file.

static int devsymSectorSize(sqlite3_file *pFile){

return g.iSectorSize;

}

** Return the device characteristic flags supported by an devsym-file.

static int devsymDeviceCharacteristics(sqlite3_file *pFile){

return g.iDeviceChar;

}

** Shared-memory methods are all pass-throughs.

static int devsymShmLock(sqlite3_file *pFile, int ofst, int n, int flags){

devsym_file *p = (devsym_file *)pFile;

return p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);

}

static int devsymShmMap(

sqlite3_file *pFile,

int iRegion,

int szRegion,

int isWrite,

void volatile **pp

){

devsym_file *p = (devsym_file *)pFile;

return p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);

}

static void devsymShmBarrier(sqlite3_file *pFile){

devsym_file *p = (devsym_file *)pFile;

p->pReal->pMethods->xShmBarrier(p->pReal);

}

static int devsymShmUnmap(sqlite3_file *pFile, int delFlag){

devsym_file *p = (devsym_file *)pFile;

return p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);

}

** Open an devsym file handle.

static int devsymOpen(

sqlite3_vfs *pVfs,

const char *zName,

sqlite3_file *pFile,

int flags,

int *pOutFlags

){

static sqlite3_io_methods devsym_io_methods = {

2, /* iVersion */

devsymClose, /* xClose */

devsymRead, /* xRead */

devsymWrite, /* xWrite */

devsymTruncate, /* xTruncate */

devsymSync, /* xSync */

devsymFileSize, /* xFileSize */

devsymLock, /* xLock */

devsymUnlock, /* xUnlock */

devsymCheckReservedLock, /* xCheckReservedLock */

devsymFileControl, /* xFileControl */

devsymSectorSize, /* xSectorSize */

devsymDeviceCharacteristics, /* xDeviceCharacteristics */

devsymShmMap, /* xShmMap */

devsymShmLock, /* xShmLock */

devsymShmBarrier, /* xShmBarrier */

devsymShmUnmap /* xShmUnmap */

};

int rc;

devsym_file *p = (devsym_file *)pFile;

p->pReal = (sqlite3_file *)&p[1];

rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);

if( p->pReal->pMethods ){

pFile->pMethods = &devsym_io_methods;

}

return rc;

}

** Delete the file located at zPath. If the dirSync argument is true,

** ensure the file-system modifications are synced to disk before

** returning.

static int devsymDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){

return sqlite3OsDelete(g.pVfs, zPath, dirSync);

}

** Test for access permissions. Return true if the requested permission

** is available, or false otherwise.

static int devsymAccess(

sqlite3_vfs *pVfs,

const char *zPath,

int flags,

int *pResOut

){

return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut);

}

** Populate buffer zOut with the full canonical pathname corresponding

** to the pathname in zPath. zOut is guaranteed to point to a buffer

** of at least (DEVSYM_MAX_PATHNAME+1) bytes.

static int devsymFullPathname(

sqlite3_vfs *pVfs,

const char *zPath,

int nOut,

char *zOut

){

return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut);

}

#ifndef SQLITE_OMIT_LOAD_EXTENSION

** Open the dynamic library located at zPath and return a handle.

static void *devsymDlOpen(sqlite3_vfs *pVfs, const char *zPath){

return sqlite3OsDlOpen(g.pVfs, zPath);

}

** Populate the buffer zErrMsg (size nByte bytes) with a human readable

** utf-8 string describing the most recent error encountered associated

** with dynamic libraries.

static void devsymDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){

sqlite3OsDlError(g.pVfs, nByte, zErrMsg);

}

** Return a pointer to the symbol zSymbol in the dynamic library pHandle.

static void (*devsymDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){

return sqlite3OsDlSym(g.pVfs, p, zSym);

}

** Close the dynamic library handle pHandle.

static void devsymDlClose(sqlite3_vfs *pVfs, void *pHandle){

sqlite3OsDlClose(g.pVfs, pHandle);

}

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

** Populate the buffer pointed to by zBufOut with nByte bytes of

** random data.

static int devsymRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){

return sqlite3OsRandomness(g.pVfs, nByte, zBufOut);

}

** Sleep for nMicro microseconds. Return the number of microseconds

** actually slept.

static int devsymSleep(sqlite3_vfs *pVfs, int nMicro){

return sqlite3OsSleep(g.pVfs, nMicro);

}

** Return the current time as a Julian Day number in *pTimeOut.

static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){

return g.pVfs->xCurrentTime(g.pVfs, pTimeOut);

}

** Return the sector-size in bytes for an writecrash-file.

static int writecrashSectorSize(sqlite3_file *pFile){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsSectorSize(p->pReal);

}

** Return the device characteristic flags supported by an writecrash-file.

static int writecrashDeviceCharacteristics(sqlite3_file *pFile){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsDeviceCharacteristics(p->pReal);

}

** Write data to an writecrash-file.

static int writecrashWrite(

sqlite3_file *pFile,

const void *zBuf,

int iAmt,

sqlite_int64 iOfst

){

devsym_file *p = (devsym_file *)pFile;

if( g.nWriteCrash>0 ){

g.nWriteCrash--;

if( g.nWriteCrash==0 ) abort();

}

return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);

}

** Open an writecrash file handle.

static int writecrashOpen(

sqlite3_vfs *pVfs,

const char *zName,

sqlite3_file *pFile,

int flags,

int *pOutFlags

){

static sqlite3_io_methods writecrash_io_methods = {

2, /* iVersion */

devsymClose, /* xClose */

devsymRead, /* xRead */

writecrashWrite, /* xWrite */

devsymTruncate, /* xTruncate */

devsymSync, /* xSync */

devsymFileSize, /* xFileSize */

devsymLock, /* xLock */

devsymUnlock, /* xUnlock */

devsymCheckReservedLock, /* xCheckReservedLock */

devsymFileControl, /* xFileControl */

writecrashSectorSize, /* xSectorSize */

writecrashDeviceCharacteristics, /* xDeviceCharacteristics */

devsymShmMap, /* xShmMap */

devsymShmLock, /* xShmLock */

devsymShmBarrier, /* xShmBarrier */

devsymShmUnmap /* xShmUnmap */

};

int rc;

devsym_file *p = (devsym_file *)pFile;

p->pReal = (sqlite3_file *)&p[1];

rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);

if( p->pReal->pMethods ){

pFile->pMethods = &writecrash_io_methods;

}

return rc;

}

static sqlite3_vfs devsym_vfs = {

2, /* iVersion */

sizeof(devsym_file), /* szOsFile */

DEVSYM_MAX_PATHNAME, /* mxPathname */

0, /* pNext */

DEVSYM_VFS_NAME, /* zName */

0, /* pAppData */

devsymOpen, /* xOpen */

devsymDelete, /* xDelete */

devsymAccess, /* xAccess */

devsymFullPathname, /* xFullPathname */

#ifndef SQLITE_OMIT_LOAD_EXTENSION

devsymDlOpen, /* xDlOpen */

devsymDlError, /* xDlError */

devsymDlSym, /* xDlSym */

devsymDlClose, /* xDlClose */

#else

0, /* xDlOpen */

0, /* xDlError */

0, /* xDlSym */

0, /* xDlClose */

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

devsymRandomness, /* xRandomness */

devsymSleep, /* xSleep */

devsymCurrentTime, /* xCurrentTime */

0, /* xGetLastError */

0 /* xCurrentTimeInt64 */

};

static sqlite3_vfs writecrash_vfs = {

2, /* iVersion */

sizeof(devsym_file), /* szOsFile */

DEVSYM_MAX_PATHNAME, /* mxPathname */

0, /* pNext */

WRITECRASH_NAME, /* zName */

0, /* pAppData */

writecrashOpen, /* xOpen */

devsymDelete, /* xDelete */

devsymAccess, /* xAccess */

devsymFullPathname, /* xFullPathname */

#ifndef SQLITE_OMIT_LOAD_EXTENSION

devsymDlOpen, /* xDlOpen */

devsymDlError, /* xDlError */

devsymDlSym, /* xDlSym */

devsymDlClose, /* xDlClose */

#else

0, /* xDlOpen */

0, /* xDlError */

0, /* xDlSym */

0, /* xDlClose */

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

devsymRandomness, /* xRandomness */

devsymSleep, /* xSleep */

devsymCurrentTime, /* xCurrentTime */

0, /* xGetLastError */

0 /* xCurrentTimeInt64 */

};

** This procedure registers the devsym vfs with SQLite. If the argument is

** true, the devsym vfs becomes the new default vfs. It is the only publicly

** available function in this file.

void devsym_register(int iDeviceChar, int iSectorSize){

if( g.pVfs==0 ){

g.pVfs = sqlite3_vfs_find(0);

devsym_vfs.szOsFile += g.pVfs->szOsFile;

writecrash_vfs.szOsFile += g.pVfs->szOsFile;

sqlite3_vfs_register(&devsym_vfs, 0);

sqlite3_vfs_register(&writecrash_vfs, 0);

}

if( iDeviceChar>=0 ){

g.iDeviceChar = iDeviceChar;

}else{

g.iDeviceChar = 0;

}

if( iSectorSize>=0 ){

g.iSectorSize = iSectorSize;

}else{

g.iSectorSize = 512;

}

void devsym_unregister(){

sqlite3_vfs_unregister(&devsym_vfs);

sqlite3_vfs_unregister(&writecrash_vfs);

g.pVfs = 0;

g.iDeviceChar = 0;

g.iSectorSize = 0;

}

void devsym_crash_on_write(int nWrite){

if( g.pVfs==0 ){

g.pVfs = sqlite3_vfs_find(0);

devsym_vfs.szOsFile += g.pVfs->szOsFile;

writecrash_vfs.szOsFile += g.pVfs->szOsFile;

sqlite3_vfs_register(&devsym_vfs, 0);

sqlite3_vfs_register(&writecrash_vfs, 0);

}

g.nWriteCrash = nWrite;

}

#endif

sqlcipher/src/test_devsym.c at sqlite-release · sqlcipher/sqlcipher · GitHub

Uh oh!

Expand file tree

Breadcrumbs

test_devsym.c

Latest commit

History

Breadcrumbs

test_devsym.c

File metadata and controls