#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#include <stdarg.h>

#include "sqlite3.h"

static const char zUsage[] =

"sqlite3_rsync ORIGIN REPLICA ?OPTIONS?\n"

"\n"

"One of ORIGIN or REPLICA is a pathname to a database on the local\n"

"machine and the other is of the form \"USER@HOST:PATH\" describing\n"

"a database on a remote machine. This utility makes REPLICA into a\n"

"copy of ORIGIN\n"

"\n"

"OPTIONS:\n"

"\n"

" --exe PATH Name of the sqlite3_rsync program on the remote side\n"

" --help Show this help screen\n"

" --protocol N Use sync protocol version N.\n"

" --ssh PATH Name of the SSH program used to reach the remote side\n"

" -v Verbose. Multiple v's for increasing output\n"

" --version Show detailed version information\n"

" --wal-only Do not sync unless both databases are in WAL mode\n"

;

typedef unsigned char u8;

typedef sqlite3_uint64 u64;

typedef struct SQLiteRsync SQLiteRsync;

struct SQLiteRsync {

};

#define PROTOCOL_VERSION 2

#define ORIGIN_BEGIN 0x41 /* Initial message */

#define ORIGIN_END 0x42 /* Time to quit */

#define ORIGIN_ERROR 0x43 /* Error message from the remote */

#define ORIGIN_PAGE 0x44 /* New page data */

#define ORIGIN_TXN 0x45 /* Transaction commit */

#define ORIGIN_MSG 0x46 /* Informational message */

#define ORIGIN_DETAIL 0x47 /* Request finer-grain hash info */

#define ORIGIN_READY 0x48 /* Ready for next round of hash exchanges */

#define REPLICA_BEGIN 0x61 /* Welcome message */

#define REPLICA_ERROR 0x62 /* Error. Report and quit. */

#define REPLICA_END 0x63 /* Replica wants to stop */

#define REPLICA_HASH 0x64 /* One or more pages hashes to report */

#define REPLICA_READY 0x65 /* Read to receive page content */

#define REPLICA_MSG 0x66 /* Informational message */

#define REPLICA_CONFIG 0x67 /* Hash exchange configuration */

#ifdef _WIN32

#include <windows.h>

#include <io.h>

#include <fcntl.h>

static void win32_fatal_error(const char *zMsg){

fprintf(stderr, "%s", zMsg);

exit(1);

}

extern int _open_osfhandle(intptr_t,int);

#include <unistd.h>

#include <signal.h>

#include <sys/wait.h>

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

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

# define PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))

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

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

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

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

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

# define PTR_TO_INT(X) ((int)(intptr_t)(X))

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

# define INT_TO_PTR(X) ((void*)(X))

# define PTR_TO_INT(X) ((int)(X))

extern int sqlite3_sha_init(

);

#ifdef _WIN32

static int win32_create_child_process(

){

STARTUPINFOW si;

PROCESS_INFORMATION pi;

BOOL rc;

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

si.cb = sizeof(si);

si.dwFlags = STARTF_USESTDHANDLES;

SetHandleInformation(hIn, HANDLE_FLAG_INHERIT, TRUE);

si.hStdInput = hIn;

SetHandleInformation(hOut, HANDLE_FLAG_INHERIT, TRUE);

si.hStdOutput = hOut;

SetHandleInformation(hErr, HANDLE_FLAG_INHERIT, TRUE);

si.hStdError = hErr;

rc = CreateProcessW(

NULL, /* Application Name */

zCmd, /* Command-line */

NULL, /* Process attributes */

NULL, /* Thread attributes */

TRUE, /* Inherit Handles */

0, /* Create flags */

NULL, /* Environment */

NULL, /* Current directory */

&si, /* Startup Info */

&pi /* Process Info */

);

if( rc ){

CloseHandle( pi.hProcess );

CloseHandle( pi.hThread );

*pChildPid = pi.dwProcessId;

}else{

win32_fatal_error("cannot create child process");

}

return rc!=0;

}

void *win32_utf8_to_unicode(const char *zUtf8){

int nByte = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, 0, 0);

wchar_t *zUnicode = malloc( nByte*2 );

MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, zUnicode, nByte);

return zUnicode;

}

