sqlcipher/src/sqliteInt.h at Xcode5 · securitykernel/sqlcipher · GitHub

History

3344 lines (3135 loc) · 141 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

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

** 2001 September 15

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

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

** Internal interface definitions for SQLite.

#ifndef _SQLITEINT_H_

#define _SQLITEINT_H_

** These #defines should enable >2GB file support on POSIX if the

** underlying operating system supports it. If the OS lacks

** large file support, or if the OS is windows, these should be no-ops.

** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any

** system #includes. Hence, this block of code must be the very first

** code in all source files.

** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch

** on the compiler command line. This is necessary if you are compiling

** on a recent machine (ex: Red Hat 7.2) but you want your code to work

** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2

** without this option, LFS is enable. But LFS does not exist in the kernel

** in Red Hat 6.0, so the code won't work. Hence, for maximum binary

** portability you should omit LFS.

** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE 1

# ifndef _FILE_OFFSET_BITS

# define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

** Include the configuration header output by 'configure' if we're using the

** autoconf-based build

#ifdef _HAVE_SQLITE_CONFIG_H

#include "config.h"

#endif

#include "sqliteLimit.h"

/* Disable nuisance warnings on Borland compilers */

#if defined(__BORLANDC__)

#pragma warn -rch /* unreachable code */

#pragma warn -ccc /* Condition is always true or false */

#pragma warn -aus /* Assigned value is never used */

#pragma warn -csu /* Comparing signed and unsigned */

#pragma warn -spa /* Suspicious pointer arithmetic */

#endif

/* Needed for various definitions... */

#ifndef _GNU_SOURCE

# define _GNU_SOURCE

#endif

#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)

# define _BSD_SOURCE

#endif

** Include standard header files as necessary

#ifdef HAVE_STDINT_H

#include <stdint.h>

#endif

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#endif

** The following macros are used to cast pointers to integers and

** integers to pointers. The way you do this varies from one compiler

** to the next, so we have developed the following set of #if statements

** to generate appropriate macros for a wide range of compilers.

** The correct "ANSI" way to do this is to use the intptr_t type.

** Unfortunately, that typedef is not available on all compilers, or

** if it is available, it requires an #include of specific headers

** that vary from one machine to the next.

** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on

** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).

** So we have to define the macros in different ways depending on the

** compiler.

#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */

# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))

#elif !defined(__GNUC__) /* Works for compilers other than LLVM */

# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])

# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))

#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */

# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))

#else /* Generates a warning - but it always works */

# define SQLITE_INT_TO_PTR(X) ((void*)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(X))

#endif

** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.

** 0 means mutexes are permanently disable and the library is never

** threadsafe. 1 means the library is serialized which is the highest

** level of threadsafety. 2 means the library is multithreaded - multiple

** threads can use SQLite as long as no two threads try to use the same

** database connection at the same time.

** Older versions of SQLite used an optional THREADSAFE macro.

** We support that for legacy.

#if !defined(SQLITE_THREADSAFE)

# if defined(THREADSAFE)

# define SQLITE_THREADSAFE THREADSAFE

# else

# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

# endif

#endif

** Powersafe overwrite is on by default. But can be turned off using

** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.

#ifndef SQLITE_POWERSAFE_OVERWRITE

# define SQLITE_POWERSAFE_OVERWRITE 1

#endif

** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.

** It determines whether or not the features related to

** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can

** be overridden at runtime using the sqlite3_config() API.

#if !defined(SQLITE_DEFAULT_MEMSTATUS)

# define SQLITE_DEFAULT_MEMSTATUS 1

#endif

** Exactly one of the following macros must be defined in order to

** specify which memory allocation subsystem to use.

** SQLITE_SYSTEM_MALLOC // Use normal system malloc()

** SQLITE_WIN32_MALLOC // Use Win32 native heap API

** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails

** SQLITE_MEMDEBUG // Debugging version of system malloc()

** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the

** assert() macro is enabled, each call into the Win32 native heap subsystem

** will cause HeapValidate to be called. If heap validation should fail, an

** assertion will be triggered.

** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as

** the default.

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)>1

# error "Two or more of the following compile-time configuration options\

are defined but at most one is allowed:\

SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\

SQLITE_ZERO_MALLOC"

#endif

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)==0

# define SQLITE_SYSTEM_MALLOC 1

#endif

** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the

** sizes of memory allocations below this value where possible.

#if !defined(SQLITE_MALLOC_SOFT_LIMIT)

# define SQLITE_MALLOC_SOFT_LIMIT 1024

#endif

** We need to define _XOPEN_SOURCE as follows in order to enable

** recursive mutexes on most Unix systems and fchmod() on OpenBSD.

** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit

** it.

#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)

# define _XOPEN_SOURCE 600

#endif

** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that

** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,

** make it true by defining or undefining NDEBUG.

** Setting NDEBUG makes the code smaller and faster by disabling the

** assert() statements in the code. So we want the default action

** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG

** is set. Thus NDEBUG becomes an opt-in rather than an opt-out

** feature.

#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)

# define NDEBUG 1

#endif

#if defined(NDEBUG) && defined(SQLITE_DEBUG)

# undef NDEBUG

#endif

** The testcase() macro is used to aid in coverage testing. When

** doing coverage testing, the condition inside the argument to

** testcase() must be evaluated both true and false in order to

** get full branch coverage. The testcase() macro is inserted

** to help ensure adequate test coverage in places where simple

** condition/decision coverage is inadequate. For example, testcase()

** can be used to make sure boundary values are tested. For

** bitmask tests, testcase() can be used to make sure each bit

** is significant and used at least once. On switch statements

** where multiple cases go to the same block of code, testcase()

** can insure that all cases are evaluated.

#ifdef SQLITE_COVERAGE_TEST

void sqlite3Coverage(int);

# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }

#else

# define testcase(X)

#endif

** The TESTONLY macro is used to enclose variable declarations or

** other bits of code that are needed to support the arguments

** within testcase() and assert() macros.

#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)

# define TESTONLY(X) X

#else

# define TESTONLY(X)

#endif

** Sometimes we need a small amount of code such as a variable initialization

** to setup for a later assert() statement. We do not want this code to

** appear when assert() is disabled. The following macro is therefore

** used to contain that setup code. The "VVA" acronym stands for

** "Verification, Validation, and Accreditation". In other words, the

** code within VVA_ONLY() will only run during verification processes.

#ifndef NDEBUG

# define VVA_ONLY(X) X

#else

# define VVA_ONLY(X)

#endif

** The ALWAYS and NEVER macros surround boolean expressions which

** are intended to always be true or false, respectively. Such

** expressions could be omitted from the code completely. But they

** are included in a few cases in order to enhance the resilience

** of SQLite to unexpected behavior - to make the code "self-healing"

** or "ductile" rather than being "brittle" and crashing at the first

** hint of unplanned behavior.

** In other words, ALWAYS and NEVER are added for defensive code.

** When doing coverage testing ALWAYS and NEVER are hard-coded to

** be true and false so that the unreachable code they specify will

** not be counted as untested code.

#if defined(SQLITE_COVERAGE_TEST)

# define ALWAYS(X) (1)

# define NEVER(X) (0)

#elif !defined(NDEBUG)

# define ALWAYS(X) ((X)?1:(assert(0),0))

# define NEVER(X) ((X)?(assert(0),1):0)

#else

# define ALWAYS(X) (X)

# define NEVER(X) (X)

#endif

** Return true (non-zero) if the input is a integer that is too large

** to fit in 32-bits. This macro is used inside of various testcase()

** macros to verify that we have tested SQLite for large-file support.

#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)

** The macro unlikely() is a hint that surrounds a boolean

** expression that is usually false. Macro likely() surrounds

** a boolean expression that is usually true. These hints could,

** in theory, be used by the compiler to generate better code, but

** currently they are just comments for human readers.

#define likely(X) (X)

#define unlikely(X) (X)

#include "sqlite3.h"

#include "hash.h"

#include "parse.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <stddef.h>

** If compiling for a processor that lacks floating point support,

** substitute integer for floating-point

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite_int64

# define float sqlite_int64

# define LONGDOUBLE_TYPE sqlite_int64

# ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)

# endif

# define SQLITE_OMIT_DATETIME_FUNCS 1

# define SQLITE_OMIT_TRACE 1

# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT

# undef SQLITE_HAVE_ISNAN

#endif

#ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (1e99)

#endif

** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0

** afterward. Having this macro allows us to cause the C compiler

** to omit code used by TEMP tables without messy #ifndef statements.