static int popen2(

){

#ifdef _WIN32

HANDLE hStdinRd, hStdinWr, hStdoutRd, hStdoutWr, hStderr;

SECURITY_ATTRIBUTES saAttr;

DWORD childPid = 0;

int fd;

saAttr.nLength = sizeof(saAttr);

saAttr.bInheritHandle = TRUE;

saAttr.lpSecurityDescriptor = NULL;

hStderr = GetStdHandle(STD_ERROR_HANDLE);

if( !CreatePipe(&hStdoutRd, &hStdoutWr, &saAttr, 4096) ){

win32_fatal_error("cannot create pipe for stdout");

}

SetHandleInformation( hStdoutRd, HANDLE_FLAG_INHERIT, FALSE);

if( !CreatePipe(&hStdinRd, &hStdinWr, &saAttr, 4096) ){

win32_fatal_error("cannot create pipe for stdin");

}

SetHandleInformation( hStdinWr, HANDLE_FLAG_INHERIT, FALSE);

win32_create_child_process(win32_utf8_to_unicode(zCmd),

hStdinRd, hStdoutWr, hStderr,&childPid);

*pChildPid = childPid;

fd = _open_osfhandle(PTR_TO_INT(hStdoutRd), 0);

*ppIn = fdopen(fd, "rb");

fd = _open_osfhandle(PTR_TO_INT(hStdinWr), 0);

*ppOut = _fdopen(fd, "wb");

CloseHandle(hStdinRd);

CloseHandle(hStdoutWr);

return 0;

int pin[2], pout[2];

*ppIn = 0;

*ppOut = 0;

*pChildPid = 0;

if( pipe(pin)<0 ){

return 1;

}

if( pipe(pout)<0 ){

close(pin[0]);

close(pin[1]);

return 1;

}

*pChildPid = fork();

if( *pChildPid<0 ){

close(pin[0]);

close(pin[1]);

close(pout[0]);

close(pout[1]);

*pChildPid = 0;

return 1;

}

signal(SIGPIPE,SIG_IGN);

if( *pChildPid==0 ){

int fd;

/* This is the child process */

close(0);

fd = dup(pout[0]);

if( fd!=0 ) {

fprintf(stderr,"popen2() failed to open file descriptor 0");

exit(1);

}

close(pout[0]);

close(pout[1]);

close(1);

fd = dup(pin[1]);

if( fd!=1 ){

fprintf(stderr,"popen() failed to open file descriptor 1");

exit(1);

}

close(pin[0]);

close(pin[1]);

if( bDirect ){

execl(zCmd, zCmd, (char*)0);

}else{

execl("/bin/sh", "/bin/sh", "-c", zCmd, (char*)0);

}

return 1;

}else{

/* This is the parent process */

close(pin[1]);

*ppIn = fdopen(pin[0], "r");

close(pout[0]);

*ppOut = fdopen(pout[1], "w");

return 0;

}

}

static void pclose2(FILE *pIn, FILE *pOut, int childPid){

#ifdef _WIN32

/* Not implemented, yet */

fclose(pIn);

fclose(pOut);

fclose(pIn);

fclose(pOut);

while( waitpid(0, 0, WNOHANG)>0 ) {}

}

static const char aSafeChar[256] = {

#ifdef _WIN32

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x */

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 1x */

1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 2x */

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, /* 3x */

1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, /* 5x */

1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* 7x */

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x */

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 1x */

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 2x */

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, /* 3x */

1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* 5x */

1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* 7x */

/* all bytes 0x80 through 0xbf are unescaped, being secondary

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 8x */

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 9x */

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* ax */

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* bx */

3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* cx */

3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* dx */

4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, /* ex */

5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 /* fx */

};

int append_escaped_arg(sqlite3_str *pStr, const char *zIn, int isFilename){

int i;

unsigned char c;

int needEscape = 0;

int n = sqlite3_str_length(pStr);

char *z = sqlite3_str_value(pStr);

/* Look for illegal byte-sequences and byte-sequences that require

for(i=0; (c = (unsigned char)zIn[i])!=0; i++){

if( aSafeChar[c] ){

unsigned char x = aSafeChar[c];

needEscape = 1;

if( x==2 ){

/* Bad ASCII character */

return 1;

}else if( x>2 ){

if( (zIn[i+1]&0xc0)!=0x80

|| (x>=4 && (zIn[i+2]&0xc0)!=0x80)

|| (x==5 && (zIn[i+3]&0xc0)!=0x80)

){

/* Bad UTF8 character */

return 1;

}

i += x-2;

}

}

}

/* Separate from the previous argument by a space */

if( n>0 && !isspace(z[n-1]) ){

sqlite3_str_appendchar(pStr, 1, ' ');

}

/* Check for characters that need quoting */