#ifdef SQLITE_OMIT_TEMPDB

#define OMIT_TEMPDB 1

#else

#define OMIT_TEMPDB 0

#endif

** The "file format" number is an integer that is incremented whenever

** the VDBE-level file format changes. The following macros define the

** the default file format for new databases and the maximum file format

** that the library can read.

#define SQLITE_MAX_FILE_FORMAT 4

#ifndef SQLITE_DEFAULT_FILE_FORMAT

# define SQLITE_DEFAULT_FILE_FORMAT 4

#endif

** Determine whether triggers are recursive by default. This can be

** changed at run-time using a pragma.

#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS

# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

#endif

** Provide a default value for SQLITE_TEMP_STORE in case it is not specified

** on the command-line

#ifndef SQLITE_TEMP_STORE

# define SQLITE_TEMP_STORE 1

# define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */

#endif

** GCC does not define the offsetof() macro so we'll have to do it

** ourselves.

#ifndef offsetof

#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))

#endif

** Macros to compute minimum and maximum of two numbers.

#define MIN(A,B) ((A)<(B)?(A):(B))

#define MAX(A,B) ((A)>(B)?(A):(B))

** Check to see if this machine uses EBCDIC. (Yes, believe it or

** not, there are still machines out there that use EBCDIC.)

#if 'A' == '\301'

# define SQLITE_EBCDIC 1

#else

# define SQLITE_ASCII 1

#endif

** Integers of known sizes. These typedefs might change for architectures

** where the sizes very. Preprocessor macros are available so that the

** types can be conveniently redefined at compile-type. Like this:

** cc '-DUINTPTR_TYPE=long long int' ...

#ifndef UINT32_TYPE

# ifdef HAVE_UINT32_T

# define UINT32_TYPE uint32_t

# else

# define UINT32_TYPE unsigned int

# endif

#endif

#ifndef UINT16_TYPE

# ifdef HAVE_UINT16_T

# define UINT16_TYPE uint16_t

# else

# define UINT16_TYPE unsigned short int

# endif

#endif

#ifndef INT16_TYPE

# ifdef HAVE_INT16_T

# define INT16_TYPE int16_t

# else

# define INT16_TYPE short int

# endif

#endif

#ifndef UINT8_TYPE

# ifdef HAVE_UINT8_T

# define UINT8_TYPE uint8_t

# else

# define UINT8_TYPE unsigned char

# endif

#endif

#ifndef INT8_TYPE

# ifdef HAVE_INT8_T

# define INT8_TYPE int8_t

# else

# define INT8_TYPE signed char

# endif

#endif

#ifndef LONGDOUBLE_TYPE

# define LONGDOUBLE_TYPE long double

#endif

typedef sqlite_int64 i64; /* 8-byte signed integer */

typedef sqlite_uint64 u64; /* 8-byte unsigned integer */

typedef UINT32_TYPE u32; /* 4-byte unsigned integer */

typedef UINT16_TYPE u16; /* 2-byte unsigned integer */

typedef INT16_TYPE i16; /* 2-byte signed integer */

typedef UINT8_TYPE u8; /* 1-byte unsigned integer */

typedef INT8_TYPE i8; /* 1-byte signed integer */

** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value

** that can be stored in a u32 without loss of data. The value

** is 0x00000000ffffffff. But because of quirks of some compilers, we

** have to specify the value in the less intuitive manner shown:

#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)

** The datatype used to store estimates of the number of rows in a

** table or index. This is an unsigned integer type. For 99.9% of

** the world, a 32-bit integer is sufficient. But a 64-bit integer

** can be used at compile-time if desired.

#ifdef SQLITE_64BIT_STATS

typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */

#else

typedef u32 tRowcnt; /* 32-bit is the default */

#endif

** Macros to determine whether the machine is big or little endian,

** evaluated at runtime.

#ifdef SQLITE_AMALGAMATION

const int sqlite3one = 1;

#else

extern const int sqlite3one;

#endif

#if defined(i386) || defined(__i386__) || defined(_M_IX86)\

|| defined(__x86_64) || defined(__x86_64__)

# define SQLITE_BIGENDIAN 0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE SQLITE_UTF16LE

#else

# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)

# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#endif

** Constants for the largest and smallest possible 64-bit signed integers.

** These macros are designed to work correctly on both 32-bit and 64-bit

** compilers.

#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))

#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

** Round up a number to the next larger multiple of 8. This is used

** to force 8-byte alignment on 64-bit architectures.

#define ROUND8(x) (((x)+7)&~7)

** Round down to the nearest multiple of 8

#define ROUNDDOWN8(x) ((x)&~7)

** Assert that the pointer X is aligned to an 8-byte boundary. This

** macro is used only within assert() to verify that the code gets

** all alignment restrictions correct.

** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the

** underlying malloc() implemention might return us 4-byte aligned

** pointers. In that case, only verify 4-byte alignment.

#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC

# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)

#else

# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)

#endif

** Disable MMAP on platforms where it is known to not work

#if defined(__OpenBSD__) || defined(__QNXNTO__)

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

#endif

** Default maximum size of memory used by memory-mapped I/O in the VFS

#ifdef __APPLE__

# include <TargetConditionals.h>

# if TARGET_OS_IPHONE

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

# endif

#endif

#ifndef SQLITE_MAX_MMAP_SIZE

# if defined(__linux__) \

|| defined(_WIN32) \

|| (defined(__APPLE__) && defined(__MACH__)) \

|| defined(__sun)

# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */

# else

# define SQLITE_MAX_MMAP_SIZE 0

# endif

# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

#endif

** The default MMAP_SIZE is zero on all platforms. Or, even if a larger

** default MMAP_SIZE is specified at compile-time, make sure that it does

** not exceed the maximum mmap size.

#ifndef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE 0

# define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */

#endif

#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE

# undef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE

#endif

** An instance of the following structure is used to store the busy-handler

** callback for a given sqlite handle.

** The sqlite.busyHandler member of the sqlite struct contains the busy

** callback for the database handle. Each pager opened via the sqlite

** handle is passed a pointer to sqlite.busyHandler. The busy-handler

** callback is currently invoked only from within pager.c.

typedef struct BusyHandler BusyHandler;

struct BusyHandler {

int (*xFunc)(void *,int); /* The busy callback */

void *pArg; /* First arg to busy callback */

int nBusy; /* Incremented with each busy call */

};

** Name of the master database table. The master database table

** is a special table that holds the names and attributes of all

** user tables and indices.

#define MASTER_NAME "sqlite_master"

#define TEMP_MASTER_NAME "sqlite_temp_master"

** The root-page of the master database table.

#define MASTER_ROOT 1

** The name of the schema table.

#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

** A convenience macro that returns the number of elements in

** an array.

#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))

** Determine if the argument is a power of two

#define IsPowerOfTwo(X) (((X)&((X)-1))==0)

** The following value as a destructor means to use sqlite3DbFree().

** The sqlite3DbFree() routine requires two parameters instead of the

** one parameter that destructors normally want. So we have to introduce

** this magic value that the code knows to handle differently. Any

** pointer will work here as long as it is distinct from SQLITE_STATIC

** and SQLITE_TRANSIENT.

#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)

** When SQLITE_OMIT_WSD is defined, it means that the target platform does

** not support Writable Static Data (WSD) such as global and static variables.

** All variables must either be on the stack or dynamically allocated from

** the heap. When WSD is unsupported, the variable declarations scattered

** throughout the SQLite code must become constants instead. The SQLITE_WSD

** macro is used for this purpose. And instead of referencing the variable

** directly, we use its constant as a key to lookup the run-time allocated

** buffer that holds real variable. The constant is also the initializer

** for the run-time allocated buffer.

** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL

** macros become no-ops and have zero performance impact.

#ifdef SQLITE_OMIT_WSD

#define SQLITE_WSD const

#define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))

#define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)

int sqlite3_wsd_init(int N, int J);

void *sqlite3_wsd_find(void *K, int L);

#else

#define SQLITE_WSD

#define GLOBAL(t,v) v

#define sqlite3GlobalConfig sqlite3Config

#endif

** The following macros are used to suppress compiler warnings and to

** make it clear to human readers when a function parameter is deliberately

** left unused within the body of a function. This usually happens when

** a function is called via a function pointer. For example the

** implementation of an SQL aggregate step callback may not use the

** parameter indicating the number of arguments passed to the aggregate,

** if it knows that this is enforced elsewhere.

** When a function parameter is not used at all within the body of a function,

** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.

** However, these macros may also be used to suppress warnings related to