if( !needEscape ){

if( isFilename && zIn[0]=='-' ){

sqlite3_str_appendchar(pStr, 1, '.');

#if defined(_WIN32)

sqlite3_str_appendchar(pStr, 1, '\\');

sqlite3_str_appendchar(pStr, 1, '/');

}

sqlite3_str_appendall(pStr, zIn);

}else{

#if defined(_WIN32)

/* Quoting strategy for windows:

sqlite3_str_appendchar(pStr, 1, '"');

if( isFilename && zIn[0]=='-' ){

sqlite3_str_appendchar(pStr, 1, '.');

sqlite3_str_appendchar(pStr, 1, '\\');

}else if( zIn[0]=='/' ){

sqlite3_str_appendchar(pStr, 1, '.');

}

for(i=0; (c = (unsigned char)zIn[i])!=0; i++){

sqlite3_str_appendchar(pStr, 1, (char)c);

if( c=='"' ) sqlite3_str_appendchar(pStr, 1, '"');

if( c=='\\' ) sqlite3_str_appendchar(pStr, 1, '\\');

if( c=='%' && isFilename ) sqlite3_str_append(pStr, "%cd:~,%", 7);

}

sqlite3_str_appendchar(pStr, 1, '"');

/* Quoting strategy for unix:

if( strchr(zIn,'\'') ){

if( isFilename && zIn[0]=='-' ){

sqlite3_str_appendchar(pStr, 1, '.');

sqlite3_str_appendchar(pStr, 1, '/');

}

for(i=0; (c = (unsigned char)zIn[i])!=0; i++){

if( aSafeChar[c] && aSafeChar[c]!=2 ){

sqlite3_str_appendchar(pStr, 1, '\\');

}

sqlite3_str_appendchar(pStr, 1, (char)c);

}

}else{

sqlite3_str_appendchar(pStr, 1, '\'');

if( isFilename && zIn[0]=='-' ){

sqlite3_str_appendchar(pStr, 1, '.');

sqlite3_str_appendchar(pStr, 1, '/');

}

sqlite3_str_appendall(pStr, zIn);

sqlite3_str_appendchar(pStr, 1, '\'');

}

}

return 0;

}

void add_path_argument(sqlite3_str *pStr){

append_escaped_arg(pStr,

"PATH=$HOME/bin:/usr/local/bin:/opt/homebrew/bin"

":/opt/local/bin:$PATH", 0);

}

#ifndef Hash_BYTEORDER

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

defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \

defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \

defined(__arm__)

# define Hash_BYTEORDER 1234

# elif defined(sparc) || defined(__ppc__)

# define Hash_BYTEORDER 4321

# define Hash_BYTEORDER 0

typedef struct HashContext HashContext;

struct HashContext {

};

static void KeccakF1600Step(HashContext *p){

int i;

u64 b0, b1, b2, b3, b4;

u64 c0, c1, c2, c3, c4;

u64 d0, d1, d2, d3, d4;

static const u64 RC[] = {

0x0000000000000001ULL, 0x0000000000008082ULL,

0x800000000000808aULL, 0x8000000080008000ULL,

0x000000000000808bULL, 0x0000000080000001ULL,

0x8000000080008081ULL, 0x8000000000008009ULL,

0x000000000000008aULL, 0x0000000000000088ULL,

0x0000000080008009ULL, 0x000000008000000aULL,

0x000000008000808bULL, 0x800000000000008bULL,

0x8000000000008089ULL, 0x8000000000008003ULL,

0x8000000000008002ULL, 0x8000000000000080ULL,

0x000000000000800aULL, 0x800000008000000aULL,

0x8000000080008081ULL, 0x8000000000008080ULL,

0x0000000080000001ULL, 0x8000000080008008ULL

};

# define a00 (p->u.s[0])

# define a01 (p->u.s[1])

# define a02 (p->u.s[2])

# define a03 (p->u.s[3])

# define a04 (p->u.s[4])

# define a10 (p->u.s[5])

# define a11 (p->u.s[6])

# define a12 (p->u.s[7])

# define a13 (p->u.s[8])

# define a14 (p->u.s[9])

# define a20 (p->u.s[10])

# define a21 (p->u.s[11])

# define a22 (p->u.s[12])

# define a23 (p->u.s[13])

# define a24 (p->u.s[14])

# define a30 (p->u.s[15])

# define a31 (p->u.s[16])

# define a32 (p->u.s[17])

# define a33 (p->u.s[18])

# define a34 (p->u.s[19])

# define a40 (p->u.s[20])

# define a41 (p->u.s[21])

# define a42 (p->u.s[22])

# define a43 (p->u.s[23])

# define a44 (p->u.s[24])

# define ROL64(a,x) ((a<<x)|(a>>(64-x)))

/* v---- Number of rounds. SHA3 has 24 here. */

for(i=0; i<6; i++){

c0 = a00^a10^a20^a30^a40;

c1 = a01^a11^a21^a31^a41;

c2 = a02^a12^a22^a32^a42;

c3 = a03^a13^a23^a33^a43;

c4 = a04^a14^a24^a34^a44;

d0 = c4^ROL64(c1, 1);

d1 = c0^ROL64(c2, 1);

d2 = c1^ROL64(c3, 1);

d3 = c2^ROL64(c4, 1);

d4 = c3^ROL64(c0, 1);

b0 = (a00^d0);

b1 = ROL64((a11^d1), 44);

b2 = ROL64((a22^d2), 43);

b3 = ROL64((a33^d3), 21);

b4 = ROL64((a44^d4), 14);

a00 = b0 ^((~b1)& b2 );

a00 ^= RC[i];

a11 = b1 ^((~b2)& b3 );

a22 = b2 ^((~b3)& b4 );

a33 = b3 ^((~b4)& b0 );

a44 = b4 ^((~b0)& b1 );

b2 = ROL64((a20^d0), 3);

b3 = ROL64((a31^d1), 45);

b4 = ROL64((a42^d2), 61);

b0 = ROL64((a03^d3), 28);

b1 = ROL64((a14^d4), 20);

a20 = b0 ^((~b1)& b2 );

a31 = b1 ^((~b2)& b3 );

a42 = b2 ^((~b3)& b4 );

a03 = b3 ^((~b4)& b0 );

a14 = b4 ^((~b0)& b1 );

b4 = ROL64((a40^d0), 18);

b0 = ROL64((a01^d1), 1);

b1 = ROL64((a12^d2), 6);

b2 = ROL64((a23^d3), 25);

b3 = ROL64((a34^d4), 8);

a40 = b0 ^((~b1)& b2 );

a01 = b1 ^((~b2)& b3 );

a12 = b2 ^((~b3)& b4 );

a23 = b3 ^((~b4)& b0 );

a34 = b4 ^((~b0)& b1 );

b1 = ROL64((a10^d0), 36);

b2 = ROL64((a21^d1), 10);

b3 = ROL64((a32^d2), 15);

b4 = ROL64((a43^d3), 56);

b0 = ROL64((a04^d4), 27);

a10 = b0 ^((~b1)& b2 );

a21 = b1 ^((~b2)& b3 );

a32 = b2 ^((~b3)& b4 );

a43 = b3 ^((~b4)& b0 );

a04 = b4 ^((~b0)& b1 );

b3 = ROL64((a30^d0), 41);

b4 = ROL64((a41^d1), 2);

b0 = ROL64((a02^d2), 62);

b1 = ROL64((a13^d3), 55);

b2 = ROL64((a24^d4), 39);

a30 = b0 ^((~b1)& b2 );

a41 = b1 ^((~b2)& b3 );

a02 = b2 ^((~b3)& b4 );

a13 = b3 ^((~b4)& b0 );

a24 = b4 ^((~b0)& b1 );

}

}