** parameters that may or may not be used depending on compilation options.

** For example those parameters only used in assert() statements. In these

** cases the parameters are named as per the usual conventions.

#define UNUSED_PARAMETER(x) (void)(x)

#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

** Forward references to structures

typedef struct AggInfo AggInfo;

typedef struct AuthContext AuthContext;

typedef struct AutoincInfo AutoincInfo;

typedef struct Bitvec Bitvec;

typedef struct CollSeq CollSeq;

typedef struct Column Column;

typedef struct Db Db;

typedef struct Schema Schema;

typedef struct Expr Expr;

typedef struct ExprList ExprList;

typedef struct ExprSpan ExprSpan;

typedef struct FKey FKey;

typedef struct FuncDestructor FuncDestructor;

typedef struct FuncDef FuncDef;

typedef struct FuncDefHash FuncDefHash;

typedef struct IdList IdList;

typedef struct Index Index;

typedef struct IndexSample IndexSample;

typedef struct KeyClass KeyClass;

typedef struct KeyInfo KeyInfo;

typedef struct Lookaside Lookaside;

typedef struct LookasideSlot LookasideSlot;

typedef struct Module Module;

typedef struct NameContext NameContext;

typedef struct Parse Parse;

typedef struct RowSet RowSet;

typedef struct Savepoint Savepoint;

typedef struct Select Select;

typedef struct SelectDest SelectDest;

typedef struct SrcList SrcList;

typedef struct StrAccum StrAccum;

typedef struct Table Table;

typedef struct TableLock TableLock;

typedef struct Token Token;

typedef struct Trigger Trigger;

typedef struct TriggerPrg TriggerPrg;

typedef struct TriggerStep TriggerStep;

typedef struct UnpackedRecord UnpackedRecord;

typedef struct VTable VTable;

typedef struct VtabCtx VtabCtx;

typedef struct Walker Walker;

typedef struct WhereInfo WhereInfo;

** Defer sourcing vdbe.h and btree.h until after the "u8" and

** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque

** pointer types (i.e. FuncDef) defined above.

#include "btree.h"

#include "vdbe.h"

#include "pager.h"

#include "pcache.h"

#include "os.h"

#include "mutex.h"

** Each database file to be accessed by the system is an instance

** of the following structure. There are normally two of these structures

** in the sqlite.aDb[] array. aDb[0] is the main database file and

** aDb[1] is the database file used to hold temporary tables. Additional

** databases may be attached.

struct Db {

char *zName; /* Name of this database */

Btree *pBt; /* The B*Tree structure for this database file */

u8 safety_level; /* How aggressive at syncing data to disk */

Schema *pSchema; /* Pointer to database schema (possibly shared) */

};

** An instance of the following structure stores a database schema.

** Most Schema objects are associated with a Btree. The exception is

** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.

** In shared cache mode, a single Schema object can be shared by multiple

** Btrees that refer to the same underlying BtShared object.

** Schema objects are automatically deallocated when the last Btree that

** references them is destroyed. The TEMP Schema is manually freed by

** sqlite3_close().

** A thread must be holding a mutex on the corresponding Btree in order

** to access Schema content. This implies that the thread must also be

** holding a mutex on the sqlite3 connection pointer that owns the Btree.

** For a TEMP Schema, only the connection mutex is required.

struct Schema {

int schema_cookie; /* Database schema version number for this file */

int iGeneration; /* Generation counter. Incremented with each change */

Hash tblHash; /* All tables indexed by name */

Hash idxHash; /* All (named) indices indexed by name */

Hash trigHash; /* All triggers indexed by name */

Hash fkeyHash; /* All foreign keys by referenced table name */

Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */

u8 file_format; /* Schema format version for this file */

u8 enc; /* Text encoding used by this database */

u16 flags; /* Flags associated with this schema */

int cache_size; /* Number of pages to use in the cache */

};

** These macros can be used to test, set, or clear bits in the

** Db.pSchema->flags field.

#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P))

#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0)

#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P)

#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P)

** Allowed values for the DB.pSchema->flags field.

** The DB_SchemaLoaded flag is set after the database schema has been

** read into internal hash tables.

** DB_UnresetViews means that one or more views have column names that

** have been filled out. If the schema changes, these column names might

** changes and so the view will need to be reset.

#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */

#define DB_UnresetViews 0x0002 /* Some views have defined column names */

#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */

** The number of different kinds of things that can be limited

** using the sqlite3_limit() interface.

#define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1)

** Lookaside malloc is a set of fixed-size buffers that can be used

** to satisfy small transient memory allocation requests for objects

** associated with a particular database connection. The use of

** lookaside malloc provides a significant performance enhancement

** (approx 10%) by avoiding numerous malloc/free requests while parsing

** SQL statements.

** The Lookaside structure holds configuration information about the

** lookaside malloc subsystem. Each available memory allocation in

** the lookaside subsystem is stored on a linked list of LookasideSlot

** objects.

** Lookaside allocations are only allowed for objects that are associated

** with a particular database connection. Hence, schema information cannot

** be stored in lookaside because in shared cache mode the schema information

** is shared by multiple database connections. Therefore, while parsing

** schema information, the Lookaside.bEnabled flag is cleared so that

** lookaside allocations are not used to construct the schema objects.

struct Lookaside {

u16 sz; /* Size of each buffer in bytes */

u8 bEnabled; /* False to disable new lookaside allocations */

u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */

int nOut; /* Number of buffers currently checked out */

int mxOut; /* Highwater mark for nOut */

int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */

LookasideSlot *pFree; /* List of available buffers */

void *pStart; /* First byte of available memory space */

void *pEnd; /* First byte past end of available space */

};

struct LookasideSlot {

LookasideSlot *pNext; /* Next buffer in the list of free buffers */

};

** A hash table for function definitions.

** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.

** Collisions are on the FuncDef.pHash chain.

struct FuncDefHash {

FuncDef *a[23]; /* Hash table for functions */

};

** Each database connection is an instance of the following structure.

struct sqlite3 {

sqlite3_vfs *pVfs; /* OS Interface */

struct Vdbe *pVdbe; /* List of active virtual machines */

CollSeq *pDfltColl; /* The default collating sequence (BINARY) */

sqlite3_mutex *mutex; /* Connection mutex */

Db *aDb; /* All backends */

int nDb; /* Number of backends currently in use */

int flags; /* Miscellaneous flags. See below */

i64 lastRowid; /* ROWID of most recent insert (see above) */

i64 szMmap; /* Default mmap_size setting */

unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */

int errCode; /* Most recent error code (SQLITE_*) */

int errMask; /* & result codes with this before returning */

u16 dbOptFlags; /* Flags to enable/disable optimizations */

u8 autoCommit; /* The auto-commit flag. */

u8 temp_store; /* 1: file 2: memory 0: default */

u8 mallocFailed; /* True if we have seen a malloc failure */

u8 dfltLockMode; /* Default locking-mode for attached dbs */

signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */

u8 suppressErr; /* Do not issue error messages if true */

u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */

u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */

int nextPagesize; /* Pagesize after VACUUM if >0 */

u32 magic; /* Magic number for detect library misuse */

int nChange; /* Value returned by sqlite3_changes() */

int nTotalChange; /* Value returned by sqlite3_total_changes() */

int aLimit[SQLITE_N_LIMIT]; /* Limits */

struct sqlite3InitInfo { /* Information used during initialization */

int newTnum; /* Rootpage of table being initialized */

u8 iDb; /* Which db file is being initialized */

u8 busy; /* TRUE if currently initializing */

u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */

} init;

int nVdbeActive; /* Number of VDBEs currently running */

int nVdbeRead; /* Number of active VDBEs that read or write */

int nVdbeWrite; /* Number of active VDBEs that read and write */

int nVdbeExec; /* Number of nested calls to VdbeExec() */

int nExtension; /* Number of loaded extensions */

void **aExtension; /* Array of shared library handles */

void (*xTrace)(void*,const char*); /* Trace function */

void *pTraceArg; /* Argument to the trace function */

void (*xProfile)(void*,const char*,u64); /* Profiling function */

void *pProfileArg; /* Argument to profile function */

void *pCommitArg; /* Argument to xCommitCallback() */

int (*xCommitCallback)(void*); /* Invoked at every commit. */

void *pRollbackArg; /* Argument to xRollbackCallback() */

void (*xRollbackCallback)(void*); /* Invoked at every commit. */

void *pUpdateArg;

void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);

#ifndef SQLITE_OMIT_WAL

int (*xWalCallback)(void *, sqlite3 *, const char *, int);