static void HashInit(HashContext *p, int iSize){

memset(p, 0, sizeof(*p));

p->iSize = iSize;

if( iSize>=128 && iSize<=512 ){

p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;

}else{

p->nRate = (1600 - 2*256)/8;

}

#if Hash_BYTEORDER==1234

/* Known to be little-endian at compile-time. No-op */

#elif Hash_BYTEORDER==4321

p->ixMask = 7; /* Big-endian */

{

static unsigned int one = 1;

if( 1==*(unsigned char*)&one ){

/* Little endian. No byte swapping. */

p->ixMask = 0;

}else{

/* Big endian. Byte swap. */

p->ixMask = 7;

}

}

}

static void HashUpdate(

){

unsigned int i = 0;

if( aData==0 ) return;

#if Hash_BYTEORDER==1234

if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){

for(; i+7<nData; i+=8){

p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];

p->nLoaded += 8;

if( p->nLoaded>=p->nRate ){

KeccakF1600Step(p);

p->nLoaded = 0;

}

}

}

for(; i<nData; i++){

#if Hash_BYTEORDER==1234

p->u.x[p->nLoaded] ^= aData[i];

#elif Hash_BYTEORDER==4321

p->u.x[p->nLoaded^0x07] ^= aData[i];

p->u.x[p->nLoaded^p->ixMask] ^= aData[i];

p->nLoaded++;

if( p->nLoaded==p->nRate ){

KeccakF1600Step(p);

p->nLoaded = 0;

}

}

}