void *pWalArg;

#endif

void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);

void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);

void *pCollNeededArg;

sqlite3_value *pErr; /* Most recent error message */

char *zErrMsg; /* Most recent error message (UTF-8 encoded) */

char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */

union {

volatile int isInterrupted; /* True if sqlite3_interrupt has been called */

double notUsed1; /* Spacer */

} u1;

Lookaside lookaside; /* Lookaside malloc configuration */

#ifndef SQLITE_OMIT_AUTHORIZATION

int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);

/* Access authorization function */

void *pAuthArg; /* 1st argument to the access auth function */

#endif

#ifndef SQLITE_OMIT_PROGRESS_CALLBACK

int (*xProgress)(void *); /* The progress callback */

void *pProgressArg; /* Argument to the progress callback */

unsigned nProgressOps; /* Number of opcodes for progress callback */

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

int nVTrans; /* Allocated size of aVTrans */

Hash aModule; /* populated by sqlite3_create_module() */

VtabCtx *pVtabCtx; /* Context for active vtab connect/create */

VTable **aVTrans; /* Virtual tables with open transactions */

VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */

#endif

FuncDefHash aFunc; /* Hash table of connection functions */

Hash aCollSeq; /* All collating sequences */

BusyHandler busyHandler; /* Busy callback */

Db aDbStatic[2]; /* Static space for the 2 default backends */

Savepoint *pSavepoint; /* List of active savepoints */

int busyTimeout; /* Busy handler timeout, in msec */

int nSavepoint; /* Number of non-transaction savepoints */

int nStatement; /* Number of nested statement-transactions */

i64 nDeferredCons; /* Net deferred constraints this transaction. */

i64 nDeferredImmCons; /* Net deferred immediate constraints */

int *pnBytesFreed; /* If not NULL, increment this in DbFree() */

#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY

/* The following variables are all protected by the STATIC_MASTER

** mutex, not by sqlite3.mutex. They are used by code in notify.c.

** When X.pUnlockConnection==Y, that means that X is waiting for Y to

** unlock so that it can proceed.

** When X.pBlockingConnection==Y, that means that something that X tried

** tried to do recently failed with an SQLITE_LOCKED error due to locks

** held by Y.

sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */

sqlite3 *pUnlockConnection; /* Connection to watch for unlock */

void *pUnlockArg; /* Argument to xUnlockNotify */

void (*xUnlockNotify)(void **, int); /* Unlock notify callback */

sqlite3 *pNextBlocked; /* Next in list of all blocked connections */

#endif

};

** A macro to discover the encoding of a database.

#define ENC(db) ((db)->aDb[0].pSchema->enc)

** Possible values for the sqlite3.flags.

#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */

#define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */

#define SQLITE_FullFSync 0x00000004 /* Use full fsync on the backend */

#define SQLITE_CkptFullFSync 0x00000008 /* Use full fsync for checkpoint */

#define SQLITE_CacheSpill 0x00000010 /* OK to spill pager cache */

#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */

#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */

#define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */

/* DELETE, or UPDATE and return */

/* the count using a callback. */

#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */

/* result set is empty */

#define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */

#define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */

#define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */

#define SQLITE_VdbeAddopTrace 0x00001000 /* Trace sqlite3VdbeAddOp() calls */

#define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */

#define SQLITE_ReadUncommitted 0x0004000 /* For shared-cache mode */

#define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */

#define SQLITE_RecoveryMode 0x00010000 /* Ignore schema errors */

#define SQLITE_ReverseOrder 0x00020000 /* Reverse unordered SELECTs */

#define SQLITE_RecTriggers 0x00040000 /* Enable recursive triggers */

#define SQLITE_ForeignKeys 0x00080000 /* Enforce foreign key constraints */

#define SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */

#define SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */

#define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */

#define SQLITE_EnableTrigger 0x00800000 /* True to enable triggers */

#define SQLITE_DeferFKs 0x01000000 /* Defer all FK constraints */

View remainder of file in raw view

sqlcipher/src/sqliteInt.h at Xcode5 · securitykernel/sqlcipher · GitHub

Navigation Menu

Expand file tree

Breadcrumbs

sqliteInt.h

Latest commit

History

Breadcrumbs

sqliteInt.h

File metadata and controls

Footer

Footer navigation