static unsigned char *HashFinal(HashContext *p){

unsigned int i;

if( p->nLoaded==p->nRate-1 ){

const unsigned char c1 = 0x86;

HashUpdate(p, &c1, 1);

}else{

const unsigned char c2 = 0x06;

const unsigned char c3 = 0x80;

HashUpdate(p, &c2, 1);

p->nLoaded = p->nRate - 1;

HashUpdate(p, &c3, 1);

}

for(i=0; i<p->nRate; i++){

p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];

}

return &p->u.x[p->nRate];

}

static void hashFunc(

){

HashContext cx;

int eType = sqlite3_value_type(argv[0]);

int nByte = sqlite3_value_bytes(argv[0]);

if( eType==SQLITE_NULL ) return;

HashInit(&cx, 160);

if( eType==SQLITE_BLOB ){

HashUpdate(&cx, sqlite3_value_blob(argv[0]), nByte);

}else{

HashUpdate(&cx, sqlite3_value_text(argv[0]), nByte);

}

sqlite3_result_blob(context, HashFinal(&cx), 160/8, SQLITE_TRANSIENT);

}

static void agghashStep(

){

HashContext *pCx;

int eType = sqlite3_value_type(argv[0]);

int nByte = sqlite3_value_bytes(argv[0]);

if( eType==SQLITE_NULL ) return;

pCx = (HashContext*)sqlite3_aggregate_context(context, sizeof(*pCx));

if( pCx==0 ) return;

if( pCx->iSize==0 ) HashInit(pCx, 160);

if( eType==SQLITE_BLOB ){

HashUpdate(pCx, sqlite3_value_blob(argv[0]), nByte);

}else{

HashUpdate(pCx, sqlite3_value_text(argv[0]), nByte);

}

}

static void agghashFinal(sqlite3_context *context){

HashContext *pCx = (HashContext*)sqlite3_aggregate_context(context, 0);

if( pCx ){

sqlite3_result_blob(context, HashFinal(pCx), 160/8, SQLITE_TRANSIENT);

}

}

static int hashRegister(sqlite3 *db){

int rc;

rc = sqlite3_create_function(db, "hash", 1,

SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,

0, hashFunc, 0, 0);

if( rc==SQLITE_OK ){

rc = sqlite3_create_function(db, "agghash", 1,

SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,

0, 0, agghashStep, agghashFinal);

}

return rc;

}

const char *file_tail(const char *z){

const char *zTail = z;

if( !zTail ) return 0;

while( z[0] ){

if( z[0]=='/' ) zTail = &z[1];

z++;

}

return zTail;

}

static void logError(SQLiteRsync *p, const char *zFormat, ...){

if( p->zErrFile ){

FILE *pErr = fopen(p->zErrFile, "a");

if( pErr ){

va_list ap;

va_start(ap, zFormat);

vfprintf(pErr, zFormat, ap);

va_end(ap);

fclose(pErr);

}

}

p->nErr++;

}

static void debugMessage(SQLiteRsync *p, const char *zFormat, ...){

if( p->zDebugFile ){

if( p->pDebug==0 ){

p->pDebug = fopen(p->zDebugFile, "wb");

}

if( p->pDebug ){

va_list ap;

va_start(ap, zFormat);

vfprintf(p->pDebug, zFormat, ap);

va_end(ap);

fflush(p->pDebug);

}

}

}

static int readUint32(SQLiteRsync *p, unsigned int *pU){

unsigned char buf[4];

if( fread(buf, sizeof(buf), 1, p->pIn)==1 ){

*pU = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];

p->nIn += 4;

return 0;

}else{

logError(p, "failed to read a 32-bit integer\n");

return 1;

}

}

static int writeUint32(SQLiteRsync *p, unsigned int x){

unsigned char buf[4];

buf[3] = x & 0xff;

x >>= 8;

buf[2] = x & 0xff;

x >>= 8;

buf[1] = x & 0xff;

x >>= 8;

buf[0] = x;

if( p->pLog ) fwrite(buf, sizeof(buf), 1, p->pLog);

if( fwrite(buf, sizeof(buf), 1, p->pOut)!=1 ){

logError(p, "failed to write 32-bit integer 0x%x\n", x);

p->nWrErr++;

return 1;

}

p->nOut += 4;

return 0;

}

int readByte(SQLiteRsync *p){

int c = fgetc(p->pIn);

if( c!=EOF ) p->nIn++;

return c;

}