rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

pgindent run on all C files. Java run to follow. initdb/regression 

tests pass.
This commit is contained in:
Bruce Momjian 2001-10-25 05:50:21 +00:00
parent 59da2105d8
commit b81844b173
818 changed files with 21684 additions and 20491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contrib/array/array_iterator.h
View File

@ -34,7 +34,6 @@ int32 array_all_int4le(ArrayType *array, int4 value);
int32 array_oideq(ArrayType *array, Oid value);
int32 array_all_oidne(ArrayType *array, Oid value);
#endif
/*

696
contrib/btree_gist/btree_gist.c
View File

@ -8,43 +8,46 @@
#include "utils/geo_decls.h"
#include "utils/elog.h"
typedef int (*CMPFUNC)(const void *a, const void *b);
typedef void (*BINARY_UNION)(Datum*, char*);
typedef int (*CMPFUNC) (const void *a, const void *b);
typedef void (*BINARY_UNION) (Datum *, char *);
typedef struct intkey {
int4 lower;
int4 upper;
} INT4KEY;
typedef struct intkey
{
int4 lower;
int4 upper;
} INT4KEY;
typedef struct tskey {
Timestamp lower;
Timestamp upper;
} TSKEY;
typedef struct tskey
{
Timestamp lower;
Timestamp upper;
} TSKEY;
/* used for sorting */
typedef struct rix {
int index;
char *r;
} RIX;
typedef struct rix
{
int index;
char *r;
} RIX;
/*
** int4key in/out
*/
PG_FUNCTION_INFO_V1(int4key_in);
PG_FUNCTION_INFO_V1(int4key_out);
Datum int4key_in(PG_FUNCTION_ARGS);
Datum int4key_out(PG_FUNCTION_ARGS);
Datum int4key_in(PG_FUNCTION_ARGS);
Datum int4key_out(PG_FUNCTION_ARGS);
/*
** tskey in/out
*/
PG_FUNCTION_INFO_V1(tskey_in);
PG_FUNCTION_INFO_V1(tskey_out);
Datum tskey_in(PG_FUNCTION_ARGS);
Datum tskey_out(PG_FUNCTION_ARGS);
Datum tskey_in(PG_FUNCTION_ARGS);
Datum tskey_out(PG_FUNCTION_ARGS);
/*
** int4 ops
** int4 ops
*/
PG_FUNCTION_INFO_V1(gint4_compress);
PG_FUNCTION_INFO_V1(gint4_union);
@ -53,15 +56,15 @@ PG_FUNCTION_INFO_V1(gint4_consistent);
PG_FUNCTION_INFO_V1(gint4_penalty);
PG_FUNCTION_INFO_V1(gint4_same);
Datum gint4_compress(PG_FUNCTION_ARGS);
Datum gint4_union(PG_FUNCTION_ARGS);
Datum gint4_picksplit(PG_FUNCTION_ARGS);
Datum gint4_consistent(PG_FUNCTION_ARGS);
Datum gint4_penalty(PG_FUNCTION_ARGS);
Datum gint4_same(PG_FUNCTION_ARGS);
Datum gint4_compress(PG_FUNCTION_ARGS);
Datum gint4_union(PG_FUNCTION_ARGS);
Datum gint4_picksplit(PG_FUNCTION_ARGS);
Datum gint4_consistent(PG_FUNCTION_ARGS);
Datum gint4_penalty(PG_FUNCTION_ARGS);
Datum gint4_same(PG_FUNCTION_ARGS);
static void gint4_binary_union(Datum *r1, char *r2);
static int int4key_cmp(const void *a, const void *b);
static int int4key_cmp(const void *a, const void *b);
/*
** timestamp ops
@ -73,51 +76,51 @@ PG_FUNCTION_INFO_V1(gts_consistent);
PG_FUNCTION_INFO_V1(gts_penalty);
PG_FUNCTION_INFO_V1(gts_same);
Datum gts_compress(PG_FUNCTION_ARGS);
Datum gts_union(PG_FUNCTION_ARGS);
Datum gts_picksplit(PG_FUNCTION_ARGS);
Datum gts_consistent(PG_FUNCTION_ARGS);
Datum gts_penalty(PG_FUNCTION_ARGS);
Datum gts_same(PG_FUNCTION_ARGS);
Datum gts_compress(PG_FUNCTION_ARGS);
Datum gts_union(PG_FUNCTION_ARGS);
Datum gts_picksplit(PG_FUNCTION_ARGS);
Datum gts_consistent(PG_FUNCTION_ARGS);
Datum gts_penalty(PG_FUNCTION_ARGS);
Datum gts_same(PG_FUNCTION_ARGS);
static void gts_binary_union(Datum *r1, char *r2);
static int tskey_cmp(const void *a, const void *b);
static int tskey_cmp(const void *a, const void *b);
/* define for comparison */
#define TSGE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
timestamp_ge, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
timestamp_ge, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
)))
#define TSGT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
timestamp_gt, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
timestamp_gt, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
)))
#define TSEQ( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
timestamp_eq, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
timestamp_eq, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
)))
#define TSLT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
timestamp_lt, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
timestamp_lt, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
)))
#define TSLE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
timestamp_le, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
timestamp_le, \
PointerGetDatum( ts1 ), \
PointerGetDatum( ts2 ) \
)))
/*
** Common btree-function (for all ops)
*/
static GIST_SPLITVEC * btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
BINARY_UNION bu, CMPFUNC cmp);
static GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
BINARY_UNION bu, CMPFUNC cmp);
PG_FUNCTION_INFO_V1(btree_decompress);
Datum btree_decompress(PG_FUNCTION_ARGS);
Datum btree_decompress(PG_FUNCTION_ARGS);
/**************************************************
* int4 ops
@ -126,334 +129,364 @@ Datum btree_decompress(PG_FUNCTION_ARGS);
Datum
gint4_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
GISTENTRY *retval;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if (entry->leafkey)
{
INT4KEY *r = palloc(sizeof(INT4KEY));
if ( entry->leafkey) {
INT4KEY *r = palloc(sizeof(INT4KEY));
retval = palloc(sizeof(GISTENTRY));
r->lower = r->upper = (entry->key);
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, sizeof(INT4KEY),FALSE);
} else {
retval = entry;
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, sizeof(INT4KEY), FALSE);
}
PG_RETURN_POINTER( retval );
else
retval = entry;
PG_RETURN_POINTER(retval);
}
Datum
Datum
gint4_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
int4 query = PG_GETARG_INT32(1);
INT4KEY *kkk= (INT4KEY *)DatumGetPointer(entry->key);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int4 query = PG_GETARG_INT32(1);
INT4KEY *kkk = (INT4KEY *) DatumGetPointer(entry->key);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
switch(strategy) {
case BTLessEqualStrategyNumber:
retval = ( query >= kkk->lower );
break;
case BTLessStrategyNumber:
if (GIST_LEAF(entry))
retval = ( query > kkk->lower );
else
retval = ( query >= kkk->lower );
break;
case BTEqualStrategyNumber:
/* in leaf page kkk->lower always = kkk->upper */
if (GIST_LEAF(entry))
retval = ( query == kkk->lower );
else
retval = ( kkk->lower <= query && query <= kkk->upper );
break;
case BTGreaterStrategyNumber:
if (GIST_LEAF(entry))
retval = ( query < kkk->upper );
else
retval = ( query <= kkk->upper );
break;
case BTGreaterEqualStrategyNumber:
retval = ( query <= kkk->upper );
break;
default:
retval = FALSE;
}
PG_RETURN_BOOL(retval);
switch (strategy)
{
case BTLessEqualStrategyNumber:
retval = (query >= kkk->lower);
break;
case BTLessStrategyNumber:
if (GIST_LEAF(entry))
retval = (query > kkk->lower);
else
retval = (query >= kkk->lower);
break;
case BTEqualStrategyNumber:
/* in leaf page kkk->lower always = kkk->upper */
if (GIST_LEAF(entry))
retval = (query == kkk->lower);
else
retval = (kkk->lower <= query && query <= kkk->upper);
break;
case BTGreaterStrategyNumber:
if (GIST_LEAF(entry))
retval = (query < kkk->upper);
else
retval = (query <= kkk->upper);
break;
case BTGreaterEqualStrategyNumber:
retval = (query <= kkk->upper);
break;
default:
retval = FALSE;
}
PG_RETURN_BOOL(retval);
}
Datum
gint4_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
int i, numranges;
INT4KEY *cur, *out=palloc(sizeof(INT4KEY));
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int i,
numranges;
INT4KEY *cur,
*out = palloc(sizeof(INT4KEY));
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
*(int*) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
*(int *) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) );
out->lower = cur->lower;
out->upper = cur->upper;
cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
out->lower = cur->lower;
out->upper = cur->upper;
for (i = 1; i < numranges; i++) {
cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
if ( out->lower > cur->lower ) out->lower = cur->lower;
if ( out->upper < cur->upper ) out->upper = cur->upper;
}
for (i = 1; i < numranges; i++)
{
cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
if (out->lower > cur->lower)
out->lower = cur->lower;
if (out->upper < cur->upper)
out->upper = cur->upper;
}
PG_RETURN_POINTER( out );
PG_RETURN_POINTER(out);
}
Datum
gint4_penalty(PG_FUNCTION_ARGS)
{
INT4KEY *origentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key );
INT4KEY *newentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key );
float *result = (float*) PG_GETARG_POINTER(2);
*result = Max( newentry->upper - origentry->upper, 0 ) +
Max( origentry->lower - newentry->lower, 0 );
INT4KEY *origentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
INT4KEY *newentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float *) PG_GETARG_POINTER(2);
PG_RETURN_POINTER( result );
*result = Max(newentry->upper - origentry->upper, 0) +
Max(origentry->lower - newentry->lower, 0);
PG_RETURN_POINTER(result);
}
Datum
gint4_picksplit(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER( btree_picksplit(
(bytea*)PG_GETARG_POINTER(0),
(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
gint4_binary_union,
int4key_cmp
) );
PG_RETURN_POINTER(btree_picksplit(
(bytea *) PG_GETARG_POINTER(0),
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
gint4_binary_union,
int4key_cmp
));
}
Datum
gint4_same(PG_FUNCTION_ARGS)
{
INT4KEY *b1 = (INT4KEY*) PG_GETARG_POINTER(0);
INT4KEY *b2 = (INT4KEY*) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2);
INT4KEY *b1 = (INT4KEY *) PG_GETARG_POINTER(0);
INT4KEY *b2 = (INT4KEY *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
*result = ( b1->lower == b2->lower && b1->upper == b2->upper ) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
*result = (b1->lower == b2->lower && b1->upper == b2->upper) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
}
static void
static void
gint4_binary_union(Datum *r1, char *r2)
{
INT4KEY *b1;
INT4KEY *b2 = (INT4KEY*) r2;
if ( ! DatumGetPointer( *r1 ) ) {
*r1 = PointerGetDatum( palloc( sizeof(INT4KEY) ) );
b1 = (INT4KEY*)DatumGetPointer( *r1 );
b1->upper = b2->upper;
b1->lower = b2->lower;
} else {
b1 = (INT4KEY*)DatumGetPointer( *r1 );
INT4KEY *b1;
INT4KEY *b2 = (INT4KEY *) r2;
b1->lower = ( b1->lower > b2->lower ) ?
b2->lower : b1->lower;
b1->upper = ( b1->upper > b2->upper ) ?
b1->upper : b2->upper;
}
if (!DatumGetPointer(*r1))
{
*r1 = PointerGetDatum(palloc(sizeof(INT4KEY)));
b1 = (INT4KEY *) DatumGetPointer(*r1);
b1->upper = b2->upper;
b1->lower = b2->lower;
}
else
{
b1 = (INT4KEY *) DatumGetPointer(*r1);
b1->lower = (b1->lower > b2->lower) ?
b2->lower : b1->lower;
b1->upper = (b1->upper > b2->upper) ?
b1->upper : b2->upper;
}
}
static int
int4key_cmp(const void *a, const void *b) {
return ( ((INT4KEY*)(((RIX*)a)->r))->lower - ((INT4KEY*)(((RIX*)b)->r))->lower );
static int
int4key_cmp(const void *a, const void *b)
{
return (((INT4KEY *) (((RIX *) a)->r))->lower - ((INT4KEY *) (((RIX *) b)->r))->lower);
}
/**************************************************
* timestamp ops
**************************************************/
**************************************************/
Datum
gts_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
GISTENTRY *retval;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if (entry->leafkey)
{
TSKEY *r = (TSKEY *) palloc(sizeof(TSKEY));
if ( entry->leafkey) {
TSKEY *r = (TSKEY *)palloc( sizeof(TSKEY) );
retval = palloc(sizeof(GISTENTRY));
if ( entry->key ) {
r->lower = r->upper = *(Timestamp*)(entry->key);
if (entry->key)
{
r->lower = r->upper = *(Timestamp *) (entry->key);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, sizeof(TSKEY), FALSE);
} else {
}
else
{
gistentryinit(*retval, PointerGetDatum(NULL),
entry->rel, entry->page,
entry->offset, 0, FALSE);
}
} else {
retval = entry;
}
}
PG_RETURN_POINTER( retval );
else
retval = entry;
PG_RETURN_POINTER(retval);
}
Datum
Datum
gts_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
Timestamp *query = (Timestamp *)PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
TSKEY *key;
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
*/
if ( ! entry->key )
return FALSE;
key = (TSKEY*) DatumGetPointer(entry->key);
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Timestamp *query = (Timestamp *) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
TSKEY *key;
switch(strategy) {
case BTLessEqualStrategyNumber:
retval = TSGE( query, &(key->lower) );
break;
case BTLessStrategyNumber:
if (GIST_LEAF(entry))
retval = TSGT( query, &(key->lower) );
else
retval = TSGE( query, &(key->lower) );
break;
case BTEqualStrategyNumber:
/* in leaf page key->lower always = key->upper */
if (GIST_LEAF(entry))
retval = TSEQ( query, &(key->lower));
else
retval = ( TSLE( &(key->lower), query ) && TSLE( query, &(key->upper) ) );
break;
case BTGreaterStrategyNumber:
if (GIST_LEAF(entry))
retval = TSLT( query, &(key->upper) );
else
retval = TSLE( query, &(key->upper) );
break;
case BTGreaterEqualStrategyNumber:
retval = TSLE( query, &(key->upper) );
break;
default:
retval = FALSE;
}
PG_RETURN_BOOL(retval);
/*
* * if entry is not leaf, use gbox_internal_consistent, * else use
* gbox_leaf_consistent
*/
if (!entry->key)
return FALSE;
key = (TSKEY *) DatumGetPointer(entry->key);
switch (strategy)
{
case BTLessEqualStrategyNumber:
retval = TSGE(query, &(key->lower));
break;
case BTLessStrategyNumber:
if (GIST_LEAF(entry))
retval = TSGT(query, &(key->lower));
else
retval = TSGE(query, &(key->lower));
break;
case BTEqualStrategyNumber:
/* in leaf page key->lower always = key->upper */
if (GIST_LEAF(entry))
retval = TSEQ(query, &(key->lower));
else
retval = (TSLE(&(key->lower), query) && TSLE(query, &(key->upper)));
break;
case BTGreaterStrategyNumber:
if (GIST_LEAF(entry))
retval = TSLT(query, &(key->upper));
else
retval = TSLE(query, &(key->upper));
break;
case BTGreaterEqualStrategyNumber:
retval = TSLE(query, &(key->upper));
break;
default:
retval = FALSE;
}
PG_RETURN_BOOL(retval);
}
Datum
gts_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
int i, numranges;
TSKEY *cur, *out=palloc(sizeof(TSKEY));
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int i,
numranges;
TSKEY *cur,
*out = palloc(sizeof(TSKEY));
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
*(int*) PG_GETARG_POINTER(1) = sizeof(TSKEY);
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) );
out->lower = cur->lower;
out->upper = cur->upper;
cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
out->lower = cur->lower;
out->upper = cur->upper;
for (i = 1; i < numranges; i++) {
cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
if ( TSGT( &out->lower, &cur->lower ) ) out->lower = cur->lower;
if ( TSLT( &out->upper, &cur->upper ) ) out->upper = cur->upper;
}
for (i = 1; i < numranges; i++)
{
cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
if (TSGT(&out->lower, &cur->lower))
out->lower = cur->lower;
if (TSLT(&out->upper, &cur->upper))
out->upper = cur->upper;
}
PG_RETURN_POINTER( out );
PG_RETURN_POINTER(out);
}
Datum
gts_penalty(PG_FUNCTION_ARGS)
{
TSKEY *origentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key );
TSKEY *newentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key );
float *result = (float*) PG_GETARG_POINTER(2);
Interval *intr;
TSKEY *origentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
TSKEY *newentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float *) PG_GETARG_POINTER(2);
Interval *intr;
intr = DatumGetIntervalP( DirectFunctionCall2(
timestamp_mi,
TimestampGetDatum( newentry->upper ),
TimestampGetDatum( origentry->upper )) );
intr = DatumGetIntervalP(DirectFunctionCall2(
timestamp_mi,
TimestampGetDatum(newentry->upper),
TimestampGetDatum(origentry->upper)));
/* see interval_larger */
*result = Max( intr->time+intr->month * (30.0 * 86400),0 );
pfree( intr );
intr = DatumGetIntervalP( DirectFunctionCall2(
timestamp_mi,
TimestampGetDatum( origentry->lower ),
TimestampGetDatum( newentry->lower )) );
*result = Max(intr->time + intr->month * (30.0 * 86400), 0);
pfree(intr);
intr = DatumGetIntervalP(DirectFunctionCall2(
timestamp_mi,
TimestampGetDatum(origentry->lower),
TimestampGetDatum(newentry->lower)));
/* see interval_larger */
*result += Max( intr->time+intr->month * (30.0 * 86400),0 );
pfree( intr );
PG_RETURN_POINTER( result );
*result += Max(intr->time + intr->month * (30.0 * 86400), 0);
pfree(intr);
PG_RETURN_POINTER(result);
}
Datum
gts_picksplit(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER( btree_picksplit(
(bytea*)PG_GETARG_POINTER(0),
(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
gts_binary_union,
tskey_cmp
) );
PG_RETURN_POINTER(btree_picksplit(
(bytea *) PG_GETARG_POINTER(0),
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
gts_binary_union,
tskey_cmp
));
}
Datum
gts_same(PG_FUNCTION_ARGS)
{
TSKEY *b1 = (TSKEY*) PG_GETARG_POINTER(0);
TSKEY *b2 = (TSKEY*) PG_GETARG_POINTER(1);
TSKEY *b1 = (TSKEY *) PG_GETARG_POINTER(0);
TSKEY *b2 = (TSKEY *) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2);
if ( b1 && b2 )
*result = ( TSEQ( &(b1->lower), &(b2->lower) ) && TSEQ( &(b1->upper), &(b2->upper) ) ) ? TRUE : FALSE;
else
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
bool *result = (bool *) PG_GETARG_POINTER(2);
if (b1 && b2)
*result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE;
else
*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
}
static void
static void
gts_binary_union(Datum *r1, char *r2)
{
TSKEY *b1;
TSKEY *b2 = (TSKEY*) r2;
TSKEY *b1;
TSKEY *b2 = (TSKEY *) r2;
if ( ! DatumGetPointer( *r1 ) ) {
*r1 = PointerGetDatum( palloc( sizeof(TSKEY) ) );
b1 = (TSKEY*)DatumGetPointer( *r1 );
b1->upper = b2->upper;
b1->lower = b2->lower;
} else {
b1 = (TSKEY*)DatumGetPointer( *r1 );
if (!DatumGetPointer(*r1))
{
*r1 = PointerGetDatum(palloc(sizeof(TSKEY)));
b1 = (TSKEY *) DatumGetPointer(*r1);
b1->upper = b2->upper;
b1->lower = b2->lower;
}
else
{
b1 = (TSKEY *) DatumGetPointer(*r1);
b1->lower = ( TSGT( &b1->lower, &b2->lower) ) ?
b2->lower : b1->lower;
b1->upper = ( TSGT( &b1->upper, &b2->upper) ) ?
b1->upper : b2->upper;
}
b1->lower = (TSGT(&b1->lower, &b2->lower)) ?
b2->lower : b1->lower;
b1->upper = (TSGT(&b1->upper, &b2->upper)) ?
b1->upper : b2->upper;
}
}
static int
tskey_cmp(const void *a, const void *b) {
return DatumGetInt32(
DirectFunctionCall2(
timestamp_cmp,
TimestampGetDatum( ((TSKEY*)(((RIX*)a)->r))->lower ),
TimestampGetDatum( ((TSKEY*)(((RIX*)b)->r))->lower )
)
);
static int
tskey_cmp(const void *a, const void *b)
{
return DatumGetInt32(
DirectFunctionCall2(
timestamp_cmp,
TimestampGetDatum(((TSKEY *) (((RIX *) a)->r))->lower),
TimestampGetDatum(((TSKEY *) (((RIX *) b)->r))->lower)
)
);
}
/**************************************************
@ -466,43 +499,48 @@ tskey_cmp(const void *a, const void *b) {
static GIST_SPLITVEC *
btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
{
OffsetNumber i;
RIX *array;
OffsetNumber maxoff;
int nbytes;
OffsetNumber i;
RIX *array;
OffsetNumber maxoff;
int nbytes;
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1;
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
v->spl_left = (OffsetNumber *) palloc(nbytes);
v->spl_right = (OffsetNumber *) palloc(nbytes);
v->spl_nleft = 0;
v->spl_nright = 0;
v->spl_ldatum = PointerGetDatum( 0 );
v->spl_rdatum = PointerGetDatum( 0 );
array = (RIX*)palloc( sizeof(RIX) * (maxoff+1) );
/* copy the data into RIXes, and sort the RIXes */
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
array[i].index = i;
array[i].r=(char *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
}
qsort((void*)&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
sizeof(RIX), cmp);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
v->spl_left[ v->spl_nleft ] = array[i].index;
v->spl_nleft++;
(*bu)( &v->spl_ldatum, array[i].r );
} else {
v->spl_right[ v->spl_nright ] = array[i].index;
v->spl_nright++;
(*bu)( &v->spl_rdatum, array[i].r );
}
}
pfree(array);
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
v->spl_left = (OffsetNumber *) palloc(nbytes);
v->spl_right = (OffsetNumber *) palloc(nbytes);
v->spl_nleft = 0;
v->spl_nright = 0;
v->spl_ldatum = PointerGetDatum(0);
v->spl_rdatum = PointerGetDatum(0);
array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
return( v );
/* copy the data into RIXes, and sort the RIXes */
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
array[i].index = i;
array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
}
qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
sizeof(RIX), cmp);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = array[i].index;
v->spl_nleft++;
(*bu) (&v->spl_ldatum, array[i].r);
}
else
{
v->spl_right[v->spl_nright] = array[i].index;
v->spl_nright++;
(*bu) (&v->spl_rdatum, array[i].r);
}
}
pfree(array);
return (v);
}
/*
@ -512,38 +550,44 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
Datum
btree_decompress(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER(PG_GETARG_POINTER(0));
PG_RETURN_POINTER(PG_GETARG_POINTER(0));
}
/**************************************************
* In/Out for keys, not really needed
**************************************************/
Datum
int4key_in(PG_FUNCTION_ARGS) {
INT4KEY *key = palloc(sizeof(INT4KEY));
Datum
int4key_in(PG_FUNCTION_ARGS)
{
INT4KEY *key = palloc(sizeof(INT4KEY));
if ( sscanf( PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2 )
if (sscanf(PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2)
elog(ERROR, "Error in input format");
PG_RETURN_POINTER( key );
}
Datum int4key_out(PG_FUNCTION_ARGS) {
INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0);
char *str=palloc(sizeof(char)*22);
sprintf(str,"%d|%d", key->lower, key->upper);
PG_RETURN_POINTER( str );
PG_RETURN_POINTER(key);
}
Datum
tskey_in(PG_FUNCTION_ARGS) {
elog(ERROR, "Not implemented");
PG_RETURN_POINTER( NULL );
int4key_out(PG_FUNCTION_ARGS)
{
INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0);
char *str = palloc(sizeof(char) * 22);
sprintf(str, "%d|%d", key->lower, key->upper);
PG_RETURN_POINTER(str);
}
Datum
tskey_out(PG_FUNCTION_ARGS) {
tskey_in(PG_FUNCTION_ARGS)
{
elog(ERROR, "Not implemented");
PG_RETURN_POINTER( NULL );
PG_RETURN_POINTER(NULL);
}
Datum
tskey_out(PG_FUNCTION_ARGS)
{
elog(ERROR, "Not implemented");
PG_RETURN_POINTER(NULL);
}

40
contrib/chkpass/chkpass.c
View File

@ -4,7 +4,7 @@
* darcy@druid.net
* http://www.druid.net/darcy/
*
* $Id: chkpass.c,v 1.4 2001/05/30 02:11:46 darcy Exp $
* $Id: chkpass.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
* best viewed with tabs set to 4
*/
@ -31,7 +31,7 @@
typedef struct chkpass
{
char password[16];
char password[16];
} chkpass;
/*
@ -62,12 +62,12 @@ PG_FUNCTION_INFO_V1(chkpass_in)
Datum
chkpass_in(PG_FUNCTION_ARGS)
{
char *str = PG_GETARG_CSTRING(0);
chkpass *result;
char *str = PG_GETARG_CSTRING(0);
chkpass *result;
char mysalt[4];
static bool random_initialized = false;
static bool random_initialized = false;
static char salt_chars[] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* special case to let us enter encrypted passwords */
if (*str == ':')
@ -81,7 +81,7 @@ chkpass_in(PG_FUNCTION_ARGS)
if (verify_pass(str) != 0)
{
elog(ERROR, "chkpass_in: purported CHKPASS \"%s\" is a weak password",
str);
str);
PG_RETURN_POINTER(NULL);
}
@ -159,17 +159,18 @@ Datum
chkpass_eq(PG_FUNCTION_ARGS)
{
chkpass *a1 = (chkpass *) PG_GETARG_POINTER(0);
text *a2 = (text *) PG_GETARG_TEXT_P(1);
char str[10];
int sz = 8;
text *a2 = (text *) PG_GETARG_TEXT_P(1);
char str[10];
int sz = 8;
if (!a1 || !a2)
PG_RETURN_BOOL(0);
if (a2->vl_len < 12) sz = a2->vl_len - 4;
if (a2->vl_len < 12)
sz = a2->vl_len - 4;
strncpy(str, a2->vl_dat, sz);
str[sz] = 0;
PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) == 0);
PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) == 0);
}
PG_FUNCTION_INFO_V1(chkpass_ne)
@ -177,14 +178,15 @@ Datum
chkpass_ne(PG_FUNCTION_ARGS)
{
chkpass *a1 = (chkpass *) PG_GETARG_POINTER(0);
text *a2 = (text *) PG_GETARG_TEXT_P(1);
char str[10];
int sz = 8;
text *a2 = (text *) PG_GETARG_TEXT_P(1);
char str[10];
int sz = 8;
if (!a1 || !a2) PG_RETURN_BOOL(0);
if (a2->vl_len < 12) sz = a2->vl_len - 4;
if (!a1 || !a2)
PG_RETURN_BOOL(0);
if (a2->vl_len < 12)
sz = a2->vl_len - 4;
strncpy(str, a2->vl_dat, sz);
str[sz] = 0;
PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) != 0);
PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) != 0);
}

9
contrib/cube/cube.c
View File

@ -166,7 +166,6 @@ g_cube_consistent(GISTENTRY *entry,
NDBOX * query,
StrategyNumber strategy)
{
/*
* if entry is not leaf, use g_cube_internal_consistent, else use
* g_cube_leaf_consistent
@ -206,7 +205,7 @@ g_cube_union(bytea *entryvec, int *sizep)
for (i = 1; i < numranges; i++)
{
out = g_cube_binary_union(tmp, (NDBOX *)
DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key),
DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key),
sizep);
if (i > 1)
pfree(tmp);
@ -220,13 +219,13 @@ g_cube_union(bytea *entryvec, int *sizep)
** GiST Compress and Decompress methods for boxes
** do not do anything.
*/
GISTENTRY *
GISTENTRY *
g_cube_compress(GISTENTRY *entry)
{
return (entry);
}
GISTENTRY *
GISTENTRY *
g_cube_decompress(GISTENTRY *entry)
{
return (entry);
@ -365,7 +364,6 @@ g_cube_picksplit(bytea *entryvec,
maxoff = OffsetNumberNext(maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
/*
* If we've already decided where to place this item, just put it
* on the right list. Otherwise, we need to figure out which page
@ -1001,7 +999,6 @@ cube_contains(NDBOX * box_a, NDBOX * box_b)
if (a->dim < b->dim)
{
/*
* the further comparisons will make sense if the excess
* dimensions of (b) were zeroes

441
contrib/dbase/dbf.c
View File

@ -21,159 +21,171 @@
/* open a dbf-file, get it's field-info and store this information */
dbhead *dbf_open(u_char *file, int flags) {
int file_no;
dbhead *dbh;
f_descr *fields;
dbf_header *head;
dbf_field *fieldc;
dbhead *
dbf_open(u_char *file, int flags)
{
int file_no;
dbhead *dbh;
f_descr *fields;
dbf_header *head;
dbf_field *fieldc;
int t;
if ((dbh = (dbhead *)malloc(sizeof(dbhead))) == NULL) {
return (dbhead *)DBF_ERROR;
}
if ((dbh = (dbhead *) malloc(sizeof(dbhead))) == NULL)
return (dbhead *) DBF_ERROR;
if ((head = (dbf_header *)malloc(sizeof(dbf_header))) == NULL) {
if ((head = (dbf_header *) malloc(sizeof(dbf_header))) == NULL)
{
free(dbh);
return (dbhead *)DBF_ERROR;
return (dbhead *) DBF_ERROR;
}
if ((fieldc = (dbf_field *)malloc(sizeof(dbf_field))) == NULL) {
if ((fieldc = (dbf_field *) malloc(sizeof(dbf_field))) == NULL)
{
free(head);
free(dbh);
return (dbhead *)DBF_ERROR;
return (dbhead *) DBF_ERROR;
}
if ((file_no = open(file, flags)) == -1) {
if ((file_no = open(file, flags)) == -1)
{
free(fieldc);
free(head);
free(dbh);
return (dbhead *)DBF_ERROR;
return (dbhead *) DBF_ERROR;
}
/* read in the disk-header */
if (read(file_no, head, sizeof(dbf_header)) == -1) {
if (read(file_no, head, sizeof(dbf_header)) == -1)
{
close(file_no);
free(fieldc);
free(head);
free(dbh);
return (dbhead *)DBF_ERROR;
return (dbhead *) DBF_ERROR;
}
if (!(head->dbh_dbt & DBH_NORMAL)) {
close(file_no);
free(fieldc);
free(head);
free(dbh);
return (dbhead *)DBF_ERROR;
if (!(head->dbh_dbt & DBH_NORMAL))
{
close(file_no);
free(fieldc);
free(head);
free(dbh);
return (dbhead *) DBF_ERROR;
}
dbh->db_fd = file_no;
if (head->dbh_dbt & DBH_MEMO) {
if (head->dbh_dbt & DBH_MEMO)
dbh->db_memo = 1;
} else {
else
dbh->db_memo = 0;
}
dbh->db_year = head->dbh_year;
dbh->db_month = head->dbh_month;
dbh->db_day = head->dbh_day;
dbh->db_hlen = get_short((u_char *)&head->dbh_hlen);
dbh->db_records = get_long((u_char *)&head->dbh_records);
dbh->db_hlen = get_short((u_char *) &head->dbh_hlen);
dbh->db_records = get_long((u_char *) &head->dbh_records);
dbh->db_currec = 0;
dbh->db_rlen = get_short((u_char *)&head->dbh_rlen);
dbh->db_rlen = get_short((u_char *) &head->dbh_rlen);
dbh->db_nfields = (dbh->db_hlen - sizeof(dbf_header)) / sizeof(dbf_field);
/* dbh->db_hlen - sizeof(dbf_header) isn't the
correct size, cos dbh->hlen is in fact
a little more cos of the 0x0D (and
possibly another byte, 0x4E, I have
seen this somewhere). Because of rounding
everything turns out right :) */
/*
* dbh->db_hlen - sizeof(dbf_header) isn't the correct size, cos
* dbh->hlen is in fact a little more cos of the 0x0D (and possibly
* another byte, 0x4E, I have seen this somewhere). Because of
* rounding everything turns out right :)
*/
if ((fields = (f_descr *)calloc(dbh->db_nfields, sizeof(f_descr)))
== NULL) {
close(file_no);
free(fieldc);
free(head);
free(dbh);
return (dbhead *)DBF_ERROR;
if ((fields = (f_descr *) calloc(dbh->db_nfields, sizeof(f_descr)))
== NULL)
{
close(file_no);
free(fieldc);
free(head);
free(dbh);
return (dbhead *) DBF_ERROR;
}
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
/* Maybe I have calculated the number of fields incorrectly. This can happen
when programs reserve lots of space at the end of the header for future
expansion. This will catch this situation */
if (fields[t].db_name[0] == 0x0D) {
expansion. This will catch this situation */
if (fields[t].db_name[0] == 0x0D)
{
dbh->db_nfields = t;
break;
}
read(file_no, fieldc, sizeof(dbf_field));
strncpy(fields[t].db_name, fieldc->dbf_name, DBF_NAMELEN);
fields[t].db_type = fieldc->dbf_type;
fields[t].db_type = fieldc->dbf_type;
fields[t].db_flen = fieldc->dbf_flen;
fields[t].db_dec = fieldc->dbf_dec;
fields[t].db_dec = fieldc->dbf_dec;
}
dbh->db_offset = dbh->db_hlen;
dbh->db_fields = fields;
if ((dbh->db_buff = (u_char *)malloc(dbh->db_rlen)) == NULL) {
return (dbhead *)DBF_ERROR;
}
if ((dbh->db_buff = (u_char *) malloc(dbh->db_rlen)) == NULL)
return (dbhead *) DBF_ERROR;
free(fieldc);
free(head);
free(fieldc);
free(head);
return dbh;
}
int dbf_write_head(dbhead *dbh) {
int
dbf_write_head(dbhead * dbh)
{
dbf_header head;
time_t now;
struct tm *dbf_time;
time_t now;
struct tm *dbf_time;
if (lseek(dbh->db_fd, 0, SEEK_SET) == -1) {
if (lseek(dbh->db_fd, 0, SEEK_SET) == -1)
return DBF_ERROR;
}
/* fill up the diskheader */
/* Set dataarea of head to '\0' */
memset(&head,'\0',sizeof(dbf_header));
memset(&head, '\0', sizeof(dbf_header));
head.dbh_dbt = DBH_NORMAL;
if (dbh->db_memo) head.dbh_dbt = DBH_MEMO;
if (dbh->db_memo)
head.dbh_dbt = DBH_MEMO;
now = time((time_t *)NULL);
now = time((time_t *) NULL);
dbf_time = localtime(&now);
head.dbh_year = dbf_time->tm_year;
head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + 1 */
head.dbh_month = dbf_time->tm_mon + 1; /* Months since January +
* 1 */
head.dbh_day = dbf_time->tm_mday;
put_long(head.dbh_records, dbh->db_records);
put_short(head.dbh_hlen, dbh->db_hlen);
put_short(head.dbh_rlen, dbh->db_rlen);
if (write(dbh->db_fd, &head, sizeof(dbf_header)) != sizeof(dbf_header))
return DBF_ERROR;
return 0;
}
int dbf_put_fields(dbhead *dbh) {
int
dbf_put_fields(dbhead * dbh)
{
dbf_field field;
u_long t;
u_char end = 0x0D;
if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1) {
if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1)
return DBF_ERROR;
}
/* Set dataarea of field to '\0' */
memset(&field,'\0',sizeof(dbf_field));
memset(&field, '\0', sizeof(dbf_field));
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
strncpy(field.dbf_name, dbh->db_fields[t].db_name, DBF_NAMELEN - 1);
field.dbf_type = dbh->db_fields[t].db_type;
field.dbf_flen = dbh->db_fields[t].db_flen;
@ -189,16 +201,18 @@ int dbf_put_fields(dbhead *dbh) {
return 0;
}
int dbf_add_field(dbhead *dbh, u_char *name, u_char type,
u_char length, u_char dec) {
f_descr *ptr;
u_char *foo;
u_long size, field_no;
int
dbf_add_field(dbhead * dbh, u_char *name, u_char type,
u_char length, u_char dec)
{
f_descr *ptr;
u_char *foo;
u_long size,
field_no;
size = (dbh->db_nfields + 1) * sizeof(f_descr);
if (!(ptr = (f_descr *) realloc(dbh->db_fields, size))) {
if (!(ptr = (f_descr *) realloc(dbh->db_fields, size)))
return DBF_ERROR;
}
dbh->db_fields = ptr;
field_no = dbh->db_nfields;
@ -211,71 +225,81 @@ u_long size, field_no;
dbh->db_hlen += sizeof(dbf_field);
dbh->db_rlen += length;
if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen))) {
if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen)))
return DBF_ERROR;
}
dbh->db_buff = foo;
return 0;
}
dbhead *dbf_open_new(u_char *name, int flags) {
dbhead *dbh;
dbhead *
dbf_open_new(u_char *name, int flags)
{
dbhead *dbh;
if (!(dbh = (dbhead *)malloc(sizeof(dbhead)))) {
return (dbhead *)DBF_ERROR;
}
if (!(dbh = (dbhead *) malloc(sizeof(dbhead))))
return (dbhead *) DBF_ERROR;
if (flags & O_CREAT) {
if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1) {
if (flags & O_CREAT)
{
if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1)
{
free(dbh);
return (dbhead *)DBF_ERROR;
}
} else {
if ((dbh->db_fd = open(name, flags)) == -1) {
free(dbh);
return (dbhead *)DBF_ERROR;
return (dbhead *) DBF_ERROR;
}
}
else
{
if ((dbh->db_fd = open(name, flags)) == -1)
{
free(dbh);
return (dbhead *) DBF_ERROR;
}
}
dbh->db_offset = 0;
dbh->db_memo = 0;
dbh->db_year = 0;
dbh->db_month = 0;
dbh->db_day = 0;
dbh->db_day = 0;
dbh->db_hlen = sizeof(dbf_header) + 1;
dbh->db_records = 0;
dbh->db_currec = 0;
dbh->db_rlen = 1;
dbh->db_nfields = 0;
dbh->db_buff = NULL;
dbh->db_fields = (f_descr *)NULL;
dbh->db_fields = (f_descr *) NULL;
return dbh;
}
void dbf_close(dbhead *dbh) {
int t;
void
dbf_close(dbhead * dbh)
{
int t;
close(dbh->db_fd);
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
free(&dbh->db_fields[t]);
}
if (dbh->db_buff != NULL) {
if (dbh->db_buff != NULL)
free(dbh->db_buff);
}
free(dbh);
}
int dbf_get_record(dbhead *dbh, field *fields, u_long rec) {
u_char *data;
int t, i, offset;
u_char *dbffield, *end;
int
dbf_get_record(dbhead * dbh, field * fields, u_long rec)
{
u_char *data;
int t,
i,
offset;
u_char *dbffield,
*end;
/* calculate at which offset we have to read. *DON'T* forget the
0x0D which seperates field-descriptions from records!
@ -284,112 +308,133 @@ int dbf_get_record(dbhead *dbh, field *fields, u_long rec) {
*/
offset = dbh->db_hlen + (rec * dbh->db_rlen);
if (lseek(dbh->db_fd, offset, SEEK_SET) == -1) {
if (lseek(dbh->db_fd, offset, SEEK_SET) == -1)
{
lseek(dbh->db_fd, 0, SEEK_SET);
dbh->db_offset = 0;
return DBF_ERROR;
}
dbh->db_offset = offset;
dbh->db_currec = rec;
dbh->db_offset = offset;
dbh->db_currec = rec;
data = dbh->db_buff;
read(dbh->db_fd, data, dbh->db_rlen);
read(dbh->db_fd, data, dbh->db_rlen);
if (data[0] == DBF_DELETED) {
return DBF_DELETED;
}
if (data[0] == DBF_DELETED)
return DBF_DELETED;
dbffield = &data[1];
for (t = 0; t < dbh->db_nfields; t++) {
strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
fields[t].db_type = dbh->db_fields[t].db_type;
fields[t].db_flen = dbh->db_fields[t].db_flen;
fields[t].db_dec = dbh->db_fields[t].db_dec;
dbffield = &data[1];
for (t = 0; t < dbh->db_nfields; t++)
{
strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
fields[t].db_type = dbh->db_fields[t].db_type;
fields[t].db_flen = dbh->db_fields[t].db_flen;
fields[t].db_dec = dbh->db_fields[t].db_dec;
if (fields[t].db_type == 'C') {
end = &dbffield[fields[t].db_flen - 1 ];
i = fields[t].db_flen;
while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) {
end--;
i--;
}
strncpy(fields[t].db_contents, dbffield, i);
fields[t].db_contents[i] = '\0';
} else {
end = dbffield;
i = fields[t].db_flen;
while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) {
end++;
i--;
}
strncpy(fields[t].db_contents, end, i);
fields[t].db_contents[i] = '\0';
}
if (fields[t].db_type == 'C')
{
end = &dbffield[fields[t].db_flen - 1];
i = fields[t].db_flen;
while ((i > 0) && ((*end < 0x21) || (*end > 0x7E)))
{
end--;
i--;
}
strncpy(fields[t].db_contents, dbffield, i);
fields[t].db_contents[i] = '\0';
}
else
{
end = dbffield;
i = fields[t].db_flen;
while ((i > 0) && ((*end < 0x21) || (*end > 0x7E)))
{
end++;
i--;
}
strncpy(fields[t].db_contents, end, i);
fields[t].db_contents[i] = '\0';
}
dbffield += fields[t].db_flen;
dbffield += fields[t].db_flen;
}
dbh->db_offset += dbh->db_rlen;
dbh->db_offset += dbh->db_rlen;
return DBF_VALID;
}
field *dbf_build_record(dbhead *dbh) {
int t;
field *fields;
field *
dbf_build_record(dbhead * dbh)
{
int t;
field *fields;
if (!(fields = (field *)calloc(dbh->db_nfields, sizeof(field)))) {
return (field *)DBF_ERROR;
}
for ( t = 0; t < dbh->db_nfields; t++) {
if (!(fields = (field *) calloc(dbh->db_nfields, sizeof(field))))
return (field *) DBF_ERROR;
for (t = 0; t < dbh->db_nfields; t++)
{
if (!(fields[t].db_contents =
(u_char *)malloc(dbh->db_fields[t].db_flen + 1))) {
for (t = 0; t < dbh->db_nfields; t++) {
if (fields[t].db_contents != 0) {
(u_char *) malloc(dbh->db_fields[t].db_flen + 1)))
{
for (t = 0; t < dbh->db_nfields; t++)
{
if (fields[t].db_contents != 0)
{
free(fields[t].db_contents);
free(fields);
}
return (field *)DBF_ERROR;
return (field *) DBF_ERROR;
}
}
strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
fields[t].db_type = dbh->db_fields[t].db_type;
fields[t].db_flen = dbh->db_fields[t].db_flen;
fields[t].db_dec = dbh->db_fields[t].db_dec;
fields[t].db_dec = dbh->db_fields[t].db_dec;
}
return fields;
}
void dbf_free_record(dbhead *dbh, field *rec) {
int t;
void
dbf_free_record(dbhead * dbh, field * rec)
{
int t;
for ( t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
free(rec[t].db_contents);
}
free(rec);
}
int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
u_long offset, new, idx, t, h, length;
u_char *data, end = 0x1a;
double fl;
u_char foo[128], format[32];
int
dbf_put_record(dbhead * dbh, field * rec, u_long where)
{
u_long offset,
new,
idx,
t,
h,
length;
u_char *data,
end = 0x1a;
double fl;
u_char foo[128],
format[32];
/* offset: offset in file for this record
/* offset: offset in file for this record
new: real offset after lseek
idx: index to which place we are inside the 'hardcore'-data for this
record
t: field-counter
data: the hardcore-data that is put on disk
h: index into the field-part in the hardcore-data
length: length of the data to copy
length: length of the data to copy
fl: a float used to get the right precision with real numbers
foo: copy of db_contents when field is not 'C'
format: sprintf format-string to get the right precision with real numbers
format: sprintf format-string to get the right precision with real numbers
NOTE: this declaration of 'foo' can cause overflow when the contents-field
is longer the 127 chars (which is highly unlikely, cos it is not used
@ -399,16 +444,17 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
DO A SEEK_END WITH 0!!!!!! USE -1 !!!!!!!!!!
*/
if (where > dbh->db_records) {
if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1) {
if (where > dbh->db_records)
{
if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1)
return DBF_ERROR;
}
dbh->db_records++;
} else {
}
else
{
offset = dbh->db_hlen + (where * dbh->db_rlen);
if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1) {
if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1)
return DBF_ERROR;
}
}
dbh->db_offset = new;
@ -416,49 +462,54 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
data = dbh->db_buff;
/* Set dataarea of data to ' ' (space) */
memset(data,' ',dbh->db_rlen);
memset(data, ' ', dbh->db_rlen);
/* data[0] = DBF_VALID; */
idx = 1;
for (t = 0; t < dbh->db_nfields; t++) {
for (t = 0; t < dbh->db_nfields; t++)
{
/* if field is empty, don't do a thing */
if (rec[t].db_contents[0] != '\0') {
if (rec[t].db_contents[0] != '\0')
{
/* Handle text */
if (rec[t].db_type == 'C') {
if (strlen(rec[t].db_contents) > rec[t].db_flen) {
length = rec[t].db_flen;
} else {
length = strlen(rec[t].db_contents);
if (rec[t].db_type == 'C')
{
if (strlen(rec[t].db_contents) > rec[t].db_flen)
length = rec[t].db_flen;
else
length = strlen(rec[t].db_contents);
strncpy(data + idx, rec[t].db_contents, length);
}
strncpy(data+idx, rec[t].db_contents, length);
} else {
else
{
/* Handle the rest */
/* Numeric is special, because of real numbers */
if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0)) {
fl = atof(rec[t].db_contents);
sprintf(format, "%%.%df", rec[t].db_dec);
sprintf(foo, format, fl);
} else {
strcpy(foo, rec[t].db_contents);
if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0))
{
fl = atof(rec[t].db_contents);
sprintf(format, "%%.%df", rec[t].db_dec);
sprintf(foo, format, fl);
}
else
strcpy(foo, rec[t].db_contents);
if (strlen(foo) > rec[t].db_flen)
length = rec[t].db_flen;
else
length = strlen(foo);
h = rec[t].db_flen - length;
strncpy(data + idx + h, foo, length);
}
if (strlen(foo) > rec[t].db_flen) {
length = rec[t].db_flen;
} else {
length = strlen(foo);
}
h = rec[t].db_flen - length;
strncpy(data+idx+h, foo, length);
}
}
idx += rec[t].db_flen;
idx += rec[t].db_flen;
}
if (write(dbh->db_fd, data, dbh->db_rlen) != dbh->db_rlen)
return DBF_ERROR;
/* There's a 0x1A at the end of a dbf-file */
if (where == dbh->db_records) {
if (where == dbh->db_records)
{
if (write(dbh->db_fd, &end, 1) != 1)
return DBF_ERROR;
}

135
contrib/dbase/dbf.h
View File

@ -26,7 +26,7 @@
/* maximum fieldname-length */
#define DBF_NAMELEN 11
#define DBF_NAMELEN 11
/* magic-cookies for the file */
@ -37,89 +37,93 @@
#define DBF_ERROR -1
#define DBF_VALID 0x20
#define DBF_DELETED 0x2A
#define DBF_DELETED 0x2A
/* diskheader */
typedef struct {
u_char dbh_dbt; /* indentification field */
u_char dbh_year; /* last modification-date */
u_char dbh_month;
u_char dbh_day;
u_char dbh_records[4]; /* number of records */
u_char dbh_hlen[2]; /* length of this header */
u_char dbh_rlen[2]; /* length of a record */
u_char dbh_stub[20]; /* misc stuff we don't need */
} dbf_header;
typedef struct
{
u_char dbh_dbt; /* indentification field */
u_char dbh_year; /* last modification-date */
u_char dbh_month;
u_char dbh_day;
u_char dbh_records[4]; /* number of records */
u_char dbh_hlen[2]; /* length of this header */
u_char dbh_rlen[2]; /* length of a record */
u_char dbh_stub[20]; /* misc stuff we don't need */
} dbf_header;
/* disk field-description */
typedef struct {
u_char dbf_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char dbf_type; /* field-type */
u_char dbf_reserved[4]; /* some reserved stuff */
u_char dbf_flen; /* field-length */
u_char dbf_dec; /* number of decimal positions if
type is 'N' */
u_char dbf_stub[14]; /* stuff we don't need */
} dbf_field;
typedef struct
{
u_char dbf_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char dbf_type; /* field-type */
u_char dbf_reserved[4]; /* some reserved stuff */
u_char dbf_flen; /* field-length */
u_char dbf_dec; /* number of decimal positions if type is
* 'N' */
u_char dbf_stub[14]; /* stuff we don't need */
} dbf_field;
/* memory field-description */
typedef struct {
u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char db_type; /* field-type */
u_char db_flen; /* field-length */
u_char db_dec; /* number of decimal positions */
} f_descr;
typedef struct
{
u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char db_type; /* field-type */
u_char db_flen; /* field-length */
u_char db_dec; /* number of decimal positions */
} f_descr;
/* memory dfb-header */
typedef struct {
int db_fd; /* file-descriptor */
u_long db_offset; /* current offset in file */
u_char db_memo; /* memo-file present */
u_char db_year; /* last update as YYMMDD */
u_char db_month;
u_char db_day;
u_long db_hlen; /* length of the diskheader, for
calculating the offsets */
u_long db_records; /* number of records */
u_long db_currec; /* current record-number starting
at 0 */
u_short db_rlen; /* length of the record */
u_char db_nfields; /* number of fields */
u_char *db_buff; /* record-buffer to save malloc()'s */
f_descr *db_fields; /* pointer to an array of field-
descriptions */
} dbhead;
typedef struct
{
int db_fd; /* file-descriptor */
u_long db_offset; /* current offset in file */
u_char db_memo; /* memo-file present */
u_char db_year; /* last update as YYMMDD */
u_char db_month;
u_char db_day;
u_long db_hlen; /* length of the diskheader, for
* calculating the offsets */
u_long db_records; /* number of records */
u_long db_currec; /* current record-number starting at 0 */
u_short db_rlen; /* length of the record */
u_char db_nfields; /* number of fields */
u_char *db_buff; /* record-buffer to save malloc()'s */
f_descr *db_fields; /* pointer to an array of field-
* descriptions */
} dbhead;
/* structure that contains everything a user wants from a field, including
the contents (in ASCII). Warning! db_flen may be bigger than the actual
length of db_name! This is because a field doesn't have to be completely
filled */
typedef struct {
u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char db_type; /* field-type */
u_char db_flen; /* field-length */
u_char db_dec; /* number of decimal positions */
u_char* db_contents; /* contents of the field in ASCII */
} field;
typedef struct
{
u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */
u_char db_type; /* field-type */
u_char db_flen; /* field-length */
u_char db_dec; /* number of decimal positions */
u_char *db_contents; /* contents of the field in ASCII */
} field;
/* prototypes for functions */
extern dbhead* dbf_open(u_char *file ,int flags);
extern int dbf_write_head(dbhead *dbh);
extern int dbf_put_fields(dbhead *dbh);
extern int dbf_add_field(dbhead *dbh, u_char *name, u_char type,
u_char length, u_char dec);
extern dbhead * dbf_open_new(u_char *name, int flags);
extern void dbf_close(dbhead *dbh);
extern int dbf_get_record(dbhead *dbh, field *fields, u_long rec);
extern field* dbf_build_record(dbhead *dbh);
extern void dbf_free_record(dbhead *dbh, field* fields);
extern int dbf_put_record(dbhead *dbh, field *rec, u_long where);
extern dbhead *dbf_open(u_char *file, int flags);
extern int dbf_write_head(dbhead * dbh);
extern int dbf_put_fields(dbhead * dbh);
extern int dbf_add_field(dbhead * dbh, u_char *name, u_char type,
u_char length, u_char dec);
extern dbhead *dbf_open_new(u_char *name, int flags);
extern void dbf_close(dbhead * dbh);
extern int dbf_get_record(dbhead * dbh, field * fields, u_long rec);
extern field *dbf_build_record(dbhead * dbh);
extern void dbf_free_record(dbhead * dbh, field * fields);
extern int dbf_put_record(dbhead * dbh, field * rec, u_long where);
/*********************************************************************
@ -131,5 +135,4 @@ extern long get_long(u_char *cp);
extern void put_long(u_char *cp, long lval);
extern short get_short(u_char *cp);
extern void put_short(u_char *cp, short lval);
#endif /* _DBF_H */
#endif /* _DBF_H */

773
contrib/dbase/dbf2pg.c
View File

File diff suppressed because it is too large Load Diff

44
contrib/dbase/endian.c
View File

@ -5,41 +5,45 @@
/*
* routine to change little endian long to host long
*/
long get_long(u_char *cp)
long
get_long(u_char *cp)
{
long ret;
long ret;
ret = *cp++;
ret += ((*cp++)<<8);
ret += ((*cp++)<<16);
ret += ((*cp++)<<24);
ret = *cp++;
ret += ((*cp++) << 8);
ret += ((*cp++) << 16);
ret += ((*cp++) << 24);
return ret;
return ret;
}
void put_long(u_char *cp, long lval)
void
put_long(u_char *cp, long lval)
{
cp[0] = lval & 0xff;
cp[1] = (lval >> 8) & 0xff;
cp[2] = (lval >> 16) & 0xff;
cp[3] = (lval >> 24) & 0xff;
cp[0] = lval & 0xff;
cp[1] = (lval >> 8) & 0xff;
cp[2] = (lval >> 16) & 0xff;
cp[3] = (lval >> 24) & 0xff;
}
/*
* routine to change little endian short to host short
*/
short get_short(u_char *cp)
short
get_short(u_char *cp)
{
short ret;
short ret;
ret = *cp++;
ret += ((*cp++)<<8);
ret = *cp++;
ret += ((*cp++) << 8);
return ret;
return ret;
}
void put_short(u_char *cp, short sval)
void
put_short(u_char *cp, short sval)
{
cp[0] = sval & 0xff;
cp[1] = (sval >> 8) & 0xff;
cp[0] = sval & 0xff;
cp[1] = (sval >> 8) & 0xff;
}

165
contrib/dblink/dblink.c
View File

@ -4,18 +4,18 @@
* Functions returning results from a remote database
*
* Copyright (c) Joseph Conway <joe.conway@mail.com>, 2001;
*
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without a written agreement
* is hereby granted, provided that the above copyright notice and this
* paragraph and the following two paragraphs appear in all copies.
*
*
* IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
* LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
* DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*
* THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
@ -30,29 +30,28 @@ PG_FUNCTION_INFO_V1(dblink);
Datum
dblink(PG_FUNCTION_ARGS)
{
PGconn *conn = NULL;
PGresult *res = NULL;
dblink_results *results;
char *optstr;
char *sqlstatement;
char *curstr = "DECLARE mycursor CURSOR FOR ";
char *execstatement;
char *msg;
int ntuples = 0;
ReturnSetInfo *rsi;
PGconn *conn = NULL;
PGresult *res = NULL;
dblink_results *results;
char *optstr;
char *sqlstatement;
char *curstr = "DECLARE mycursor CURSOR FOR ";
char *execstatement;
char *msg;
int ntuples = 0;
ReturnSetInfo *rsi;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) {
if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
elog(ERROR, "dblink: NULL arguments are not permitted");
}
if (fcinfo->resultinfo == NULL || ! IsA(fcinfo->resultinfo, ReturnSetInfo)) {
if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo))
elog(ERROR, "dblink: function called in context that does not accept a set result");
}
optstr = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
sqlstatement = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
if (fcinfo->flinfo->fn_extra == NULL) {
if (fcinfo->flinfo->fn_extra == NULL)
{
conn = PQconnectdb(optstr);
if (PQstatus(conn) == CONNECTION_BAD)
@ -73,13 +72,14 @@ dblink(PG_FUNCTION_ARGS)
PQclear(res);
execstatement = (char *) palloc(strlen(curstr) + strlen(sqlstatement) + 1);
if (execstatement != NULL) {
if (execstatement != NULL)
{
strcpy(execstatement, curstr);
strcat(execstatement, sqlstatement);
strcat(execstatement, "\0");
} else {
elog(ERROR, "dblink: insufficient memory" );
}
else
elog(ERROR, "dblink: insufficient memory");
res = PQexec(conn, execstatement);
if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK))
@ -88,23 +88,27 @@ dblink(PG_FUNCTION_ARGS)
PQclear(res);
PQfinish(conn);
elog(ERROR, "dblink: sql error: %s", msg);
} else {
}
else
{
/*
* got results, start fetching them
*/
PQclear(res);
PQclear(res);
res = PQexec(conn, "FETCH ALL in mycursor");
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) {
res = PQexec(conn, "FETCH ALL in mycursor");
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
msg = pstrdup(PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
elog(ERROR, "dblink: sql error: %s", msg);
}
}
ntuples = PQntuples(res);
if (ntuples > 0) {
if (ntuples > 0)
{
results = init_dblink_results(fcinfo->flinfo->fn_mcxt);
results->tup_num = 0;
@ -116,44 +120,48 @@ dblink(PG_FUNCTION_ARGS)
results = NULL;
results = fcinfo->flinfo->fn_extra;
/* close the cursor */
res = PQexec(conn, "CLOSE mycursor");
PQclear(res);
/* close the cursor */
res = PQexec(conn, "CLOSE mycursor");
PQclear(res);
/* commit the transaction */
res = PQexec(conn, "COMMIT");
PQclear(res);
/* commit the transaction */
res = PQexec(conn, "COMMIT");
PQclear(res);
/* close the connection to the database and cleanup */
PQfinish(conn);
/* close the connection to the database and cleanup */
PQfinish(conn);
rsi = (ReturnSetInfo *)fcinfo->resultinfo;
rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprMultipleResult;
PG_RETURN_POINTER(results);
} else {
}
else
{
PQclear(res);
PQclear(res);
/* close the cursor */
res = PQexec(conn, "CLOSE mycursor");
PQclear(res);
/* close the cursor */
res = PQexec(conn, "CLOSE mycursor");
PQclear(res);
/* commit the transaction */
res = PQexec(conn, "COMMIT");
PQclear(res);
/* commit the transaction */
res = PQexec(conn, "COMMIT");
PQclear(res);
/* close the connection to the database and cleanup */
PQfinish(conn);
/* close the connection to the database and cleanup */
PQfinish(conn);
rsi = (ReturnSetInfo *)fcinfo->resultinfo;
rsi->isDone = ExprEndResult ;
rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprEndResult;
PG_RETURN_NULL();
}
}
} else {
}
else
{
/*
* check for more results
*/
@ -162,29 +170,30 @@ dblink(PG_FUNCTION_ARGS)
results->tup_num++;
ntuples = PQntuples(results->res);
if (results->tup_num < ntuples) {
if (results->tup_num < ntuples)
{
/*
* fetch them if available
*/
rsi = (ReturnSetInfo *)fcinfo->resultinfo;
rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprMultipleResult;
PG_RETURN_POINTER(results);
} else {
}
else
{
/*
* or if no more, clean things up
*/
results = fcinfo->flinfo->fn_extra;
PQclear(results->res);
PQclear(results->res);
rsi = (ReturnSetInfo *)fcinfo->resultinfo;
rsi->isDone = ExprEndResult ;
rsi = (ReturnSetInfo *) fcinfo->resultinfo;
rsi->isDone = ExprEndResult;
PG_RETURN_NULL();
}
@ -204,48 +213,48 @@ PG_FUNCTION_INFO_V1(dblink_tok);
Datum
dblink_tok(PG_FUNCTION_ARGS)
{
dblink_results *results;
int fldnum;
text *result_text;
char *result;
int nfields = 0;
int text_len = 0;
dblink_results *results;
int fldnum;
text *result_text;
char *result;
int nfields = 0;
int text_len = 0;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) {
if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
elog(ERROR, "dblink: NULL arguments are not permitted");
}
results = (dblink_results *) PG_GETARG_POINTER(0);
if (results == NULL) {
if (results == NULL)
elog(ERROR, "dblink: function called with invalid result pointer");
}
fldnum = PG_GETARG_INT32(1);
if (fldnum < 0) {
if (fldnum < 0)
elog(ERROR, "dblink: field number < 0 not permitted");
}
nfields = PQnfields(results->res);
if (fldnum > (nfields - 1)) {
if (fldnum > (nfields - 1))
elog(ERROR, "dblink: field number %d does not exist", fldnum);
}
if (PQgetisnull(results->res, results->tup_num, fldnum) == 1) {
if (PQgetisnull(results->res, results->tup_num, fldnum) == 1)
{
PG_RETURN_NULL();
} else {
}
else
{
text_len = PQgetlength(results->res, results->tup_num, fldnum);
result = (char *) palloc(text_len + 1);
if (result != NULL) {
if (result != NULL)
{
strcpy(result, PQgetvalue(results->res, results->tup_num, fldnum));
strcat(result, "\0");
} else {
elog(ERROR, "dblink: insufficient memory" );
}
else
elog(ERROR, "dblink: insufficient memory");
result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(result)));
@ -267,8 +276,8 @@ dblink_tok(PG_FUNCTION_ARGS)
dblink_results *
init_dblink_results(MemoryContext fn_mcxt)
{
MemoryContext oldcontext;
dblink_results *retval;
MemoryContext oldcontext;
dblink_results *retval;
oldcontext = MemoryContextSwitchTo(fn_mcxt);

11
contrib/dblink/dblink.h
View File

@ -4,18 +4,18 @@
* Functions returning results from a remote database
*
* Copyright (c) Joseph Conway <joe.conway@mail.com>, 2001;
*
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without a written agreement
* is hereby granted, provided that the above copyright notice and this
* paragraph and the following two paragraphs appear in all copies.
*
*
* IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
* LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
* DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*
* THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
@ -52,9 +52,9 @@ typedef struct
/*
* the actual query results
*/
PGresult *res;
PGresult *res;
} dblink_results;
} dblink_results;
/*
* External declarations
@ -66,5 +66,4 @@ extern Datum dblink_tok(PG_FUNCTION_ARGS);
* Internal declarations
*/
dblink_results *init_dblink_results(MemoryContext fn_mcxt);
#endif /* DBLINK_H */

108
contrib/fulltextindex/fti.c
View File

@ -6,52 +6,52 @@
#include "commands/trigger.h"
/*
* Trigger function accepts variable number of arguments:
* Trigger function accepts variable number of arguments:
*
* 1. relation in which to store the substrings
* 2. fields to extract substrings from
*
* The relation in which to insert *must* have the following layout:
* The relation in which to insert *must* have the following layout:
*
* string varchar(#)
* id oid
*
* where # is the largest size of the varchar columns being indexed
* where # is the largest size of the varchar columns being indexed
*
* Example:
*
* -- Create the SQL function based on the compiled shared object
* create function fti() returns opaque as
* '/usr/local/pgsql/lib/contrib/fti.so' language 'C';
* -- Create the SQL function based on the compiled shared object
* create function fti() returns opaque as
* '/usr/local/pgsql/lib/contrib/fti.so' language 'C';
*
* -- Create the FTI table
* create table product_fti (string varchar(255), id oid);
* -- Create the FTI table
* create table product_fti (string varchar(255), id oid);
*
* -- Create an index to assist string matches
* create index product_fti_string_idx on product_fti (string);
* -- Create an index to assist string matches
* create index product_fti_string_idx on product_fti (string);
*
* -- Create an index to assist trigger'd deletes
* create index product_fti_id_idx on product_fti (id);
* -- Create an index to assist trigger'd deletes
* create index product_fti_id_idx on product_fti (id);
*
* -- Create an index on the product oid column to assist joins
* -- between the fti table and the product table
* create index product_oid_idx on product (oid);
* -- Create an index on the product oid column to assist joins
* -- between the fti table and the product table
* create index product_oid_idx on product (oid);
*
* -- Create the trigger to perform incremental changes to the full text index.
* create trigger product_fti_trig after update or insert or delete on product
* for each row execute procedure fti(product_fti, title, artist);
* ^^^^^^^^^^^
* table where full text index is stored
* ^^^^^^^^^^^^^
* columns to index in the base table
* -- Create the trigger to perform incremental changes to the full text index.
* create trigger product_fti_trig after update or insert or delete on product
* for each row execute procedure fti(product_fti, title, artist);
* ^^^^^^^^^^^
* table where full text index is stored
* ^^^^^^^^^^^^^
* columns to index in the base table
*
* After populating 'product', try something like:
* After populating 'product', try something like:
*
* SELECT DISTINCT(p.*) FROM product p, product_fti f1, product_fti f2 WHERE
* SELECT DISTINCT(p.*) FROM product p, product_fti f1, product_fti f2 WHERE
* f1.string ~ '^slippery' AND f2.string ~ '^wet' AND p.oid=f1.id AND p.oid=f2.id;
*
* To check that your indicies are being used correctly, make sure you
* EXPLAIN SELECT ... your test query above.
* To check that your indicies are being used correctly, make sure you
* EXPLAIN SELECT ... your test query above.
*
* CHANGELOG
* ---------
@ -76,14 +76,14 @@
* TODO
* ----
*
* prevent generating duplicate words for an oid in the fti table
* save a plan for deletes
* create a function that will make the index *after* we have populated
* the main table (probably first delete all contents to be sure there's
* nothing in it, then re-populate the fti-table)
* prevent generating duplicate words for an oid in the fti table
* save a plan for deletes
* create a function that will make the index *after* we have populated
* the main table (probably first delete all contents to be sure there's
* nothing in it, then re-populate the fti-table)
*
* can we do something with operator overloading or a seperate function
* that can build the final query automatigally?
* can we do something with operator overloading or a seperate function
* that can build the final query automatigally?
*/
#define MAX_FTI_QUERY_LENGTH 8192
@ -103,16 +103,15 @@ char *StopWords[] = { /* list of words to skip in indexing */
"the",
"yes"
};
#endif /* USE_STOP_WORDS */
#endif /* USE_STOP_WORDS */
/* stuff for caching query-plans, stolen from contrib/spi/\*.c */
typedef struct
{
char *ident;
int nplans;
void **splan;
} EPlan;
char *ident;
int nplans;
void **splan;
} EPlan;
static EPlan *InsertPlans = NULL;
static EPlan *DeletePlans = NULL;
@ -201,13 +200,11 @@ fti(PG_FUNCTION_ARGS)
Oid *argtypes;
Datum values[1];
EPlan *plan;
int i;
int i;
snprintf(query, MAX_FTI_QUERY_LENGTH, "D%s", indexname);
for (i = 1; i < nargs; i++)
{
snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]);
}
plan = find_plan(query, &DeletePlans, &nDeletePlans);
if (plan->nplans <= 0)
@ -238,23 +235,21 @@ fti(PG_FUNCTION_ARGS)
if (isinsert)
{
char *substring;
char *column;
void *pplan;
Oid *argtypes;
char *substring;
char *column;
void *pplan;
Oid *argtypes;
Datum values[2];
int colnum;
struct varlena *data;
EPlan *plan;
int i;
char *buff;
char *string;
struct varlena *data;
EPlan *plan;
int i;
char *buff;
char *string;
snprintf(query, MAX_FTI_QUERY_LENGTH, "I%s", indexname);
for (i = 1; i < nargs; i++)
{
snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]);
}
plan = find_plan(query, &InsertPlans, &nInsertPlans);
@ -269,7 +264,7 @@ fti(PG_FUNCTION_ARGS)
/* prepare plan to gain speed */
snprintf(query, MAX_FTI_QUERY_LENGTH, "INSERT INTO %s (string, id) VALUES ($1, $2)",
indexname);
indexname);
pplan = SPI_prepare(query, 2, argtypes);
if (!pplan)
elog(ERROR, "Full Text Indexing: SPI_prepare: Returned NULL in insert");
@ -303,7 +298,7 @@ fti(PG_FUNCTION_ARGS)
string++;
}
data = (struct varlena *) palloc(sizeof(int32) + strlen(column) + 1);
data = (struct varlena *) palloc(sizeof(int32) + strlen(column) +1);
buff = palloc(strlen(column) + 1);
/* saves lots of calls in while-loop and in breakup() */
@ -348,7 +343,6 @@ breakup(char *string, char *substring)
while (cur_pos > string) /* don't read before start of 'string' */
{
/*
* skip pieces at the end of a string that are not alfa-numeric
* (ie. 'string$%^&', last_start first points to '&', and after
@ -409,7 +403,7 @@ is_stopword(char *text)
else
StopHigh = StopMiddle;
}
#endif /* USE_STOP_WORDS */
#endif /* USE_STOP_WORDS */
return (false);
}

495
contrib/fuzzystrmatch/fuzzystrmatch.c
View File

@ -24,13 +24,13 @@
* documentation for any purpose, without fee, and without a written agreement
* is hereby granted, provided that the above copyright notice and this
* paragraph and the following two paragraphs appear in all copies.
*
*
* IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
* LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
* DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*
* THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
@ -50,23 +50,22 @@ PG_FUNCTION_INFO_V1(levenshtein);
Datum
levenshtein(PG_FUNCTION_ARGS)
{
char *str_s;
char *str_s0;
char *str_t;
int cols = 0;
int rows = 0;
int *u_cells;
int *l_cells;
int *tmp;
int i;
int j;
char *str_s;
char *str_s0;
char *str_t;
int cols = 0;
int rows = 0;
int *u_cells;
int *l_cells;
int *tmp;
int i;
int j;
/*
* Fetch the arguments.
* str_s is referred to as the "source"
* cols = length of source + 1 to allow for the initialization column
* str_t is referred to as the "target", rows = length of target + 1
* rows = length of target + 1 to allow for the initialization row
* Fetch the arguments. str_s is referred to as the "source" cols =
* length of source + 1 to allow for the initialization column str_t
* is referred to as the "target", rows = length of target + 1 rows =
* length of target + 1 to allow for the initialization row
*/
str_s = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
str_t = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
@ -75,18 +74,19 @@ levenshtein(PG_FUNCTION_ARGS)
rows = strlen(str_t) + 1;
/*
* Restrict the length of the strings being compared to something reasonable
* because we will have to perform rows * cols calcualtions. If longer strings need to be
* compared, increase MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for
* speed and memory usage).
* Restrict the length of the strings being compared to something
* reasonable because we will have to perform rows * cols
* calcualtions. If longer strings need to be compared, increase
* MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for speed
* and memory usage).
*/
if ((cols > MAX_LEVENSHTEIN_STRLEN + 1) || (rows > MAX_LEVENSHTEIN_STRLEN + 1))
elog(ERROR, "levenshtein: Arguments may not exceed %d characters in length", MAX_LEVENSHTEIN_STRLEN);
/*
* If either rows or cols is 0, the answer is the other value.
* This makes sense since it would take that many insertions
* the build a matching string
* If either rows or cols is 0, the answer is the other value. This
* makes sense since it would take that many insertions the build a
* matching string
*/
if (cols == 0)
@ -96,8 +96,9 @@ levenshtein(PG_FUNCTION_ARGS)
PG_RETURN_INT32(cols);
/*
* Allocate two vectors of integers. One will be used for the "upper" row,
* the other for the "lower" row. Initialize the "upper" row to 0..cols
* Allocate two vectors of integers. One will be used for the "upper"
* row, the other for the "lower" row. Initialize the "upper" row to
* 0..cols
*/
u_cells = palloc(sizeof(int) * cols);
for (i = 0; i < cols; i++)
@ -106,33 +107,35 @@ levenshtein(PG_FUNCTION_ARGS)
l_cells = palloc(sizeof(int) * cols);
/*
* Use str_s0 to "rewind" the pointer to str_s in the nested for loop below
* Use str_s0 to "rewind" the pointer to str_s in the nested for loop
* below
*/
str_s0 = str_s;
/*
* Loop throught the rows, starting at row 1. Row 0 is used for the initial
* "upper" row.
* Loop throught the rows, starting at row 1. Row 0 is used for the
* initial "upper" row.
*/
for (j = 1; j < rows; j++)
{
/*
* We'll always start with col 1,
* and initialize lower row col 0 to j
* We'll always start with col 1, and initialize lower row col 0
* to j
*/
l_cells[0] = j;
for (i = 1; i < cols; i++)
{
int c = 0;
int c1 = 0;
int c2 = 0;
int c3 = 0;
int c = 0;
int c1 = 0;
int c2 = 0;
int c3 = 0;
/*
* The "cost" value is 0 if the character at the current col position
* in the source string, matches the character at the current row position
* in the target string; cost is 1 otherwise.
* The "cost" value is 0 if the character at the current col
* position in the source string, matches the character at the
* current row position in the target string; cost is 1
* otherwise.
*/
c = ((CHAREQ(str_s, str_t)) ? 0 : 1);
@ -152,8 +155,7 @@ levenshtein(PG_FUNCTION_ARGS)
c3 = u_cells[i - 1] + c;
/*
* The lower right cell is set to the minimum
* of c1, c2, c3
* The lower right cell is set to the minimum of c1, c2, c3
*/
l_cells[i] = (c1 < c2 ? c1 : c2) < c3 ? (c1 < c2 ? c1 : c2) : c3;
@ -164,8 +166,8 @@ levenshtein(PG_FUNCTION_ARGS)
}
/*
* Lower row now becomes the upper row, and the upper row
* gets reused as the new lower row.
* Lower row now becomes the upper row, and the upper row gets
* reused as the new lower row.
*/
tmp = u_cells;
u_cells = l_cells;
@ -183,8 +185,8 @@ levenshtein(PG_FUNCTION_ARGS)
}
/*
* Because the final value (at position row, col) was swapped from
* the lower row to the upper row, that's where we'll find it.
* Because the final value (at position row, col) was swapped from the
* lower row to the upper row, that's where we'll find it.
*/
PG_RETURN_INT32(u_cells[cols - 1]);
}
@ -199,10 +201,10 @@ Datum
metaphone(PG_FUNCTION_ARGS)
{
int reqlen;
char *str_i;
char *str_i;
size_t str_i_len;
char *metaph;
text *result_text;
char *metaph;
text *result_text;
int retval;
str_i = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
@ -240,7 +242,7 @@ metaphone(PG_FUNCTION_ARGS)
}
/*
/*
* Original code by Michael G Schwern starts here.
* Code slightly modified for use as PostgreSQL
* function (palloc, etc). Original includes
@ -255,26 +257,28 @@ metaphone(PG_FUNCTION_ARGS)
/* Look at the current letter in the word */
#define Curr_Letter (toupper(word[w_idx]))
/* Go N letters back. */
#define Look_Back_Letter(n) (w_idx >= n ? toupper(word[w_idx-n]) : '\0')
#define Look_Back_Letter(n) (w_idx >= n ? toupper(word[w_idx-n]) : '\0')
/* Previous letter. I dunno, should this return null on failure? */
#define Prev_Letter (Look_Back_Letter(1))
/* Look two letters down. It makes sure you don't walk off the string. */
#define After_Next_Letter (Next_Letter != '\0' ? toupper(word[w_idx+2]) \
: '\0')
: '\0')
#define Look_Ahead_Letter(n) (toupper(Lookahead(word+w_idx, n)))
/* Allows us to safely look ahead an arbitrary # of letters */
/* I probably could have just used strlen... */
char Lookahead(char * word, int how_far) {
char letter_ahead = '\0'; /* null by default */
int idx;
for(idx = 0; word[idx] != '\0' && idx < how_far; idx++);
/* Edge forward in the string... */
letter_ahead = word[idx]; /* idx will be either == to how_far or
* at the end of the string
*/
char
Lookahead(char *word, int how_far)
{
char letter_ahead = '\0'; /* null by default */
int idx;
for (idx = 0; word[idx] != '\0' && idx < how_far; idx++);
/* Edge forward in the string... */
letter_ahead = word[idx]; /* idx will be either == to how_far or at
* the end of the string */
return letter_ahead;
}
@ -282,29 +286,30 @@ char Lookahead(char * word, int how_far) {
/* phonize one letter */
#define Phonize(c) do {(*phoned_word)[p_idx++] = c;} while (0)
/* Slap a null character on the end of the phoned word */
#define End_Phoned_Word do {(*phoned_word)[p_idx] = '\0';} while (0)
#define End_Phoned_Word do {(*phoned_word)[p_idx] = '\0';} while (0)
/* How long is the phoned word? */
#define Phone_Len (p_idx)
/* Note is a letter is a 'break' in the word */
#define Isbreak(c) (!isalpha(c))
#define Isbreak(c) (!isalpha(c))
int _metaphone (
/* IN */
char * word,
int max_phonemes,
/* OUT */
char ** phoned_word
) {
int w_idx = 0; /* point in the phonization we're at. */
int p_idx = 0; /* end of the phoned phrase */
int
_metaphone(
/* IN */
char *word,
int max_phonemes,
/* OUT */
char **phoned_word
)
{
int w_idx = 0; /* point in the phonization we're at. */
int p_idx = 0; /* end of the phoned phrase */
/*-- Parameter checks --*/
/*
* Shouldn't be necessary, but left these here anyway
* jec Aug 3, 2001
* Shouldn't be necessary, but left these here anyway jec Aug 3, 2001
*/
/* Negative phoneme length is meaningless */
@ -314,13 +319,16 @@ int _metaphone (
/* Empty/null string is meaningless */
if ((word == NULL) || !(strlen(word) > 0))
elog(ERROR, "metaphone: Input string length must be > 0");
/*-- Allocate memory for our phoned_phrase --*/
if (max_phonemes == 0) { /* Assume largest possible */
*phoned_word = palloc(sizeof(char) * strlen(word) + 1);
if (max_phonemes == 0)
{ /* Assume largest possible */
*phoned_word = palloc(sizeof(char) * strlen(word) +1);
if (!*phoned_word)
return META_ERROR;
} else {
}
else
{
*phoned_word = palloc(sizeof(char) * max_phonemes + 1);
if (!*phoned_word)
return META_ERROR;
@ -328,62 +336,70 @@ int _metaphone (
/*-- The first phoneme has to be processed specially. --*/
/* Find our first letter */
for( ; !isalpha(Curr_Letter); w_idx++ ) {
for (; !isalpha(Curr_Letter); w_idx++)
{
/* On the off chance we were given nothing but crap... */
if( Curr_Letter == '\0' ) {
if (Curr_Letter == '\0')
{
End_Phoned_Word
return META_SUCCESS; /* For testing */
return META_SUCCESS; /* For testing */
}
}
switch (Curr_Letter) {
/* AE becomes E */
}
switch (Curr_Letter)
{
/* AE becomes E */
case 'A':
if( Next_Letter == 'E' ) {
if (Next_Letter == 'E')
{
Phonize('E');
w_idx+=2;
w_idx += 2;
}
/* Remember, preserve vowels at the beginning */
else {
else
{
Phonize('A');
w_idx++;
}
break;
/* [GKP]N becomes N */
/* [GKP]N becomes N */
case 'G':
case 'K':
case 'P':
if( Next_Letter == 'N' ) {
if (Next_Letter == 'N')
{
Phonize('N');
w_idx+=2;
w_idx += 2;
}
break;
/* WH becomes H,
WR becomes R
W if followed by a vowel */
/*
* WH becomes H, WR becomes R W if followed by a vowel
*/
case 'W':
if( Next_Letter == 'H' ||
Next_Letter == 'R' )
if (Next_Letter == 'H' ||
Next_Letter == 'R')
{
Phonize(Next_Letter);
w_idx+=2;
Phonize(Next_Letter);
w_idx += 2;
}
else if ( isvowel(Next_Letter) ) {
Phonize('W');
w_idx+=2;
else if (isvowel(Next_Letter))
{
Phonize('W');
w_idx += 2;
}
/* else ignore */
break;
/* X becomes S */
/* X becomes S */
case 'X':
Phonize('S');
w_idx++;
break;
/* Vowels are kept */
/* We did A already
case 'A':
case 'a':
*/
/* Vowels are kept */
/*
* We did A already case 'A': case 'a':
*/
case 'E':
case 'I':
case 'O':
@ -395,220 +411,235 @@ int _metaphone (
/* do nothing */
break;
}
/* On to the metaphoning */
for(; Curr_Letter != '\0' &&
(max_phonemes == 0 || Phone_Len < max_phonemes);
w_idx++) {
/* How many letters to skip because an eariler encoding handled
* multiple letters */
unsigned short int skip_letter = 0;
/* THOUGHT: It would be nice if, rather than having things like...
* well, SCI. For SCI you encode the S, then have to remember
* to skip the C. So the phonome SCI invades both S and C. It would
* be better, IMHO, to skip the C from the S part of the encoding.
* Hell, I'm trying it.
/* On to the metaphoning */
for (; Curr_Letter != '\0' &&
(max_phonemes == 0 || Phone_Len < max_phonemes);
w_idx++)
{
/*
* How many letters to skip because an eariler encoding handled
* multiple letters
*/
unsigned short int skip_letter = 0;
/*
* THOUGHT: It would be nice if, rather than having things
* like... well, SCI. For SCI you encode the S, then have to
* remember to skip the C. So the phonome SCI invades both S and
* C. It would be better, IMHO, to skip the C from the S part of
* the encoding. Hell, I'm trying it.
*/
/* Ignore non-alphas */
if( !isalpha(Curr_Letter) )
if (!isalpha(Curr_Letter))
continue;
/* Drop duplicates, except CC */
if( Curr_Letter == Prev_Letter &&
Curr_Letter != 'C' )
if (Curr_Letter == Prev_Letter &&
Curr_Letter != 'C')
continue;
switch (Curr_Letter) {
/* B -> B unless in MB */
switch (Curr_Letter)
{
/* B -> B unless in MB */
case 'B':
if( Prev_Letter != 'M' )
if (Prev_Letter != 'M')
Phonize('B');
break;
/* 'sh' if -CIA- or -CH, but not SCH, except SCHW.
* (SCHW is handled in S)
* S if -CI-, -CE- or -CY-
* dropped if -SCI-, SCE-, -SCY- (handed in S)
* else K
*/
/*
* 'sh' if -CIA- or -CH, but not SCH, except SCHW. (SCHW
* is handled in S) S if -CI-, -CE- or -CY- dropped if
* -SCI-, SCE-, -SCY- (handed in S) else K
*/
case 'C':
if( MAKESOFT(Next_Letter) ) { /* C[IEY] */
if( After_Next_Letter == 'A' &&
Next_Letter == 'I' ) { /* CIA */
if (MAKESOFT(Next_Letter))
{ /* C[IEY] */
if (After_Next_Letter == 'A' &&
Next_Letter == 'I')
{ /* CIA */
Phonize(SH);
}
/* SC[IEY] */
else if ( Prev_Letter == 'S' ) {
/* Dropped */
}
else {
Phonize('S');
else if (Prev_Letter == 'S')
{
/* Dropped */
}
else
Phonize('S');
}
else if ( Next_Letter == 'H' ) {
else if (Next_Letter == 'H')
{
#ifndef USE_TRADITIONAL_METAPHONE
if( After_Next_Letter == 'R' ||
Prev_Letter == 'S' ) { /* Christ, School */
if (After_Next_Letter == 'R' ||
Prev_Letter == 'S')
{ /* Christ, School */
Phonize('K');
}
else {
else
Phonize(SH);
}
#else
Phonize(SH);
#endif
skip_letter++;
}
else {
else
Phonize('K');
}
break;
/* J if in -DGE-, -DGI- or -DGY-
* else T
*/
/*
* J if in -DGE-, -DGI- or -DGY- else T
*/
case 'D':
if( Next_Letter == 'G' &&
MAKESOFT(After_Next_Letter) ) {
if (Next_Letter == 'G' &&
MAKESOFT(After_Next_Letter))
{
Phonize('J');
skip_letter++;
}
else
Phonize('T');
break;
/* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH
* else dropped if -GNED, -GN,
* else dropped if -DGE-, -DGI- or -DGY- (handled in D)
* else J if in -GE-, -GI, -GY and not GG
* else K
*/
/*
* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH else
* dropped if -GNED, -GN, else dropped if -DGE-, -DGI- or
* -DGY- (handled in D) else J if in -GE-, -GI, -GY and
* not GG else K
*/
case 'G':
if( Next_Letter == 'H' ) {
if( !( NOGHTOF(Look_Back_Letter(3)) ||
Look_Back_Letter(4) == 'H' ) ) {
if (Next_Letter == 'H')
{
if (!(NOGHTOF(Look_Back_Letter(3)) ||
Look_Back_Letter(4) == 'H'))
{
Phonize('F');
skip_letter++;
}
else {
else
{
/* silent */
}
}
else if( Next_Letter == 'N' ) {
if( Isbreak(After_Next_Letter) ||
( After_Next_Letter == 'E' &&
Look_Ahead_Letter(3) == 'D' ) ) {
else if (Next_Letter == 'N')
{
if (Isbreak(After_Next_Letter) ||
(After_Next_Letter == 'E' &&
Look_Ahead_Letter(3) == 'D'))
{
/* dropped */
}
else
Phonize('K');
}
else if( MAKESOFT(Next_Letter) &&
Prev_Letter != 'G' ) {
else if (MAKESOFT(Next_Letter) &&
Prev_Letter != 'G')
Phonize('J');
}
else {
else
Phonize('K');
}
break;
/* H if before a vowel and not after C,G,P,S,T */
/* H if before a vowel and not after C,G,P,S,T */
case 'H':
if( isvowel(Next_Letter) &&
!AFFECTH(Prev_Letter) )
if (isvowel(Next_Letter) &&
!AFFECTH(Prev_Letter))
Phonize('H');
break;
/* dropped if after C
* else K
*/
/*
* dropped if after C else K
*/
case 'K':
if( Prev_Letter != 'C' )
if (Prev_Letter != 'C')
Phonize('K');
break;
/* F if before H
* else P
*/
/*
* F if before H else P
*/
case 'P':
if( Next_Letter == 'H' ) {
if (Next_Letter == 'H')
Phonize('F');
}
else {
else
Phonize('P');
}
break;
/* K
*/
/*
* K
*/
case 'Q':
Phonize('K');
break;
/* 'sh' in -SH-, -SIO- or -SIA- or -SCHW-
* else S
*/
/*
* 'sh' in -SH-, -SIO- or -SIA- or -SCHW- else S
*/
case 'S':
if( Next_Letter == 'I' &&
( After_Next_Letter == 'O' ||
After_Next_Letter == 'A' ) ) {
if (Next_Letter == 'I' &&
(After_Next_Letter == 'O' ||
After_Next_Letter == 'A'))
Phonize(SH);
}
else if ( Next_Letter == 'H' ) {
else if (Next_Letter == 'H')
{
Phonize(SH);
skip_letter++;
}
#ifndef USE_TRADITIONAL_METAPHONE
else if ( Next_Letter == 'C' &&
Look_Ahead_Letter(2) == 'H' &&
Look_Ahead_Letter(3) == 'W' ) {
else if (Next_Letter == 'C' &&
Look_Ahead_Letter(2) == 'H' &&
Look_Ahead_Letter(3) == 'W')
{
Phonize(SH);
skip_letter += 2;
}
#endif
else {
else
Phonize('S');
}
break;
/* 'sh' in -TIA- or -TIO-
* else 'th' before H
* else T
*/
/*
* 'sh' in -TIA- or -TIO- else 'th' before H else T
*/
case 'T':
if( Next_Letter == 'I' &&
( After_Next_Letter == 'O' ||
After_Next_Letter == 'A' ) ) {
if (Next_Letter == 'I' &&
(After_Next_Letter == 'O' ||
After_Next_Letter == 'A'))
Phonize(SH);
}
else if ( Next_Letter == 'H' ) {
else if (Next_Letter == 'H')
{
Phonize(TH);
skip_letter++;
}
else {
else
Phonize('T');
}
break;
/* F */
/* F */
case 'V':
Phonize('F');
break;
/* W before a vowel, else dropped */
/* W before a vowel, else dropped */
case 'W':
if( isvowel(Next_Letter) )
if (isvowel(Next_Letter))
Phonize('W');
break;
/* KS */
/* KS */
case 'X':
Phonize('K');
Phonize('S');
break;
/* Y if followed by a vowel */
/* Y if followed by a vowel */
case 'Y':
if( isvowel(Next_Letter) )
if (isvowel(Next_Letter))
Phonize('Y');
break;
/* S */
/* S */
case 'Z':
Phonize('S');
break;
/* No transformation */
/* No transformation */
case 'F':
case 'J':
case 'L':
@ -620,15 +651,15 @@ int _metaphone (
default:
/* nothing */
break;
} /* END SWITCH */
} /* END SWITCH */
w_idx += skip_letter;
} /* END FOR */
} /* END FOR */
End_Phoned_Word;
return(META_SUCCESS);
} /* END metaphone */
return (META_SUCCESS);
} /* END metaphone */
/*

56
contrib/fuzzystrmatch/fuzzystrmatch.h
View File

@ -24,13 +24,13 @@
* documentation for any purpose, without fee, and without a written agreement
* is hereby granted, provided that the above copyright notice and this
* paragraph and the following two paragraphs appear in all copies.
*
*
* IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
* LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
* DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*
* THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
@ -88,7 +88,7 @@ static const char *soundex_table = "01230120022455012623010202";
*/
#define MAX_METAPHONE_STRLEN 255
/*
/*
* Original code by Michael G Schwern starts here.
* Code slightly modified for use as PostgreSQL
* function (combined *.h into here).
@ -96,26 +96,26 @@ static const char *soundex_table = "01230120022455012623010202";
/**************************************************************************
metaphone -- Breaks english phrases down into their phonemes.
Input
word -- An english word to be phonized
max_phonemes -- How many phonemes to calculate. If 0, then it
word -- An english word to be phonized
max_phonemes -- How many phonemes to calculate. If 0, then it
will phonize the entire phrase.
phoned_word -- The final phonized word. (We'll allocate the
phoned_word -- The final phonized word. (We'll allocate the
memory.)
Output
error -- A simple error flag, returns TRUE or FALSE
NOTES: ALL non-alpha characters are ignored, this includes whitespace,
NOTES: ALL non-alpha characters are ignored, this includes whitespace,
although non-alpha characters will break up phonemes.
****************************************************************************/
/**************************************************************************
my constants -- constants I like
Probably redundant.
***************************************************************************/
#define META_ERROR FALSE
@ -123,22 +123,23 @@ static const char *soundex_table = "01230120022455012623010202";
#define META_FAILURE FALSE
/* I add modifications to the traditional metaphone algorithm that you
/* I add modifications to the traditional metaphone algorithm that you
might find in books. Define this if you want metaphone to behave
traditionally */
#undef USE_TRADITIONAL_METAPHONE
/* Special encodings */
#define SH 'X'
#define SH 'X'
#define TH '0'
char Lookahead(char * word, int how_far);
int _metaphone (
/* IN */
char * word,
int max_phonemes,
/* OUT */
char ** phoned_word
char Lookahead(char *word, int how_far);
int
_metaphone(
/* IN */
char *word,
int max_phonemes,
/* OUT */
char **phoned_word
);
/* Metachar.h ... little bits about characters for metaphone */
@ -146,9 +147,9 @@ int _metaphone (
/*-- Character encoding array & accessing macros --*/
/* Stolen directly out of the book... */
char _codes[26] = {
1,16,4,16,9,2,4,16,9,2,0,2,2,2,1,4,0,2,4,4,1,0,0,0,8,0
/* a b c d e f g h i j k l m n o p q r s t u v w x y z */
char _codes[26] = {
1, 16, 4, 16, 9, 2, 4, 16, 9, 2, 0, 2, 2, 2, 1, 4, 0, 2, 4, 4, 1, 0, 0, 0, 8, 0
/* a b c d e f g h i j k l m n o p q r s t u v w x y z */
};
@ -157,16 +158,15 @@ char _codes[26] = {
#define isvowel(c) (ENCODE(c) & 1) /* AEIOU */
/* These letters are passed through unchanged */
#define NOCHANGE(c) (ENCODE(c) & 2) /* FJMNR */
#define NOCHANGE(c) (ENCODE(c) & 2) /* FJMNR */
/* These form dipthongs when preceding H */
#define AFFECTH(c) (ENCODE(c) & 4) /* CGPST */
#define AFFECTH(c) (ENCODE(c) & 4) /* CGPST */
/* These make C and G soft */
#define MAKESOFT(c) (ENCODE(c) & 8) /* EIY */
#define MAKESOFT(c) (ENCODE(c) & 8) /* EIY */
/* These prevent GH from becoming F */
#define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */
#define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */
#endif /* FUZZYSTRMATCH_H */

9
contrib/lo/lo.c
View File

@ -1,7 +1,7 @@
/*
* PostgreSQL type definitions for managed LargeObjects.
*
* $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.8 2001/03/22 03:59:09 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.9 2001/10/25 05:49:19 momjian Exp $
*
*/
@ -33,8 +33,8 @@ typedef Oid Blob;
*/
Blob *lo_in(char *str); /* Create from String */
char *lo_out(Blob * addr);/* Output oid as String */
Oid lo_oid(Blob * addr);/* Return oid as an oid */
char *lo_out(Blob * addr); /* Output oid as String */
Oid lo_oid(Blob * addr); /* Return oid as an oid */
Blob *lo(Oid oid); /* Return Blob based on oid */
Datum lo_manage(PG_FUNCTION_ARGS); /* Trigger handler */
@ -64,7 +64,6 @@ lo_in(char *str)
}
else
{
/*
* There is no Oid passed, so create a new one
*/
@ -140,7 +139,7 @@ lo_manage(PG_FUNCTION_ARGS)
TupleDesc tupdesc; /* Tuple Descriptor */
HeapTuple rettuple; /* Tuple to be returned */
bool isdelete; /* are we deleting? */
HeapTuple newtuple = NULL;/* The new value for tuple */
HeapTuple newtuple = NULL; /* The new value for tuple */
HeapTuple trigtuple; /* The original value of tuple */
if (!CALLED_AS_TRIGGER(fcinfo))

12
contrib/mSQL-interface/mpgsql.c
View File

@ -229,7 +229,7 @@ msqlGetSequenceInfo(int a, char *b)
{
}
m_field *
m_field *
msqlFetchField(m_result * mr)
{
m_field *m = (m_field *) mr->fieldCursor;
@ -242,7 +242,7 @@ msqlFetchField(m_result * mr)
return NULL;
}
m_result *
m_result *
msqlListDBs(int a)
{
m_result *m;
@ -256,7 +256,7 @@ msqlListDBs(int a)
return NULL;
}
m_result *
m_result *
msqlListTables(int a)
{
m_result *m;
@ -272,13 +272,13 @@ msqlListTables(int a)
return NULL;
}
m_result *
m_result *
msqlListFields(int a, char *b)
{
}
m_result *
m_result *
msqlListIndex(int a, char *b, char *c)
{
m_result *m;
@ -294,7 +294,7 @@ msqlListIndex(int a, char *b, char *c)
return NULL;
}
m_result *
m_result *
msqlStoreResult(void)
{
if (queryres)

1
contrib/miscutil/misc_utils.h
View File

@ -6,5 +6,4 @@ int unlisten(char *relname);
int max(int x, int y);
int min(int x, int y);
int active_listeners(text *relname);
#endif

4
contrib/pg_controldata/pg_controldata.c
View File

@ -6,7 +6,7 @@
* copyright (c) Oliver Elphick <olly@lfix.co.uk>, 2001;
* licence: BSD
*
* $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.4 2001/09/06 10:49:29 petere Exp $
* $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
*/
#include "postgres.h"
@ -24,7 +24,7 @@ dbState(DBState state)
{
switch (state)
{
case DB_STARTUP:
case DB_STARTUP:
return "STARTUP";
case DB_SHUTDOWNED:
return "SHUTDOWNED";

11
contrib/pg_dumplo/lo_export.c
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.7 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.8 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -32,14 +32,14 @@ load_lolist(LODumpMaster * pgLO)
int i;
int n;
/*
/*
* Now find any candidate tables who have columns of type oid.
*
* NOTE: System tables including pg_largeobject will be ignored.
* Otherwise we'd end up dumping all LOs, referenced or not.
*
* NOTE: the system oid column is ignored, as it has attnum < 1.
* This shouldn't matter for correctness, but it saves time.
* NOTE: the system oid column is ignored, as it has attnum < 1. This
* shouldn't matter for correctness, but it saves time.
*/
pgLO->res = PQexec(pgLO->conn,
"SELECT c.relname, a.attname "
@ -107,8 +107,7 @@ pglo_export(LODumpMaster * pgLO)
for (ll = pgLO->lolist; ll->lo_table != NULL; ll++)
{
/*
/*
* Query: find the LOs referenced by this column
*/
sprintf(Qbuff, "SELECT DISTINCT l.loid FROM \"%s\" x, pg_largeobject l WHERE x.\"%s\" = l.loid",

6
contrib/pg_dumplo/lo_import.c
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.5 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -50,7 +50,7 @@ pglo_import(LODumpMaster * pgLO)
sprintf(lo_path, "%s/%s", pgLO->space, path);
/*
/*
* Import LO
*/
if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0)
@ -78,7 +78,7 @@ pglo_import(LODumpMaster * pgLO)
pgLO->counter++;
/*
/*
* UPDATE oid in tab
*/
sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u",

9
contrib/pg_dumplo/main.c
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.8 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.9 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -152,7 +152,7 @@ main(int argc, char **argv)
exit(RE_ERROR);
}
/*
/*
* Check space
*/
if (!pgLO->space && !pgLO->action == ACTION_SHOW)
@ -170,7 +170,7 @@ main(int argc, char **argv)
exit(RE_ERROR);
}
/*
/*
* Make connection
*/
pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db,
@ -186,7 +186,7 @@ main(int argc, char **argv)
pgLO->user = PQuser(pgLO->conn);
/*
/*
* Init index file
*/
if (pgLO->action != ACTION_SHOW)
@ -304,7 +304,6 @@ usage()
"-q run quietly\n"
"-w not dump, but show all LO in DB\n"
); /* puts() */
#endif
puts(

13
contrib/pg_dumplo/pg_dumplo.h
View File

@ -1,7 +1,7 @@
/* -------------------------------------------------------------------------
* pg_dumplo
*
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.4 2001/03/22 03:59:10 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.5 2001/10/25 05:49:19 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
@ -64,11 +64,11 @@ typedef struct
typedef enum
{
ACTION_NONE,
ACTION_SHOW,
ACTION_EXPORT_ATTR,
ACTION_EXPORT_ALL,
ACTION_IMPORT
ACTION_NONE,
ACTION_SHOW,
ACTION_EXPORT_ATTR,
ACTION_EXPORT_ALL,
ACTION_IMPORT
} PGLODUMP_ACTIONS;
extern char *progname;
@ -78,5 +78,4 @@ extern void index_file(LODumpMaster * pgLO);
extern void load_lolist(LODumpMaster * pgLO);
extern void pglo_export(LODumpMaster * pgLO);
extern void pglo_import(LODumpMaster * pgLO);
#endif /* PG_DUMPLO_H */

7
contrib/pg_resetxlog/pg_resetxlog.c
View File

@ -23,7 +23,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.7 2001/10/25 00:55:48 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.8 2001/10/25 05:49:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -147,7 +147,6 @@ ReadControlFile(void)
if ((fd = open(ControlFilePath, O_RDONLY)) < 0)
{
/*
* If pg_control is not there at all, or we can't read it, the
* odds are we've been handed a bad DataDir path, so give up. User
@ -412,7 +411,6 @@ CheckControlVersion0(char *buffer, int len)
(char *) malloc(_INTL_MAXLOGRECSZ));
if (record == NULL)
{
/*
* We have to guess at the checkpoint contents.
*/
@ -493,7 +491,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer)
readFile = XLogFileOpen(readId, readSeg);
if (readFile < 0)
goto next_record_is_invalid;
readOff = (uint32) (-1);/* force read to occur below */
readOff = (uint32) (-1); /* force read to occur below */
}
targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ;
@ -617,7 +615,6 @@ GuessControlValues(void)
{
#ifdef USE_LOCALE
char *localeptr;
#endif
/*

145
contrib/pgbench/pgbench.c
View File

@ -1,5 +1,5 @@
/*
* $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.11 2001/10/24 08:07:22 ishii Exp $
* $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.12 2001/10/25 05:49:19 momjian Exp $
*
* pgbench: a simple TPC-B like benchmark program for PostgreSQL
* written by Tatsuo Ishii
@ -39,7 +39,6 @@
/* for getrlimit */
#include <sys/resource.h>
#endif /* WIN32 */
/********************************************************************
@ -67,7 +66,8 @@ int tps = 1;
int remains; /* number of remained clients */
int is_connect; /* establish connection for each transactoin */
int is_connect; /* establish connection for each
* transactoin */
char *pghost = "";
char *pgport = NULL;
@ -107,31 +107,32 @@ getrand(int min, int max)
}
/* set up a connection to the backend */
static PGconn *doConnect()
static PGconn *
doConnect()
{
PGconn *con;
PGconn *con;
con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName,
login, pwd);
if (con == NULL)
{
fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
fprintf(stderr, "Memory allocatin problem?\n");
return(NULL);
}
if (PQstatus(con) == CONNECTION_BAD)
{
fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName,
login, pwd);
if (con == NULL)
{
fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
fprintf(stderr, "Memory allocatin problem?\n");
return (NULL);
}
if (PQerrorMessage(con))
fprintf(stderr, "%s", PQerrorMessage(con));
else
fprintf(stderr, "No explanation from the backend\n");
if (PQstatus(con) == CONNECTION_BAD)
{
fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
return(NULL);
}
return (con);
if (PQerrorMessage(con))
fprintf(stderr, "%s", PQerrorMessage(con));
else
fprintf(stderr, "No explanation from the backend\n");
return (NULL);
}
return (con);
}
/* throw away response from backend */
@ -162,7 +163,7 @@ check(CState * state, PGresult *res, int n, int good)
st->con = NULL;
return (-1);
}
return (0); /* OK */
return (0); /* OK */
}
/* process a transaction */
@ -242,8 +243,8 @@ doOne(CState * state, int n, int debug)
if (is_connect)
{
PQfinish(st->con);
st->con = NULL;
PQfinish(st->con);
st->con = NULL;
}
if (++st->cnt >= nxacts)
@ -251,8 +252,8 @@ doOne(CState * state, int n, int debug)
remains--; /* I've done */
if (st->con != NULL)
{
PQfinish(st->con);
st->con = NULL;
PQfinish(st->con);
st->con = NULL;
}
return;
}
@ -267,15 +268,15 @@ doOne(CState * state, int n, int debug)
if (st->con == NULL)
{
if ((st->con = doConnect()) == NULL)
{
fprintf(stderr, "Client %d aborted in establishing connection.\n",
n);
remains--; /* I've aborted */
PQfinish(st->con);
st->con = NULL;
return;
}
if ((st->con = doConnect()) == NULL)
{
fprintf(stderr, "Client %d aborted in establishing connection.\n",
n);
remains--; /* I've aborted */
PQfinish(st->con);
st->con = NULL;
return;
}
}
switch (st->state)
@ -358,8 +359,8 @@ doSelectOnly(CState * state, int n, int debug)
if (is_connect)
{
PQfinish(st->con);
st->con = NULL;
PQfinish(st->con);
st->con = NULL;
}
if (++st->cnt >= nxacts)
@ -367,8 +368,8 @@ doSelectOnly(CState * state, int n, int debug)
remains--; /* I've done */
if (st->con != NULL)
{
PQfinish(st->con);
st->con = NULL;
PQfinish(st->con);
st->con = NULL;
}
return;
}
@ -383,15 +384,15 @@ doSelectOnly(CState * state, int n, int debug)
if (st->con == NULL)
{
if ((st->con = doConnect()) == NULL)
{
fprintf(stderr, "Client %d aborted in establishing connection.\n",
n);
remains--; /* I've aborted */
PQfinish(st->con);
st->con = NULL;
return;
}
if ((st->con = doConnect()) == NULL)
{
fprintf(stderr, "Client %d aborted in establishing connection.\n",
n);
remains--; /* I've aborted */
PQfinish(st->con);
st->con = NULL;
return;
}
}
switch (st->state)
@ -450,7 +451,7 @@ init()
int i;
if ((con = doConnect()) == NULL)
exit(1);
exit(1);
for (i = 0; i < (sizeof(DDLs) / sizeof(char *)); i++)
{
@ -532,29 +533,30 @@ init()
if (j % 10000 == 0)
{
/*
* every 10000 tuples, we commit the copy command.
* this should avoid generating too much WAL logs
* every 10000 tuples, we commit the copy command. this should
* avoid generating too much WAL logs
*/
fprintf(stderr, "%d tuples done.\n", j);
if (PQputline(con, "\\.\n"))
{
fprintf(stderr, "very last PQputline failed\n");
exit(1);
fprintf(stderr, "very last PQputline failed\n");
exit(1);
}
if (PQendcopy(con))
{
fprintf(stderr, "PQendcopy failed\n");
exit(1);
fprintf(stderr, "PQendcopy failed\n");
exit(1);
}
/*
* do a checkpoint to purge the old WAL logs
*/
res = PQexec(con, "checkpoint");
if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "%s", PQerrorMessage(con));
exit(1);
fprintf(stderr, "%s", PQerrorMessage(con));
exit(1);
}
}
}
@ -634,7 +636,6 @@ main(int argc, char **argv)
#ifndef __CYGWIN__
struct rlimit rlim;
#endif
PGconn *con;
@ -691,9 +692,9 @@ main(int argc, char **argv)
}
#endif /* #ifndef __CYGWIN__ */
break;
case 'C':
is_connect = 1;
break;
case 'C':
is_connect = 1;
break;
case 's':
tps = atoi(optarg);
if (tps <= 0)
@ -734,7 +735,7 @@ main(int argc, char **argv)
if (is_init_mode)
{
init();
init();
exit(0);
}
@ -749,7 +750,7 @@ main(int argc, char **argv)
/* opening connection... */
con = doConnect();
if (con == NULL)
exit(1);
exit(1);
if (PQstatus(con) == CONNECTION_BAD)
{
@ -836,12 +837,12 @@ main(int argc, char **argv)
if (is_connect == 0)
{
/* make connections to the database */
for (i = 0; i < nclients; i++)
{
if ((state[i].con = doConnect()) == NULL)
exit(1);
}
/* make connections to the database */
for (i = 0; i < nclients; i++)
{
if ((state[i].con = doConnect()) == NULL)
exit(1);
}
}
/* time after connections set up */

743
contrib/pgcrypto/blf.c
View File

@ -11,15 +11,15 @@
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Niels Provos.
* must display the following acknowledgement:
* This product includes software developed by Niels Provos.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@ -46,338 +46,354 @@
#undef inline
#ifdef __GNUC__
#define inline __inline
#else /* !__GNUC__ */
#else /* !__GNUC__ */
#define inline
#endif /* !__GNUC__ */
#endif /* !__GNUC__ */
/* Function for Feistel Networks */
#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \
#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \
+ (s)[0x100 + (((x)>>16)&0xFF)]) \
^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
+ (s)[0x300 + ( (x) &0xFF)])
+ (s)[0x300 + ( (x) &0xFF)])
#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
void
Blowfish_encipher(blf_ctx *c, uint32 *x)
Blowfish_encipher(blf_ctx * c, uint32 *x)
{
uint32 Xl;
uint32 Xr;
uint32 *s = c->S[0];
uint32 *p = c->P;
uint32 Xl;
uint32 Xr;
uint32 *s = c->S[0];
uint32 *p = c->P;
Xl = x[0];
Xr = x[1];
Xl ^= p[0];
BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
BLFRND(s, p, Xr, Xl, 1);
BLFRND(s, p, Xl, Xr, 2);
BLFRND(s, p, Xr, Xl, 3);
BLFRND(s, p, Xl, Xr, 4);
BLFRND(s, p, Xr, Xl, 5);
BLFRND(s, p, Xl, Xr, 6);
BLFRND(s, p, Xr, Xl, 7);
BLFRND(s, p, Xl, Xr, 8);
BLFRND(s, p, Xr, Xl, 9);
BLFRND(s, p, Xl, Xr, 10);
BLFRND(s, p, Xr, Xl, 11);
BLFRND(s, p, Xl, Xr, 12);
BLFRND(s, p, Xr, Xl, 13);
BLFRND(s, p, Xl, Xr, 14);
BLFRND(s, p, Xr, Xl, 15);
BLFRND(s, p, Xl, Xr, 16);
x[0] = Xr ^ p[17];
x[1] = Xl;
}
void
Blowfish_decipher(blf_ctx *c, uint32 *x)
Blowfish_decipher(blf_ctx * c, uint32 *x)
{
uint32 Xl;
uint32 Xr;
uint32 *s = c->S[0];
uint32 *p = c->P;
uint32 Xl;
uint32 Xr;
uint32 *s = c->S[0];
uint32 *p = c->P;
Xl = x[0];
Xr = x[1];
Xl ^= p[17];
BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
BLFRND(s, p, Xr, Xl, 16);
BLFRND(s, p, Xl, Xr, 15);
BLFRND(s, p, Xr, Xl, 14);
BLFRND(s, p, Xl, Xr, 13);
BLFRND(s, p, Xr, Xl, 12);
BLFRND(s, p, Xl, Xr, 11);
BLFRND(s, p, Xr, Xl, 10);
BLFRND(s, p, Xl, Xr, 9);
BLFRND(s, p, Xr, Xl, 8);
BLFRND(s, p, Xl, Xr, 7);
BLFRND(s, p, Xr, Xl, 6);
BLFRND(s, p, Xl, Xr, 5);
BLFRND(s, p, Xr, Xl, 4);
BLFRND(s, p, Xl, Xr, 3);
BLFRND(s, p, Xr, Xl, 2);
BLFRND(s, p, Xl, Xr, 1);
x[0] = Xr ^ p[0];
x[1] = Xl;
}
void
Blowfish_initstate(blf_ctx *c)
Blowfish_initstate(blf_ctx * c)
{
/* P-box and S-box tables initialized with digits of Pi */
const blf_ctx initstate =
{ {
{
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
{
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
{
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
{
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
{{
{
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
{
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
{
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
{
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
},
{
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
@ -385,7 +401,7 @@ Blowfish_initstate(blf_ctx *c)
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b
} };
}};
*c = initstate;
@ -394,14 +410,15 @@ Blowfish_initstate(blf_ctx *c)
uint32
Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
{
uint8 i;
uint16 j;
uint32 temp;
uint8 i;
uint16 j;
uint32 temp;
temp = 0x00000000;
j = *current;
for (i = 0; i < 4; i++, j++) {
for (i = 0; i < 4; i++, j++)
{
if (j >= databytes)
j = 0;
temp = (temp << 8) | data[j];
@ -412,16 +429,17 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
}
void
Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
Blowfish_expand0state(blf_ctx * c, const uint8 *key, uint16 keybytes)
{
uint16 i;
uint16 j;
uint16 k;
uint32 temp;
uint32 data[2];
uint16 i;
uint16 j;
uint16 k;
uint32 temp;
uint32 data[2];
j = 0;
for (i = 0; i < BLF_N + 2; i++) {
for (i = 0; i < BLF_N + 2; i++)
{
/* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp;
@ -430,15 +448,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
j = 0;
data[0] = 0x00000000;
data[1] = 0x00000000;
for (i = 0; i < BLF_N + 2; i += 2) {
for (i = 0; i < BLF_N + 2; i += 2)
{
Blowfish_encipher(c, data);
c->P[i] = data[0];
c->P[i + 1] = data[1];
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
for (i = 0; i < 4; i++)
{
for (k = 0; k < 256; k += 2)
{
Blowfish_encipher(c, data);
c->S[i][k] = data[0];
@ -449,17 +470,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
void
Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
const uint8 *key, uint16 keybytes)
Blowfish_expandstate(blf_ctx * c, const uint8 *data, uint16 databytes,
const uint8 *key, uint16 keybytes)
{
uint16 i;
uint16 j;
uint16 k;
uint32 temp;
uint32 d[2];
uint16 i;
uint16 j;
uint16 k;
uint32 temp;
uint32 d[2];
j = 0;
for (i = 0; i < BLF_N + 2; i++) {
for (i = 0; i < BLF_N + 2; i++)
{
/* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp;
@ -468,7 +490,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
j = 0;
d[0] = 0x00000000;
d[1] = 0x00000000;
for (i = 0; i < BLF_N + 2; i += 2) {
for (i = 0; i < BLF_N + 2; i += 2)
{
d[0] ^= Blowfish_stream2word(data, databytes, &j);
d[1] ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, d);
@ -477,9 +500,11 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
c->P[i + 1] = d[1];
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
d[0]^= Blowfish_stream2word(data, databytes, &j);
for (i = 0; i < 4; i++)
{
for (k = 0; k < 256; k += 2)
{
d[0] ^= Blowfish_stream2word(data, databytes, &j);
d[1] ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, d);
@ -491,7 +516,7 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
}
void
blf_key(blf_ctx *c, const uint8 *k, uint16 len)
blf_key(blf_ctx * c, const uint8 *k, uint16 len)
{
/* Initalize S-boxes and subkeys with Pi */
Blowfish_initstate(c);
@ -501,38 +526,43 @@ blf_key(blf_ctx *c, const uint8 *k, uint16 len)
}
void
blf_enc(blf_ctx *c, uint32 *data, uint16 blocks)
blf_enc(blf_ctx * c, uint32 *data, uint16 blocks)
{
uint32 *d;
uint16 i;
uint32 *d;
uint16 i;
d = data;
for (i = 0; i < blocks; i++) {
for (i = 0; i < blocks; i++)
{
Blowfish_encipher(c, d);
d += 2;
}
}
void
blf_dec(blf_ctx *c, uint32 *data, uint16 blocks)
blf_dec(blf_ctx * c, uint32 *data, uint16 blocks)
{
uint32 *d;
uint16 i;
uint32 *d;
uint16 i;
d = data;
for (i = 0; i < blocks; i++) {
for (i = 0; i < blocks; i++)
{
Blowfish_decipher(c, d);
d += 2;
}
}
void
blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len)
blf_ecb_encrypt(blf_ctx * c, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 i;
uint32 l,
r,
d[2];
uint32 i;
for (i = 0; i < len; i += 8) {
for (i = 0; i < len; i += 8)
{
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l;
@ -553,12 +583,15 @@ blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len)
}
void
blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len)
blf_ecb_decrypt(blf_ctx * c, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 i;
uint32 l,
r,
d[2];
uint32 i;
for (i = 0; i < len; i += 8) {
for (i = 0; i < len; i += 8)
{
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l;
@ -579,12 +612,16 @@ blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len)
}
void
blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len)
blf_cbc_encrypt(blf_ctx * c, uint8 *iv, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint32 i, j;
uint32 l,
r,
d[2];
uint32 i,
j;
for (i = 0; i < len; i += 8) {
for (i = 0; i < len; i += 8)
{
for (j = 0; j < 8; j++)
data[j] ^= iv[j];
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
@ -608,15 +645,19 @@ blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len)
}
void
blf_cbc_decrypt(blf_ctx *c, uint8 *iva, uint8 *data, uint32 len)
blf_cbc_decrypt(blf_ctx * c, uint8 *iva, uint8 *data, uint32 len)
{
uint32 l, r, d[2];
uint8 *iv;
uint32 i, j;
uint32 l,
r,
d[2];
uint8 *iv;
uint32 i,
j;
iv = data + len - 16;
data = data + len - 8;
for (i = len - 8; i >= 8; i -= 8) {
for (i = len - 8; i >= 8; i -= 8)
{
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
d[0] = l;

56
contrib/pgcrypto/blf.h
View File

@ -1,4 +1,4 @@
/* $OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */
/* $OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */
/*
* Blowfish - a fast block cipher designed by Bruce Schneier
@ -10,15 +10,15 @@
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Niels Provos.
* must display the following acknowledgement:
* This product includes software developed by Niels Provos.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@ -42,14 +42,15 @@
* of the key affect all cipherbits.
*/
#define BLF_N 16 /* Number of Subkeys */
#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */
#define BLF_N 16 /* Number of Subkeys */
#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */
/* Blowfish context */
typedef struct BlowfishContext {
uint32 S[4][256]; /* S-Boxes */
uint32 P[BLF_N + 2]; /* Subkeys */
} blf_ctx;
typedef struct BlowfishContext
{
uint32 S[4][256]; /* S-Boxes */
uint32 P[BLF_N + 2]; /* Subkeys */
} blf_ctx;
/* Raw access to customized Blowfish
* blf_key is just:
@ -57,26 +58,25 @@ typedef struct BlowfishContext {
* Blowfish_expand0state( state, key, keylen )
*/
void Blowfish_encipher (blf_ctx *, uint32 *);
void Blowfish_decipher (blf_ctx *, uint32 *);
void Blowfish_initstate (blf_ctx *);
void Blowfish_expand0state (blf_ctx *, const uint8 *, uint16);
void Blowfish_expandstate
(blf_ctx *, const uint8 *, uint16, const uint8 *, uint16);
void Blowfish_encipher(blf_ctx *, uint32 *);
void Blowfish_decipher(blf_ctx *, uint32 *);
void Blowfish_initstate(blf_ctx *);
void Blowfish_expand0state(blf_ctx *, const uint8 *, uint16);
void Blowfish_expandstate
(blf_ctx *, const uint8 *, uint16, const uint8 *, uint16);
/* Standard Blowfish */
void blf_key (blf_ctx *, const uint8 *, uint16);
void blf_enc (blf_ctx *, uint32 *, uint16);
void blf_dec (blf_ctx *, uint32 *, uint16);
void blf_key(blf_ctx *, const uint8 *, uint16);
void blf_enc(blf_ctx *, uint32 *, uint16);
void blf_dec(blf_ctx *, uint32 *, uint16);
/* Converts uint8 to uint32 */
uint32 Blowfish_stream2word (const uint8 *, uint16, uint16 *);
uint32 Blowfish_stream2word(const uint8 *, uint16, uint16 *);
void blf_ecb_encrypt (blf_ctx *, uint8 *, uint32);
void blf_ecb_decrypt (blf_ctx *, uint8 *, uint32);
void blf_cbc_encrypt (blf_ctx *, uint8 *, uint8 *, uint32);
void blf_cbc_decrypt (blf_ctx *, uint8 *, uint8 *, uint32);
void blf_ecb_encrypt(blf_ctx *, uint8 *, uint32);
void blf_ecb_decrypt(blf_ctx *, uint8 *, uint32);
void blf_cbc_encrypt(blf_ctx *, uint8 *, uint8 *, uint32);
void blf_cbc_decrypt(blf_ctx *, uint8 *, uint8 *, uint32);
#endif

171
contrib/pgcrypto/crypt-blowfish.c
View File

@ -57,10 +57,11 @@ typedef unsigned int BF_word;
typedef BF_word BF_key[BF_N + 2];
typedef struct {
BF_word S[4][0x100];
BF_key P;
} BF_ctx;
typedef struct
{
BF_word S[4][0x100];
BF_key P;
} BF_ctx;
/*
* Magic IV for 64 Blowfish encryptions that we do at the end.
@ -347,7 +348,7 @@ static BF_ctx BF_init_state = {
};
static unsigned char BF_itoa64[64 + 1] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static unsigned char BF_atoi64[0x60] = {
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1,
@ -367,22 +368,30 @@ do { \
(dst) = tmp; \
} while (0)
static int BF_decode(BF_word *dst, const char *src, int size)
static int
BF_decode(BF_word * dst, const char *src, int size)
{
unsigned char *dptr = (unsigned char *)dst;
unsigned char *dptr = (unsigned char *) dst;
unsigned char *end = dptr + size;
unsigned char *sptr = (unsigned char *)src;
unsigned int tmp, c1, c2, c3, c4;
unsigned char *sptr = (unsigned char *) src;
unsigned int tmp,
c1,
c2,
c3,
c4;
do {
do
{
BF_safe_atoi64(c1, *sptr++);
BF_safe_atoi64(c2, *sptr++);
*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
if (dptr >= end) break;
if (dptr >= end)
break;
BF_safe_atoi64(c3, *sptr++);
*dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2);
if (dptr >= end) break;
if (dptr >= end)
break;
BF_safe_atoi64(c4, *sptr++);
*dptr++ = ((c3 & 0x03) << 6) | c4;
@ -391,18 +400,22 @@ static int BF_decode(BF_word *dst, const char *src, int size)
return 0;
}
static void BF_encode(char *dst, const BF_word *src, int size)
static void
BF_encode(char *dst, const BF_word * src, int size)
{
unsigned char *sptr = (unsigned char *)src;
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *)dst;
unsigned int c1, c2;
unsigned char *dptr = (unsigned char *) dst;
unsigned int c1,
c2;
do {
do
{
c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -411,7 +424,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -423,18 +437,20 @@ static void BF_encode(char *dst, const BF_word *src, int size)
} while (sptr < end);
}
static void BF_swap(BF_word *x, int count)
static void
BF_swap(BF_word * x, int count)
{
static int endianness_check = 1;
char *is_little_endian = (char *)&endianness_check;
BF_word tmp;
static int endianness_check = 1;
char *is_little_endian = (char *) &endianness_check;
BF_word tmp;
if (*is_little_endian)
do {
tmp = *x;
tmp = (tmp << 16) | (tmp >> 16);
*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
} while (--count);
do
{
tmp = *x;
tmp = (tmp << 16) | (tmp >> 16);
*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
} while (--count);
}
#if BF_SCALE
@ -504,7 +520,8 @@ static void BF_swap(BF_word *x, int count)
#if BF_ASM
extern void _BF_body_r(BF_ctx *ctx);
extern void _BF_body_r(BF_ctx * ctx);
#define BF_body() \
_BF_body_r(&data.ctx);
@ -527,22 +544,28 @@ extern void _BF_body_r(BF_ctx *ctx);
*(ptr - 2) = L; \
*(ptr - 1) = R; \
} while (ptr < &data.ctx.S[3][0xFF]);
#endif
static void BF_set_key(const char *key, BF_key expanded, BF_key initial)
static void
BF_set_key(const char *key, BF_key expanded, BF_key initial)
{
const char *ptr = key;
int i, j;
BF_word tmp;
int i,
j;
BF_word tmp;
for (i = 0; i < BF_N + 2; i++) {
for (i = 0; i < BF_N + 2; i++)
{
tmp = 0;
for (j = 0; j < 4; j++) {
for (j = 0; j < 4; j++)
{
tmp <<= 8;
tmp |= *ptr;
if (!*ptr) ptr = key; else ptr++;
if (!*ptr)
ptr = key;
else
ptr++;
}
expanded[i] = tmp;
@ -550,41 +573,51 @@ static void BF_set_key(const char *key, BF_key expanded, BF_key initial)
}
}
char *_crypt_blowfish_rn(const char *key, const char *setting,
char *output, int size)
char *
_crypt_blowfish_rn(const char *key, const char *setting,
char *output, int size)
{
struct {
BF_ctx ctx;
BF_key expanded_key;
union {
BF_word salt[4];
BF_word output[6];
} binary;
} data;
BF_word L, R;
BF_word tmp1, tmp2, tmp3, tmp4;
BF_word *ptr;
BF_word count;
int i;
struct
{
BF_ctx ctx;
BF_key expanded_key;
union
{
BF_word salt[4];
BF_word output[6];
} binary;
} data;
BF_word L,
R;
BF_word tmp1,
tmp2,
tmp3,
tmp4;
BF_word *ptr;
BF_word count;
int i;
if (size < 7 + 22 + 31 + 1) {
if (size < 7 + 22 + 31 + 1)
{
__set_errno(ERANGE);
return NULL;
}
if (setting[0] != '$' ||
setting[1] != '2' ||
setting[2] != 'a' ||
setting[3] != '$' ||
setting[4] < '0' || setting[4] > '3' ||
setting[5] < '0' || setting[5] > '9' ||
setting[6] != '$') {
setting[1] != '2' ||
setting[2] != 'a' ||
setting[3] != '$' ||
setting[4] < '0' || setting[4] > '3' ||
setting[5] < '0' || setting[5] > '9' ||
setting[6] != '$')
{
__set_errno(EINVAL);
return NULL;
}
count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) {
count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16))
{
memset(data.binary.salt, 0, sizeof(data.binary.salt));
__set_errno(EINVAL);
return NULL;
@ -596,7 +629,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S));
L = R = 0;
for (i = 0; i < BF_N + 2; i += 2) {
for (i = 0; i < BF_N + 2; i += 2)
{
L ^= data.binary.salt[i & 2];
R ^= data.binary.salt[(i & 2) + 1];
BF_ENCRYPT;
@ -605,7 +639,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
}
ptr = data.ctx.S[0];
do {
do
{
ptr += 4;
L ^= data.binary.salt[(BF_N + 2) & 3];
R ^= data.binary.salt[(BF_N + 3) & 3];
@ -620,7 +655,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
*(ptr - 1) = R;
} while (ptr < &data.ctx.S[3][0xFF]);
do {
do
{
data.ctx.P[0] ^= data.expanded_key[0];
data.ctx.P[1] ^= data.expanded_key[1];
data.ctx.P[2] ^= data.expanded_key[2];
@ -668,12 +704,14 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
BF_body();
} while (--count);
for (i = 0; i < 6; i += 2) {
for (i = 0; i < 6; i += 2)
{
L = BF_magic_w[i];
R = BF_magic_w[i + 1];
count = 64;
do {
do
{
BF_ENCRYPT;
} while (--count);
@ -683,7 +721,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
memcpy(output, setting, 7 + 22 - 1);
output[7 + 22 - 1] = BF_itoa64[(int)
BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30];
BF_atoi64[(int) setting[7 + 22 - 1] - 0x20] & 0x30];
/* This has to be bug-compatible with the original implementation, so
* only encode 23 of the 24 bytes. :-) */
@ -698,4 +736,3 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
return output;
}

67
contrib/pgcrypto/crypt-des.c
View File

@ -244,8 +244,8 @@ des_init()
}
/*
* Convert the inverted S-boxes into 4 arrays of 8 bits.
* Each will handle 12 bits of the S-box input.
* Convert the inverted S-boxes into 4 arrays of 8 bits. Each will
* handle 12 bits of the S-box input.
*/
for (b = 0; b < 4; b++)
for (i = 0; i < 64; i++)
@ -409,10 +409,9 @@ des_setkey(const char *key)
&& rawkey1 == old_rawkey1)
{
/*
* Already setup for this key.
* This optimisation fails on a zero key (which is weak and
* has bad parity anyway) in order to simplify the starting
* conditions.
* Already setup for this key. This optimisation fails on a zero
* key (which is weak and has bad parity anyway) in order to
* simplify the starting conditions.
*/
return (0);
}
@ -420,7 +419,7 @@ des_setkey(const char *key)
old_rawkey1 = rawkey1;
/*
* Do key permutation and split into two 28-bit subkeys.
* Do key permutation and split into two 28-bit subkeys.
*/
k0 = key_perm_maskl[0][rawkey0 >> 25]
| key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
@ -438,8 +437,9 @@ des_setkey(const char *key)
| key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
| key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
| key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
/*
* Rotate subkeys and do compression permutation.
* Rotate subkeys and do compression permutation.
*/
shifts = 0;
for (round = 0; round < 16; round++)
@ -476,10 +476,10 @@ des_setkey(const char *key)
}
static int
do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
{
/*
* l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
* l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
*/
uint32 l,
r,
@ -513,7 +513,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
}
/*
* Do initial permutation (IP).
* Do initial permutation (IP).
*/
l = ip_maskl[0][l_in >> 24]
| ip_maskl[1][(l_in >> 16) & 0xff]
@ -556,21 +556,24 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
| ((r & 0x000001f8) << 3)
| ((r & 0x0000001f) << 1)
| ((r & 0x80000000) >> 31);
/*
* Do salting for crypt() and friends, and
* XOR with the permuted key.
* Do salting for crypt() and friends, and XOR with the
* permuted key.
*/
f = (r48l ^ r48r) & saltbits;
r48l ^= f ^ *kl++;
r48r ^= f ^ *kr++;
/*
* Do sbox lookups (which shrink it back to 32 bits)
* and do the pbox permutation at the same time.
* Do sbox lookups (which shrink it back to 32 bits) and do
* the pbox permutation at the same time.
*/
f = psbox[0][m_sbox[0][r48l >> 12]]
| psbox[1][m_sbox[1][r48l & 0xfff]]
| psbox[2][m_sbox[2][r48r >> 12]]
| psbox[3][m_sbox[3][r48r & 0xfff]];
/*
* Now that we've permuted things, complete f().
*/
@ -581,6 +584,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
r = l;
l = f;
}
/*
* Do final permutation (inverse of IP).
*/
@ -654,8 +658,8 @@ px_crypt_des(const char *key, const char *setting)
/*
* Copy the key, shifting each character up by one bit
* and padding with zeros.
* Copy the key, shifting each character up by one bit and padding
* with zeros.
*/
q = (uint8 *) keybuf;
while (q - (uint8 *) keybuf - 8)
@ -670,9 +674,8 @@ px_crypt_des(const char *key, const char *setting)
if (*setting == _PASSWORD_EFMT1)
{
/*
* "new"-style:
* setting - underscore, 4 bytes of count, 4 bytes of salt
* key - unlimited characters
* "new"-style: setting - underscore, 4 bytes of count, 4 bytes of
* salt key - unlimited characters
*/
for (i = 1, count = 0L; i < 5; i++)
count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
@ -687,6 +690,7 @@ px_crypt_des(const char *key, const char *setting)
*/
if (des_cipher((uint8 *) keybuf, (uint8 *) keybuf, 0L, 1))
return (NULL);
/*
* And XOR with the next 8 characters of the key.
*/
@ -700,11 +704,10 @@ px_crypt_des(const char *key, const char *setting)
strncpy(output, setting, 9);
/*
* Double check that we weren't given a short setting.
* If we were, the above code will probably have created
* wierd values for count and salt, but we don't really care.
* Just make sure the output string doesn't have an extra
* NUL in it.
* Double check that we weren't given a short setting. If we were,
* the above code will probably have created wierd values for
* count and salt, but we don't really care. Just make sure the
* output string doesn't have an extra NUL in it.
*/
output[9] = '\0';
p = output + strlen(output);
@ -713,9 +716,7 @@ px_crypt_des(const char *key, const char *setting)
#endif /* !DISABLE_XDES */
{
/*
* "old"-style:
* setting - 2 bytes of salt
* key - up to 8 characters
* "old"-style: setting - 2 bytes of salt key - up to 8 characters
*/
count = 25;
@ -723,22 +724,24 @@ px_crypt_des(const char *key, const char *setting)
| ascii_to_bin(setting[0]);
output[0] = setting[0];
/*
* If the encrypted password that the salt was extracted from
* is only 1 character long, the salt will be corrupted. We
* need to ensure that the output string doesn't have an extra
* NUL in it!
* If the encrypted password that the salt was extracted from is
* only 1 character long, the salt will be corrupted. We need to
* ensure that the output string doesn't have an extra NUL in it!
*/
output[1] = setting[1] ? setting[1] : output[0];
p = output + 2;
}
setup_salt(salt);
/*
* Do it.
*/
if (do_des(0L, 0L, &r0, &r1, count))
return (NULL);
/*
* Now encode the result...
*/

103
contrib/pgcrypto/crypt-gensalt.c
View File

@ -7,7 +7,7 @@
* entirely in crypt_blowfish.c.
*
* Put bcrypt generator also here as crypt-blowfish.c
* may not be compiled always. -- marko
* may not be compiled always. -- marko
*/
#include "postgres.h"
@ -22,48 +22,55 @@
typedef unsigned int BF_word;
unsigned char _crypt_itoa64[64 + 1] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
char *_crypt_gensalt_traditional_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
char *
_crypt_gensalt_traditional_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
if (size < 2 || output_size < 2 + 1 || (count && count != 25)) {
if (output_size > 0) output[0] = '\0';
if (size < 2 || output_size < 2 + 1 || (count && count != 25))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 2 + 1) ? ERANGE : EINVAL);
return NULL;
}
output[0] = _crypt_itoa64[(unsigned int)input[0] & 0x3f];
output[1] = _crypt_itoa64[(unsigned int)input[1] & 0x3f];
output[0] = _crypt_itoa64[(unsigned int) input[0] & 0x3f];
output[1] = _crypt_itoa64[(unsigned int) input[1] & 0x3f];
output[2] = '\0';
return output;
}
char *_crypt_gensalt_extended_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
char *
_crypt_gensalt_extended_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
unsigned long value;
/* Even iteration counts make it easier to detect weak DES keys from a look
* at the hash, so they should be avoided */
if (size < 3 || output_size < 1 + 4 + 4 + 1 ||
(count && (count > 0xffffff || !(count & 1)))) {
if (output_size > 0) output[0] = '\0';
(count && (count > 0xffffff || !(count & 1))))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL);
return NULL;
}
if (!count) count = 725;
if (!count)
count = 725;
output[0] = '_';
output[1] = _crypt_itoa64[count & 0x3f];
output[2] = _crypt_itoa64[(count >> 6) & 0x3f];
output[3] = _crypt_itoa64[(count >> 12) & 0x3f];
output[4] = _crypt_itoa64[(count >> 18) & 0x3f];
value = (unsigned long)input[0] |
((unsigned long)input[1] << 8) |
((unsigned long)input[2] << 16);
value = (unsigned long) input[0] |
((unsigned long) input[1] << 8) |
((unsigned long) input[2] << 16);
output[5] = _crypt_itoa64[value & 0x3f];
output[6] = _crypt_itoa64[(value >> 6) & 0x3f];
output[7] = _crypt_itoa64[(value >> 12) & 0x3f];
@ -73,13 +80,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count,
return output;
}
char *_crypt_gensalt_md5_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
char *
_crypt_gensalt_md5_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
unsigned long value;
if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) {
if (output_size > 0) output[0] = '\0';
if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL);
return NULL;
}
@ -87,19 +97,20 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
output[0] = '$';
output[1] = '1';
output[2] = '$';
value = (unsigned long)input[0] |
((unsigned long)input[1] << 8) |
((unsigned long)input[2] << 16);
value = (unsigned long) input[0] |
((unsigned long) input[1] << 8) |
((unsigned long) input[2] << 16);
output[3] = _crypt_itoa64[value & 0x3f];
output[4] = _crypt_itoa64[(value >> 6) & 0x3f];
output[5] = _crypt_itoa64[(value >> 12) & 0x3f];
output[6] = _crypt_itoa64[(value >> 18) & 0x3f];
output[7] = '\0';
if (size >= 6 && output_size >= 3 + 4 + 4 + 1) {
value = (unsigned long)input[3] |
((unsigned long)input[4] << 8) |
((unsigned long)input[5] << 16);
if (size >= 6 && output_size >= 3 + 4 + 4 + 1)
{
value = (unsigned long) input[3] |
((unsigned long) input[4] << 8) |
((unsigned long) input[5] << 16);
output[7] = _crypt_itoa64[value & 0x3f];
output[8] = _crypt_itoa64[(value >> 6) & 0x3f];
output[9] = _crypt_itoa64[(value >> 12) & 0x3f];
@ -113,20 +124,24 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
static unsigned char BF_itoa64[64 + 1] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static void BF_encode(char *dst, const BF_word *src, int size)
static void
BF_encode(char *dst, const BF_word * src, int size)
{
unsigned char *sptr = (unsigned char *)src;
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *)dst;
unsigned int c1, c2;
unsigned char *dptr = (unsigned char *) dst;
unsigned int c1,
c2;
do {
do
{
c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -135,7 +150,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2;
if (sptr >= end) {
if (sptr >= end)
{
*dptr++ = BF_itoa64[c1];
break;
}
@ -147,17 +163,21 @@ static void BF_encode(char *dst, const BF_word *src, int size)
} while (sptr < end);
}
char *_crypt_gensalt_blowfish_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
char *
_crypt_gensalt_blowfish_rn(unsigned long count,
const char *input, int size, char *output, int output_size)
{
if (size < 16 || output_size < 7 + 22 + 1 ||
(count && (count < 4 || count > 31))) {
if (output_size > 0) output[0] = '\0';
(count && (count < 4 || count > 31)))
{
if (output_size > 0)
output[0] = '\0';
__set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL);
return NULL;
}
if (!count) count = 5;
if (!count)
count = 5;
output[0] = '$';
output[1] = '2';
@ -167,9 +187,8 @@ char *_crypt_gensalt_blowfish_rn(unsigned long count,
output[5] = '0' + count % 10;
output[6] = '$';
BF_encode(&output[7], (BF_word *)input, 16);
BF_encode(&output[7], (BF_word *) input, 16);
output[7 + 22] = '\0';
return output;
}

19
contrib/pgcrypto/crypt-md5.c
View File

@ -9,7 +9,7 @@
* $FreeBSD: src/lib/libcrypt/crypt-md5.c,v 1.5 1999/12/17 20:21:45 peter Exp $
*
*/
/* $Id: crypt-md5.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ */
/* $Id: crypt-md5.c,v 1.2 2001/10/25 05:49:19 momjian Exp $ */
#include <postgres.h>
#include "px.h"
@ -23,12 +23,9 @@
char *
px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
{
static char *magic = "$1$"; /*
* This string is magic for
* this algorithm. Having
* it this way, we can get
* get better later on
*/
static char *magic = "$1$"; /* This string is magic for this
* algorithm. Having it this way, we can
* get get better later on */
static char *p;
static const char *sp,
*ep;
@ -43,7 +40,7 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
if (!passwd || dstlen < 120)
return NULL;
/* Refine the Salt first */
sp = salt;
@ -99,9 +96,9 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
px_md_finish(ctx, final);
/*
* and now, just to make sure things don't run too fast
* On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
* and now, just to make sure things don't run too fast On a 60 Mhz
* Pentium this takes 34 msec, so you would need 30 seconds to build a
* 1000 entry dictionary...
*/
for (i = 0; i < 1000; i++)
{

302
contrib/pgcrypto/internal.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: internal.c,v 1.5 2001/10/15 19:12:48 tgl Exp $
* $Id: internal.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
*/
@ -61,11 +61,18 @@ static struct int_digest
{
char *name;
void (*init) (PX_MD * h);
} int_digest_list[] =
} int_digest_list[] =
{
{ "md5", init_md5 },
{ "sha1", init_sha1 },
{ NULL, NULL }
{
"md5", init_md5
},
{
"sha1", init_sha1
},
{
NULL, NULL
}
};
/* MD5 */
@ -83,7 +90,7 @@ int_md5_block_len(PX_MD * h)
}
static void
int_md5_update(PX_MD * h, const uint8 * data, uint dlen)
int_md5_update(PX_MD * h, const uint8 *data, uint dlen)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
@ -99,7 +106,7 @@ int_md5_reset(PX_MD * h)
}
static void
int_md5_finish(PX_MD * h, uint8 * dst)
int_md5_finish(PX_MD * h, uint8 *dst)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
@ -130,7 +137,7 @@ int_sha1_block_len(PX_MD * h)
}
static void
int_sha1_update(PX_MD * h, const uint8 * data, uint dlen)
int_sha1_update(PX_MD * h, const uint8 *data, uint dlen)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
@ -146,7 +153,7 @@ int_sha1_reset(PX_MD * h)
}
static void
int_sha1_finish(PX_MD * h, uint8 * dst)
int_sha1_finish(PX_MD * h, uint8 *dst)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
@ -209,22 +216,27 @@ init_sha1(PX_MD * md)
#define INT_MAX_KEY (512/8)
#define INT_MAX_IV (128/8)
struct int_ctx {
uint8 keybuf[INT_MAX_KEY];
uint8 iv[INT_MAX_IV];
union {
blf_ctx bf;
struct int_ctx
{
uint8 keybuf[INT_MAX_KEY];
uint8 iv[INT_MAX_IV];
union
{
blf_ctx bf;
rijndael_ctx rj;
} ctx;
uint keylen;
int is_init;
int mode;
} ctx;
uint keylen;
int is_init;
int mode;
};
static void intctx_free(PX_Cipher *c)
static void
intctx_free(PX_Cipher * c)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
if (cx) {
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (cx)
{
memset(cx, 0, sizeof *cx);
px_free(cx);
}
@ -238,78 +250,88 @@ static void intctx_free(PX_Cipher *c)
#define MODE_ECB 0
#define MODE_CBC 1
static uint rj_block_size(PX_Cipher *c)
static uint
rj_block_size(PX_Cipher * c)
{
return 128/8;
return 128 / 8;
}
static uint rj_key_size(PX_Cipher *c)
static uint
rj_key_size(PX_Cipher * c)
{
return 256/8;
return 256 / 8;
}
static uint rj_iv_size(PX_Cipher *c)
static uint
rj_iv_size(PX_Cipher * c)
{
return 128/8;
return 128 / 8;
}
static int rj_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
static int
rj_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (klen <= 128/8)
cx->keylen = 128/8;
else if (klen <= 192/8)
cx->keylen = 192/8;
else if (klen <= 256/8)
cx->keylen = 256/8;
if (klen <= 128 / 8)
cx->keylen = 128 / 8;
else if (klen <= 192 / 8)
cx->keylen = 192 / 8;
else if (klen <= 256 / 8)
cx->keylen = 256 / 8;
else
return -1;
memcpy(&cx->keybuf, key, klen);
if (iv)
memcpy(cx->iv, iv, 128/8);
memcpy(cx->iv, iv, 128 / 8);
return 0;
}
static int rj_real_init(struct int_ctx *cx, int dir)
static int
rj_real_init(struct int_ctx * cx, int dir)
{
aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen*8, dir);
aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir);
return 0;
}
static int rj_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
rj_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
if (!cx->is_init) {
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (!cx->is_init)
{
if (rj_real_init(cx, 1))
return -1;
}
if (dlen == 0)
return 0;
if ((dlen & 15) || (((unsigned)res) & 3))
if ((dlen & 15) || (((unsigned) res) & 3))
return -1;
memcpy(res, data, dlen);
if (cx->mode == MODE_CBC) {
if (cx->mode == MODE_CBC)
{
aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen);
memcpy(cx->iv, res + dlen - 16, 16);
} else
}
else
aes_ecb_encrypt(&cx->ctx.rj, res, dlen);
return 0;
}
static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
rj_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (!cx->is_init)
if (rj_real_init(cx, 0))
return -1;
@ -317,17 +339,19 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
if (dlen == 0)
return 0;
if ((dlen & 15) || (((unsigned)res) & 3))
if ((dlen & 15) || (((unsigned) res) & 3))
return -1;
memcpy(res, data, dlen);
if (cx->mode == MODE_CBC) {
if (cx->mode == MODE_CBC)
{
aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen);
memcpy(cx->iv, data + dlen - 16, 16);
} else
}
else
aes_ecb_decrypt(&cx->ctx.rj, res, dlen);
return 0;
}
@ -335,11 +359,12 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
* initializers
*/
static PX_Cipher * rj_load(int mode)
static PX_Cipher *
rj_load(int mode)
{
PX_Cipher *c;
PX_Cipher *c;
struct int_ctx *cx;
c = px_alloc(sizeof *c);
memset(c, 0, sizeof *c);
@ -363,24 +388,28 @@ static PX_Cipher * rj_load(int mode)
* blowfish
*/
static uint bf_block_size(PX_Cipher *c)
static uint
bf_block_size(PX_Cipher * c)
{
return 8;
}
static uint bf_key_size(PX_Cipher *c)
static uint
bf_key_size(PX_Cipher * c)
{
return BLF_MAXKEYLEN;
}
static uint bf_iv_size(PX_Cipher *c)
static uint
bf_iv_size(PX_Cipher * c)
{
return 8;
}
static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
static int
bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
struct int_ctx *cx = (struct int_ctx *) c->ptr;
blf_key(&cx->ctx.bf, key, klen);
if (iv)
@ -389,55 +418,60 @@ static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
return 0;
}
static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static int
bf_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
if (dlen == 0)
return 0;
if ((dlen & 7) || (((unsigned)res) & 3))
return -1;
memcpy(res, data, dlen);
switch (cx->mode) {
case MODE_ECB:
blf_ecb_encrypt(&cx->ctx.bf, res, dlen);
break;
case MODE_CBC:
blf_cbc_encrypt(&cx->ctx.bf, cx->iv, res, dlen);
memcpy(cx->iv, res + dlen - 8, 8);
}
return 0;
}
static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *)c->ptr;
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (dlen == 0)
return 0;
if ((dlen & 7) || (((unsigned)res) & 3))
if ((dlen & 7) || (((unsigned) res) & 3))
return -1;
memcpy(res, data, dlen);
switch (cx->mode) {
case MODE_ECB:
blf_ecb_decrypt(&cx->ctx.bf, res, dlen);
break;
case MODE_CBC:
blf_cbc_decrypt(&cx->ctx.bf, cx->iv, res, dlen);
memcpy(cx->iv, data + dlen - 8, 8);
switch (cx->mode)
{
case MODE_ECB:
blf_ecb_encrypt(&cx->ctx.bf, res, dlen);
break;
case MODE_CBC:
blf_cbc_encrypt(&cx->ctx.bf, cx->iv, res, dlen);
memcpy(cx->iv, res + dlen - 8, 8);
}
return 0;
}
static PX_Cipher * bf_load(int mode)
static int
bf_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
PX_Cipher *c;
struct int_ctx *cx = (struct int_ctx *) c->ptr;
if (dlen == 0)
return 0;
if ((dlen & 7) || (((unsigned) res) & 3))
return -1;
memcpy(res, data, dlen);
switch (cx->mode)
{
case MODE_ECB:
blf_ecb_decrypt(&cx->ctx.bf, res, dlen);
break;
case MODE_CBC:
blf_cbc_decrypt(&cx->ctx.bf, cx->iv, res, dlen);
memcpy(cx->iv, data + dlen - 8, 8);
}
return 0;
}
static PX_Cipher *
bf_load(int mode)
{
PX_Cipher *c;
struct int_ctx *cx;
c = px_alloc(sizeof *c);
memset(c, 0, sizeof *c);
@ -458,47 +492,64 @@ static PX_Cipher * bf_load(int mode)
/* ciphers */
static PX_Cipher * rj_128_ecb()
static PX_Cipher *
rj_128_ecb()
{
return rj_load(MODE_ECB);
}
static PX_Cipher * rj_128_cbc()
static PX_Cipher *
rj_128_cbc()
{
return rj_load(MODE_CBC);
}
static PX_Cipher * bf_ecb_load()
static PX_Cipher *
bf_ecb_load()
{
return bf_load(MODE_ECB);
}
static PX_Cipher * bf_cbc_load()
static PX_Cipher *
bf_cbc_load()
{
return bf_load(MODE_CBC);
}
static struct {
char *name;
PX_Cipher *(*load)(void);
} int_ciphers [] = {
{ "bf-cbc", bf_cbc_load },
{ "bf-ecb", bf_ecb_load },
{ "aes-128-cbc", rj_128_cbc },
{ "aes-128-ecb", rj_128_ecb },
{ NULL, NULL }
static struct
{
char *name;
PX_Cipher *(*load) (void);
} int_ciphers[] =
{
{
"bf-cbc", bf_cbc_load
},
{
"bf-ecb", bf_ecb_load
},
{
"aes-128-cbc", rj_128_cbc
},
{
"aes-128-ecb", rj_128_ecb
},
{
NULL, NULL
}
};
static PX_Alias int_aliases [] = {
{ "bf", "bf-cbc" },
{ "blowfish", "bf-cbc" },
{ "aes", "aes-128-cbc" },
{ "aes-ecb", "aes-128-ecb" },
{ "aes-cbc", "aes-128-cbc" },
{ "aes-128", "aes-128-cbc" },
{ "rijndael", "aes-128-cbc" },
{ "rijndael-128", "aes-128-cbc" },
{ NULL, NULL }
static PX_Alias int_aliases[] = {
{"bf", "bf-cbc"},
{"blowfish", "bf-cbc"},
{"aes", "aes-128-cbc"},
{"aes-ecb", "aes-128-ecb"},
{"aes-cbc", "aes-128-cbc"},
{"aes-128", "aes-128-cbc"},
{"rijndael", "aes-128-cbc"},
{"rijndael-128", "aes-128-cbc"},
{NULL, NULL}
};
/* PUBLIC FUNCTIONS */
@ -523,15 +574,16 @@ px_find_digest(const char *name, PX_MD ** res)
}
int
px_find_cipher(const char *name, PX_Cipher **res)
px_find_cipher(const char *name, PX_Cipher ** res)
{
int i;
PX_Cipher *c = NULL;
int i;
PX_Cipher *c = NULL;
name = px_resolve_alias(int_aliases, name);
for (i = 0; int_ciphers[i].name; i++)
if (!strcmp(int_ciphers[i].name, name)) {
if (!strcmp(int_ciphers[i].name, name))
{
c = int_ciphers[i].load();
break;
}
@ -542,5 +594,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c;
return 0;
}

14
contrib/pgcrypto/md5.c
View File

@ -1,4 +1,4 @@
/* $Id: md5.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */
/* $Id: md5.c,v 1.8 2001/10/25 05:49:19 momjian Exp $ */
/* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */
/*
@ -132,7 +132,7 @@ static const uint8 md5_paddat[MD5_BUFLEN] = {
static void md5_calc(uint8 *, md5_ctxt *);
void
md5_init(md5_ctxt *ctxt)
md5_init(md5_ctxt * ctxt)
{
ctxt->md5_n = 0;
ctxt->md5_i = 0;
@ -144,7 +144,7 @@ md5_init(md5_ctxt *ctxt)
}
void
md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len)
md5_loop(md5_ctxt * ctxt, const uint8 *input, unsigned len)
{
unsigned int gap,
i;
@ -173,7 +173,7 @@ md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len)
}
void
md5_pad(md5_ctxt *ctxt)
md5_pad(md5_ctxt * ctxt)
{
unsigned int gap;
@ -215,7 +215,7 @@ md5_pad(md5_ctxt *ctxt)
}
void
md5_result(uint8 *digest, md5_ctxt *ctxt)
md5_result(uint8 *digest, md5_ctxt * ctxt)
{
/* 4 byte words */
#if BYTE_ORDER == LITTLE_ENDIAN
@ -242,11 +242,11 @@ md5_result(uint8 *digest, md5_ctxt *ctxt)
}
#if BYTE_ORDER == BIG_ENDIAN
static uint32 X[16];
static uint32 X[16];
#endif
static void
md5_calc(uint8 *b64, md5_ctxt *ctxt)
md5_calc(uint8 *b64, md5_ctxt * ctxt)
{
uint32 A = ctxt->md5_sta;
uint32 B = ctxt->md5_stb;

125
contrib/pgcrypto/mhash.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: mhash.c,v 1.4 2001/08/21 00:42:41 momjian Exp $
* $Id: mhash.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
*/
#include <postgres.h>
@ -75,7 +75,7 @@ digest_reset(PX_MD * h)
}
static void
digest_update(PX_MD * h, const uint8 * data, uint dlen)
digest_update(PX_MD * h, const uint8 *data, uint dlen)
{
MHASH mh = (MHASH) h->p.ptr;
@ -83,7 +83,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen)
}
static void
digest_finish(PX_MD * h, uint8 * dst)
digest_finish(PX_MD * h, uint8 *dst)
{
MHASH mh = (MHASH) h->p.ptr;
uint hlen = digest_result_size(h);
@ -111,34 +111,37 @@ digest_free(PX_MD * h)
/* ENCRYPT / DECRYPT */
static uint
cipher_block_size(PX_Cipher *c)
cipher_block_size(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT)c->ptr;
MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_get_block_size(ctx);
}
static uint
cipher_key_size(PX_Cipher *c)
cipher_key_size(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT)c->ptr;
MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_get_key_size(ctx);
}
static uint
cipher_iv_size(PX_Cipher *c)
cipher_iv_size(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT)c->ptr;
MCRYPT ctx = (MCRYPT) c->ptr;
return mcrypt_enc_mode_has_iv(ctx)
? mcrypt_enc_get_iv_size(ctx) : 0;
}
static int
cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
cipher_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
int err;
MCRYPT ctx = (MCRYPT)c->ptr;
int err;
MCRYPT ctx = (MCRYPT) c->ptr;
err = mcrypt_generic_init(ctx, (char *)key, klen, (char*)iv);
err = mcrypt_generic_init(ctx, (char *) key, klen, (char *) iv);
if (err < 0)
elog(ERROR, "mcrypt_generic_init error: %s", mcrypt_strerror(err));
@ -147,10 +150,10 @@ cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
}
static int
cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
cipher_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
int err;
MCRYPT ctx = (MCRYPT)c->ptr;
int err;
MCRYPT ctx = (MCRYPT) c->ptr;
memcpy(res, data, dlen);
@ -161,10 +164,10 @@ cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
}
static int
cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
cipher_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
int err;
MCRYPT ctx = (MCRYPT)c->ptr;
int err;
MCRYPT ctx = (MCRYPT) c->ptr;
memcpy(res, data, dlen);
@ -176,15 +179,15 @@ cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
static void
cipher_free(PX_Cipher *c)
cipher_free(PX_Cipher * c)
{
MCRYPT ctx = (MCRYPT)c->ptr;
MCRYPT ctx = (MCRYPT) c->ptr;
if (c->pstat)
mcrypt_generic_end(ctx);
else
mcrypt_module_close(ctx);
px_free(c);
}
@ -223,33 +226,34 @@ static char *modes[] = {
};
static PX_Alias aliases[] = {
{"bf", "blowfish" },
{"3des", "tripledes" },
{"des3", "tripledes" },
{"aes", "rijndael-128" },
{"rijndael", "rijndael-128" },
{"aes-128", "rijndael-128" },
{"aes-192", "rijndael-192" },
{"aes-256", "rijndael-256" },
{ NULL, NULL }
{"bf", "blowfish"},
{"3des", "tripledes"},
{"des3", "tripledes"},
{"aes", "rijndael-128"},
{"rijndael", "rijndael-128"},
{"aes-128", "rijndael-128"},
{"aes-192", "rijndael-192"},
{"aes-256", "rijndael-256"},
{NULL, NULL}
};
static PX_Alias mode_aliases[] = {
#if 0 /* N/A */
{ "cfb", "ncfb" },
{ "ofb", "nofb" },
{ "cfb64", "ncfb" },
#if 0 /* N/A */
{"cfb", "ncfb"},
{"ofb", "nofb"},
{"cfb64", "ncfb"},
#endif
/* { "ofb64", "nofb" }, not sure it works */
{ "cfb8", "cfb" },
{ "ofb8", "ofb" },
{ NULL, NULL }
{"cfb8", "cfb"},
{"ofb8", "ofb"},
{NULL, NULL}
};
static int is_mode(char *s)
static int
is_mode(char *s)
{
char **p;
char **p;
if (*s >= '0' && *s <= '9')
return 0;
@ -263,7 +267,7 @@ static int is_mode(char *s)
/* PUBLIC FUNCTIONS */
int
px_find_digest(const char *name, PX_MD **res)
px_find_digest(const char *name, PX_MD ** res)
{
PX_MD *h;
MHASH mh;
@ -290,19 +294,21 @@ px_find_digest(const char *name, PX_MD **res)
int
px_find_cipher(const char *name, PX_Cipher **res)
px_find_cipher(const char *name, PX_Cipher ** res)
{
char nbuf[PX_MAX_NAMELEN + 1];
char nbuf[PX_MAX_NAMELEN + 1];
const char *mode = NULL;
char *p;
MCRYPT ctx;
char *p;
MCRYPT ctx;
PX_Cipher *c;
PX_Cipher *c;
strcpy(nbuf, name);
if ((p = strrchr(nbuf, '-')) != NULL) {
if (is_mode(p + 1)) {
if ((p = strrchr(nbuf, '-')) != NULL)
{
if (is_mode(p + 1))
{
mode = p + 1;
*p = 0;
}
@ -310,19 +316,19 @@ px_find_cipher(const char *name, PX_Cipher **res)
name = px_resolve_alias(aliases, nbuf);
if (!mode) {
if (!mode)
{
mode = "cbc";
/*
if (mcrypt_module_is_block_algorithm(name, NULL))
mode = "cbc";
else
mode = "stream";
*/
* if (mcrypt_module_is_block_algorithm(name, NULL)) mode = "cbc";
* else mode = "stream";
*/
}
mode = px_resolve_alias(mode_aliases, mode);
ctx = mcrypt_module_open((char*)name, NULL, (char*)mode, NULL);
if (ctx == (void*)MCRYPT_FAILED)
ctx = mcrypt_module_open((char *) name, NULL, (char *) mode, NULL);
if (ctx == (void *) MCRYPT_FAILED)
return -1;
c = palloc(sizeof *c);
@ -339,4 +345,3 @@ px_find_cipher(const char *name, PX_Cipher **res)
*res = c;
return 0;
}

2
contrib/pgcrypto/misc.c
View File

@ -33,7 +33,7 @@
#include "px-crypt.h"
char px_crypt_a64[] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* 0000000000111111111122222222223333333333444444444455555555556666 */
/* 0123456789012345678901234567890123456789012345678901234567890123 */

242
contrib/pgcrypto/openssl.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: openssl.c,v 1.5 2001/09/23 04:12:44 momjian Exp $
* $Id: openssl.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
*/
#include <postgres.h>
@ -60,7 +60,7 @@ digest_reset(PX_MD * h)
}
static void
digest_update(PX_MD * h, const uint8 * data, uint dlen)
digest_update(PX_MD * h, const uint8 *data, uint dlen)
{
EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr;
@ -68,7 +68,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen)
}
static void
digest_finish(PX_MD * h, uint8 * dst)
digest_finish(PX_MD * h, uint8 *dst)
{
EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr;
@ -94,50 +94,57 @@ digest_free(PX_MD * h)
*/
typedef struct {
union {
struct {
BF_KEY key;
int num;
} bf;
typedef struct
{
union
{
struct
{
BF_KEY key;
int num;
} bf;
EVP_CIPHER_CTX evp_ctx;
} u;
} u;
const EVP_CIPHER *evp_ciph;
uint8 key[EVP_MAX_KEY_LENGTH];
uint8 iv[EVP_MAX_IV_LENGTH];
uint klen;
uint init;
} ossldata;
uint8 key[EVP_MAX_KEY_LENGTH];
uint8 iv[EVP_MAX_IV_LENGTH];
uint klen;
uint init;
} ossldata;
/* generic EVP */
static uint
gen_evp_block_size(PX_Cipher *c)
gen_evp_block_size(PX_Cipher * c)
{
ossldata *od = (ossldata *)c->ptr;
ossldata *od = (ossldata *) c->ptr;
return EVP_CIPHER_block_size(od->evp_ciph);
}
static uint
gen_evp_key_size(PX_Cipher *c)
gen_evp_key_size(PX_Cipher * c)
{
ossldata *od = (ossldata *)c->ptr;
ossldata *od = (ossldata *) c->ptr;
return EVP_CIPHER_key_length(od->evp_ciph);
}
static uint
gen_evp_iv_size(PX_Cipher *c)
gen_evp_iv_size(PX_Cipher * c)
{
uint ivlen;
ossldata *od = (ossldata *)c->ptr;
uint ivlen;
ossldata *od = (ossldata *) c->ptr;
ivlen = EVP_CIPHER_iv_length(od->evp_ciph);
return ivlen;
}
static void
gen_evp_free(PX_Cipher *c)
gen_evp_free(PX_Cipher * c)
{
ossldata *od = (ossldata*)c->ptr;
ossldata *od = (ossldata *) c->ptr;
memset(od, 0, sizeof(*od));
pfree(od);
pfree(c);
@ -146,13 +153,14 @@ gen_evp_free(PX_Cipher *c)
/* fun */
static int
gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
gen_evp_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
ossldata *od = (ossldata*)c->ptr;
uint bs = gen_evp_block_size(c);
if (iv) {
ossldata *od = (ossldata *) c->ptr;
uint bs = gen_evp_block_size(c);
if (iv)
memcpy(od->iv, iv, bs);
} else
else
memset(od->iv, 0, bs);
memcpy(od->key, key, klen);
od->klen = klen;
@ -161,19 +169,20 @@ gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
}
static void
_gen_init(PX_Cipher *c, int enc)
_gen_init(PX_Cipher * c, int enc)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
od->evp_ciph->init(&od->u.evp_ctx, od->key, od->iv, enc);
od->init = 1;
od->u.evp_ctx.encrypt = enc;
}
static int
gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
gen_evp_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
if (!od->init)
_gen_init(c, 1);
od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen);
@ -181,9 +190,10 @@ gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
}
static int
gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
gen_evp_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
if (!od->init)
_gen_init(c, 0);
od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen);
@ -193,84 +203,95 @@ gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
/* Blowfish */
static int
bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv)
bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_set_key(&od->u.bf.key, klen, key);
if (iv) {
if (iv)
memcpy(od->iv, iv, BF_BLOCK);
} else
else
memset(od->iv, 0, BF_BLOCK);
od->u.bf.num = 0;
return 0;
}
static int
bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
uint bs = gen_evp_block_size(c), i;
ossldata *od = c->ptr;
uint bs = gen_evp_block_size(c),
i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_ENCRYPT);
BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_ENCRYPT);
return 0;
}
static int
bf_ecb_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_ecb_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
uint bs = gen_evp_block_size(c), i;
ossldata *od = c->ptr;
uint bs = gen_evp_block_size(c),
i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_DECRYPT);
BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_DECRYPT);
return 0;
}
static int
bf_cbc_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_ENCRYPT);
return 0;
}
static int
bf_cbc_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_DECRYPT);
return 0;
}
static int
bf_cfb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_ENCRYPT);
&od->u.bf.num, BF_ENCRYPT);
return 0;
}
static int
bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_DECRYPT);
&od->u.bf.num, BF_DECRYPT);
return 0;
}
static int
bf_ofb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_ofb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num);
return 0;
}
static int
bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
bf_ofb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res)
{
ossldata *od = c->ptr;
ossldata *od = c->ptr;
BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num);
return 0;
}
@ -279,14 +300,14 @@ bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res)
* aliases
*/
static PX_Alias ossl_aliases [] = {
{ "bf", "bf-cbc" },
{ "blowfish", "bf-cbc" },
{ "blowfish-cbc", "bf-cbc" },
{ "blowfish-ecb", "bf-ecb" },
{ "blowfish-cfb", "bf-cfb" },
{ "blowfish-ofb", "bf-ofb" },
{ NULL }
static PX_Alias ossl_aliases[] = {
{"bf", "bf-cbc"},
{"blowfish", "bf-cbc"},
{"blowfish-cbc", "bf-cbc"},
{"blowfish-ecb", "bf-ecb"},
{"blowfish-cfb", "bf-cfb"},
{"blowfish-ofb", "bf-ofb"},
{NULL}
};
/*
@ -299,19 +320,44 @@ static PX_Alias ossl_mode_aliases [] = {
/*
* Special handlers
*/
struct {
char *name;
PX_Cipher cf;
} spec_types [] = {
{ "bf-cbc", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free}},
{ "bf-ecb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free}},
{ "bf-cfb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free}},
{ "bf-ofb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free}},
{ NULL }
struct
{
char *name;
PX_Cipher cf;
} spec_types[] =
{
{
"bf-cbc",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free
}
},
{
"bf-ecb",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free
}
},
{
"bf-cfb",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free
}
},
{
"bf-ofb",
{
gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size,
bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free
}
},
{
NULL
}
};
/*
@ -322,7 +368,7 @@ static PX_Cipher gen_evp_handler = {
gen_evp_init, gen_evp_encrypt, gen_evp_decrypt, gen_evp_free
};
static int px_openssl_initialized = 0;
static int px_openssl_initialized = 0;
/* ATM not needed
static void *o_alloc(uint s) { return px_alloc(s); }
@ -333,7 +379,7 @@ static void o_free(void *p) { px_free(p); }
/* PUBLIC functions */
int
px_find_digest(const char *name, PX_MD **res)
px_find_digest(const char *name, PX_MD ** res)
{
const EVP_MD *md;
EVP_MD_CTX *ctx;
@ -342,7 +388,7 @@ px_find_digest(const char *name, PX_MD **res)
if (!px_openssl_initialized)
{
px_openssl_initialized = 1;
/*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/
/* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */
OpenSSL_add_all_algorithms();
}
@ -368,17 +414,19 @@ px_find_digest(const char *name, PX_MD **res)
int
px_find_cipher(const char *name, PX_Cipher **res)
px_find_cipher(const char *name, PX_Cipher ** res)
{
uint i;
PX_Cipher *c = NULL, *csrc;
ossldata *od;
uint i;
PX_Cipher *c = NULL,
*csrc;
ossldata *od;
const EVP_CIPHER *evp_c;
if (!px_openssl_initialized) {
if (!px_openssl_initialized)
{
px_openssl_initialized = 1;
/*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/
/* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */
OpenSSL_add_all_algorithms();
}
@ -390,23 +438,23 @@ px_find_cipher(const char *name, PX_Cipher **res)
od = px_alloc(sizeof(*od));
memset(od, 0, sizeof(*od));
od->evp_ciph = evp_c;
csrc = NULL;
for (i = 0; spec_types[i].name; i++)
if (!strcmp(name, spec_types[i].name)) {
if (!strcmp(name, spec_types[i].name))
{
csrc = &spec_types[i].cf;
break;
}
if (csrc == NULL)
csrc = &gen_evp_handler;
c = px_alloc(sizeof(*c));
memcpy(c, csrc, sizeof(*c));
c->ptr = od;
*res = c;
return 0;
}

107
contrib/pgcrypto/pgcrypto.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: pgcrypto.c,v 1.9 2001/09/23 04:12:44 momjian Exp $
* $Id: pgcrypto.c,v 1.10 2001/10/25 05:49:19 momjian Exp $
*/
#include <postgres.h>
@ -41,7 +41,7 @@
typedef int (*PFN) (const char *name, void **res);
static void *
find_provider(text * name, PFN pf, char *desc, int silent);
find_provider(text *name, PFN pf, char *desc, int silent);
/* SQL function: hash(text, text) returns text */
PG_FUNCTION_INFO_V1(pg_digest);
@ -313,17 +313,21 @@ PG_FUNCTION_INFO_V1(pg_encrypt);
Datum
pg_encrypt(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *res;
text *type;
PX_Combo *c;
uint dlen, klen, rlen;
int err;
bytea *data,
*key,
*res;
text *type;
PX_Combo *c;
uint dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(2);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0);
c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
@ -341,8 +345,9 @@ pg_encrypt(PG_FUNCTION_ARGS)
PG_FREE_IF_COPY(data, 0);
PG_FREE_IF_COPY(key, 1);
PG_FREE_IF_COPY(type, 2);
if (err) {
if (err)
{
pfree(res);
elog(ERROR, "encrypt error: %d", err);
}
@ -357,17 +362,21 @@ PG_FUNCTION_INFO_V1(pg_decrypt);
Datum
pg_decrypt(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *res;
text *type;
PX_Combo *c;
uint dlen, klen, rlen;
int err;
bytea *data,
*key,
*res;
text *type;
PX_Combo *c;
uint dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(2);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0);
c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
@ -401,18 +410,24 @@ PG_FUNCTION_INFO_V1(pg_encrypt_iv);
Datum
pg_encrypt_iv(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *iv, *res;
text *type;
PX_Combo *c;
uint dlen, klen, ivlen, rlen;
int err;
bytea *data,
*key,
*iv,
*res;
text *type;
PX_Combo *c;
uint dlen,
klen,
ivlen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)
|| PG_ARGISNULL(2) || PG_ARGISNULL(3))
|| PG_ARGISNULL(2) || PG_ARGISNULL(3))
PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(3);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0);
c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
@ -449,18 +464,24 @@ PG_FUNCTION_INFO_V1(pg_decrypt_iv);
Datum
pg_decrypt_iv(PG_FUNCTION_ARGS)
{
int err;
bytea *data, *key, *iv, *res;
text *type;
PX_Combo *c;
uint dlen, klen, rlen, ivlen;
int err;
bytea *data,
*key,
*iv,
*res;
text *type;
PX_Combo *c;
uint dlen,
klen,
rlen,
ivlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1)
|| PG_ARGISNULL(2) || PG_ARGISNULL(3))
|| PG_ARGISNULL(2) || PG_ARGISNULL(3))
PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(3);
c = find_provider(type, (PFN)px_find_combo, "Cipher", 0);
c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
@ -480,7 +501,7 @@ pg_decrypt_iv(PG_FUNCTION_ARGS)
if (err)
elog(ERROR, "decrypt_iv error: %d", err);
VARATT_SIZEP(res) = VARHDRSZ + rlen;
PG_FREE_IF_COPY(data, 0);
@ -497,15 +518,15 @@ PG_FUNCTION_INFO_V1(pg_cipher_exists);
Datum
pg_cipher_exists(PG_FUNCTION_ARGS)
{
text *arg;
PX_Combo *c;
text *arg;
PX_Combo *c;
if (PG_ARGISNULL(0))
PG_RETURN_NULL();
arg = PG_GETARG_TEXT_P(0);
c = find_provider(arg, (PFN)px_find_combo, "Cipher", 1);
c = find_provider(arg, (PFN) px_find_combo, "Cipher", 1);
if (c != NULL)
px_combo_free(c);
@ -514,7 +535,7 @@ pg_cipher_exists(PG_FUNCTION_ARGS)
static void *
find_provider(text * name,
find_provider(text *name,
PFN provider_lookup,
char *desc, int silent)
{

4
contrib/pgcrypto/pgcrypto.h
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: pgcrypto.h,v 1.5 2001/09/23 04:12:44 momjian Exp $
* $Id: pgcrypto.h,v 1.6 2001/10/25 05:49:20 momjian Exp $
*/
#ifndef _PG_CRYPTO_H
@ -45,6 +45,4 @@ Datum pg_decrypt(PG_FUNCTION_ARGS);
Datum pg_encrypt_iv(PG_FUNCTION_ARGS);
Datum pg_decrypt_iv(PG_FUNCTION_ARGS);
Datum pg_cipher_exists(PG_FUNCTION_ARGS);
#endif

85
contrib/pgcrypto/px-crypt.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px-crypt.c,v 1.2 2001/09/23 04:12:44 momjian Exp $
* $Id: px-crypt.c,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#include <postgres.h>
@ -38,7 +38,7 @@
static char *
run_crypt_des(const char *psw, const char *salt,
char *buf, unsigned len)
char *buf, unsigned len)
{
char *res;
@ -51,37 +51,51 @@ run_crypt_des(const char *psw, const char *salt,
static char *
run_crypt_md5(const char *psw, const char *salt,
char *buf, unsigned len)
char *buf, unsigned len)
{
char *res;
res = px_crypt_md5(psw, salt, buf, len);
return res;
}
static char *
run_crypt_bf(const char *psw, const char *salt,
char *buf, unsigned len)
char *buf, unsigned len)
{
char *res;
res = _crypt_blowfish_rn(psw, salt, buf, len);
return res;
}
static struct
{
char *id;
char *id;
unsigned id_len;
char *(*crypt) (const char *psw, const char *salt,
char *buf, unsigned len);
} px_crypt_list[] =
{
{ "$2a$", 4, run_crypt_bf },
{ "$2$", 3, NULL }, /* N/A */
{ "$1$", 3, run_crypt_md5 },
{ "_", 1, run_crypt_des },
{ "", 0, run_crypt_des },
{ NULL, 0, NULL }
{
"$2a$", 4, run_crypt_bf
},
{
"$2$", 3, NULL
}, /* N/A */
{
"$1$", 3, run_crypt_md5
},
{
"_", 1, run_crypt_des
},
{
"", 0, run_crypt_des
},
{
NULL, 0, NULL
}
};
char *
@ -125,41 +139,45 @@ px_crypt(const char *psw, const char *salt,
* salt generators
*/
struct generator {
char *name;
char *(*gen)(unsigned long count, const char *input, int size,
char *output, int output_size);
int input_len;
int def_rounds;
int min_rounds;
int max_rounds;
struct generator
{
char *name;
char *(*gen) (unsigned long count, const char *input, int size,
char *output, int output_size);
int input_len;
int def_rounds;
int min_rounds;
int max_rounds;
};
static struct generator gen_list [] = {
{ "des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0 },
{ "md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0 },
{ "xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF },
{ "bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31 },
{ NULL, NULL, 0, 0, 0 }
static struct generator gen_list[] = {
{"des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0},
{"md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0},
{"xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF},
{"bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31},
{NULL, NULL, 0, 0, 0}
};
uint
px_gen_salt(const char *salt_type, char *buf, int rounds)
{
int i, res;
int i,
res;
struct generator *g;
char *p;
char rbuf[16];
for (i = 0; gen_list[i].name; i++) {
char *p;
char rbuf[16];
for (i = 0; gen_list[i].name; i++)
{
g = &gen_list[i];
if (strcasecmp(g->name, salt_type) != 0)
continue;
if (g->def_rounds) {
if (g->def_rounds)
{
if (rounds == 0)
rounds = g->def_rounds;
if (rounds < g->min_rounds || rounds > g->max_rounds)
return 0;
}
@ -170,10 +188,9 @@ px_gen_salt(const char *salt_type, char *buf, int rounds)
p = g->gen(rounds, rbuf, g->input_len, buf, PX_MAX_SALT_LEN);
memset(rbuf, 0, sizeof(rbuf));
return p != NULL ? strlen(p) : 0;
}
return 0;
}

18
contrib/pgcrypto/px-crypt.h
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px-crypt.h,v 1.2 2001/09/23 04:12:44 momjian Exp $
* $Id: px-crypt.h,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#ifndef _PX_CRYPT_H
@ -36,7 +36,7 @@
#define PX_MAX_CRYPT 128
/* max salt returned by gen_salt() */
#define PX_MAX_SALT_LEN 128
#define PX_MAX_SALT_LEN 128
/* default rounds for xdes salt */
/* NetBSD bin/passwd/local_passwd.c has (29 * 25)*/
@ -58,19 +58,20 @@ unsigned px_gen_salt(const char *salt_type, char *dst, int rounds);
/* misc.c */
extern void px_crypt_to64(char *s, unsigned long v, int n);
extern char px_crypt_a64[];
/* avoid conflicts with system libs */
#define _crypt_to64 px_crypt_to64
#define _crypt_a64 px_crypt_a64
/* crypt-gensalt.c */
char *_crypt_gensalt_traditional_rn(unsigned long count,
const char *input, int size, char *output, int output_size);
const char *input, int size, char *output, int output_size);
char *_crypt_gensalt_extended_rn(unsigned long count,
const char *input, int size, char *output, int output_size);
const char *input, int size, char *output, int output_size);
char *_crypt_gensalt_md5_rn(unsigned long count,
const char *input, int size, char *output, int output_size);
const char *input, int size, char *output, int output_size);
char *_crypt_gensalt_blowfish_rn(unsigned long count,
const char *input, int size, char *output, int output_size);
const char *input, int size, char *output, int output_size);
#ifndef PX_SYSTEM_CRYPT
@ -85,8 +86,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
char *px_crypt_des(const char *key, const char *setting);
/* crypt-md5.c */
char *px_crypt_md5(const char *pw, const char *salt,
char *dst, unsigned dstlen);
char *px_crypt_md5(const char *pw, const char *salt,
char *dst, unsigned dstlen);
#endif /* !PX_SYSTEM_CRYPT */
#endif /* _PX_CRYPT_H */

8
contrib/pgcrypto/px-hmac.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px-hmac.c,v 1.1 2001/08/21 01:32:01 momjian Exp $
* $Id: px-hmac.c,v 1.2 2001/10/25 05:49:20 momjian Exp $
*/
@ -50,7 +50,7 @@ hmac_block_size(PX_HMAC * h)
}
static void
hmac_init(PX_HMAC * h, const uint8 * key, uint klen)
hmac_init(PX_HMAC * h, const uint8 *key, uint klen)
{
uint bs,
hlen,
@ -95,13 +95,13 @@ hmac_reset(PX_HMAC * h)
}
static void
hmac_update(PX_HMAC * h, const uint8 * data, uint dlen)
hmac_update(PX_HMAC * h, const uint8 *data, uint dlen)
{
px_md_update(h->md, data, dlen);
}
static void
hmac_finish(PX_HMAC * h, uint8 * dst)
hmac_finish(PX_HMAC * h, uint8 *dst)
{
PX_MD *md = h->md;
uint bs,

164
contrib/pgcrypto/px.c
View File

@ -1,7 +1,7 @@
/*
* px.c
* Various cryptographic stuff for PostgreSQL.
*
*
* Copyright (c) 2001 Marko Kreen
* All rights reserved.
*
@ -9,15 +9,15 @@
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px.c,v 1.2 2001/09/06 03:21:39 momjian Exp $
* $Id: px.c,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#include <postgres.h>
@ -35,9 +35,10 @@
const char *
px_resolve_alias(const PX_Alias *list, const char *name)
px_resolve_alias(const PX_Alias * list, const char *name)
{
while (list->name) {
while (list->name)
{
if (!strcasecmp(list->alias, name))
return list->name;
list++;
@ -50,32 +51,35 @@ px_resolve_alias(const PX_Alias *list, const char *name)
*/
static uint
combo_encrypt_len(PX_Combo *cx, uint dlen)
combo_encrypt_len(PX_Combo * cx, uint dlen)
{
return dlen + 512;
}
static uint
combo_decrypt_len(PX_Combo *cx, uint dlen)
combo_decrypt_len(PX_Combo * cx, uint dlen)
{
return dlen;
}
static int
combo_init(PX_Combo *cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen)
combo_init(PX_Combo * cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen)
{
int err;
uint bs, ks, ivs;
PX_Cipher *c = cx->cipher;
uint8 *ivbuf = NULL;
uint8 *keybuf;
int err;
uint bs,
ks,
ivs;
PX_Cipher *c = cx->cipher;
uint8 *ivbuf = NULL;
uint8 *keybuf;
bs = px_cipher_block_size(c);
ks = px_cipher_key_size(c);
ivs = px_cipher_iv_size(c);
if (ivs > 0) {
if (ivs > 0)
{
ivbuf = px_alloc(ivs);
memset(ivbuf, 0, ivs);
if (ivlen > ivs)
@ -97,39 +101,48 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen,
}
static int
combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen)
combo_encrypt(PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen)
{
int err = 0;
uint8 *bbuf;
uint bs, maxlen, bpos, i, pad;
int err = 0;
uint8 *bbuf;
uint bs,
maxlen,
bpos,
i,
pad;
PX_Cipher *c = cx->cipher;
PX_Cipher *c = cx->cipher;
bbuf = NULL;
maxlen = *rlen;
bs = px_cipher_block_size(c);
/* encrypt */
if (bs > 1) {
if (bs > 1)
{
bbuf = px_alloc(bs * 4);
bpos = dlen % bs;
*rlen = dlen - bpos;
memcpy(bbuf, data + *rlen, bpos);
/* encrypt full-block data */
if (*rlen) {
if (*rlen)
{
err = px_cipher_encrypt(c, data, *rlen, res);
if (err)
goto out;
}
/* bbuf has now bpos bytes of stuff */
if (cx->padding) {
if (cx->padding)
{
pad = bs - (bpos % bs);
for (i = 0; i < pad; i++)
bbuf[bpos++] = pad;
} else if (bpos % bs) {
}
else if (bpos % bs)
{
/* ERROR? */
pad = bs - (bpos % bs);
for (i = 0; i < pad; i++)
@ -137,11 +150,14 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
}
/* encrypt the rest - pad */
if (bpos) {
if (bpos)
{
err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen);
*rlen += bpos;
}
} else {
}
else
{
/* stream cipher/mode - no pad needed */
err = px_cipher_encrypt(c, data, dlen, res);
if (err)
@ -149,48 +165,53 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen,
*rlen = dlen;
}
out:
if (bbuf) px_free(bbuf);
if (bbuf)
px_free(bbuf);
return err;
}
static int
combo_decrypt(PX_Combo *cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen)
combo_decrypt(PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen)
{
uint bs, i, pad;
uint pad_ok;
uint bs,
i,
pad;
uint pad_ok;
PX_Cipher *c = cx->cipher;
PX_Cipher *c = cx->cipher;
bs = px_cipher_block_size(c);
if (bs > 1 && (dlen % bs) != 0) {
if (bs > 1 && (dlen % bs) != 0)
goto block_error;
}
/* decrypt */
*rlen = dlen;
px_cipher_decrypt(c, data, dlen, res);
/* unpad */
if (bs > 1 && cx->padding) {
if (bs > 1 && cx->padding)
{
pad = res[*rlen - 1];
pad_ok = 0;
if (pad > 0 && pad <= bs && pad <= *rlen) {
if (pad > 0 && pad <= bs && pad <= *rlen)
{
pad_ok = 1;
for (i = *rlen - pad; i < *rlen; i++)
if (res[i] != pad) {
if (res[i] != pad)
{
pad_ok = 0;
break;
}
}
if (pad_ok)
*rlen -= pad;
}
return 0;
/* error reporting should be done in pgcrypto.c */
block_error:
elog(NOTICE, "Data not a multiple of block size");
@ -198,7 +219,7 @@ block_error:
}
static void
combo_free(PX_Combo *cx)
combo_free(PX_Combo * cx)
{
if (cx->cipher)
px_cipher_free(cx->cipher);
@ -211,31 +232,38 @@ combo_free(PX_Combo *cx)
static int
parse_cipher_name(char *full, char **cipher, char **pad)
{
char *p, *p2, *q;
char *p,
*p2,
*q;
*cipher = full;
*pad = NULL;
p = strchr(full, '/');
if (p != NULL)
*p++ = 0;
while (p != NULL) {
while (p != NULL)
{
if ((q = strchr(p, '/')) != NULL)
*q++ = 0;
if (!*p) {
if (!*p)
{
p = q;
continue;
}
p2 = strchr(p, ':');
if (p2 != NULL) {
if (p2 != NULL)
{
*p2++ = 0;
if (!strcmp(p, "pad"))
*pad = p2;
else
return -1;
} else
}
else
return -1;
p = q;
}
return 0;
@ -244,12 +272,14 @@ parse_cipher_name(char *full, char **cipher, char **pad)
/* provider */
int
px_find_combo(const char *name, PX_Combo **res)
px_find_combo(const char *name, PX_Combo ** res)
{
int err;
char *buf, *s_cipher, *s_pad;
int err;
char *buf,
*s_cipher,
*s_pad;
PX_Combo *cx;
PX_Combo *cx;
cx = px_alloc(sizeof(*cx));
memset(cx, 0, sizeof(*cx));
@ -258,7 +288,8 @@ px_find_combo(const char *name, PX_Combo **res)
strcpy(buf, name);
err = parse_cipher_name(buf, &s_cipher, &s_pad);
if (err) {
if (err)
{
px_free(buf);
px_free(cx);
return err;
@ -267,15 +298,17 @@ px_find_combo(const char *name, PX_Combo **res)
err = px_find_cipher(s_cipher, &cx->cipher);
if (err)
goto err1;
if (s_pad != NULL) {
if (s_pad != NULL)
{
if (!strcmp(s_pad, "pkcs"))
cx->padding = 1;
else if (!strcmp(s_pad, "none"))
cx->padding = 0;
else
goto err1;
} else
}
else
cx->padding = 1;
cx->init = combo_init;
@ -290,7 +323,7 @@ px_find_combo(const char *name, PX_Combo **res)
*res = cx;
return 0;
err1:
if (cx->cipher)
px_cipher_free(cx->cipher);
@ -298,4 +331,3 @@ err1:
px_free(buf);
return -1;
}

148
contrib/pgcrypto/px.h
View File

@ -1,7 +1,7 @@
/*
* px.h
* Header file for pgcrypto.
*
*
* Copyright (c) 2001 Marko Kreen
* All rights reserved.
*
@ -9,15 +9,15 @@
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: px.h,v 1.2 2001/09/23 04:12:44 momjian Exp $
* $Id: px.h,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
#ifndef __PX_H
@ -36,22 +36,21 @@
#define px_alloc(s) palloc(s)
#define px_realloc(p, s) prealloc(p, s)
#define px_free(p) pfree(p)
#define px_free(p) pfree(p)
#else
void *xalloc(size_t s);
void *xrealloc(void *p, size_t s);
void xfree(void *p);
void *xalloc(size_t s);
void *xrealloc(void *p, size_t s);
void xfree(void *p);
#define px_alloc(s) xalloc(s)
#define px_realloc(p, s) xrealloc(p, s)
#define px_free(p) xfree(p)
#define px_free(p) xfree(p)
#endif
/* max len of 'type' parms */
#define PX_MAX_NAMELEN 128
#define PX_MAX_NAMELEN 128
/* max salt returned */
#define PX_MAX_SALT_LEN 128
@ -63,79 +62,86 @@ typedef struct px_hmac PX_HMAC;
typedef struct px_cipher PX_Cipher;
typedef struct px_combo PX_Combo;
struct px_digest {
uint (*result_size)(PX_MD *h);
uint (*block_size)(PX_MD *h);
void (*reset)(PX_MD *h);
void (*update)(PX_MD *h, const uint8 *data, uint dlen);
void (*finish)(PX_MD *h, uint8 *dst);
void (*free)(PX_MD *h);
struct px_digest
{
uint (*result_size) (PX_MD * h);
uint (*block_size) (PX_MD * h);
void (*reset) (PX_MD * h);
void (*update) (PX_MD * h, const uint8 *data, uint dlen);
void (*finish) (PX_MD * h, uint8 *dst);
void (*free) (PX_MD * h);
/* private */
union {
uint code;
union
{
uint code;
const void *ptr;
} p;
} p;
};
struct px_alias {
char *alias;
char *name;
struct px_alias
{
char *alias;
char *name;
};
struct px_hmac {
uint (*result_size)(PX_HMAC *h);
uint (*block_size)(PX_HMAC *h);
void (*reset)(PX_HMAC *h);
void (*update)(PX_HMAC *h, const uint8 *data, uint dlen);
void (*finish)(PX_HMAC *h, uint8 *dst);
void (*free)(PX_HMAC *h);
void (*init)(PX_HMAC *h, const uint8 *key, uint klen);
PX_MD *md;
struct px_hmac
{
uint (*result_size) (PX_HMAC * h);
uint (*block_size) (PX_HMAC * h);
void (*reset) (PX_HMAC * h);
void (*update) (PX_HMAC * h, const uint8 *data, uint dlen);
void (*finish) (PX_HMAC * h, uint8 *dst);
void (*free) (PX_HMAC * h);
void (*init) (PX_HMAC * h, const uint8 *key, uint klen);
PX_MD *md;
/* private */
struct {
uint8 *ipad;
uint8 *opad;
} p;
struct
{
uint8 *ipad;
uint8 *opad;
} p;
};
struct px_cipher {
uint (*block_size)(PX_Cipher *c);
uint (*key_size)(PX_Cipher *c); /* max key len */
uint (*iv_size)(PX_Cipher *c);
int (*init)(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv);
int (*encrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res);
int (*decrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res);
void (*free)(PX_Cipher *c);
struct px_cipher
{
uint (*block_size) (PX_Cipher * c);
uint (*key_size) (PX_Cipher * c); /* max key len */
uint (*iv_size) (PX_Cipher * c);
int (*init) (PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv);
int (*encrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res);
int (*decrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res);
void (*free) (PX_Cipher * c);
/* private */
void *ptr;
int pstat; /* mcrypt uses it */
void *ptr;
int pstat; /* mcrypt uses it */
};
struct px_combo {
int (*init)(PX_Combo *cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen);
int (*encrypt)(PX_Combo *cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen);
int (*decrypt)(PX_Combo *cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen);
uint (*encrypt_len)(PX_Combo *cx, uint dlen);
uint (*decrypt_len)(PX_Combo *cx, uint dlen);
void (*free)(PX_Combo *cx);
struct px_combo
{
int (*init) (PX_Combo * cx, const uint8 *key, uint klen,
const uint8 *iv, uint ivlen);
int (*encrypt) (PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen);
int (*decrypt) (PX_Combo * cx, const uint8 *data, uint dlen,
uint8 *res, uint *rlen);
uint (*encrypt_len) (PX_Combo * cx, uint dlen);
uint (*decrypt_len) (PX_Combo * cx, uint dlen);
void (*free) (PX_Combo * cx);
PX_Cipher *cipher;
uint padding;
PX_Cipher *cipher;
uint padding;
};
int px_find_digest(const char *name, PX_MD **res);
int px_find_hmac(const char *name, PX_HMAC **res);
int px_find_cipher(const char *name, PX_Cipher **res);
int px_find_combo(const char *name, PX_Combo **res);
int px_find_digest(const char *name, PX_MD ** res);
int px_find_hmac(const char *name, PX_HMAC ** res);
int px_find_cipher(const char *name, PX_Cipher ** res);
int px_find_combo(const char *name, PX_Combo ** res);
int px_get_random_bytes(uint8 *dst, unsigned count);
int px_get_random_bytes(uint8 *dst, unsigned count);
const char *px_resolve_alias(const PX_Alias *aliases, const char *name);
const char *px_resolve_alias(const PX_Alias * aliases, const char *name);
#define px_md_result_size(md) (md)->result_size(md)
#define px_md_block_size(md) (md)->block_size(md)
@ -174,6 +180,4 @@ const char *px_resolve_alias(const PX_Alias *aliases, const char *name);
(c)->decrypt(c, data, dlen, res, rlen)
#define px_combo_free(c) (c)->free(c)
#endif /* __PX_H */
#endif /* __PX_H */

60
contrib/pgcrypto/random.c
View File

@ -26,7 +26,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: random.c,v 1.2 2001/09/29 03:12:51 momjian Exp $
* $Id: random.c,v 1.3 2001/10/25 05:49:20 momjian Exp $
*/
@ -44,13 +44,15 @@
static int
safe_read(int fd, void *buf, size_t count)
{
int done = 0;
char *p = buf;
int res;
while (count) {
int done = 0;
char *p = buf;
int res;
while (count)
{
res = read(fd, p, count);
if (res <= 0) {
if (res <= 0)
{
if (errno == EINTR)
continue;
return -1;
@ -65,8 +67,8 @@ safe_read(int fd, void *buf, size_t count)
int
px_get_random_bytes(uint8 *dst, unsigned count)
{
int fd;
int res;
int fd;
int res;
fd = open(RAND_DEV, O_RDONLY);
if (fd == -1)
@ -75,21 +77,20 @@ px_get_random_bytes(uint8 *dst, unsigned count)
close(fd);
return res;
}
#endif /* RAND_DEV */
#endif /* RAND_DEV */
#ifdef RAND_SILLY
int px_get_random_bytes(uint8 *dst, unsigned count)
int
px_get_random_bytes(uint8 *dst, unsigned count)
{
int i;
for (i = 0; i < count; i++) {
int i;
for (i = 0; i < count; i++)
*dst++ = random();
}
return i;
}
#endif /* RAND_SILLY */
#endif /* RAND_SILLY */
#ifdef RAND_OPENSSL
@ -98,30 +99,29 @@ int px_get_random_bytes(uint8 *dst, unsigned count)
#include <openssl/rand.h>
#include <openssl/err.h>
static int openssl_random_init = 0;
static int openssl_random_init = 0;
int px_get_random_bytes(uint8 *dst, unsigned count)
int
px_get_random_bytes(uint8 *dst, unsigned count)
{
int res;
int res;
if (!openssl_random_init) {
if (RAND_get_rand_method() == NULL) {
if (!openssl_random_init)
{
if (RAND_get_rand_method() == NULL)
RAND_set_rand_method(RAND_SSLeay());
}
openssl_random_init = 1;
}
/*
* OpenSSL random should re-feeded occasionally.
* From /dev/urandom preferrably.
* OpenSSL random should re-feeded occasionally. From /dev/urandom
* preferrably.
*/
res = RAND_bytes(dst, count);
if (res > 0)
return count;
return -1;
}
#endif /* RAND_OPENSSL */
#endif /* RAND_OPENSSL */

711
contrib/pgcrypto/rijndael.c
View File

@ -1,40 +1,40 @@
/* $OpenBSD: rijndael.c,v 1.6 2000/12/09 18:51:34 markus Exp $ */
/* $OpenBSD: rijndael.c,v 1.6 2000/12/09 18:51:34 markus Exp $ */
/* This is an independent implementation of the encryption algorithm: */
/* */
/* RIJNDAEL by Joan Daemen and Vincent Rijmen */
/* */
/* which is a candidate algorithm in the Advanced Encryption Standard */
/* programme of the US National Institute of Standards and Technology. */
/* */
/* Copyright in this implementation is held by Dr B R Gladman but I */
/* This is an independent implementation of the encryption algorithm: */
/* */
/* RIJNDAEL by Joan Daemen and Vincent Rijmen */
/* */
/* which is a candidate algorithm in the Advanced Encryption Standard */
/* programme of the US National Institute of Standards and Technology. */
/* */
/* Copyright in this implementation is held by Dr B R Gladman but I */
/* hereby give permission for its free direct or derivative use subject */
/* to acknowledgment of its origin and compliance with any conditions */
/* that the originators of the algorithm place on its exploitation. */
/* */
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999 */
/* to acknowledgment of its origin and compliance with any conditions */
/* that the originators of the algorithm place on its exploitation. */
/* */
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999 */
/* Timing data for Rijndael (rijndael.c)
Algorithm: rijndael (rijndael.c)
128 bit key:
Key Setup: 305/1389 cycles (encrypt/decrypt)
Encrypt: 374 cycles = 68.4 mbits/sec
Decrypt: 352 cycles = 72.7 mbits/sec
Mean: 363 cycles = 70.5 mbits/sec
Key Setup: 305/1389 cycles (encrypt/decrypt)
Encrypt: 374 cycles = 68.4 mbits/sec
Decrypt: 352 cycles = 72.7 mbits/sec
Mean: 363 cycles = 70.5 mbits/sec
192 bit key:
Key Setup: 277/1595 cycles (encrypt/decrypt)
Encrypt: 439 cycles = 58.3 mbits/sec
Decrypt: 425 cycles = 60.2 mbits/sec
Mean: 432 cycles = 59.3 mbits/sec
Key Setup: 277/1595 cycles (encrypt/decrypt)
Encrypt: 439 cycles = 58.3 mbits/sec
Decrypt: 425 cycles = 60.2 mbits/sec
Mean: 432 cycles = 59.3 mbits/sec
256 bit key:
Key Setup: 374/1960 cycles (encrypt/decrypt)
Encrypt: 502 cycles = 51.0 mbits/sec
Decrypt: 498 cycles = 51.4 mbits/sec
Mean: 500 cycles = 51.2 mbits/sec
Key Setup: 374/1960 cycles (encrypt/decrypt)
Encrypt: 502 cycles = 51.0 mbits/sec
Decrypt: 498 cycles = 51.4 mbits/sec
Mean: 500 cycles = 51.2 mbits/sec
*/
@ -47,29 +47,29 @@ Mean: 500 cycles = 51.2 mbits/sec
static void gen_tabs(void);
/* 3. Basic macros for speeding up generic operations */
/* 3. Basic macros for speeding up generic operations */
/* Circular rotate of 32 bit values */
/* Circular rotate of 32 bit values */
#define rotr(x,n) (((x) >> ((int)(n))) | ((x) << (32 - (int)(n))))
#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n))))
#define rotr(x,n) (((x) >> ((int)(n))) | ((x) << (32 - (int)(n))))
#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n))))
/* Invert byte order in a 32 bit variable */
/* Invert byte order in a 32 bit variable */
#define bswap(x) ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00))
#define bswap(x) ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00))
/* Extract byte from a 32 bit quantity (little endian notation) */
/* Extract byte from a 32 bit quantity (little endian notation) */
#define byte(x,n) ((u1byte)((x) >> (8 * n)))
#define byte(x,n) ((u1byte)((x) >> (8 * n)))
#if BYTE_ORDER != LITTLE_ENDIAN
#define BYTE_SWAP
#endif
#ifdef BYTE_SWAP
#define io_swap(x) bswap(x)
#ifdef BYTE_SWAP
#define io_swap(x) bswap(x)
#else
#define io_swap(x) (x)
#define io_swap(x) (x)
#endif
#ifdef PRINT_TABS
@ -81,279 +81,311 @@ static void gen_tabs(void);
#include "rijndael.tbl"
#define tab_gen 1
#else /* !PRE_CALC_TABLES */
#else /* !PRE_CALC_TABLES */
static u1byte pow_tab[256];
static u1byte log_tab[256];
static u1byte sbx_tab[256];
static u1byte isb_tab[256];
static u4byte rco_tab[ 10];
static u4byte ft_tab[4][256];
static u4byte it_tab[4][256];
static u1byte pow_tab[256];
static u1byte log_tab[256];
static u1byte sbx_tab[256];
static u1byte isb_tab[256];
static u4byte rco_tab[10];
static u4byte ft_tab[4][256];
static u4byte it_tab[4][256];
#ifdef LARGE_TABLES
static u4byte fl_tab[4][256];
static u4byte il_tab[4][256];
#ifdef LARGE_TABLES
static u4byte fl_tab[4][256];
static u4byte il_tab[4][256];
#endif
static u4byte tab_gen = 0;
#endif /* !PRE_CALC_TABLES */
static u4byte tab_gen = 0;
#endif /* !PRE_CALC_TABLES */
#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0)
#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0)
#define f_rn(bo, bi, n, k) \
bo[n] = ft_tab[0][byte(bi[n],0)] ^ \
ft_tab[1][byte(bi[(n + 1) & 3],1)] ^ \
ft_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
#define f_rn(bo, bi, n, k) \
bo[n] = ft_tab[0][byte(bi[n],0)] ^ \
ft_tab[1][byte(bi[(n + 1) & 3],1)] ^ \
ft_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
#define i_rn(bo, bi, n, k) \
bo[n] = it_tab[0][byte(bi[n],0)] ^ \
it_tab[1][byte(bi[(n + 3) & 3],1)] ^ \
it_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
#define i_rn(bo, bi, n, k) \
bo[n] = it_tab[0][byte(bi[n],0)] ^ \
it_tab[1][byte(bi[(n + 3) & 3],1)] ^ \
it_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
#ifdef LARGE_TABLES
#define ls_box(x) \
( fl_tab[0][byte(x, 0)] ^ \
fl_tab[1][byte(x, 1)] ^ \
fl_tab[2][byte(x, 2)] ^ \
fl_tab[3][byte(x, 3)] )
#define ls_box(x) \
( fl_tab[0][byte(x, 0)] ^ \
fl_tab[1][byte(x, 1)] ^ \
fl_tab[2][byte(x, 2)] ^ \
fl_tab[3][byte(x, 3)] )
#define f_rl(bo, bi, n, k) \
bo[n] = fl_tab[0][byte(bi[n],0)] ^ \
fl_tab[1][byte(bi[(n + 1) & 3],1)] ^ \
fl_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
#define f_rl(bo, bi, n, k) \
bo[n] = fl_tab[0][byte(bi[n],0)] ^ \
fl_tab[1][byte(bi[(n + 1) & 3],1)] ^ \
fl_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
#define i_rl(bo, bi, n, k) \
bo[n] = il_tab[0][byte(bi[n],0)] ^ \
il_tab[1][byte(bi[(n + 3) & 3],1)] ^ \
il_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
#define i_rl(bo, bi, n, k) \
bo[n] = il_tab[0][byte(bi[n],0)] ^ \
il_tab[1][byte(bi[(n + 3) & 3],1)] ^ \
il_tab[2][byte(bi[(n + 2) & 3],2)] ^ \
il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
#else
#define ls_box(x) \
((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \
((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \
((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \
((u4byte)sbx_tab[byte(x, 3)] << 24)
#define ls_box(x) \
((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \
((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \
((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \
((u4byte)sbx_tab[byte(x, 3)] << 24)
#define f_rl(bo, bi, n, k) \
bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n)
#define i_rl(bo, bi, n, k) \
bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)
#define f_rl(bo, bi, n, k) \
bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n)
#define i_rl(bo, bi, n, k) \
bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \
rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)
#endif
static void
gen_tabs(void)
{
#ifndef PRE_CALC_TABLES
u4byte i, t;
u1byte p, q;
u4byte i,
t;
u1byte p,
q;
/* log and power tables for GF(2**8) finite field with */
/* 0x11b as modular polynomial - the simplest prmitive */
/* root is 0x11, used here to generate the tables */
/* log and power tables for GF(2**8) finite field with */
/* 0x11b as modular polynomial - the simplest prmitive */
/* root is 0x11, used here to generate the tables */
for(i = 0,p = 1; i < 256; ++i) {
pow_tab[i] = (u1byte)p; log_tab[p] = (u1byte)i;
for (i = 0, p = 1; i < 256; ++i)
{
pow_tab[i] = (u1byte) p;
log_tab[p] = (u1byte) i;
p = p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0);
}
log_tab[1] = 0; p = 1;
log_tab[1] = 0;
p = 1;
for(i = 0; i < 10; ++i) {
rco_tab[i] = p;
for (i = 0; i < 10; ++i)
{
rco_tab[i] = p;
p = (p << 1) ^ (p & 0x80 ? 0x1b : 0);
}
/* note that the affine byte transformation matrix in */
/* rijndael specification is in big endian format with */
/* bit 0 as the most significant bit. In the remainder */
/* of the specification the bits are numbered from the */
/* least significant end of a byte. */
/* note that the affine byte transformation matrix in */
/* rijndael specification is in big endian format with */
/* bit 0 as the most significant bit. In the remainder */
/* of the specification the bits are numbered from the */
/* least significant end of a byte. */
for(i = 0; i < 256; ++i) {
p = (i ? pow_tab[255 - log_tab[i]] : 0); q = p;
q = (q >> 7) | (q << 1); p ^= q;
q = (q >> 7) | (q << 1); p ^= q;
q = (q >> 7) | (q << 1); p ^= q;
q = (q >> 7) | (q << 1); p ^= q ^ 0x63;
sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i;
for (i = 0; i < 256; ++i)
{
p = (i ? pow_tab[255 - log_tab[i]] : 0);
q = p;
q = (q >> 7) | (q << 1);
p ^= q;
q = (q >> 7) | (q << 1);
p ^= q;
q = (q >> 7) | (q << 1);
p ^= q;
q = (q >> 7) | (q << 1);
p ^= q ^ 0x63;
sbx_tab[i] = (u1byte) p;
isb_tab[p] = (u1byte) i;
}
for(i = 0; i < 256; ++i) {
p = sbx_tab[i];
for (i = 0; i < 256; ++i)
{
p = sbx_tab[i];
#ifdef LARGE_TABLES
t = p; fl_tab[0][i] = t;
fl_tab[1][i] = rotl(t, 8);
#ifdef LARGE_TABLES
t = p;
fl_tab[0][i] = t;
fl_tab[1][i] = rotl(t, 8);
fl_tab[2][i] = rotl(t, 16);
fl_tab[3][i] = rotl(t, 24);
#endif
t = ((u4byte)ff_mult(2, p)) |
((u4byte)p << 8) |
((u4byte)p << 16) |
((u4byte)ff_mult(3, p) << 24);
t = ((u4byte) ff_mult(2, p)) |
((u4byte) p << 8) |
((u4byte) p << 16) |
((u4byte) ff_mult(3, p) << 24);
ft_tab[0][i] = t;
ft_tab[1][i] = rotl(t, 8);
ft_tab[1][i] = rotl(t, 8);
ft_tab[2][i] = rotl(t, 16);
ft_tab[3][i] = rotl(t, 24);
p = isb_tab[i];
p = isb_tab[i];
#ifdef LARGE_TABLES
t = p; il_tab[0][i] = t;
il_tab[1][i] = rotl(t, 8);
il_tab[2][i] = rotl(t, 16);
#ifdef LARGE_TABLES
t = p;
il_tab[0][i] = t;
il_tab[1][i] = rotl(t, 8);
il_tab[2][i] = rotl(t, 16);
il_tab[3][i] = rotl(t, 24);
#endif
t = ((u4byte)ff_mult(14, p)) |
((u4byte)ff_mult( 9, p) << 8) |
((u4byte)ff_mult(13, p) << 16) |
((u4byte)ff_mult(11, p) << 24);
it_tab[0][i] = t;
it_tab[1][i] = rotl(t, 8);
it_tab[2][i] = rotl(t, 16);
it_tab[3][i] = rotl(t, 24);
#endif
t = ((u4byte) ff_mult(14, p)) |
((u4byte) ff_mult(9, p) << 8) |
((u4byte) ff_mult(13, p) << 16) |
((u4byte) ff_mult(11, p) << 24);
it_tab[0][i] = t;
it_tab[1][i] = rotl(t, 8);
it_tab[2][i] = rotl(t, 16);
it_tab[3][i] = rotl(t, 24);
}
tab_gen = 1;
#endif /* !PRE_CALC_TABLES */
#endif /* !PRE_CALC_TABLES */
}
#define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b)
#define imix_col(y,x) \
u = star_x(x); \
v = star_x(u); \
w = star_x(v); \
t = w ^ (x); \
(y) = u ^ v ^ w; \
#define imix_col(y,x) \
u = star_x(x); \
v = star_x(u); \
w = star_x(v); \
t = w ^ (x); \
(y) = u ^ v ^ w; \
(y) ^= rotr(u ^ t, 8) ^ \
rotr(v ^ t, 16) ^ \
rotr(t,24)
rotr(v ^ t, 16) ^ \
rotr(t,24)
/* initialise the key schedule from the user supplied key */
/* initialise the key schedule from the user supplied key */
#define loop4(i) \
do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
t ^= e_key[4 * i]; e_key[4 * i + 4] = t; \
t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; \
t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; \
t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; \
#define loop4(i) \
do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
t ^= e_key[4 * i]; e_key[4 * i + 4] = t; \
t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; \
t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; \
t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; \
} while (0)
#define loop6(i) \
do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
t ^= e_key[6 * i]; e_key[6 * i + 6] = t; \
t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; \
t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; \
t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; \
t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; \
t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; \
#define loop6(i) \
do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
t ^= e_key[6 * i]; e_key[6 * i + 6] = t; \
t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; \
t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; \
t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; \
t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; \
t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; \
} while (0)
#define loop8(i) \
do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
t ^= e_key[8 * i]; e_key[8 * i + 8] = t; \
t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; \
t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; \
t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; \
t = e_key[8 * i + 4] ^ ls_box(t); \
e_key[8 * i + 12] = t; \
t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; \
t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; \
t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; \
#define loop8(i) \
do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \
t ^= e_key[8 * i]; e_key[8 * i + 8] = t; \
t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; \
t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; \
t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; \
t = e_key[8 * i + 4] ^ ls_box(t); \
e_key[8 * i + 12] = t; \
t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; \
t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; \
t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; \
} while (0)
rijndael_ctx *
rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len,
int encrypt)
{
u4byte i, t, u, v, w;
u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key;
rijndael_set_key(rijndael_ctx * ctx, const u4byte * in_key, const u4byte key_len,
int encrypt)
{
u4byte i,
t,
u,
v,
w;
u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key;
ctx->decrypt = !encrypt;
if(!tab_gen)
if (!tab_gen)
gen_tabs();
ctx->k_len = (key_len + 31) / 32;
e_key[0] = io_swap(in_key[0]); e_key[1] = io_swap(in_key[1]);
e_key[2] = io_swap(in_key[2]); e_key[3] = io_swap(in_key[3]);
switch(ctx->k_len) {
case 4: t = e_key[3];
for(i = 0; i < 10; ++i)
loop4(i);
break;
e_key[0] = io_swap(in_key[0]);
e_key[1] = io_swap(in_key[1]);
e_key[2] = io_swap(in_key[2]);
e_key[3] = io_swap(in_key[3]);
case 6: e_key[4] = io_swap(in_key[4]); t = e_key[5] = io_swap(in_key[5]);
for(i = 0; i < 8; ++i)
loop6(i);
break;
switch (ctx->k_len)
{
case 4:
t = e_key[3];
for (i = 0; i < 10; ++i)
loop4(i);
break;
case 8: e_key[4] = io_swap(in_key[4]); e_key[5] = io_swap(in_key[5]);
e_key[6] = io_swap(in_key[6]); t = e_key[7] = io_swap(in_key[7]);
for(i = 0; i < 7; ++i)
loop8(i);
break;
case 6:
e_key[4] = io_swap(in_key[4]);
t = e_key[5] = io_swap(in_key[5]);
for (i = 0; i < 8; ++i)
loop6(i);
break;
case 8:
e_key[4] = io_swap(in_key[4]);
e_key[5] = io_swap(in_key[5]);
e_key[6] = io_swap(in_key[6]);
t = e_key[7] = io_swap(in_key[7]);
for (i = 0; i < 7; ++i)
loop8(i);
break;
}
if (!encrypt) {
d_key[0] = e_key[0]; d_key[1] = e_key[1];
d_key[2] = e_key[2]; d_key[3] = e_key[3];
if (!encrypt)
{
d_key[0] = e_key[0];
d_key[1] = e_key[1];
d_key[2] = e_key[2];
d_key[3] = e_key[3];
for(i = 4; i < 4 * ctx->k_len + 24; ++i) {
for (i = 4; i < 4 * ctx->k_len + 24; ++i)
imix_col(d_key[i], e_key[i]);
}
}
return ctx;
}
/* encrypt a block of text */
/* encrypt a block of text */
#define f_nround(bo, bi, k) \
f_rn(bo, bi, 0, k); \
f_rn(bo, bi, 1, k); \
f_rn(bo, bi, 2, k); \
f_rn(bo, bi, 3, k); \
k += 4
f_rn(bo, bi, 0, k); \
f_rn(bo, bi, 1, k); \
f_rn(bo, bi, 2, k); \
f_rn(bo, bi, 3, k); \
k += 4
#define f_lround(bo, bi, k) \
f_rl(bo, bi, 0, k); \
f_rl(bo, bi, 1, k); \
f_rl(bo, bi, 2, k); \
f_rl(bo, bi, 3, k)
f_rl(bo, bi, 0, k); \
f_rl(bo, bi, 1, k); \
f_rl(bo, bi, 2, k); \
f_rl(bo, bi, 3, k)
void
rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
{
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
u4byte b0[4], b1[4], *kp;
rijndael_encrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk)
{
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
u4byte b0[4],
b1[4],
*kp;
b0[0] = io_swap(in_blk[0]) ^ e_key[0];
b0[1] = io_swap(in_blk[1]) ^ e_key[1];
@ -362,46 +394,59 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
kp = e_key + 4;
if(k_len > 6) {
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
if (k_len > 6)
{
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
}
if(k_len > 4) {
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
if (k_len > 4)
{
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
}
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_nround(b0, b1, kp);
f_nround(b1, b0, kp); f_lround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_nround(b0, b1, kp);
f_nround(b1, b0, kp);
f_lround(b0, b1, kp);
out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]);
out_blk[0] = io_swap(b0[0]);
out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]);
out_blk[3] = io_swap(b0[3]);
}
/* decrypt a block of text */
/* decrypt a block of text */
#define i_nround(bo, bi, k) \
i_rn(bo, bi, 0, k); \
i_rn(bo, bi, 1, k); \
i_rn(bo, bi, 2, k); \
i_rn(bo, bi, 3, k); \
k -= 4
i_rn(bo, bi, 0, k); \
i_rn(bo, bi, 1, k); \
i_rn(bo, bi, 2, k); \
i_rn(bo, bi, 3, k); \
k -= 4
#define i_lround(bo, bi, k) \
i_rl(bo, bi, 0, k); \
i_rl(bo, bi, 1, k); \
i_rl(bo, bi, 2, k); \
i_rl(bo, bi, 3, k)
i_rl(bo, bi, 0, k); \
i_rl(bo, bi, 1, k); \
i_rl(bo, bi, 2, k); \
i_rl(bo, bi, 3, k)
void
rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
{
u4byte b0[4], b1[4], *kp;
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key;
rijndael_decrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk)
{
u4byte b0[4],
b1[4],
*kp;
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
u4byte *d_key = ctx->d_key;
b0[0] = io_swap(in_blk[0]) ^ e_key[4 * k_len + 24];
b0[1] = io_swap(in_blk[1]) ^ e_key[4 * k_len + 25];
@ -410,22 +455,33 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
kp = d_key + 4 * (k_len + 5);
if(k_len > 6) {
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
if (k_len > 6)
{
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
}
if(k_len > 4) {
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
if (k_len > 4)
{
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
}
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_nround(b0, b1, kp);
i_nround(b1, b0, kp); i_lround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_nround(b0, b1, kp);
i_nround(b1, b0, kp);
i_lround(b0, b1, kp);
out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]);
out_blk[0] = io_swap(b0[0]);
out_blk[1] = io_swap(b0[1]);
out_blk[2] = io_swap(b0[2]);
out_blk[3] = io_swap(b0[3]);
}
/*
@ -435,19 +491,24 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
* should be true for PX. -marko
*/
void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc)
void
aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc)
{
uint32 *k;
k = (uint32*)key;
uint32 *k;
k = (uint32 *) key;
rijndael_set_key(ctx, k, keybits, enc);
}
void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
void
aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len)
{
unsigned bs = 16;
uint32 *d;
while (len >= bs) {
d = (uint32*)data;
unsigned bs = 16;
uint32 *d;
while (len >= bs)
{
d = (uint32 *) data;
rijndael_encrypt(ctx, d, d);
len -= bs;
@ -455,12 +516,15 @@ void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
}
}
void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
void
aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len)
{
unsigned bs = 16;
uint32 *d;
while (len >= bs) {
d = (uint32*)data;
unsigned bs = 16;
uint32 *d;
while (len >= bs)
{
d = (uint32 *) data;
rijndael_decrypt(ctx, d, d);
len -= bs;
@ -468,42 +532,55 @@ void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
}
}
void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
void
aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len)
{
uint32 *iv = (uint32 *)iva;
uint32 *d = (uint32 *)data;
unsigned bs = 16;
uint32 *iv = (uint32 *) iva;
uint32 *d = (uint32 *) data;
unsigned bs = 16;
while (len >= bs)
{
d[0] ^= iv[0];
d[1] ^= iv[1];
d[2] ^= iv[2];
d[3] ^= iv[3];
while (len >= bs) {
d[0] ^= iv[0]; d[1] ^= iv[1];
d[2] ^= iv[2]; d[3] ^= iv[3];
rijndael_encrypt(ctx, d, d);
iv = d;
d += bs/4;
d += bs / 4;
len -= bs;
}
}
void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
void
aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len)
{
uint32 *d = (uint32 *)data;
unsigned bs = 16;
uint32 buf[4], iv[4];
uint32 *d = (uint32 *) data;
unsigned bs = 16;
uint32 buf[4],
iv[4];
memcpy(iv, iva, bs);
while (len >= bs) {
buf[0] = d[0]; buf[1] = d[1];
buf[2] = d[2]; buf[3] = d[3];
while (len >= bs)
{
buf[0] = d[0];
buf[1] = d[1];
buf[2] = d[2];
buf[3] = d[3];
rijndael_decrypt(ctx, buf, d);
d[0] ^= iv[0]; d[1] ^= iv[1];
d[2] ^= iv[2]; d[3] ^= iv[3];
iv[0] = buf[0]; iv[1] = buf[1];
iv[2] = buf[2]; iv[3] = buf[3];
d[0] ^= iv[0];
d[1] ^= iv[1];
d[2] ^= iv[2];
d[3] ^= iv[3];
iv[0] = buf[0];
iv[1] = buf[1];
iv[2] = buf[2];
iv[3] = buf[3];
d += 4;
len -= bs;
}
@ -514,15 +591,18 @@ void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
*
* On i386 lifts 17k from .bss to .rodata
* and avoids 1k code and setup time.
* -marko
* -marko
*/
#ifdef PRINT_TABS
static void show256u8(char *name, uint8 *data)
static void
show256u8(char *name, uint8 *data)
{
int i;
int i;
printf("static const u1byte %s[256] = {\n ", name);
for (i = 0; i < 256; ) {
for (i = 0; i < 256;)
{
printf("%u", pow_tab[i++]);
if (i < 256)
printf(i % 16 ? ", " : ",\n ");
@ -531,12 +611,17 @@ static void show256u8(char *name, uint8 *data)
}
static void show4x256u32(char *name, uint32 data[4][256])
static void
show4x256u32(char *name, uint32 data[4][256])
{
int i, j;
int i,
j;
printf("static const u4byte %s[4][256] = {\n{\n ", name);
for (i = 0; i < 4; i++) {
for (j = 0; j < 256; ) {
for (i = 0; i < 4; i++)
{
for (j = 0; j < 256;)
{
printf("0x%08x", data[i][j]);
j++;
if (j < 256)
@ -547,11 +632,12 @@ static void show4x256u32(char *name, uint32 data[4][256])
printf("};\n\n");
}
int main()
int
main()
{
int i;
char *hdr = "/* Generated by rijndael.c */\n\n";
int i;
char *hdr = "/* Generated by rijndael.c */\n\n";
gen_tabs();
printf(hdr);
@ -559,7 +645,7 @@ int main()
show256u8("log_tab", log_tab);
show256u8("sbx_tab", sbx_tab);
show256u8("isb_tab", isb_tab);
show4x256u32("ft_tab", ft_tab);
show4x256u32("it_tab", it_tab);
#ifdef LARGE_TABLES
@ -567,14 +653,15 @@ int main()
show4x256u32("il_tab", il_tab);
#endif
printf("static const u4byte rco_tab[10] = {\n ");
for (i = 0; i < 10; i++) {
for (i = 0; i < 10; i++)
{
printf("0x%08x", rco_tab[i]);
if (i < 9) printf(", ");
if (i == 4) printf("\n ");
if (i < 9)
printf(", ");
if (i == 4)
printf("\n ");
}
printf("\n};\n\n");
return 0;
}
#endif

76
contrib/pgcrypto/rijndael.h
View File

@ -1,57 +1,57 @@
/* $OpenBSD: rijndael.h,v 1.3 2001/05/09 23:01:32 markus Exp $ */
/* $OpenBSD: rijndael.h,v 1.3 2001/05/09 23:01:32 markus Exp $ */
/* This is an independent implementation of the encryption algorithm: */
/* */
/* RIJNDAEL by Joan Daemen and Vincent Rijmen */
/* */
/* which is a candidate algorithm in the Advanced Encryption Standard */
/* programme of the US National Institute of Standards and Technology. */
/* */
/* Copyright in this implementation is held by Dr B R Gladman but I */
/* This is an independent implementation of the encryption algorithm: */
/* */
/* RIJNDAEL by Joan Daemen and Vincent Rijmen */
/* */
/* which is a candidate algorithm in the Advanced Encryption Standard */
/* programme of the US National Institute of Standards and Technology. */
/* */
/* Copyright in this implementation is held by Dr B R Gladman but I */
/* hereby give permission for its free direct or derivative use subject */
/* to acknowledgment of its origin and compliance with any conditions */
/* that the originators of the algorithm place on its exploitation. */
/* */
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999 */
/* to acknowledgment of its origin and compliance with any conditions */
/* that the originators of the algorithm place on its exploitation. */
/* */
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999 */
#ifndef _RIJNDAEL_H_
#define _RIJNDAEL_H_
/* 1. Standard types for AES cryptography source code */
/* 1. Standard types for AES cryptography source code */
typedef uint8 u1byte; /* an 8 bit unsigned character type */
typedef uint16 u2byte; /* a 16 bit unsigned integer type */
typedef uint32 u4byte; /* a 32 bit unsigned integer type */
typedef uint8 u1byte; /* an 8 bit unsigned character type */
typedef uint16 u2byte; /* a 16 bit unsigned integer type */
typedef uint32 u4byte; /* a 32 bit unsigned integer type */
typedef int8 s1byte; /* an 8 bit signed character type */
typedef int16 s2byte; /* a 16 bit signed integer type */
typedef int32 s4byte; /* a 32 bit signed integer type */
typedef int8 s1byte; /* an 8 bit signed character type */
typedef int16 s2byte; /* a 16 bit signed integer type */
typedef int32 s4byte; /* a 32 bit signed integer type */
typedef struct _rijndael_ctx {
u4byte k_len;
int decrypt;
u4byte e_key[64];
u4byte d_key[64];
} rijndael_ctx;
typedef struct _rijndael_ctx
{
u4byte k_len;
int decrypt;
u4byte e_key[64];
u4byte d_key[64];
} rijndael_ctx;
/* 2. Standard interface for AES cryptographic routines */
/* 2. Standard interface for AES cryptographic routines */
/* These are all based on 32 bit unsigned values and will therefore */
/* require endian conversions for big-endian architectures */
/* require endian conversions for big-endian architectures */
rijndael_ctx *
rijndael_set_key (rijndael_ctx *, const u4byte *, const u4byte, int);
void rijndael_encrypt (rijndael_ctx *, const u4byte *, u4byte *);
void rijndael_decrypt (rijndael_ctx *, const u4byte *, u4byte *);
rijndael_set_key(rijndael_ctx *, const u4byte *, const u4byte, int);
void rijndael_encrypt(rijndael_ctx *, const u4byte *, u4byte *);
void rijndael_decrypt(rijndael_ctx *, const u4byte *, u4byte *);
/* conventional interface */
void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc);
void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len);
void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len);
void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len);
void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len);
void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc);
void aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len);
void aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len);
void aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len);
void aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len);
#endif /* _RIJNDAEL_H_ */
#endif /* _RIJNDAEL_H_ */

12
contrib/pgcrypto/sha1.c
View File

@ -1,4 +1,4 @@
/* $Id: sha1.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */
/* $Id: sha1.c,v 1.8 2001/10/25 05:49:20 momjian Exp $ */
/* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */
/*
@ -87,7 +87,7 @@ do { \
static void sha1_step(struct sha1_ctxt *);
static void
sha1_step(struct sha1_ctxt *ctxt)
sha1_step(struct sha1_ctxt * ctxt)
{
uint32 a,
b,
@ -232,7 +232,7 @@ sha1_step(struct sha1_ctxt *ctxt)
/*------------------------------------------------------------*/
void
sha1_init(struct sha1_ctxt *ctxt)
sha1_init(struct sha1_ctxt * ctxt)
{
bzero(ctxt, sizeof(struct sha1_ctxt));
H(0) = 0x67452301;
@ -243,7 +243,7 @@ sha1_init(struct sha1_ctxt *ctxt)
}
void
sha1_pad(struct sha1_ctxt *ctxt)
sha1_pad(struct sha1_ctxt * ctxt)
{
size_t padlen; /* pad length in bytes */
size_t padstart;
@ -286,7 +286,7 @@ sha1_pad(struct sha1_ctxt *ctxt)
}
void
sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len)
sha1_loop(struct sha1_ctxt * ctxt, const uint8 *input0, size_t len)
{
const uint8 *input;
size_t gaplen;
@ -314,7 +314,7 @@ sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len)
}
void
sha1_result(struct sha1_ctxt *ctxt, uint8 *digest0)
sha1_result(struct sha1_ctxt * ctxt, uint8 *digest0)
{
uint8 *digest;

3
contrib/pgcrypto/sha1.h
View File

@ -1,4 +1,4 @@
/* $Id: sha1.h,v 1.5 2001/08/21 00:42:41 momjian Exp $ */
/* $Id: sha1.h,v 1.6 2001/10/25 05:49:20 momjian Exp $ */
/* $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $ */
/*
@ -71,5 +71,4 @@ typedef struct sha1_ctxt SHA1_CTX;
#define SHA1Final(x, y) sha1_result((y), (x))
#define SHA1_RESULTLEN (160/8)
#endif /* _NETINET6_SHA1_H_ */

141
contrib/pgstattuple/pgstattuple.c
View File

@ -1,5 +1,5 @@
/*
* $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.1 2001/10/01 01:52:38 ishii Exp $
* $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.2 2001/10/25 05:49:20 momjian Exp $
*
* Copyright (c) 2001 Tatsuo Ishii
*
@ -42,90 +42,91 @@ extern Datum pgstattuple(PG_FUNCTION_ARGS);
Datum
pgstattuple(PG_FUNCTION_ARGS)
{
Name p = PG_GETARG_NAME(0);
Name p = PG_GETARG_NAME(0);
Relation rel;
HeapScanDesc scan;
HeapTuple tuple;
BlockNumber nblocks;
BlockNumber block = InvalidBlockNumber;
double table_len;
uint64 tuple_len = 0;
uint64 dead_tuple_len = 0;
uint32 tuple_count = 0;
uint32 dead_tuple_count = 0;
double tuple_percent;
double dead_tuple_percent;
Relation rel;
HeapScanDesc scan;
HeapTuple tuple;
BlockNumber nblocks;
BlockNumber block = InvalidBlockNumber;
double table_len;
uint64 tuple_len = 0;
uint64 dead_tuple_len = 0;
uint32 tuple_count = 0;
uint32 dead_tuple_count = 0;
double tuple_percent;
double dead_tuple_percent;
Buffer buffer = InvalidBuffer;
uint64 free_space = 0; /* free/reusable space in bytes */
double free_percent; /* free/reusable space in % */
Buffer buffer = InvalidBuffer;
uint64 free_space = 0; /* free/reusable space in bytes */
double free_percent; /* free/reusable space in % */
rel = heap_openr(NameStr(*p), NoLock);
nblocks = RelationGetNumberOfBlocks(rel);
scan = heap_beginscan(rel, false, SnapshotAny, 0, NULL);
rel = heap_openr(NameStr(*p), NoLock);
nblocks = RelationGetNumberOfBlocks(rel);
scan = heap_beginscan(rel, false, SnapshotAny, 0, NULL);
while ((tuple = heap_getnext(scan,0)))
{
if (HeapTupleSatisfiesNow(tuple->t_data))
while ((tuple = heap_getnext(scan, 0)))
{
tuple_len += tuple->t_len;
tuple_count++;
if (HeapTupleSatisfiesNow(tuple->t_data))
{
tuple_len += tuple->t_len;
tuple_count++;
}
else
{
dead_tuple_len += tuple->t_len;
dead_tuple_count++;
}
if (!BlockNumberIsValid(block) ||
block != BlockIdGetBlockNumber(&tuple->t_self.ip_blkid))
{
block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid);
buffer = ReadBuffer(rel, block);
free_space += PageGetFreeSpace((Page) BufferGetPage(buffer));
ReleaseBuffer(buffer);
}
}
heap_endscan(scan);
heap_close(rel, NoLock);
table_len = (double) nblocks *BLCKSZ;
if (nblocks == 0)
{
tuple_percent = 0.0;
dead_tuple_percent = 0.0;
free_percent = 0.0;
}
else
{
dead_tuple_len += tuple->t_len;
dead_tuple_count++;
tuple_percent = (double) tuple_len *100.0 / table_len;
dead_tuple_percent = (double) dead_tuple_len *100.0 / table_len;
free_percent = (double) free_space *100.0 / table_len;
}
if (!BlockNumberIsValid(block) ||
block != BlockIdGetBlockNumber(&tuple->t_self.ip_blkid))
{
block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid);
buffer = ReadBuffer(rel, block);
free_space += PageGetFreeSpace((Page)BufferGetPage(buffer));
ReleaseBuffer(buffer);
}
}
heap_endscan(scan);
heap_close(rel, NoLock);
elog(NOTICE, "physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%",
table_len = (double)nblocks*BLCKSZ;
table_len / 1024 / 1024, /* phsical length in MB */
if (nblocks == 0)
{
tuple_percent = 0.0;
dead_tuple_percent = 0.0;
free_percent = 0.0;
}
else
{
tuple_percent = (double)tuple_len*100.0/table_len;
dead_tuple_percent = (double)dead_tuple_len*100.0/table_len;
free_percent = (double)free_space*100.0/table_len;
}
tuple_count, /* number of live tuples */
(double) tuple_len / 1024 / 1024, /* live tuples in MB */
tuple_percent, /* live tuples in % */
elog(NOTICE,"physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%",
dead_tuple_count, /* number of dead tuples */
(double) dead_tuple_len / 1024 / 1024, /* dead tuples in MB */
dead_tuple_percent, /* dead tuples in % */
table_len/1024/1024, /* phsical length in MB */
(double) free_space / 1024 / 1024, /* free/available space in
* MB */
tuple_count, /* number of live tuples */
(double)tuple_len/1024/1024, /* live tuples in MB */
tuple_percent, /* live tuples in % */
free_percent, /* free/available space in % */
dead_tuple_count, /* number of dead tuples */
(double)dead_tuple_len/1024/1024, /* dead tuples in MB */
dead_tuple_percent, /* dead tuples in % */
/* overhead in % */
(nblocks == 0) ? 0.0 : 100.0
- tuple_percent
- dead_tuple_percent
- free_percent);
(double)free_space/1024/1024, /* free/available space in MB */
free_percent, /* free/available space in % */
/* overhead in % */
(nblocks == 0)?0.0: 100.0
- tuple_percent
- dead_tuple_percent
- free_percent);
PG_RETURN_FLOAT8(dead_tuple_percent);
PG_RETURN_FLOAT8(dead_tuple_percent);
}

6
contrib/rserv/rserv.c
View File

@ -24,7 +24,6 @@ Datum _rserv_debug_(PG_FUNCTION_ARGS);
HeapTuple _rserv_log_(void);
int32 _rserv_sync_(int32);
int32 _rserv_debug_(int32);
#endif
static int debug = 0;
@ -44,7 +43,7 @@ _rserv_log_()
char **args; /* argument: argnum */
Relation rel; /* triggered relation */
HeapTuple tuple; /* tuple to return */
HeapTuple newtuple = NULL;/* tuple to return */
HeapTuple newtuple = NULL; /* tuple to return */
TupleDesc tupdesc; /* tuple description */
int keynum;
char *key;
@ -88,6 +87,7 @@ _rserv_log_()
newtuple = CurrentTriggerData->tg_newtuple;
#ifndef PG_FUNCTION_INFO_V1
/*
* Setting CurrentTriggerData to NULL prevents direct calls to trigger
* functions in queries. Normally, trigger functions have to be called
@ -207,7 +207,6 @@ _rserv_sync_(int32 server)
{
#ifdef PG_FUNCTION_INFO_V1
int32 server = PG_GETARG_INT32(0);
#endif
char sql[8192];
char buf[8192];
@ -253,7 +252,6 @@ _rserv_debug_(int32 newval)
{
#ifdef PG_FUNCTION_INFO_V1
int32 newval = PG_GETARG_INT32(0);
#endif
int32 oldval = debug;

625
contrib/rtree_gist/rtree_gist.c
View File

@ -1,13 +1,13 @@
/*-------------------------------------------------------------------------
*
* rtree_gist.c
* pg_amproc entries for GiSTs over 2-D boxes.
* pg_amproc entries for GiSTs over 2-D boxes.
* This gives R-tree behavior, with Guttman's poly-time split algorithm.
*
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.3 2001/10/01 17:53:11 tgl Exp $
* $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.4 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -20,9 +20,9 @@
#include "utils/geo_decls.h"
#include "utils/elog.h"
typedef Datum (*RDF)(PG_FUNCTION_ARGS);
typedef Datum (*BINARY_UNION)(Datum, Datum, int*);
typedef float (*SIZE_BOX)(Datum);
typedef Datum (*RDF) (PG_FUNCTION_ARGS);
typedef Datum (*BINARY_UNION) (Datum, Datum, int *);
typedef float (*SIZE_BOX) (Datum);
/*
** box ops
@ -34,24 +34,24 @@ PG_FUNCTION_INFO_V1(gbox_consistent);
PG_FUNCTION_INFO_V1(gbox_penalty);
PG_FUNCTION_INFO_V1(gbox_same);
Datum gbox_compress(PG_FUNCTION_ARGS);
Datum gbox_union(PG_FUNCTION_ARGS);
Datum gbox_picksplit(PG_FUNCTION_ARGS);
Datum gbox_consistent(PG_FUNCTION_ARGS);
Datum gbox_penalty(PG_FUNCTION_ARGS);
Datum gbox_same(PG_FUNCTION_ARGS);
Datum gbox_compress(PG_FUNCTION_ARGS);
Datum gbox_union(PG_FUNCTION_ARGS);
Datum gbox_picksplit(PG_FUNCTION_ARGS);
Datum gbox_consistent(PG_FUNCTION_ARGS);
Datum gbox_penalty(PG_FUNCTION_ARGS);
Datum gbox_same(PG_FUNCTION_ARGS);
static bool gbox_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy);
static float size_box( Datum box );
static float size_box(Datum box);
/*
** Polygon ops
** Polygon ops
*/
PG_FUNCTION_INFO_V1(gpoly_compress);
PG_FUNCTION_INFO_V1(gpoly_consistent);
Datum gpoly_compress(PG_FUNCTION_ARGS);
Datum gpoly_consistent(PG_FUNCTION_ARGS);
Datum gpoly_compress(PG_FUNCTION_ARGS);
Datum gpoly_consistent(PG_FUNCTION_ARGS);
/*
** Common rtree-function (for all ops)
@ -60,7 +60,7 @@ static bool rtree_internal_consistent(BOX *key, BOX *query, StrategyNumber strat
PG_FUNCTION_INFO_V1(rtree_decompress);
Datum rtree_decompress(PG_FUNCTION_ARGS);
Datum rtree_decompress(PG_FUNCTION_ARGS);
/**************************************************
* Box ops
@ -75,21 +75,21 @@ Datum rtree_decompress(PG_FUNCTION_ARGS);
Datum
gbox_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
BOX *query = (BOX*) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
BOX *query = (BOX *) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
*/
if ( ! (DatumGetPointer(entry->key) != NULL && query) )
/*
* * if entry is not leaf, use gbox_internal_consistent, * else use
* gbox_leaf_consistent
*/
if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE);
if (GIST_LEAF(entry))
PG_RETURN_BOOL(gbox_leaf_consistent((BOX *) DatumGetPointer(entry->key), query, strategy));
else
PG_RETURN_BOOL(rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), query, strategy));
if (GIST_LEAF(entry))
PG_RETURN_BOOL(gbox_leaf_consistent((BOX *) DatumGetPointer(entry->key), query, strategy));
else
PG_RETURN_BOOL(rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), query, strategy));
}
@ -100,30 +100,33 @@ gbox_consistent(PG_FUNCTION_ARGS)
Datum
gbox_union(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
int *sizep = (int*) PG_GETARG_POINTER(1);
int numranges, i;
BOX *cur, *pageunion;
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
int *sizep = (int *) PG_GETARG_POINTER(1);
int numranges,
i;
BOX *cur,
*pageunion;
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
pageunion = (BOX *)palloc( sizeof(BOX) );
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[0].key );
memcpy( (void*)pageunion, (void*)cur, sizeof( BOX ) );
for (i = 1; i < numranges; i++) {
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key );
if ( pageunion->high.x < cur->high.x )
pageunion->high.x = cur->high.x;
if ( pageunion->low.x > cur->low.x )
pageunion->low.x = cur->low.x;
if ( pageunion->high.y < cur->high.y )
pageunion->high.y = cur->high.y;
if ( pageunion->low.y > cur->low.y )
pageunion->low.y = cur->low.y;
}
*sizep = sizeof(BOX);
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
pageunion = (BOX *) palloc(sizeof(BOX));
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[0].key);
memcpy((void *) pageunion, (void *) cur, sizeof(BOX));
PG_RETURN_POINTER(pageunion);
for (i = 1; i < numranges; i++)
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (pageunion->high.x < cur->high.x)
pageunion->high.x = cur->high.x;
if (pageunion->low.x > cur->low.x)
pageunion->low.x = cur->low.x;
if (pageunion->high.y < cur->high.y)
pageunion->high.y = cur->high.y;
if (pageunion->low.y > cur->low.y)
pageunion->low.y = cur->low.y;
}
*sizep = sizeof(BOX);
PG_RETURN_POINTER(pageunion);
}
/*
@ -143,18 +146,19 @@ gbox_compress(PG_FUNCTION_ARGS)
Datum
gbox_penalty(PG_FUNCTION_ARGS)
{
GISTENTRY *origentry = (GISTENTRY*) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY*) PG_GETARG_POINTER(1);
float *result = (float*) PG_GETARG_POINTER(2);
Datum ud;
float tmp1;
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
tmp1 = size_box( ud );
if (DatumGetPointer(ud) != NULL) pfree(DatumGetPointer(ud));
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
float *result = (float *) PG_GETARG_POINTER(2);
Datum ud;
float tmp1;
*result = tmp1 - size_box( origentry->key );
PG_RETURN_POINTER(result);
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
tmp1 = size_box(ud);
if (DatumGetPointer(ud) != NULL)
pfree(DatumGetPointer(ud));
*result = tmp1 - size_box(origentry->key);
PG_RETURN_POINTER(result);
}
/*
@ -165,145 +169,183 @@ gbox_penalty(PG_FUNCTION_ARGS)
Datum
gbox_picksplit(PG_FUNCTION_ARGS)
{
bytea *entryvec = (bytea*)PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC*)PG_GETARG_POINTER(1);
OffsetNumber i;
OffsetNumber *listL, *listR, *listB, *listT;
BOX *unionL,*unionR,*unionB,*unionT;
int posL, posR, posB, posT;
BOX pageunion;
BOX *cur;
char direction=' ';
bool allisequal=true;
OffsetNumber maxoff;
int nbytes;
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
OffsetNumber i;
OffsetNumber *listL,
*listR,
*listB,
*listT;
BOX *unionL,
*unionR,
*unionB,
*unionT;
int posL,
posR,
posB,
posT;
BOX pageunion;
BOX *cur;
char direction = ' ';
bool allisequal = true;
OffsetNumber maxoff;
int nbytes;
posL = posR = posB = posT = 0;
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1;
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key );
memcpy( (void*)&pageunion, (void*)cur, sizeof( BOX ) );
/* find MBR */
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i)) {
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key );
if ( pageunion.high.x < cur->high.x )
{ allisequal=false; pageunion.high.x = cur->high.x; }
if ( pageunion.low.x > cur->low.x )
{ allisequal=false; pageunion.low.x = cur->low.x; }
if ( pageunion.high.y < cur->high.y )
{ allisequal=false; pageunion.high.y = cur->high.y; }
if ( pageunion.low.y > cur->low.y )
{ allisequal=false; pageunion.low.y = cur->low.y; }
}
posL = posR = posB = posT = 0;
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
listL = (OffsetNumber*)palloc( nbytes );
listR = (OffsetNumber*)palloc( nbytes );
unionL = (BOX*)palloc( sizeof(BOX) );
unionR = (BOX*)palloc( sizeof(BOX) );
if ( allisequal ) {
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key );
if ( memcmp( (void*)cur, (void*)&pageunion, sizeof( BOX ) ) == 0 ) {
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = v->spl_nright = 0;
memcpy( (void*)unionL, (void*)&pageunion, sizeof( BOX ) );
memcpy( (void*)unionR, (void*)&pageunion, sizeof( BOX ) );
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
v->spl_left[ v->spl_nleft ] = i;
v->spl_nleft++;
} else {
v->spl_right[ v->spl_nright ] = i;
v->spl_nright++;
}
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key);
memcpy((void *) &pageunion, (void *) cur, sizeof(BOX));
/* find MBR */
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i))
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (pageunion.high.x < cur->high.x)
{
allisequal = false;
pageunion.high.x = cur->high.x;
}
if (pageunion.low.x > cur->low.x)
{
allisequal = false;
pageunion.low.x = cur->low.x;
}
if (pageunion.high.y < cur->high.y)
{
allisequal = false;
pageunion.high.y = cur->high.y;
}
if (pageunion.low.y > cur->low.y)
{
allisequal = false;
pageunion.low.y = cur->low.y;
}
v->spl_ldatum = BoxPGetDatum( unionL );
v->spl_rdatum = BoxPGetDatum( unionR );
PG_RETURN_POINTER( v );
}
}
listB = (OffsetNumber*)palloc( nbytes );
listT = (OffsetNumber*)palloc( nbytes );
unionB = (BOX*)palloc( sizeof(BOX) );
unionT = (BOX*)palloc( sizeof(BOX) );
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
listL = (OffsetNumber *) palloc(nbytes);
listR = (OffsetNumber *) palloc(nbytes);
unionL = (BOX *) palloc(sizeof(BOX));
unionR = (BOX *) palloc(sizeof(BOX));
if (allisequal)
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key);
if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0)
{
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = v->spl_nright = 0;
memcpy((void *) unionL, (void *) &pageunion, sizeof(BOX));
memcpy((void *) unionR, (void *) &pageunion, sizeof(BOX));
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
v->spl_left[v->spl_nleft] = i;
v->spl_nleft++;
}
else
{
v->spl_right[v->spl_nright] = i;
v->spl_nright++;
}
}
v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum(unionR);
PG_RETURN_POINTER(v);
}
}
listB = (OffsetNumber *) palloc(nbytes);
listT = (OffsetNumber *) palloc(nbytes);
unionB = (BOX *) palloc(sizeof(BOX));
unionT = (BOX *) palloc(sizeof(BOX));
#define ADDLIST( list, unionD, pos ) do { \
if ( pos ) { \
if ( unionD->high.x < cur->high.x ) unionD->high.x = cur->high.x; \
if ( unionD->low.x > cur->low.x ) unionD->low.x = cur->low.x; \
if ( unionD->high.y < cur->high.y ) unionD->high.y = cur->high.y; \
if ( unionD->low.y > cur->low.y ) unionD->low.y = cur->low.y; \
if ( unionD->high.x < cur->high.x ) unionD->high.x = cur->high.x; \
if ( unionD->low.x > cur->low.x ) unionD->low.x = cur->low.x; \
if ( unionD->high.y < cur->high.y ) unionD->high.y = cur->high.y; \
if ( unionD->low.y > cur->low.y ) unionD->low.y = cur->low.y; \
} else { \
memcpy( (void*)unionD, (void*) cur, sizeof( BOX ) ); \
memcpy( (void*)unionD, (void*) cur, sizeof( BOX ) ); \
} \
list[pos] = i; \
(pos)++; \
} while(0)
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key );
if ( cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x )
ADDLIST( listL, unionL, posL );
else
ADDLIST( listR, unionR, posR );
if ( cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y )
ADDLIST( listB, unionB, posB );
else
ADDLIST( listT, unionT, posT );
}
/* which split more optimal? */
if ( Max( posL, posR ) < Max( posB, posT ) ) {
direction = 'x';
} else if ( Max( posL, posR ) > Max( posB, posT ) ) {
direction = 'y';
} else {
Datum interLR = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionL),
BoxPGetDatum(unionR));
Datum interBT = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionB),
BoxPGetDatum(unionT));
float sizeLR, sizeBT;
sizeLR = size_box( interLR );
sizeBT = size_box( interBT );
if ( sizeLR < sizeBT )
direction = 'x';
else
direction = 'y';
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
ADDLIST(listL, unionL, posL);
else
ADDLIST(listR, unionR, posR);
if (cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y)
ADDLIST(listB, unionB, posB);
else
ADDLIST(listT, unionT, posT);
}
if ( direction == 'x' ) {
pfree( unionB ); pfree( listB );
pfree( unionT ); pfree( listT );
/* which split more optimal? */
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = posL;
v->spl_nright = posR;
v->spl_ldatum = BoxPGetDatum( unionL );
v->spl_rdatum = BoxPGetDatum( unionR );
} else {
pfree( unionR ); pfree( listR );
pfree( unionL ); pfree( listL );
if (Max(posL, posR) < Max(posB, posT))
direction = 'x';
else if (Max(posL, posR) > Max(posB, posT))
direction = 'y';
else
{
Datum interLR = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionL),
BoxPGetDatum(unionR));
Datum interBT = DirectFunctionCall2(rt_box_inter,
BoxPGetDatum(unionB),
BoxPGetDatum(unionT));
float sizeLR,
sizeBT;
v->spl_left = listB;
v->spl_right = listT;
v->spl_nleft = posB;
v->spl_nright = posT;
v->spl_ldatum = BoxPGetDatum( unionB );
v->spl_rdatum = BoxPGetDatum( unionT );
}
sizeLR = size_box(interLR);
sizeBT = size_box(interBT);
PG_RETURN_POINTER (v);
if (sizeLR < sizeBT)
direction = 'x';
else
direction = 'y';
}
if (direction == 'x')
{
pfree(unionB);
pfree(listB);
pfree(unionT);
pfree(listT);
v->spl_left = listL;
v->spl_right = listR;
v->spl_nleft = posL;
v->spl_nright = posR;
v->spl_ldatum = BoxPGetDatum(unionL);
v->spl_rdatum = BoxPGetDatum(unionR);
}
else
{
pfree(unionR);
pfree(listR);
pfree(unionL);
pfree(listL);
v->spl_left = listB;
v->spl_right = listT;
v->spl_nleft = posB;
v->spl_nright = posT;
v->spl_ldatum = BoxPGetDatum(unionB);
v->spl_rdatum = BoxPGetDatum(unionT);
}
PG_RETURN_POINTER(v);
}
/*
@ -312,66 +354,71 @@ gbox_picksplit(PG_FUNCTION_ARGS)
Datum
gbox_same(PG_FUNCTION_ARGS)
{
BOX *b1 = (BOX*) PG_GETARG_POINTER(0);
BOX *b2 = (BOX*) PG_GETARG_POINTER(1);
bool *result = (bool*) PG_GETARG_POINTER(2);
if ( b1 && b2 )
*result = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(b1), PointerGetDatum(b2)) );
else
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
BOX *b1 = (BOX *) PG_GETARG_POINTER(0);
BOX *b2 = (BOX *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
if (b1 && b2)
*result = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(b1), PointerGetDatum(b2)));
else
*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
PG_RETURN_POINTER(result);
}
/*
/*
** SUPPORT ROUTINES for boxes
*/
static bool
static bool
gbox_leaf_consistent(BOX *key,
BOX *query,
StrategyNumber strategy)
BOX *query,
StrategyNumber strategy)
{
bool retval;
bool retval;
switch(strategy) {
case RTLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_left, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overright, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTSameStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTContainsStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTContainedByStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contained, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
default:
retval = FALSE;
}
return(retval);
switch (strategy)
{
case RTLeftStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_left, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverLeftStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverRightStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overright, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTRightStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTSameStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTContainsStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_contain, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTContainedByStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_contained, PointerGetDatum(key), PointerGetDatum(query)));
break;
default:
retval = FALSE;
}
return (retval);
}
static float
size_box( Datum box ) {
if ( DatumGetPointer(box) != NULL ) {
float size;
static float
size_box(Datum box)
{
if (DatumGetPointer(box) != NULL)
{
float size;
DirectFunctionCall2( rt_box_size,
box, PointerGetDatum( &size ) );
DirectFunctionCall2(rt_box_size,
box, PointerGetDatum(&size));
return size;
} else
}
else
return 0.0;
}
@ -382,91 +429,97 @@ size_box( Datum box ) {
Datum
gpoly_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
GISTENTRY *retval;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if ( entry->leafkey) {
if (entry->leafkey)
{
retval = palloc(sizeof(GISTENTRY));
if ( DatumGetPointer(entry->key) != NULL ) {
POLYGON *in;
BOX *r;
if (DatumGetPointer(entry->key) != NULL)
{
POLYGON *in;
BOX *r;
in = (POLYGON *) PG_DETOAST_DATUM(entry->key);
r = (BOX *) palloc( sizeof(BOX) );
memcpy( (void*)r, (void*)&(in->boundbox), sizeof(BOX) );
if ( in != (POLYGON *) DatumGetPointer(entry->key) )
pfree( in );
r = (BOX *) palloc(sizeof(BOX));
memcpy((void *) r, (void *) &(in->boundbox), sizeof(BOX));
if (in != (POLYGON *) DatumGetPointer(entry->key))
pfree(in);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, sizeof(BOX), FALSE);
} else {
}
else
{
gistentryinit(*retval, (Datum) 0,
entry->rel, entry->page,
entry->offset, 0,FALSE);
}
} else {
retval = entry;
entry->offset, 0, FALSE);
}
}
PG_RETURN_POINTER( retval );
else
retval = entry;
PG_RETURN_POINTER(retval);
}
Datum
gpoly_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
POLYGON *query = (POLYGON*)PG_DETOAST_DATUM( PG_GETARG_POINTER(1) );
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool result;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
POLYGON *query = (POLYGON *) PG_DETOAST_DATUM(PG_GETARG_POINTER(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool result;
/*
** if entry is not leaf, use gbox_internal_consistent,
** else use gbox_leaf_consistent
*/
if ( ! (DatumGetPointer(entry->key) != NULL && query) )
/*
* * if entry is not leaf, use gbox_internal_consistent, * else use
* gbox_leaf_consistent
*/
if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE);
result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key),
&(query->boundbox), strategy);
result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key),
&(query->boundbox), strategy);
PG_FREE_IF_COPY(query,1);
PG_RETURN_BOOL( result );
PG_FREE_IF_COPY(query, 1);
PG_RETURN_BOOL(result);
}
/*****************************************
* Common rtree-function (for all ops)
*****************************************/
static bool
static bool
rtree_internal_consistent(BOX *key,
BOX *query,
StrategyNumber strategy)
BOX *query,
StrategyNumber strategy)
{
bool retval;
bool retval;
switch(strategy) {
case RTLeftStrategyNumber:
case RTOverLeftStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTOverRightStrategyNumber:
case RTRightStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTSameStrategyNumber:
case RTContainsStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
case RTContainedByStrategyNumber:
retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) );
break;
default:
retval = FALSE;
}
return(retval);
switch (strategy)
{
case RTLeftStrategyNumber:
case RTOverLeftStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverRightStrategyNumber:
case RTRightStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTSameStrategyNumber:
case RTContainsStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_contain, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTContainedByStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break;
default:
retval = FALSE;
}
return (retval);
}
/*

14
contrib/seg/seg.c
View File

@ -138,7 +138,6 @@ seg_out(SEG * seg)
if (seg->lower == seg->upper && seg->l_ext == seg->u_ext)
{
/*
* indicates that this interval was built by seg_in off a single
* point
@ -219,7 +218,6 @@ gseg_consistent(GISTENTRY *entry,
SEG * query,
StrategyNumber strategy)
{
/*
* * if entry is not leaf, use gseg_internal_consistent, * else use
* gseg_leaf_consistent
@ -253,7 +251,7 @@ gseg_union(bytea *entryvec, int *sizep)
for (i = 1; i < numranges; i++)
{
out = gseg_binary_union(tmp, (SEG *)
DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key),
DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key),
sizep);
if (i > 1)
pfree(tmp);
@ -267,13 +265,13 @@ gseg_union(bytea *entryvec, int *sizep)
** GiST Compress and Decompress methods for segments
** do not do anything.
*/
GISTENTRY *
GISTENTRY *
gseg_compress(GISTENTRY *entry)
{
return (entry);
}
GISTENTRY *
GISTENTRY *
gseg_decompress(GISTENTRY *entry)
{
return (entry);
@ -415,7 +413,6 @@ gseg_picksplit(bytea *entryvec,
maxoff = OffsetNumberNext(maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
/*
* If we've already decided where to place this item, just put it
* on the right list. Otherwise, we need to figure out which page
@ -614,7 +611,7 @@ seg_overlap(SEG * a, SEG * b)
((a->upper >= b->upper) && (a->lower <= b->upper))
||
((b->upper >= a->upper) && (b->lower <= a->upper))
);
);
}
/* seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)?
@ -757,7 +754,6 @@ seg_size(SEG * a)
int32
seg_cmp(SEG * a, SEG * b)
{
/*
* First compare on lower boundary position
*/
@ -968,7 +964,6 @@ restore(char *result, float val, int n)
{
if (abs(exp) <= 4)
{
/*
* remove the decimal point from the mantyssa and write the
* digits to the buf array
@ -989,7 +984,6 @@ restore(char *result, float val, int n)
{
if (dp - 10 + exp >= n)
{
/*
* the decimal point is behind the last significant
* digit; the digits in between must be converted to

11
contrib/spi/refint.c
View File

@ -52,7 +52,7 @@ check_primary_key(PG_FUNCTION_ARGS)
HeapTuple tuple = NULL; /* tuple to return */
TupleDesc tupdesc; /* tuple description */
EPlan *plan; /* prepared plan */
Oid *argtypes = NULL;/* key types to prepare execution plan */
Oid *argtypes = NULL; /* key types to prepare execution plan */
bool isnull; /* to know is some column NULL or not */
char ident[2 * NAMEDATALEN]; /* to identify myself */
int ret;
@ -235,10 +235,10 @@ check_foreign_key(PG_FUNCTION_ARGS)
char *relname; /* referencing relation name */
Relation rel; /* triggered relation */
HeapTuple trigtuple = NULL; /* tuple to being changed */
HeapTuple newtuple = NULL;/* tuple to return */
HeapTuple newtuple = NULL; /* tuple to return */
TupleDesc tupdesc; /* tuple description */
EPlan *plan; /* prepared plan(s) */
Oid *argtypes = NULL;/* key types to prepare execution plan */
Oid *argtypes = NULL; /* key types to prepare execution plan */
bool isnull; /* to know is some column NULL or not */
bool isequal = true; /* are keys in both tuples equal (in
* UPDATE) */
@ -402,11 +402,11 @@ check_foreign_key(PG_FUNCTION_ARGS)
/*---------
* For 'R'estrict action we construct SELECT query:
*
* SELECT 1
* SELECT 1
* FROM _referencing_relation_
* WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]]
*
* to check is tuple referenced or not.
* to check is tuple referenced or not.
*---------
*/
if (action == 'r')
@ -537,7 +537,6 @@ check_foreign_key(PG_FUNCTION_ARGS)
*/
for (r = 0; r < nrefs; r++)
{
/*
* For 'R'estrict we may to execute plan for one tuple only, for
* other actions - for all tuples.

1
contrib/string/string_io.c
View File

@ -359,7 +359,6 @@ c_charin(unsigned char *str)
{
return (string_input(str, 1, 0, NULL));
}
#endif
/* end of file */

1
contrib/string/string_io.h
View File

@ -13,7 +13,6 @@ struct varlena *c_textin(unsigned char *str);
int32 *
c_charin(unsigned char *str)
#endif
#endif
/*

18
contrib/tsearch/crc32.c
View File

@ -87,15 +87,17 @@ static const unsigned int crc32tab[256] = {
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
unsigned int crc32_sz(char * buf, int size){
unsigned int
crc32_sz(char *buf, int size)
{
unsigned int crc = ~0;
char *p ;
int len, nr;
char *p;
int len,
nr;
len = 0 ;
nr=size;
for (len += nr, p = buf; nr--; ++p) {
_CRC32_(crc, *p) ;
}
len = 0;
nr = size;
for (len += nr, p = buf; nr--; ++p)
_CRC32_(crc, *p);
return ~crc;
}

3
contrib/tsearch/crc32.h
View File

@ -2,9 +2,8 @@
#define _CRC32_H
/* Returns crc32 of data block */
extern unsigned int crc32_sz(char * buf, int size);
extern unsigned int crc32_sz(char *buf, int size);
/* Returns crc32 of null-terminated string */
#define crc32(buf) crc32_sz((buf),strlen(buf))
#endif

14
contrib/tsearch/deflex.h
View File

@ -12,12 +12,12 @@
#define HOST 6
#define FLOAT 7
#define FINT 8
#define PARTWORD 9
#define NONLATINPARTWORD 10
#define LATPARTWORD 11
#define SPACE 12
#define SYMTAG 13
#define HTTP 14
#define PARTWORD 9
#define NONLATINPARTWORD 10
#define LATPARTWORD 11
#define SPACE 12
#define SYMTAG 13
#define HTTP 14
#define DEFISWORD 15
#define DEFISLATWORD 16
#define DEFISNONLATINWORD 17
@ -25,6 +25,4 @@
#define FILEPATH 19
extern const char *descr[];
#endif

35
contrib/tsearch/gistidx.h
View File

@ -9,7 +9,8 @@
* signature defines
*/
#define BITBYTE 8
#define SIGLENINT 64 /* >121 => key will toast, so it will not work !!! */
#define SIGLENINT 64 /* >121 => key will toast, so it will not
* work !!! */
#define SIGLEN ( sizeof(int4)*SIGLENINT )
#define SIGLENBIT (SIGLEN*BITBYTE)
@ -21,9 +22,9 @@ typedef char *BITVECP;
a;\
}
#define LOOPBIT(a) \
for(i=0;i<SIGLENBIT;i++) {\
a;\
}
for(i=0;i<SIGLENBIT;i++) {\
a;\
}
#define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITBYTE ) ) )
#define GETBITBYTE(x,i) ( ((char)(x)) >> i & 0x01 )
@ -38,27 +39,27 @@ typedef char *BITVECP;
/*
* type of index key
* type of index key
*/
typedef struct {
int4 len;
int4 flag;
char data[1];
} GISTTYPE;
typedef struct
{
int4 len;
int4 flag;
char data[1];
} GISTTYPE;
#define ARRKEY 0x01
#define SIGNKEY 0x02
#define ALLISTRUE 0x04
#define ARRKEY 0x01
#define SIGNKEY 0x02
#define ALLISTRUE 0x04
#define ISARRKEY(x) ( ((GISTTYPE*)x)->flag & ARRKEY )
#define ISARRKEY(x) ( ((GISTTYPE*)x)->flag & ARRKEY )
#define ISSIGNKEY(x) ( ((GISTTYPE*)x)->flag & SIGNKEY )
#define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE )
#define GTHDRSIZE ( sizeof(int4)*2 )
#define GTHDRSIZE ( sizeof(int4)*2 )
#define CALCGTSIZE(flag, len) ( GTHDRSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(int4)) : (((flag) & ALLISTRUE) ? 0 : SIGLEN) ) )
#define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) )
#define GETARR(x) ( (int4*)( (char*)x+GTHDRSIZE ) )
#define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) )
#define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) )
#endif

210
contrib/tsearch/morph.c
View File

@ -3,7 +3,7 @@
* New dictionary is include in dict.h. For languages which
* use latin charset it may be need to modify mapdict table.
* Teodor Sigaev <teodor@stack.net>
*/
*/
#include "postgres.h"
#include "utils/elog.h"
@ -20,157 +20,183 @@
* All of this methods are optional, but
* if all methods are NULL, then dictionary does nothing :)
* Return value of lemmatize must be palloced or the same.
* Return value of init must be malloced in other case
* it will be free in end of transaction!
* Return value of init must be malloced in other case
* it will be free in end of transaction!
*/
typedef struct {
char localename[LOCALE_NAME_BUFLEN];
typedef struct
{
char localename[LOCALE_NAME_BUFLEN];
/* init dictionary */
void* (*init)(void);
void *(*init) (void);
/* close dictionary */
void (*close)(void*);
void (*close) (void *);
/* find in dictionary */
char* (*lemmatize)(void*,char*,int*);
int (*is_stoplemm)(void*,char*,int);
int (*is_stemstoplemm)(void*,char*,int);
} DICT;
char *(*lemmatize) (void *, char *, int *);
int (*is_stoplemm) (void *, char *, int);
int (*is_stemstoplemm) (void *, char *, int);
} DICT;
/* insert all dictionaries */
#define DICT_BODY
#include "dict.h"
#undef DICT_BODY
#undef DICT_BODY
/* fill dictionary's structure */
/* fill dictionary's structure */
#define DICT_TABLE
DICT dicts[] = {
DICT dicts[] = {
{
"C",NULL,NULL,NULL,NULL,NULL /* fake dictionary */
"C", NULL, NULL, NULL, NULL, NULL /* fake dictionary */
}
#include "dict.h"
};
#undef DICT_TABLE
/* array for storing dictinary's objects (if needed) */
void* dictobjs[ lengthof(dicts) ];
void *dictobjs[
lengthof(dicts)];
#define STOPLEXEM -2
#define BYLOCALE -1
#define NODICT 0
#define DEFAULTDICT 1
#define NODICT 0
#define DEFAULTDICT 1
#define MAXNDICT 2
typedef int2 MAPDICT[MAXNDICT];
typedef int2 MAPDICT[MAXNDICT];
#define GETDICT(x,i) *( ((int2*)(x)) + (i) )
/* map dictionaries for lexem type */
static MAPDICT mapdict[] = {
{NODICT, NODICT}, /* not used */
{DEFAULTDICT, NODICT}, /* LATWORD */
{BYLOCALE, NODICT}, /* NONLATINWORD */
{BYLOCALE, DEFAULTDICT}, /* UWORD */
{NODICT, NODICT}, /* EMAIL */
{NODICT, NODICT}, /* FURL */
{NODICT, NODICT}, /* HOST */
{NODICT, NODICT}, /* FLOAT */
{NODICT, NODICT}, /* FINT */
{BYLOCALE, DEFAULTDICT}, /* PARTWORD */
{BYLOCALE, NODICT}, /* NONLATINPARTWORD */
{DEFAULTDICT, NODICT}, /* LATPARTWORD */
{STOPLEXEM, NODICT}, /* SPACE */
{STOPLEXEM, NODICT}, /* SYMTAG */
{STOPLEXEM, NODICT}, /* HTTP */
{BYLOCALE, DEFAULTDICT}, /* DEFISWORD */
{DEFAULTDICT, NODICT}, /* DEFISLATWORD */
{BYLOCALE, NODICT}, /* DEFISNONLATINWORD */
{NODICT, NODICT}, /* URI */
{NODICT, NODICT} /* FILEPATH */
{NODICT, NODICT}, /* not used */
{DEFAULTDICT, NODICT}, /* LATWORD */
{BYLOCALE, NODICT}, /* NONLATINWORD */
{BYLOCALE, DEFAULTDICT}, /* UWORD */
{NODICT, NODICT}, /* EMAIL */
{NODICT, NODICT}, /* FURL */
{NODICT, NODICT}, /* HOST */
{NODICT, NODICT}, /* FLOAT */
{NODICT, NODICT}, /* FINT */
{BYLOCALE, DEFAULTDICT}, /* PARTWORD */
{BYLOCALE, NODICT}, /* NONLATINPARTWORD */
{DEFAULTDICT, NODICT}, /* LATPARTWORD */
{STOPLEXEM, NODICT}, /* SPACE */
{STOPLEXEM, NODICT}, /* SYMTAG */
{STOPLEXEM, NODICT}, /* HTTP */
{BYLOCALE, DEFAULTDICT}, /* DEFISWORD */
{DEFAULTDICT, NODICT}, /* DEFISLATWORD */
{BYLOCALE, NODICT}, /* DEFISNONLATINWORD */
{NODICT, NODICT}, /* URI */
{NODICT, NODICT} /* FILEPATH */
};
static bool inited=false;
static bool inited = false;
void
initmorph(void)
{
int i,
j,
k;
MAPDICT *md;
bool needinit[lengthof(dicts)];
void initmorph(void) {
int i,j,k;
MAPDICT *md;
bool needinit[ lengthof(dicts) ];
#ifdef USE_LOCALE
PG_LocaleCategories lc;
PG_LocaleCategories lc;
int bylocaledict = NODICT;
int bylocaledict = NODICT;
#endif
if ( inited ) return;
for(i=1; i<lengthof(dicts);i++)
if (inited)
return;
for (i = 1; i < lengthof(dicts); i++)
needinit[i] = false;
#ifdef USE_LOCALE
PGLC_current(&lc);
for(i=1;i<lengthof(dicts);i++)
if (strcmp( dicts[i].localename, lc.lang ) == 0) {
for (i = 1; i < lengthof(dicts); i++)
if (strcmp(dicts[i].localename, lc.lang) == 0)
{
bylocaledict = i;
break;
}
PGLC_free_categories(&lc);
#endif
for(i=1; i<lengthof(mapdict);i++) {
k=0;
for (i = 1; i < lengthof(mapdict); i++)
{
k = 0;
md = &mapdict[i];
for(j=0;j<MAXNDICT;j++) {
GETDICT(md,k) = GETDICT(md,j);
if ( GETDICT(md,k) == NODICT ) {
for (j = 0; j < MAXNDICT; j++)
{
GETDICT(md, k) = GETDICT(md, j);
if (GETDICT(md, k) == NODICT)
break;
} else if ( GETDICT(md,k) == BYLOCALE ) {
else if (GETDICT(md, k) == BYLOCALE)
{
#ifdef USE_LOCALE
if ( bylocaledict == NODICT )
if (bylocaledict == NODICT)
continue;
GETDICT(md,k) = bylocaledict;
GETDICT(md, k) = bylocaledict;
#else
continue;
#endif
}
if ( GETDICT(md,k) >= (int2)lengthof(dicts) )
if (GETDICT(md, k) >= (int2) lengthof(dicts))
continue;
needinit[ GETDICT(md,k) ] = true;
k++;
needinit[GETDICT(md, k)] = true;
k++;
}
for(;k<MAXNDICT;k++)
if ( GETDICT(md,k) != STOPLEXEM )
GETDICT(md,k) = NODICT;
for (; k < MAXNDICT; k++)
if (GETDICT(md, k) != STOPLEXEM)
GETDICT(md, k) = NODICT;
}
for(i=1; i<lengthof(dicts);i++)
if ( needinit[i] && dicts[i].init )
dictobjs[i] = (*(dicts[i].init))();
for (i = 1; i < lengthof(dicts); i++)
if (needinit[i] && dicts[i].init)
dictobjs[i] = (*(dicts[i].init)) ();
inited = true;
return;
}
char* lemmatize( char* word, int *len, int type ) {
int2 nd;
int i;
DICT *dict;
char *
lemmatize(char *word, int *len, int type)
{
int2 nd;
int i;
DICT *dict;
for(i=0;i<MAXNDICT;i++) {
nd = GETDICT( &mapdict[type], i );
if ( nd == NODICT ) {
/* there is no dictionary */
for (i = 0; i < MAXNDICT; i++)
{
nd = GETDICT(&mapdict[type], i);
if (nd == NODICT)
{
/* there is no dictionary */
return word;
} else if ( nd == STOPLEXEM ) {
}
else if (nd == STOPLEXEM)
{
/* word is stopword */
return NULL;
} else {
dict = &dicts[ nd ];
if ( dict->is_stoplemm && (*(dict->is_stoplemm))(dictobjs[nd], word, *len) )
}
else
{
dict = &dicts[nd];
if (dict->is_stoplemm && (*(dict->is_stoplemm)) (dictobjs[nd], word, *len))
return NULL;
if ( dict->lemmatize ) {
int oldlen = *len;
char *newword = (*(dict->lemmatize))(dictobjs[nd], word, len);
if (dict->lemmatize)
{
int oldlen = *len;
char *newword = (*(dict->lemmatize)) (dictobjs[nd], word, len);
/* word is recognized by distionary */
if ( newword != word || *len != oldlen ) {
if ( dict->is_stemstoplemm &&
(*(dict->is_stemstoplemm))(dictobjs[nd], word, *len) ) {
if ( newword != word && newword)
if (newword != word || *len != oldlen)
{
if (dict->is_stemstoplemm &&
(*(dict->is_stemstoplemm)) (dictobjs[nd], word, *len))
{
if (newword != word && newword)
pfree(newword);
return NULL;
}
@ -183,6 +209,8 @@ char* lemmatize( char* word, int *len, int type ) {
return word;
}
bool is_stoptype(int type) {
return ( GETDICT( &mapdict[type], 0 ) == STOPLEXEM ) ? true : false;
bool
is_stoptype(int type)
{
return (GETDICT(&mapdict[type], 0) == STOPLEXEM) ? true : false;
}

6
contrib/tsearch/morph.h
View File

@ -1,9 +1,9 @@
#ifndef __MORPH_H__
#define __MORPH_H__
void initmorph(void);
void initmorph(void);
char* lemmatize( char* word, int *len, int type );
char *lemmatize(char *word, int *len, int type);
bool is_stoptype(int type);
bool is_stoptype(int type);
#endif

13
contrib/tsearch/parser.h
View File

@ -1,11 +1,10 @@
#ifndef __PARSER_H__
#define __PARSER_H__
char *token;
int tokenlen;
int tsearch_yylex(void);
void start_parse_str(char*, int);
void start_parse_fh(FILE*, int);
void end_parse(void);
char *token;
int tokenlen;
int tsearch_yylex(void);
void start_parse_str(char *, int);
void start_parse_fh(FILE *, int);
void end_parse(void);
#endif

738
contrib/tsearch/query.c
View File

File diff suppressed because it is too large Load Diff

48
contrib/tsearch/query.h
View File

@ -9,41 +9,43 @@
* item in polish notation with back link
* to left operand
*/
typedef struct ITEM {
int2 type;
int2 left;
int4 val;
typedef struct ITEM
{
int2 type;
int2 left;
int4 val;
/* user-friendly value */
uint16 distance;
uint16 length;
} ITEM;
uint16 distance;
uint16 length;
} ITEM;
/*
*Storage:
* (len)(size)(array of ITEM)(array of operand in user-friendly form)
*/
typedef struct {
int4 len;
int4 size;
char data[1];
} QUERYTYPE;
typedef struct
{
int4 len;
int4 size;
char data[1];
} QUERYTYPE;
#define HDRSIZEQT ( 2*sizeof(int4) )
#define COMPUTESIZE(size,lenofoperand) ( HDRSIZEQT + size * sizeof(ITEM) + lenofoperand )
#define GETQUERY(x) (ITEM*)( (char*)(x)+HDRSIZEQT )
#define GETOPERAND(x) ( (char*)GETQUERY(x) + ((QUERYTYPE*)x)->size * sizeof(ITEM) )
#define GETOPERAND(x) ( (char*)GETQUERY(x) + ((QUERYTYPE*)x)->size * sizeof(ITEM) )
#define ISOPERATOR(x) ( (x)=='!' || (x)=='&' || (x)=='|' || (x)=='(' || (x)==')' )
#define END 0
#define ERR 1
#define VAL 2
#define OPR 3
#define OPEN 4
#define CLOSE 5
#define VALTRUE 6 /* for stop words */
#define VALFALSE 7
#define END 0
#define ERR 1
#define VAL 2
#define OPR 3
#define OPEN 4
#define CLOSE 5
#define VALTRUE 6 /* for stop words */
#define VALFALSE 7
bool execute( ITEM* curitem, void *checkval,
bool calcnot, bool (*chkcond)(void *checkval, ITEM* val ));
bool execute(ITEM * curitem, void *checkval,
bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
#endif

322
contrib/tsearch/rewrite.c
View File

@ -19,52 +19,63 @@
#include "query.h"
#include "rewrite.h"
typedef struct NODE {
struct NODE *left;
typedef struct NODE
{
struct NODE *left;
struct NODE *right;
ITEM* valnode;
} NODE;
ITEM *valnode;
} NODE;
/*
* make query tree from plain view of query
*/
static NODE*
maketree(ITEM *in) {
NODE *node = (NODE*)palloc(sizeof(NODE));
static NODE *
maketree(ITEM * in)
{
NODE *node = (NODE *) palloc(sizeof(NODE));
node->valnode = in;
node->right = node->left = NULL;
if ( in->type == OPR ) {
node->right = maketree( in + 1 );
if ( in->val != (int4)'!' )
node->left = maketree( in + in->left );
if (in->type == OPR)
{
node->right = maketree(in + 1);
if (in->val != (int4) '!')
node->left = maketree(in + in->left);
}
return node;
}
typedef struct {
ITEM* ptr;
int4 len;
int4 cur;
} PLAINTREE;
typedef struct
{
ITEM *ptr;
int4 len;
int4 cur;
} PLAINTREE;
static void
plainnode(PLAINTREE *state, NODE* node) {
if ( state->cur == state->len ) {
plainnode(PLAINTREE * state, NODE * node)
{
if (state->cur == state->len)
{
state->len *= 2;
state->ptr=(ITEM*)repalloc( (void*)state->ptr, state->len*sizeof(ITEM) );
state->ptr = (ITEM *) repalloc((void *) state->ptr, state->len * sizeof(ITEM));
}
memcpy( (void*)&(state->ptr[state->cur]), (void*)node->valnode, sizeof(ITEM) );
if ( node->valnode->type == VAL ) {
memcpy((void *) &(state->ptr[state->cur]), (void *) node->valnode, sizeof(ITEM));
if (node->valnode->type == VAL)
state->cur++;
} else if ( node->valnode->val == (int4)'!' ) {
state->ptr[state->cur].left=1;
else if (node->valnode->val == (int4) '!')
{
state->ptr[state->cur].left = 1;
state->cur++;
plainnode(state, node->right);
} else {
int4 cur = state->cur;
}
else
{
int4 cur = state->cur;
state->cur++;
plainnode(state, node->right);
state->ptr[cur].left = state->cur - cur;
state->ptr[cur].left = state->cur - cur;
plainnode(state, node->left);
}
pfree(node);
@ -73,75 +84,96 @@ plainnode(PLAINTREE *state, NODE* node) {
/*
* make plain view of tree from 'normal' view of tree
*/
static ITEM*
plaintree(NODE *root, int4 *len) {
static ITEM *
plaintree(NODE * root, int4 *len)
{
PLAINTREE pl;
pl.cur=0;
pl.len=16;
if ( root && (root->valnode->type == VAL || root->valnode->type == OPR) ) {
pl.ptr = (ITEM*)palloc( pl.len*sizeof(ITEM) );
pl.cur = 0;
pl.len = 16;
if (root && (root->valnode->type == VAL || root->valnode->type == OPR))
{
pl.ptr = (ITEM *) palloc(pl.len * sizeof(ITEM));
plainnode(&pl, root);
} else {
pl.ptr = NULL;
}
else
pl.ptr = NULL;
*len = pl.cur;
return pl.ptr;
return pl.ptr;
}
static void
freetree(NODE *node) {
if ( !node ) return;
if ( node->left ) freetree(node->left);
if ( node->right ) freetree(node->right);
pfree( node );
freetree(NODE * node)
{
if (!node)
return;
if (node->left)
freetree(node->left);
if (node->right)
freetree(node->right);
pfree(node);
}
/*
* clean tree for ! operator.
* It's usefull for debug, but in
* It's usefull for debug, but in
* other case, such view is used with search in index.
* Operator ! always return TRUE
*/
static NODE*
clean_NOT_intree( NODE* node ) {
if ( node->valnode->type == VAL )
static NODE *
clean_NOT_intree(NODE * node)
{
if (node->valnode->type == VAL)
return node;
if ( node->valnode->val == (int4)'!' ) {
if (node->valnode->val == (int4) '!')
{
freetree(node);
return NULL;
}
/* operator & or | */
if ( node->valnode->val == (int4)'|' ) {
if ( (node->left=clean_NOT_intree(node->left)) == NULL ||
(node->right=clean_NOT_intree(node->right)) == NULL ) {
if (node->valnode->val == (int4) '|')
{
if ((node->left = clean_NOT_intree(node->left)) == NULL ||
(node->right = clean_NOT_intree(node->right)) == NULL)
{
freetree(node);
return NULL;
}
} else {
NODE *res = node;
node->left=clean_NOT_intree(node->left);
node->right=clean_NOT_intree(node->right);
if ( node->left == NULL && node->right == NULL ) {
}
else
{
NODE *res = node;
node->left = clean_NOT_intree(node->left);
node->right = clean_NOT_intree(node->right);
if (node->left == NULL && node->right == NULL)
{
pfree(node);
res = NULL;
} else if ( node->left == NULL ) {
}
else if (node->left == NULL)
{
res = node->right;
pfree(node);
} else if ( node->right == NULL ) {
}
else if (node->right == NULL)
{
res = node->left;
pfree(node);
}
}
return res;
}
return node;
return node;
}
ITEM*
clean_NOT(ITEM* ptr, int4 *len) {
NODE *root = maketree( ptr );
return plaintree(clean_NOT_intree(root), len);
ITEM *
clean_NOT(ITEM * ptr, int4 *len)
{
NODE *root = maketree(ptr);
return plaintree(clean_NOT_intree(root), len);
}
#define V_UNKNOWN 0
@ -149,86 +181,112 @@ clean_NOT(ITEM* ptr, int4 *len) {
#define V_FALSE 2
/*
* Clean query tree from values which is always in
* Clean query tree from values which is always in
* text (stopword)
*/
static NODE*
clean_fakeval_intree( NODE* node, char *result ) {
char lresult = V_UNKNOWN, rresult = V_UNKNOWN;
if ( node->valnode->type == VAL )
*/
static NODE *
clean_fakeval_intree(NODE * node, char *result)
{
char lresult = V_UNKNOWN,
rresult = V_UNKNOWN;
if (node->valnode->type == VAL)
return node;
else if ( node->valnode->type == VALTRUE ) {
pfree( node );
else if (node->valnode->type == VALTRUE)
{
pfree(node);
*result = V_TRUE;
return NULL;
}
if ( node->valnode->val == (int4)'!' ) {
node->right = clean_fakeval_intree( node->right, &rresult );
if ( ! node->right ) {
*result = ( rresult == V_TRUE ) ? V_FALSE : V_TRUE;
freetree(node);
return NULL;
}
} else if ( node->valnode->val == (int4)'|' ) {
NODE *res = node;
node->left =clean_fakeval_intree(node->left, &lresult);
node->right=clean_fakeval_intree(node->right,&rresult);
if ( lresult == V_TRUE || rresult == V_TRUE ) {
freetree(node);
*result=V_TRUE;
return NULL;
} else if ( lresult == V_FALSE && rresult == V_FALSE ) {
freetree(node);
*result=V_FALSE;
return NULL;
} else if ( lresult == V_FALSE ) {
res = node->right;
pfree(node);
} else if ( rresult == V_FALSE ) {
res = node->left;
pfree(node);
}
return res;
} else {
NODE *res = node;
node->left =clean_fakeval_intree(node->left, &lresult);
node->right=clean_fakeval_intree(node->right,&rresult);
if ( lresult == V_FALSE || rresult == V_FALSE ) {
freetree(node);
*result=V_FALSE;
return NULL;
} else if ( lresult == V_TRUE && rresult == V_TRUE ) {
freetree(node);
*result=V_TRUE;
return NULL;
} else if ( lresult == V_TRUE ) {
res = node->right;
pfree(node);
} else if ( rresult == V_TRUE ) {
res = node->left;
pfree(node);
}
return res;
}
return node;
if (node->valnode->val == (int4) '!')
{
node->right = clean_fakeval_intree(node->right, &rresult);
if (!node->right)
{
*result = (rresult == V_TRUE) ? V_FALSE : V_TRUE;
freetree(node);
return NULL;
}
}
else if (node->valnode->val == (int4) '|')
{
NODE *res = node;
node->left = clean_fakeval_intree(node->left, &lresult);
node->right = clean_fakeval_intree(node->right, &rresult);
if (lresult == V_TRUE || rresult == V_TRUE)
{
freetree(node);
*result = V_TRUE;
return NULL;
}
else if (lresult == V_FALSE && rresult == V_FALSE)
{
freetree(node);
*result = V_FALSE;
return NULL;
}
else if (lresult == V_FALSE)
{
res = node->right;
pfree(node);
}
else if (rresult == V_FALSE)
{
res = node->left;
pfree(node);
}
return res;
}
else
{
NODE *res = node;
node->left = clean_fakeval_intree(node->left, &lresult);
node->right = clean_fakeval_intree(node->right, &rresult);
if (lresult == V_FALSE || rresult == V_FALSE)
{
freetree(node);
*result = V_FALSE;
return NULL;
}
else if (lresult == V_TRUE && rresult == V_TRUE)
{
freetree(node);
*result = V_TRUE;
return NULL;
}
else if (lresult == V_TRUE)
{
res = node->right;
pfree(node);
}
else if (rresult == V_TRUE)
{
res = node->left;
pfree(node);
}
return res;
}
return node;
}
ITEM*
clean_fakeval(ITEM* ptr, int4 *len) {
NODE *root = maketree( ptr );
char result = V_UNKNOWN;
NODE *resroot;
ITEM *
clean_fakeval(ITEM * ptr, int4 *len)
{
NODE *root = maketree(ptr);
char result = V_UNKNOWN;
NODE *resroot;
resroot = clean_fakeval_intree(root, &result);
if ( result != V_UNKNOWN ) {
elog(ERROR,"Your query contained only stopword(s), ignored");
if (result != V_UNKNOWN)
{
elog(ERROR, "Your query contained only stopword(s), ignored");
*len = 0;
return NULL;
}
return plaintree(resroot, len);
return plaintree(resroot, len);
}

5
contrib/tsearch/rewrite.h
View File

@ -1,7 +1,6 @@
#ifndef __REWRITE_H__
#define __REWRITE_H__
ITEM* clean_NOT(ITEM* ptr, int4 *len);
ITEM* clean_fakeval(ITEM* ptr, int4 *len);
ITEM *clean_NOT(ITEM * ptr, int4 *len);
ITEM *clean_fakeval(ITEM * ptr, int4 *len);
#endif

543
contrib/tsearch/txtidx.c
View File

@ -17,9 +17,9 @@
#include "utils/pg_locale.h"
#include <ctype.h> /* tolower */
#include "txtidx.h"
#include "query.h"
#include <ctype.h> /* tolower */
#include "txtidx.h"
#include "query.h"
#include "deflex.h"
#include "parser.h"
@ -27,51 +27,58 @@
#include "morph.h"
PG_FUNCTION_INFO_V1(txtidx_in);
Datum txtidx_in(PG_FUNCTION_ARGS);
Datum txtidx_in(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(txtidx_out);
Datum txtidx_out(PG_FUNCTION_ARGS);
Datum txtidx_out(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(txt2txtidx);
Datum txt2txtidx(PG_FUNCTION_ARGS);
Datum txt2txtidx(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(tsearch);
Datum tsearch(PG_FUNCTION_ARGS);
Datum tsearch(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(txtidxsize);
Datum txtidxsize(PG_FUNCTION_ARGS);
Datum txtidxsize(PG_FUNCTION_ARGS);
/*
* in/out text index type
*/
static char *BufferStr;
static int
compareentry( const void * a, const void * b ) {
if ( ((WordEntry*)a)->len == ((WordEntry*)b)->len ) {
return strncmp(
&BufferStr[((WordEntry*)a)->pos],
&BufferStr[((WordEntry*)b)->pos],
((WordEntry*)b)->len );
compareentry(const void *a, const void *b)
{
if (((WordEntry *) a)->len == ((WordEntry *) b)->len)
{
return strncmp(
&BufferStr[((WordEntry *) a)->pos],
&BufferStr[((WordEntry *) b)->pos],
((WordEntry *) b)->len);
}
return ( ((WordEntry*)a)->len > ((WordEntry*)b)->len ) ? 1 : -1;
return (((WordEntry *) a)->len > ((WordEntry *) b)->len) ? 1 : -1;
}
static int
uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) {
WordEntry *ptr, *res;
uniqueentry(WordEntry * a, int4 l, char *buf, int4 *outbuflen)
{
WordEntry *ptr,
*res;
res = a;
*outbuflen = res->len;
if ( l == 1 )
if (l == 1)
return l;
ptr = a+1;
ptr = a + 1;
BufferStr = buf;
qsort((void*)a, l, sizeof(int4), compareentry );
qsort((void *) a, l, sizeof(int4), compareentry);
*outbuflen = res->len;
while (ptr - a < l) {
if ( ! (ptr->len == res->len &&
strncmp(&buf[ ptr->pos ], &buf[ res->pos ],res->len) == 0 ) ) {
while (ptr - a < l)
{
if (!(ptr->len == res->len &&
strncmp(&buf[ptr->pos], &buf[res->pos], res->len) == 0))
{
res++;
res->len = ptr->len;
res->pos = ptr->pos;
@ -81,10 +88,10 @@ uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) {
ptr++;
}
return res + 1 - a;
}
}
#define WAITWORD 1
#define WAITENDWORD 2
#define WAITENDWORD 2
#define WAITNEXTCHAR 3
#define WAITENDCMPLX 4
@ -92,81 +99,105 @@ uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) {
do { \
if ( state->curpos - state->word == state->len ) \
{ \
int4 clen = state->curpos - state->word; \
state->len *= 2; \
state->word = (char*)repalloc( (void*)state->word, state->len ); \
state->curpos = state->word + clen; \
} \
int4 clen = state->curpos - state->word; \
state->len *= 2; \
state->word = (char*)repalloc( (void*)state->word, state->len ); \
state->curpos = state->word + clen; \
} \
} while (0)
int4
gettoken_txtidx( TI_IN_STATE *state ) {
int4 oldstate = 0;
gettoken_txtidx(TI_IN_STATE * state)
{
int4 oldstate = 0;
state->curpos = state->word;
state->state = WAITWORD;
while( 1 ) {
if ( state->state == WAITWORD ) {
if ( *(state->prsbuf) == '\0' ) {
while (1)
{
if (state->state == WAITWORD)
{
if (*(state->prsbuf) == '\0')
return 0;
} else if ( *(state->prsbuf) == '\'' ) {
state->state = WAITENDCMPLX;
} else if ( *(state->prsbuf) == '\\' ) {
else if (*(state->prsbuf) == '\'')
state->state = WAITENDCMPLX;
else if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR;
oldstate = WAITENDWORD;
} else if ( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) {
}
else if (state->oprisdelim && ISOPERATOR(*(state->prsbuf)))
elog(ERROR, "Syntax error");
} else if ( *(state->prsbuf) != ' ' ) {
else if (*(state->prsbuf) != ' ')
{
*(state->curpos) = *(state->prsbuf);
state->curpos++;
state->state = WAITENDWORD;
}
} else if ( state->state == WAITNEXTCHAR ) {
if ( *(state->prsbuf) == '\0' ) {
elog(ERROR,"There is no escaped character");
} else {
}
else if (state->state == WAITNEXTCHAR)
{
if (*(state->prsbuf) == '\0')
elog(ERROR, "There is no escaped character");
else
{
RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf);
state->curpos++;
state->state = oldstate;
}
} else if ( state->state == WAITENDWORD ) {
if ( *(state->prsbuf) == '\\' ) {
}
else if (state->state == WAITENDWORD)
{
if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR;
oldstate = WAITENDWORD;
} else if ( *(state->prsbuf) == ' ' || *(state->prsbuf) == '\0' ||
( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) ) {
}
else if (*(state->prsbuf) == ' ' || *(state->prsbuf) == '\0' ||
(state->oprisdelim && ISOPERATOR(*(state->prsbuf))))
{
RESIZEPRSBUF;
if ( state->curpos == state->word )
if (state->curpos == state->word)
elog(ERROR, "Syntax error");
*(state->curpos) = '\0';
return 1;
} else {
}
else
{
RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf);
state->curpos++;
}
} else if ( state->state == WAITENDCMPLX ) {
if ( *(state->prsbuf) == '\'' ) {
}
else if (state->state == WAITENDCMPLX)
{
if (*(state->prsbuf) == '\'')
{
RESIZEPRSBUF;
*(state->curpos) = '\0';
if ( state->curpos == state->word )
if (state->curpos == state->word)
elog(ERROR, "Syntax error");
state->prsbuf++;
return 1;
} else if ( *(state->prsbuf) == '\\' ) {
}
else if (*(state->prsbuf) == '\\')
{
state->state = WAITNEXTCHAR;
oldstate = WAITENDCMPLX;
} else if ( *(state->prsbuf) == '\0' ) {
elog(ERROR,"Syntax error");
} else {
}
else if (*(state->prsbuf) == '\0')
elog(ERROR, "Syntax error");
else
{
RESIZEPRSBUF;
*(state->curpos) = *(state->prsbuf);
state->curpos++;
}
} else {
}
else
elog(ERROR, "Inner bug :(");
}
state->prsbuf++;
}
@ -174,92 +205,111 @@ gettoken_txtidx( TI_IN_STATE *state ) {
}
Datum
txtidx_in(PG_FUNCTION_ARGS) {
char *buf = (char*)PG_GETARG_POINTER(0);
txtidx_in(PG_FUNCTION_ARGS)
{
char *buf = (char *) PG_GETARG_POINTER(0);
TI_IN_STATE state;
WordEntry *arr;
int4 len=0, totallen = 64;
txtidx *in;
char *tmpbuf, *cur;
int4 i,buflen = 256;
WordEntry *arr;
int4 len = 0,
totallen = 64;
txtidx *in;
char *tmpbuf,
*cur;
int4 i,
buflen = 256;
state.prsbuf = buf;
state.len=32;
state.word = (char*)palloc( state.len );
state.len = 32;
state.word = (char *) palloc(state.len);
state.oprisdelim = false;
arr = (WordEntry*)palloc( sizeof(WordEntry) * totallen );
cur = tmpbuf = (char*)palloc( buflen );
while( gettoken_txtidx( &state ) ) {
if ( len == totallen ) {
arr = (WordEntry *) palloc(sizeof(WordEntry) * totallen);
cur = tmpbuf = (char *) palloc(buflen);
while (gettoken_txtidx(&state))
{
if (len == totallen)
{
totallen *= 2;
arr = (WordEntry*)repalloc( (void*)arr, sizeof(int4)*totallen );
arr = (WordEntry *) repalloc((void *) arr, sizeof(int4) * totallen);
}
while ( cur-tmpbuf + state.curpos - state.word >= buflen ) {
int4 dist = cur-tmpbuf;
while (cur - tmpbuf + state.curpos - state.word >= buflen)
{
int4 dist = cur - tmpbuf;
buflen *= 2;
tmpbuf = (char*)repalloc( (void*)tmpbuf, buflen );
cur = tmpbuf+dist;
tmpbuf = (char *) repalloc((void *) tmpbuf, buflen);
cur = tmpbuf + dist;
}
if ( state.curpos - state.word > 0xffff )
elog(ERROR,"Word is too long");
if (state.curpos - state.word > 0xffff)
elog(ERROR, "Word is too long");
arr[len].len = state.curpos - state.word;
if ( cur - tmpbuf > 0xffff )
elog(ERROR,"Too long value");
if (cur - tmpbuf > 0xffff)
elog(ERROR, "Too long value");
arr[len].pos = cur - tmpbuf;
memcpy( (void*)cur, (void*)state.word, arr[len].len );
memcpy((void *) cur, (void *) state.word, arr[len].len);
cur += arr[len].len;
len++;
}
pfree(state.word);
if ( !len )
elog(ERROR,"Void value");
if (!len)
elog(ERROR, "Void value");
len = uniqueentry( arr, len, tmpbuf, &buflen );
totallen = CALCDATASIZE( len, buflen );
in = (txtidx*)palloc( totallen );
len = uniqueentry(arr, len, tmpbuf, &buflen);
totallen = CALCDATASIZE(len, buflen);
in = (txtidx *) palloc(totallen);
in->len = totallen;
in->size = len;
cur = STRPTR(in);
for(i=0;i<len;i++) {
memcpy( (void*)cur, (void*)&tmpbuf[ arr[i].pos ], arr[i].len );
for (i = 0; i < len; i++)
{
memcpy((void *) cur, (void *) &tmpbuf[arr[i].pos], arr[i].len);
arr[i].pos = cur - STRPTR(in);
cur += arr[i].len;
}
pfree(tmpbuf);
memcpy( (void*)ARRPTR(in), (void*)arr, sizeof(int4)*len );
pfree( arr );
PG_RETURN_POINTER( in );
memcpy((void *) ARRPTR(in), (void *) arr, sizeof(int4) * len);
pfree(arr);
PG_RETURN_POINTER(in);
}
Datum
txtidxsize(PG_FUNCTION_ARGS) {
txtidx *in=(txtidx*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
int4 ret = in->size;
PG_FREE_IF_COPY(in,0);
PG_RETURN_INT32( ret );
txtidxsize(PG_FUNCTION_ARGS)
{
txtidx *in = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
int4 ret = in->size;
PG_FREE_IF_COPY(in, 0);
PG_RETURN_INT32(ret);
}
Datum
txtidx_out(PG_FUNCTION_ARGS) {
txtidx *out=(txtidx*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
char *outbuf;
int4 i,j,lenbuf = STRSIZE(out) + 1 /* \0 */ + out->size*2 /* '' */ + out->size - 1 /* space */;
WordEntry *ptr = ARRPTR(out);
char *curin, *curout;
txtidx_out(PG_FUNCTION_ARGS)
{
txtidx *out = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
char *outbuf;
int4 i,
j,
lenbuf = STRSIZE(out) + 1 /* \0 */ + out->size * 2 /* '' */ + out->size - 1 /* space */ ;
WordEntry *ptr = ARRPTR(out);
char *curin,
*curout;
curout = outbuf = (char*) palloc( lenbuf );
for(i=0;i<out->size;i++) {
curout = outbuf = (char *) palloc(lenbuf);
for (i = 0; i < out->size; i++)
{
curin = STRPTR(out) + ptr->pos;
if ( i!= 0 )
if (i != 0)
*curout++ = ' ';
*curout++ = '\'';
j = ptr->len;
while( j-- ) {
if ( *curin == '\'' ) {
int4 pos = curout - outbuf;
outbuf = (char*)repalloc((void*)outbuf, ++lenbuf );
while (j--)
{
if (*curin == '\'')
{
int4 pos = curout - outbuf;
outbuf = (char *) repalloc((void *) outbuf, ++lenbuf);
curout = outbuf + pos;
*curout++ = '\\';
}
@ -268,171 +318,198 @@ txtidx_out(PG_FUNCTION_ARGS) {
*curout++ = '\'';
ptr++;
}
outbuf[ lenbuf-1 ] = '\0';
PG_FREE_IF_COPY(out,0);
PG_RETURN_POINTER( outbuf );
outbuf[lenbuf - 1] = '\0';
PG_FREE_IF_COPY(out, 0);
PG_RETURN_POINTER(outbuf);
}
typedef struct {
uint16 len;
char* word;
} WORD;
typedef struct
{
uint16 len;
char *word;
} WORD;
typedef struct {
WORD *words;
int4 lenwords;
int4 curwords;
} PRSTEXT;
typedef struct
{
WORD *words;
int4 lenwords;
int4 curwords;
} PRSTEXT;
/*
* Parse text to lexems
*/
static void
parsetext( PRSTEXT *prs, char *buf, int4 buflen ) {
int type,lenlemm;
char *ptr,*ptrw;
char *lemm;
parsetext(PRSTEXT * prs, char *buf, int4 buflen)
{
int type,
lenlemm;
char *ptr,
*ptrw;
char *lemm;
start_parse_str( buf, buflen );
while( (type=tsearch_yylex()) != 0 ) {
if ( prs->curwords == prs->lenwords ) {
start_parse_str(buf, buflen);
while ((type = tsearch_yylex()) != 0)
{
if (prs->curwords == prs->lenwords)
{
prs->lenwords *= 2;
prs->words = (WORD*)repalloc( (void*)prs->words, prs->lenwords * sizeof(WORD) );
prs->words = (WORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(WORD));
}
if ( tokenlen>0xffff ) {
if (tokenlen > 0xffff)
{
end_parse();
elog(ERROR, "Word is too long");
}
lenlemm = tokenlen;
lemm = lemmatize( token, &lenlemm, type );
if ( ! lemm )
lemm = lemmatize(token, &lenlemm, type);
if (!lemm)
continue;
if ( lemm != token ) {
prs->words[ prs->curwords ].len = lenlemm;
prs->words[ prs->curwords ].word = lemm;
} else {
prs->words[ prs->curwords ].len = lenlemm;
ptrw = prs->words[ prs->curwords ].word = (char*)palloc( lenlemm );
if (lemm != token)
{
prs->words[prs->curwords].len = lenlemm;
prs->words[prs->curwords].word = lemm;
}
else
{
prs->words[prs->curwords].len = lenlemm;
ptrw = prs->words[prs->curwords].word = (char *) palloc(lenlemm);
ptr = token;
while( ptr-token < lenlemm ) {
*ptrw = tolower( (unsigned char) *ptr );
ptr++; ptrw++;
while (ptr - token < lenlemm)
{
*ptrw = tolower((unsigned char) *ptr);
ptr++;
ptrw++;
}
}
prs->curwords++;
prs->curwords++;
}
end_parse();
}
static int
compareWORD( const void * a, const void * b ) {
if ( ((WORD*)a)->len == ((WORD*)b)->len )
return strncmp(
((WORD*)a)->word,
((WORD*)b)->word,
((WORD*)b)->len );
return ( ((WORD*)a)->len > ((WORD*)b)->len ) ? 1 : -1;
compareWORD(const void *a, const void *b)
{
if (((WORD *) a)->len == ((WORD *) b)->len)
return strncmp(
((WORD *) a)->word,
((WORD *) b)->word,
((WORD *) b)->len);
return (((WORD *) a)->len > ((WORD *) b)->len) ? 1 : -1;
}
static int
uniqueWORD( WORD* a, int4 l ) {
WORD *ptr, *res;
uniqueWORD(WORD * a, int4 l)
{
WORD *ptr,
*res;
if ( l == 1 )
if (l == 1)
return l;
res = a;
ptr = a + 1;
qsort((void*)a, l, sizeof(WORD), compareWORD );
qsort((void *) a, l, sizeof(WORD), compareWORD);
while (ptr - a < l) {
if ( ! (ptr->len == res->len &&
strncmp(ptr->word, res->word ,res->len) == 0 ) ) {
while (ptr - a < l)
{
if (!(ptr->len == res->len &&
strncmp(ptr->word, res->word, res->len) == 0))
{
res++;
res->len = ptr->len;
res->len = ptr->len;
res->word = ptr->word;
} else {
pfree(ptr->word);
}
else
pfree(ptr->word);
ptr++;
}
return res + 1 - a;
}
}
/*
* make value of txtidx
*/
static txtidx *
makevalue( PRSTEXT *prs ) {
int4 i, lenstr=0, totallen;
txtidx *in;
WordEntry *ptr;
char *str,*cur;
makevalue(PRSTEXT * prs)
{
int4 i,
lenstr = 0,
totallen;
txtidx *in;
WordEntry *ptr;
char *str,
*cur;
prs->curwords = uniqueWORD( prs->words, prs->curwords );
for(i=0;i<prs->curwords;i++)
prs->curwords = uniqueWORD(prs->words, prs->curwords);
for (i = 0; i < prs->curwords; i++)
lenstr += prs->words[i].len;
totallen = CALCDATASIZE( prs->curwords, lenstr );
in = (txtidx*)palloc( totallen );
totallen = CALCDATASIZE(prs->curwords, lenstr);
in = (txtidx *) palloc(totallen);
in->len = totallen;
in->size = prs->curwords;
ptr = ARRPTR(in);
cur = str = STRPTR(in);
for(i=0;i<prs->curwords;i++) {
for (i = 0; i < prs->curwords; i++)
{
ptr->len = prs->words[i].len;
if ( cur-str > 0xffff )
elog(ERROR,"Value is too big");
ptr->pos = cur-str;
if (cur - str > 0xffff)
elog(ERROR, "Value is too big");
ptr->pos = cur - str;
ptr++;
memcpy( (void*)cur, (void*)prs->words[i].word, prs->words[i].len );
memcpy((void *) cur, (void *) prs->words[i].word, prs->words[i].len);
pfree(prs->words[i].word);
cur += prs->words[i].len;
cur += prs->words[i].len;
}
pfree(prs->words);
return in;
}
Datum
txt2txtidx(PG_FUNCTION_ARGS) {
text *in = (text*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
PRSTEXT prs;
txtidx *out = NULL;
prs.lenwords = 32;
prs.curwords = 0;
prs.words = (WORD*)palloc(sizeof(WORD)*prs.lenwords);
txt2txtidx(PG_FUNCTION_ARGS)
{
text *in = (text *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
PRSTEXT prs;
txtidx *out = NULL;
prs.lenwords = 32;
prs.curwords = 0;
prs.words = (WORD *) palloc(sizeof(WORD) * prs.lenwords);
initmorph();
parsetext( &prs, VARDATA(in), VARSIZE(in) - VARHDRSZ );
PG_FREE_IF_COPY(in,0);
if ( prs.curwords ) {
out = makevalue( &prs );
PG_RETURN_POINTER( out );
parsetext(&prs, VARDATA(in), VARSIZE(in) - VARHDRSZ);
PG_FREE_IF_COPY(in, 0);
if (prs.curwords)
{
out = makevalue(&prs);
PG_RETURN_POINTER(out);
}
pfree(prs.words);
PG_RETURN_NULL();
}
}
/*
* Trigger
*/
Datum
tsearch(PG_FUNCTION_ARGS) {
tsearch(PG_FUNCTION_ARGS)
{
TriggerData *trigdata;
Trigger *trigger;
Relation rel;
HeapTuple rettuple = NULL;
int numidxattr,i;
PRSTEXT prs;
Datum datum = (Datum)0;
Relation rel;
HeapTuple rettuple = NULL;
int numidxattr,
i;
PRSTEXT prs;
Datum datum = (Datum) 0;
if (!CALLED_AS_TRIGGER(fcinfo))
@ -448,63 +525,69 @@ tsearch(PG_FUNCTION_ARGS) {
rettuple = trigdata->tg_trigtuple;
else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
rettuple = trigdata->tg_newtuple;
else
else
elog(ERROR, "TSearch: Unknown event");
trigger = trigdata->tg_trigger;
rel = trigdata->tg_relation;
if ( trigger->tgnargs < 2 )
elog(ERROR,"TSearch: format tsearch(txtidx_field, text_field1,...)");
if (trigger->tgnargs < 2)
elog(ERROR, "TSearch: format tsearch(txtidx_field, text_field1,...)");
numidxattr = SPI_fnumber(rel->rd_att, trigger->tgargs[0]);
if ( numidxattr < 0 )
elog(ERROR,"TSearch: Can not find txtidx_field");
if (numidxattr < 0)
elog(ERROR, "TSearch: Can not find txtidx_field");
prs.lenwords = 32;
prs.curwords = 0;
prs.words = (WORD*)palloc(sizeof(WORD)*prs.lenwords);
prs.lenwords = 32;
prs.curwords = 0;
prs.words = (WORD *) palloc(sizeof(WORD) * prs.lenwords);
initmorph();
/* find all words in indexable column */
for(i=1; i<trigger->tgnargs; i++) {
int4 numattr;
text *txt_toasted, *txt;
bool isnull;
Oid oidtype;
/* find all words in indexable column */
for (i = 1; i < trigger->tgnargs; i++)
{
int4 numattr;
text *txt_toasted,
*txt;
bool isnull;
Oid oidtype;
numattr = SPI_fnumber(rel->rd_att, trigger->tgargs[i]);
oidtype = SPI_gettypeid(rel->rd_att, numattr);
if ( numattr<0 || ( ! ( oidtype==TEXTOID || oidtype==VARCHAROID ) ) ) {
if (numattr < 0 || (!(oidtype == TEXTOID || oidtype == VARCHAROID)))
{
elog(NOTICE, "TSearch: can not find field '%s'", trigger->tgargs[i]);
continue;
}
txt_toasted = (text*)DatumGetPointer( SPI_getbinval(rettuple, rel->rd_att, numattr, &isnull ) );
if ( isnull )
txt_toasted = (text *) DatumGetPointer(SPI_getbinval(rettuple, rel->rd_att, numattr, &isnull));
if (isnull)
continue;
txt = (text*)DatumGetPointer( PG_DETOAST_DATUM( PointerGetDatum ( txt_toasted ) ) );
txt = (text *) DatumGetPointer(PG_DETOAST_DATUM(PointerGetDatum(txt_toasted)));
parsetext( &prs, VARDATA(txt), VARSIZE(txt) - VARHDRSZ );
if ( txt != txt_toasted )
parsetext(&prs, VARDATA(txt), VARSIZE(txt) - VARHDRSZ);
if (txt != txt_toasted)
pfree(txt);
}
/* make txtidx value */
if (prs.curwords) {
datum = PointerGetDatum( makevalue( &prs ) );
rettuple = SPI_modifytuple( rel, rettuple, 1, &numidxattr,
&datum, NULL );
if (prs.curwords)
{
datum = PointerGetDatum(makevalue(&prs));
rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr,
&datum, NULL);
pfree(DatumGetPointer(datum));
} else {
char nulls = 'n';
pfree( prs.words );
rettuple = SPI_modifytuple( rel, rettuple, 1, &numidxattr,
&datum, &nulls );
}
else
{
char nulls = 'n';
pfree(prs.words);
rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr,
&datum, &nulls);
}
if (rettuple == NULL)
elog(ERROR, "TSearch: %d returned by SPI_modifytuple", SPI_result);
return PointerGetDatum( rettuple );
return PointerGetDatum(rettuple);
}

51
contrib/tsearch/txtidx.h
View File

@ -14,33 +14,34 @@
#include "utils/builtins.h"
#include "storage/bufpage.h"
typedef struct {
uint16 len;
uint16 pos;
} WordEntry;
typedef struct
{
uint16 len;
uint16 pos;
} WordEntry;
typedef struct {
int4 len;
int4 size;
char data[1];
} txtidx;
typedef struct
{
int4 len;
int4 size;
char data[1];
} txtidx;
#define DATAHDRSIZE (sizeof(int4)*2)
#define CALCDATASIZE(x, lenstr) ( x * sizeof(WordEntry) + DATAHDRSIZE + lenstr )
#define ARRPTR(x) ( (WordEntry*) ( (char*)x + DATAHDRSIZE ) )
#define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
#define STRSIZE(x) ( ((txtidx*)x)->len - DATAHDRSIZE - ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
#define DATAHDRSIZE (sizeof(int4)*2)
#define CALCDATASIZE(x, lenstr) ( x * sizeof(WordEntry) + DATAHDRSIZE + lenstr )
#define ARRPTR(x) ( (WordEntry*) ( (char*)x + DATAHDRSIZE ) )
#define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
#define STRSIZE(x) ( ((txtidx*)x)->len - DATAHDRSIZE - ( sizeof(WordEntry) * ((txtidx*)x)->size ) )
typedef struct {
char *prsbuf;
char *word;
char *curpos;
int4 len;
int4 state;
bool oprisdelim;
} TI_IN_STATE;
int4 gettoken_txtidx( TI_IN_STATE *state );
typedef struct
{
char *prsbuf;
char *word;
char *curpos;
int4 len;
int4 state;
bool oprisdelim;
} TI_IN_STATE;
int4 gettoken_txtidx(TI_IN_STATE * state);
#endif

1
contrib/userlock/user_locks.h
View File

@ -8,7 +8,6 @@ int user_write_unlock(unsigned int id1, unsigned int id2);
int user_write_lock_oid(Oid oid);
int user_write_unlock_oid(Oid oid);
int user_unlock_all(void);
#endif
/*

419
contrib/xml/pgxml.c
View File

@ -14,32 +14,39 @@ XML_Memory_Handling_Suite mhs;
/* passthrough functions (palloc is a macro) */
static void *pgxml_palloc(size_t size)
static void *
pgxml_palloc(size_t size)
{
return palloc(size);
return palloc(size);
}
static void *pgxml_repalloc(void *ptr, size_t size)
static void *
pgxml_repalloc(void *ptr, size_t size)
{
return repalloc(ptr,size);
return repalloc(ptr, size);
}
static void pgxml_pfree(void *ptr)
static void
pgxml_pfree(void *ptr)
{
return pfree(ptr);
return pfree(ptr);
}
static void pgxml_mhs_init()
static void
pgxml_mhs_init()
{
mhs.malloc_fcn = pgxml_palloc;
mhs.realloc_fcn = pgxml_repalloc;
mhs.free_fcn = pgxml_pfree;
mhs.malloc_fcn = pgxml_palloc;
mhs.realloc_fcn = pgxml_repalloc;
mhs.free_fcn = pgxml_pfree;
}
static void pgxml_handler_init()
static void
pgxml_handler_init()
{
/* This code should set up the relevant handlers from user-supplied
settings. Quite how these settings are made is another matter :) */
/*
* This code should set up the relevant handlers from user-supplied
* settings. Quite how these settings are made is another matter :)
*/
}
/* Returns true if document is well-formed */
@ -49,31 +56,35 @@ PG_FUNCTION_INFO_V1(pgxml_parse);
Datum
pgxml_parse(PG_FUNCTION_ARGS)
{
/* called as pgxml_parse(document) */
XML_Parser p;
text *t = PG_GETARG_TEXT_P(0); /*document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ;
/* called as pgxml_parse(document) */
XML_Parser p;
text *t = PG_GETARG_TEXT_P(0); /* document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ;
pgxml_mhs_init();
pgxml_mhs_init();
pgxml_handler_init();
pgxml_handler_init();
p = XML_ParserCreate_MM(NULL,&mhs,NULL);
if (! p) {
elog(ERROR, "pgxml: Could not create expat parser");
PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */
}
p = XML_ParserCreate_MM(NULL, &mhs, NULL);
if (!p)
{
elog(ERROR, "pgxml: Could not create expat parser");
PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */
}
if (! XML_Parse(p, (char *)VARDATA(t) , docsize, 1)) {
/* elog(NOTICE, "Parse error at line %d:%s",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p))); */
XML_ParserFree(p);
PG_RETURN_BOOL(false);
}
if (!XML_Parse(p, (char *) VARDATA(t), docsize, 1))
{
/*
* elog(NOTICE, "Parse error at line %d:%s",
* XML_GetCurrentLineNumber(p),
* XML_ErrorString(XML_GetErrorCode(p)));
*/
XML_ParserFree(p);
PG_RETURN_BOOL(false);
}
XML_ParserFree(p);
PG_RETURN_BOOL(true);
XML_ParserFree(p);
PG_RETURN_BOOL(true);
}
/* XPath handling functions */
@ -81,83 +92,88 @@ pgxml_parse(PG_FUNCTION_ARGS)
/* XPath support here is for a very skeletal kind of XPath!
It was easy to program though... */
/* This first is the core function that builds a result set. The
/* This first is the core function that builds a result set. The
actual functions called by the user manipulate that result set
in various ways.
*/
static XPath_Results *build_xpath_results(text *doc, text *pathstr)
static XPath_Results *
build_xpath_results(text *doc, text *pathstr)
{
XPath_Results *xpr;
char *res;
pgxml_udata *udata;
XML_Parser p;
int32 docsize;
XPath_Results *xpr;
char *res;
pgxml_udata *udata;
XML_Parser p;
int32 docsize;
xpr = (XPath_Results *) palloc((sizeof(XPath_Results)));
memset((void *)xpr, 0, sizeof(XPath_Results));
xpr->rescount=0;
xpr = (XPath_Results *) palloc((sizeof(XPath_Results)));
memset((void *) xpr, 0, sizeof(XPath_Results));
xpr->rescount = 0;
docsize=VARSIZE(doc)-VARHDRSZ;
docsize = VARSIZE(doc) - VARHDRSZ;
/* res isn't going to be the real return type, it is just a buffer */
/* res isn't going to be the real return type, it is just a buffer */
res = (char *) palloc(docsize);
memset((void *)res, 0, docsize);
res = (char *) palloc(docsize);
memset((void *) res, 0, docsize);
xpr->resbuf = res;
xpr->resbuf = res;
udata = (pgxml_udata *) palloc((sizeof(pgxml_udata)));
memset((void *)udata,0,sizeof(pgxml_udata));
udata = (pgxml_udata *) palloc((sizeof(pgxml_udata)));
memset((void *) udata, 0, sizeof(pgxml_udata));
udata->currentpath[0]='\0';
udata->textgrab=0;
udata->currentpath[0] = '\0';
udata->textgrab = 0;
udata->path= (char *) palloc(VARSIZE(pathstr));
memcpy(udata->path, VARDATA(pathstr), VARSIZE(pathstr)-VARHDRSZ);
udata->path = (char *) palloc(VARSIZE(pathstr));
memcpy(udata->path, VARDATA(pathstr), VARSIZE(pathstr) - VARHDRSZ);
udata->path[VARSIZE(pathstr)-VARHDRSZ]='\0';
udata->path[VARSIZE(pathstr) - VARHDRSZ] = '\0';
udata->resptr = res;
udata->reslen = 0;
udata->resptr = res;
udata->reslen = 0;
udata->xpres = xpr;
udata->xpres = xpr;
/* Now fire up the parser */
pgxml_mhs_init();
/* Now fire up the parser */
pgxml_mhs_init();
p = XML_ParserCreate_MM(NULL,&mhs,NULL);
if (! p) {
elog(ERROR, "pgxml: Could not create expat parser");
pfree(xpr);
pfree(udata->path);
pfree(udata);
pfree(res);
return NULL;
}
XML_SetUserData(p, (void *)udata);
p = XML_ParserCreate_MM(NULL, &mhs, NULL);
if (!p)
{
elog(ERROR, "pgxml: Could not create expat parser");
pfree(xpr);
pfree(udata->path);
pfree(udata);
pfree(res);
return NULL;
}
XML_SetUserData(p, (void *) udata);
/* Set the handlers */
/* Set the handlers */
XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler);
XML_SetCharacterDataHandler(p, pgxml_charhandler);
XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler);
XML_SetCharacterDataHandler(p, pgxml_charhandler);
if (! XML_Parse(p, (char *)VARDATA(doc) , docsize, 1)) {
/* elog(NOTICE, "Parse error at line %d:%s",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p))); */
XML_ParserFree(p);
pfree(xpr);
pfree(udata->path);
pfree(udata);
if (!XML_Parse(p, (char *) VARDATA(doc), docsize, 1))
{
/*
* elog(NOTICE, "Parse error at line %d:%s",
* XML_GetCurrentLineNumber(p),
* XML_ErrorString(XML_GetErrorCode(p)));
*/
XML_ParserFree(p);
pfree(xpr);
pfree(udata->path);
pfree(udata);
return NULL;
}
return NULL;
}
pfree(udata->path);
pfree(udata);
XML_ParserFree(p);
return xpr;
pfree(udata->path);
pfree(udata);
XML_ParserFree(p);
return xpr;
}
@ -166,145 +182,166 @@ PG_FUNCTION_INFO_V1(pgxml_xpath);
Datum
pgxml_xpath(PG_FUNCTION_ARGS)
{
/* called as pgxml_xpath(document,pathstr, index) for the moment*/
/* called as pgxml_xpath(document,pathstr, index) for the moment */
XPath_Results *xpresults;
text *restext;
XPath_Results *xpresults;
text *restext;
text *t = PG_GETARG_TEXT_P(0); /*document buffer */
text *t2= PG_GETARG_TEXT_P(1);
int32 ind = PG_GETARG_INT32(2) - 1;
text *t = PG_GETARG_TEXT_P(0); /* document buffer */
text *t2 = PG_GETARG_TEXT_P(1);
int32 ind = PG_GETARG_INT32(2) - 1;
xpresults = build_xpath_results(t,t2);
xpresults = build_xpath_results(t, t2);
/* This needs to be changed depending on the mechanism for returning
our set of results. */
/*
* This needs to be changed depending on the mechanism for returning
* our set of results.
*/
if (xpresults==NULL) /*parse error (not WF or parser failure) */
{
PG_RETURN_NULL();
}
if (xpresults == NULL) /* parse error (not WF or parser failure) */
PG_RETURN_NULL();
if (ind >= (xpresults->rescount))
{
PG_RETURN_NULL();
}
restext = (text *) palloc(xpresults->reslens[ind]+VARHDRSZ);
memcpy(VARDATA(restext),xpresults->results[ind],xpresults->reslens[ind]);
if (ind >= (xpresults->rescount))
PG_RETURN_NULL();
VARATT_SIZEP(restext) = xpresults->reslens[ind]+VARHDRSZ;
restext = (text *) palloc(xpresults->reslens[ind] + VARHDRSZ);
memcpy(VARDATA(restext), xpresults->results[ind], xpresults->reslens[ind]);
pfree(xpresults->resbuf);
pfree(xpresults);
VARATT_SIZEP(restext) = xpresults->reslens[ind] + VARHDRSZ;
PG_RETURN_TEXT_P(restext);
pfree(xpresults->resbuf);
pfree(xpresults);
PG_RETURN_TEXT_P(restext);
}
static void pgxml_pathcompare(void *userData)
static void
pgxml_pathcompare(void *userData)
{
char *matchpos;
char *matchpos;
matchpos=strstr(UD->currentpath, UD->path);
matchpos = strstr(UD->currentpath, UD->path);
if (matchpos == NULL) { /* Should we have more logic here ? */
if (UD->textgrab) {
UD->textgrab=0;
pgxml_finalisegrabbedtext(userData);
}
return;
}
/* OK, we have a match of some sort. Now we need to check that
our match is anchored to the *end* of the string AND
that it is immediately preceded by a '/'*/
/* This test wouldn't work if strlen (UD->path) overran the length
of the currentpath, but that's not possible because we got a match! */
if ((matchpos + strlen(UD->path))[0]=='\0')
{
if ((UD->path)[0]=='/') {
if (matchpos == UD->currentpath) {
UD->textgrab=1;
if (matchpos == NULL)
{ /* Should we have more logic here ? */
if (UD->textgrab)
{
UD->textgrab = 0;
pgxml_finalisegrabbedtext(userData);
}
return;
}
} else {
if ((matchpos-1)[0]=='/') {
UD->textgrab=1;
/*
* OK, we have a match of some sort. Now we need to check that our
* match is anchored to the *end* of the string AND that it is
* immediately preceded by a '/'
*/
/*
* This test wouldn't work if strlen (UD->path) overran the length of
* the currentpath, but that's not possible because we got a match!
*/
if ((matchpos + strlen(UD->path))[0] == '\0')
{
if ((UD->path)[0] == '/')
{
if (matchpos == UD->currentpath)
UD->textgrab = 1;
}
else
{
if ((matchpos - 1)[0] == '/')
UD->textgrab = 1;
}
}
}
}
}
static void pgxml_starthandler(void *userData, const XML_Char *name,
const XML_Char **atts)
static void
pgxml_starthandler(void *userData, const XML_Char * name,
const XML_Char ** atts)
{
char sepstr[]="/";
char sepstr[] = "/";
if ((strlen(name)+strlen(UD->currentpath))>MAXPATHLENGTH-2) {
elog(NOTICE,"Path too long");
} else {
strncat(UD->currentpath,sepstr,1);
strcat(UD->currentpath, name);
}
if (UD->textgrab)
{
/* Depending on user preference, should we "reconstitute"
the element into the result text?
*/
} else {
pgxml_pathcompare(userData);
}
if ((strlen(name) + strlen(UD->currentpath)) > MAXPATHLENGTH - 2)
elog(NOTICE, "Path too long");
else
{
strncat(UD->currentpath, sepstr, 1);
strcat(UD->currentpath, name);
}
if (UD->textgrab)
{
/*
* Depending on user preference, should we "reconstitute" the
* element into the result text?
*/
}
else
pgxml_pathcompare(userData);
}
static void pgxml_endhandler(void *userData, const XML_Char *name)
static void
pgxml_endhandler(void *userData, const XML_Char * name)
{
/* Start by removing the current element off the end of the
currentpath */
/*
* Start by removing the current element off the end of the
* currentpath
*/
char *sepptr;
char *sepptr;
sepptr=strrchr(UD->currentpath,'/');
if (sepptr==NULL) {
elog(ERROR,"There's a problem...");
sepptr=UD->currentpath;
}
if (strcmp(name, sepptr+1) !=0) {
elog(NOTICE,"Wanted [%s], got [%s]",sepptr,name);
/* unmatched entry, so do nothing */
} else {
sepptr[0]='\0'; /* Chop that element off the end */
}
sepptr = strrchr(UD->currentpath, '/');
if (sepptr == NULL)
{
elog(ERROR, "There's a problem...");
sepptr = UD->currentpath;
}
if (strcmp(name, sepptr + 1) != 0)
{
elog(NOTICE, "Wanted [%s], got [%s]", sepptr, name);
/* unmatched entry, so do nothing */
}
else
{
sepptr[0] = '\0'; /* Chop that element off the end */
}
if (UD->textgrab) {
pgxml_pathcompare(userData);
}
if (UD->textgrab)
pgxml_pathcompare(userData);
}
static void pgxml_charhandler(void *userData, const XML_Char *s, int len)
static void
pgxml_charhandler(void *userData, const XML_Char * s, int len)
{
if (UD->textgrab) {
if (len>0) {
memcpy(UD->resptr,s,len);
UD->resptr += len;
UD->reslen += len;
}
}
if (UD->textgrab)
{
if (len > 0)
{
memcpy(UD->resptr, s, len);
UD->resptr += len;
UD->reslen += len;
}
}
}
/* Should I be using PG list types here? */
static void pgxml_finalisegrabbedtext(void *userData)
static void
pgxml_finalisegrabbedtext(void *userData)
{
/* In res/reslen, we have a single result. */
UD->xpres->results[UD->xpres->rescount]= UD->resptr - UD->reslen;
UD->xpres->reslens[UD->xpres->rescount]= UD->reslen;
UD->reslen=0;
UD->xpres->rescount++;
/* In res/reslen, we have a single result. */
UD->xpres->results[UD->xpres->rescount] = UD->resptr - UD->reslen;
UD->xpres->reslens[UD->xpres->rescount] = UD->reslen;
UD->reslen = 0;
UD->xpres->rescount++;
/* This effectively concatenates all the results together but we
do know where one ends and the next begins */
/*
* This effectively concatenates all the results together but we do
* know where one ends and the next begins
*/
}

62
contrib/xml/pgxml.h
View File

@ -5,12 +5,12 @@ static void *pgxml_repalloc(void *ptr, size_t size);
static void pgxml_pfree(void *ptr);
static void pgxml_mhs_init();
static void pgxml_handler_init();
Datum pgxml_parse(PG_FUNCTION_ARGS);
Datum pgxml_xpath(PG_FUNCTION_ARGS);
static void pgxml_starthandler(void *userData, const XML_Char *name,
const XML_Char **atts);
static void pgxml_endhandler(void *userData, const XML_Char *name);
static void pgxml_charhandler(void *userData, const XML_Char *s, int len);
Datum pgxml_parse(PG_FUNCTION_ARGS);
Datum pgxml_xpath(PG_FUNCTION_ARGS);
static void pgxml_starthandler(void *userData, const XML_Char * name,
const XML_Char ** atts);
static void pgxml_endhandler(void *userData, const XML_Char * name);
static void pgxml_charhandler(void *userData, const XML_Char * s, int len);
static void pgxml_pathcompare(void *userData);
static void pgxml_finalisegrabbedtext(void *userData);
@ -18,43 +18,25 @@ static void pgxml_finalisegrabbedtext(void *userData);
#define MAXRESULTS 100
typedef struct {
int rescount;
char *results[MAXRESULTS];
int32 reslens[MAXRESULTS];
char *resbuf; /* pointer to the result buffer for pfree */
} XPath_Results;
typedef struct
{
int rescount;
char *results[MAXRESULTS];
int32 reslens[MAXRESULTS];
char *resbuf; /* pointer to the result buffer for pfree */
} XPath_Results;
typedef struct {
char currentpath[MAXPATHLENGTH];
char *path;
int textgrab;
char *resptr;
int32 reslen;
XPath_Results *xpres;
} pgxml_udata;
typedef struct
{
char currentpath[MAXPATHLENGTH];
char *path;
int textgrab;
char *resptr;
int32 reslen;
XPath_Results *xpres;
} pgxml_udata;
#define UD ((pgxml_udata *) userData)

330
contrib/xml/pgxml_dom.c
View File

@ -15,50 +15,57 @@
static void *pgxml_palloc(size_t size);
static void *pgxml_repalloc(void *ptr, size_t size);
static void pgxml_pfree(void *ptr);
static char *pgxml_pstrdup(const char* string);
static char *pgxml_pstrdup(const char *string);
static void pgxml_parser_init();
static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset, xmlDocPtr doc,
xmlChar *toptagname, xmlChar *septagname,
static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset, xmlDocPtr doc,
xmlChar * toptagname, xmlChar * septagname,
int format);
static xmlChar *pgxml_texttoxmlchar(text *textstring);
Datum pgxml_parse(PG_FUNCTION_ARGS);
Datum pgxml_xpath(PG_FUNCTION_ARGS);
Datum pgxml_parse(PG_FUNCTION_ARGS);
Datum pgxml_xpath(PG_FUNCTION_ARGS);
/* memory handling passthrough functions (e.g. palloc, pstrdup are
currently macros, and the others might become so...) */
static void *pgxml_palloc(size_t size)
static void *
pgxml_palloc(size_t size)
{
return palloc(size);
return palloc(size);
}
static void *pgxml_repalloc(void *ptr, size_t size)
static void *
pgxml_repalloc(void *ptr, size_t size)
{
return repalloc(ptr,size);
return repalloc(ptr, size);
}
static void pgxml_pfree(void *ptr)
static void
pgxml_pfree(void *ptr)
{
return pfree(ptr);
return pfree(ptr);
}
static char *pgxml_pstrdup(const char *string)
static char *
pgxml_pstrdup(const char *string)
{
return pstrdup(string);
return pstrdup(string);
}
static void pgxml_parser_init()
static void
pgxml_parser_init()
{
/* This code should also set parser settings from user-supplied
info. Quite how these settings are made is another matter :) */
/*
* This code should also set parser settings from user-supplied info.
* Quite how these settings are made is another matter :)
*/
xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup);
xmlInitParser();
xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup);
xmlInitParser();
}
@ -70,86 +77,98 @@ PG_FUNCTION_INFO_V1(pgxml_parse);
Datum
pgxml_parse(PG_FUNCTION_ARGS)
{
/* called as pgxml_parse(document) */
xmlDocPtr doctree;
text *t = PG_GETARG_TEXT_P(0); /*document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ;
/* called as pgxml_parse(document) */
xmlDocPtr doctree;
text *t = PG_GETARG_TEXT_P(0); /* document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ;
pgxml_parser_init();
pgxml_parser_init();
doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL) {
/* xmlCleanupParser(); */
PG_RETURN_BOOL(false); /* i.e. not well-formed */
}
/* xmlCleanupParser(); */
xmlFreeDoc(doctree);
PG_RETURN_BOOL(true);
doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL)
{
/* xmlCleanupParser(); */
PG_RETURN_BOOL(false); /* i.e. not well-formed */
}
/* xmlCleanupParser(); */
xmlFreeDoc(doctree);
PG_RETURN_BOOL(true);
}
static xmlChar
*pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
xmlDocPtr doc,
xmlChar *toptagname,
xmlChar *septagname,
int format)
static xmlChar
*
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
xmlDocPtr doc,
xmlChar * toptagname,
xmlChar * septagname,
int format)
{
/* Function translates a nodeset into a text representation */
/* iterates over each node in the set and calls xmlNodeDump to write
it to an xmlBuffer -from which an xmlChar * string is returned. */
/* each representation is surrounded by <tagname> ... </tagname> */
/* if format==0, add a newline between nodes?? */
/* Function translates a nodeset into a text representation */
xmlBufferPtr buf;
xmlChar *result;
int i;
/*
* iterates over each node in the set and calls xmlNodeDump to write
* it to an xmlBuffer -from which an xmlChar * string is returned.
*/
/* each representation is surrounded by <tagname> ... </tagname> */
/* if format==0, add a newline between nodes?? */
buf =xmlBufferCreate();
if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) {
xmlBufferWriteChar(buf,"<");
xmlBufferWriteCHAR(buf,toptagname);
xmlBufferWriteChar(buf,">");
}
if (nodeset != NULL) {
for (i=0; i < nodeset->nodeNr; i++) {
if ((septagname != NULL) && (xmlStrlen(septagname)>0)) {
xmlBufferWriteChar(buf,"<");
xmlBufferWriteCHAR(buf,septagname);
xmlBufferWriteChar(buf,">");
}
xmlNodeDump(buf, doc, nodeset->nodeTab[i],1,(format==2));
if ((septagname != NULL) && (xmlStrlen(septagname)>0)) {
xmlBufferWriteChar(buf,"</");
xmlBufferWriteCHAR(buf,septagname);
xmlBufferWriteChar(buf,">");
}
if (format) {
xmlBufferWriteChar(buf,"\n");
}
}
}
xmlBufferPtr buf;
xmlChar *result;
int i;
if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) {
xmlBufferWriteChar(buf,"</");
xmlBufferWriteCHAR(buf,toptagname);
xmlBufferWriteChar(buf,">");
}
result = xmlStrdup(buf->content);
xmlBufferFree(buf);
return result;
buf = xmlBufferCreate();
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
if (nodeset != NULL)
{
for (i = 0; i < nodeset->nodeNr; i++)
{
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "<");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
xmlNodeDump(buf, doc, nodeset->nodeTab[i], 1, (format == 2));
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, septagname);
xmlBufferWriteChar(buf, ">");
}
if (format)
xmlBufferWriteChar(buf, "\n");
}
}
if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
{
xmlBufferWriteChar(buf, "</");
xmlBufferWriteCHAR(buf, toptagname);
xmlBufferWriteChar(buf, ">");
}
result = xmlStrdup(buf->content);
xmlBufferFree(buf);
return result;
}
static xmlChar *pgxml_texttoxmlchar(text *textstring) {
xmlChar *res;
int32 txsize;
static xmlChar *
pgxml_texttoxmlchar(text *textstring)
{
xmlChar *res;
int32 txsize;
txsize=VARSIZE(textstring)-VARHDRSZ;
res = (xmlChar *) palloc(txsize+1);
memcpy((char *)res, VARDATA(textstring), txsize);
res[txsize]='\0';
return res;
txsize = VARSIZE(textstring) - VARHDRSZ;
res = (xmlChar *) palloc(txsize + 1);
memcpy((char *) res, VARDATA(textstring), txsize);
res[txsize] = '\0';
return res;
}
@ -158,81 +177,86 @@ PG_FUNCTION_INFO_V1(pgxml_xpath);
Datum
pgxml_xpath(PG_FUNCTION_ARGS)
{
xmlDocPtr doctree;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
xmlChar *xpath, *xpresstr, *toptag, *septag;
xmlXPathCompExprPtr comppath;
xmlDocPtr doctree;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
xmlChar *xpath,
*xpresstr,
*toptag,
*septag;
xmlXPathCompExprPtr comppath;
int32 docsize,ressize;
text *t, *xpres;
int32 docsize,
ressize;
text *t,
*xpres;
t = PG_GETARG_TEXT_P(0); /*document buffer */
xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */
toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2));
septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3));
docsize = VARSIZE(t) - VARHDRSZ;
t = PG_GETARG_TEXT_P(0); /* document buffer */
xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */
toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2));
septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3));
pgxml_parser_init();
docsize = VARSIZE(t) - VARHDRSZ;
doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL) { /* not well-formed */
PG_RETURN_NULL();
}
pgxml_parser_init();
ctxt = xmlXPathNewContext(doctree);
ctxt->node = xmlDocGetRootElement(doctree);
doctree = xmlParseMemory((char *) VARDATA(t), docsize);
if (doctree == NULL)
{ /* not well-formed */
PG_RETURN_NULL();
}
/* compile the path */
comppath = xmlXPathCompile(xpath);
if (comppath == NULL) {
elog(NOTICE, "XPath syntax error");
xmlFreeDoc(doctree);
pfree((void *) xpath);
PG_RETURN_NULL();
}
ctxt = xmlXPathNewContext(doctree);
ctxt->node = xmlDocGetRootElement(doctree);
/* Now evaluate the path expression. */
res = xmlXPathCompiledEval(comppath,ctxt);
xmlXPathFreeCompExpr(comppath);
/* compile the path */
comppath = xmlXPathCompile(xpath);
if (comppath == NULL)
{
elog(NOTICE, "XPath syntax error");
xmlFreeDoc(doctree);
pfree((void *) xpath);
PG_RETURN_NULL();
}
if (res==NULL) {
xmlFreeDoc(doctree);
pfree((void *)xpath);
PG_RETURN_NULL(); /* seems appropriate */
}
/* now we dump this node, ?surrounding by tags? */
/* To do this, we look first at the type */
switch(res->type) {
case XPATH_NODESET:
xpresstr = pgxmlNodeSetToText(res->nodesetval,
doctree,
toptag, septag, 0);
break;
case XPATH_STRING:
xpresstr = xmlStrdup(res->stringval);
break;
default:
elog(NOTICE,"Unsupported XQuery result: %d",res->type);
xpresstr = xmlStrdup("<unsupported/>");
}
/* Now evaluate the path expression. */
res = xmlXPathCompiledEval(comppath, ctxt);
xmlXPathFreeCompExpr(comppath);
/* Now convert this result back to text */
ressize = strlen(xpresstr);
xpres = (text *) palloc(ressize+VARHDRSZ);
memcpy(VARDATA(xpres),xpresstr,ressize);
VARATT_SIZEP(xpres)=ressize + VARHDRSZ;
if (res == NULL)
{
xmlFreeDoc(doctree);
pfree((void *) xpath);
PG_RETURN_NULL(); /* seems appropriate */
}
/* now we dump this node, ?surrounding by tags? */
/* To do this, we look first at the type */
switch (res->type)
{
case XPATH_NODESET:
xpresstr = pgxmlNodeSetToText(res->nodesetval,
doctree,
toptag, septag, 0);
break;
case XPATH_STRING:
xpresstr = xmlStrdup(res->stringval);
break;
default:
elog(NOTICE, "Unsupported XQuery result: %d", res->type);
xpresstr = xmlStrdup("<unsupported/>");
}
/* Free various storage */
xmlFreeDoc(doctree);
pfree((void *) xpath);
xmlFree(xpresstr);
PG_RETURN_TEXT_P(xpres);
/* Now convert this result back to text */
ressize = strlen(xpresstr);
xpres = (text *) palloc(ressize + VARHDRSZ);
memcpy(VARDATA(xpres), xpresstr, ressize);
VARATT_SIZEP(xpres) = ressize + VARHDRSZ;
/* Free various storage */
xmlFreeDoc(doctree);
pfree((void *) xpath);
xmlFree(xpresstr);
PG_RETURN_TEXT_P(xpres);
}

9
src/backend/access/common/heaptuple.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.73 2001/08/23 23:06:37 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.74 2001/10/25 05:49:20 momjian Exp $
*
* NOTES
* The old interface functions have been converted to macros
@ -241,7 +241,6 @@ nocachegetattr(HeapTuple tuple,
}
else
{
/*
* there's a null somewhere in the tuple
*/
@ -347,7 +346,6 @@ nocachegetattr(HeapTuple tuple,
(HeapTupleNoNulls(tuple) || !att_isnull(j, bp)) &&
(HeapTupleAllFixed(tuple) || att[j]->attlen > 0)); j++)
{
/*
* Fix me when going to a machine with more than a four-byte
* word!
@ -546,7 +544,6 @@ heap_deformtuple(HeapTuple tuple,
nulls[i] = ' ';
}
}
#endif
/* ----------------
@ -739,7 +736,7 @@ heap_freetuple(HeapTuple htup)
*
* This routine forms a HeapTuple by copying the given structure (tuple
* data) and adding a generic header. Note that the tuple data is
* presumed to contain no null fields. It is typically only useful
* presumed to contain no null fields. It is typically only useful
* for null-free system tables.
* ----------------
*/
@ -771,7 +768,7 @@ heap_addheader(int natts, /* max domain index */
td->t_hoff = hoff;
td->t_natts = natts;
td->t_infomask = HEAP_XMAX_INVALID; /* XXX sufficient? */
td->t_infomask = HEAP_XMAX_INVALID; /* XXX sufficient? */
memcpy((char *) td + hoff, structure, structlen);

4
src/backend/access/common/indextuple.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.54 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.55 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -49,7 +49,6 @@ index_formtuple(TupleDesc tupleDescriptor,
#ifdef TOAST_INDEX_HACK
Datum untoasted_value[INDEX_MAX_KEYS];
bool untoasted_free[INDEX_MAX_KEYS];
#endif
if (numberOfAttributes > INDEX_MAX_KEYS)
@ -338,7 +337,6 @@ nocache_index_getattr(IndexTuple tup,
for (; j <= attnum; j++)
{
/*
* Fix me when going to a machine with more than a four-byte
* word!

5
src/backend/access/common/printtup.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.59 2001/03/22 06:16:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.60 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -197,7 +197,6 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
continue;
if (OidIsValid(thisState->typoutput))
{
/*
* If we have a toasted datum, forcibly detoast it here to
* avoid memory leakage inside the type's output routine.
@ -306,7 +305,6 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
if (getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
&typoutput, &typelem, &typisvarlena))
{
/*
* If we have a toasted datum, forcibly detoast it here to
* avoid memory leakage inside the type's output routine.
@ -401,7 +399,6 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
/* send # of bytes, and opaque data */
if (thisState->typisvarlena)
{
/*
* If we have a toasted datum, must detoast before sending.
*/

10
src/backend/access/common/tupdesc.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.75 2001/06/25 21:11:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.76 2001/10/25 05:49:20 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
@ -238,9 +238,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
Form_pg_attribute attr2 = tupdesc2->attrs[i];
/*
* We do not need to check every single field here: we can disregard
* attrelid, attnum (it was used to place the row in the attrs array)
* and everything derived from the column datatype.
* We do not need to check every single field here: we can
* disregard attrelid, attnum (it was used to place the row in the
* attrs array) and everything derived from the column datatype.
*/
if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
return false;
@ -399,7 +399,6 @@ TupleDescInitEntry(TupleDesc desc,
0, 0, 0);
if (!HeapTupleIsValid(tuple))
{
/*
* here type info does not exist yet so we just fill the attribute
* with dummy information and return false.
@ -585,7 +584,6 @@ BuildDescForRelation(List *schema, char *relname)
typenameTypeId(typename),
atttypmod, attdim, attisset))
{
/*
* if TupleDescInitEntry() fails, it means there is no type in
* the system catalogs. So now we check if the type name

957
src/backend/access/gist/gist.c
View File

File diff suppressed because it is too large Load Diff

10
src/backend/access/gist/gistget.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.30 2001/08/22 18:24:26 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.31 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -251,7 +251,7 @@ gistindex_keytest(IndexTuple tuple,
if (key[0].sk_flags & SK_ISNULL)
return false;
*/
gistdentryinit(giststate, key[0].sk_attno-1, &de,
gistdentryinit(giststate, key[0].sk_attno - 1, &de,
datum, r, p, offset,
IndexTupleSize(tuple) - sizeof(IndexTupleData),
FALSE, isNull);
@ -271,9 +271,9 @@ gistindex_keytest(IndexTuple tuple,
ObjectIdGetDatum(key[0].sk_procedure));
}
if ( de.key != datum && ! isAttByVal( giststate, key[0].sk_attno-1 ) )
if ( DatumGetPointer(de.key) != NULL )
pfree( DatumGetPointer(de.key) );
if (de.key != datum && !isAttByVal(giststate, key[0].sk_attno - 1))
if (DatumGetPointer(de.key) != NULL)
pfree(DatumGetPointer(de.key));
if (DatumGetBool(test) == !!(key[0].sk_flags & SK_NEGATE))
return false;

13
src/backend/access/gist/gistscan.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.39 2001/08/22 18:24:26 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.40 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -112,7 +112,7 @@ gistrescan(PG_FUNCTION_ARGS)
s->keyData[i].sk_procedure
= RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno,
s->keyData[i].sk_procedure);
s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno-1];
s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno - 1];
}
}
else
@ -137,13 +137,13 @@ gistrescan(PG_FUNCTION_ARGS)
/*----------
* s->keyData[i].sk_procedure =
* index_getprocid(s->relation, 1, GIST_CONSISTENT_PROC);
* index_getprocid(s->relation, 1, GIST_CONSISTENT_PROC);
*----------
*/
s->keyData[i].sk_procedure
= RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno,
s->keyData[i].sk_procedure);
s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno-1];
s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno - 1];
}
}
@ -234,8 +234,8 @@ gistendscan(PG_FUNCTION_ARGS)
{
gistfreestack(p->s_stack);
gistfreestack(p->s_markstk);
if ( p->giststate != NULL )
freeGISTstate( p->giststate );
if (p->giststate != NULL)
freeGISTstate(p->giststate);
pfree(s->opaque);
}
@ -383,7 +383,6 @@ adjustiptr(IndexScanDesc s,
}
else
{
/*
* remember that we're before the current
* tuple

3
src/backend/access/gist/giststrat.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.18 2001/10/25 05:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,5 +121,4 @@ RelationInvokeGISTStrategy(Relation r,
return (RelationInvokeStrategy(r, &GISTEvaluationData, attnum, s,
left, right));
}
#endif

35
src/backend/access/hash/hash.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.52 2001/07/15 22:48:15 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.53 2001/10/25 05:49:20 momjian Exp $
*
* NOTES
* This file contains only the public interface routines.
@ -37,11 +37,11 @@ typedef struct
} HashBuildState;
static void hashbuildCallback(Relation index,
HeapTuple htup,
Datum *attdata,
char *nulls,
bool tupleIsAlive,
void *state);
HeapTuple htup,
Datum *attdata,
char *nulls,
bool tupleIsAlive,
void *state);
/*
@ -80,7 +80,7 @@ hashbuild(PG_FUNCTION_ARGS)
/* do the heap scan */
reltuples = IndexBuildHeapScan(heap, index, indexInfo,
hashbuildCallback, (void *) &buildstate);
hashbuildCallback, (void *) &buildstate);
/* all done */
BuildingHash = false;
@ -121,7 +121,7 @@ hashbuildCallback(Relation index,
bool tupleIsAlive,
void *state)
{
HashBuildState *buildstate = (HashBuildState *) state;
HashBuildState *buildstate = (HashBuildState *) state;
IndexTuple itup;
HashItem hitem;
InsertIndexResult res;
@ -164,6 +164,7 @@ hashinsert(PG_FUNCTION_ARGS)
Datum *datum = (Datum *) PG_GETARG_POINTER(1);
char *nulls = (char *) PG_GETARG_POINTER(2);
ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
#ifdef NOT_USED
Relation heapRel = (Relation) PG_GETARG_POINTER(4);
#endif
@ -176,14 +177,13 @@ hashinsert(PG_FUNCTION_ARGS)
itup->t_tid = *ht_ctid;
/*
* If the single index key is null, we don't insert it into the
* index. Hash tables support scans on '='. Relational algebra
* says that A = B returns null if either A or B is null. This
* means that no qualification used in an index scan could ever
* return true on a null attribute. It also means that indices
* can't be used by ISNULL or NOTNULL scans, but that's an
* artifact of the strategy map architecture chosen in 1986, not
* of the way nulls are handled here.
* If the single index key is null, we don't insert it into the index.
* Hash tables support scans on '='. Relational algebra says that A =
* B returns null if either A or B is null. This means that no
* qualification used in an index scan could ever return true on a
* null attribute. It also means that indices can't be used by ISNULL
* or NOTNULL scans, but that's an artifact of the strategy map
* architecture chosen in 1986, not of the way nulls are handled here.
*/
if (IndexTupleHasNulls(itup))
{
@ -262,7 +262,6 @@ hashrescan(PG_FUNCTION_ARGS)
#ifdef NOT_USED /* XXX surely it's wrong to ignore this? */
bool fromEnd = PG_GETARG_BOOL(1);
#endif
ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2);
ItemPointer iptr;
@ -412,7 +411,7 @@ hashbulkdelete(PG_FUNCTION_ARGS)
IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1);
void *callback_state = (void *) PG_GETARG_POINTER(2);
IndexBulkDeleteResult *result;
BlockNumber num_pages;
BlockNumber num_pages;
double tuples_removed;
double num_index_tuples;
RetrieveIndexResult res;

6
src/backend/access/hash/hashinsert.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.22 2001/03/07 21:20:26 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.23 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -133,13 +133,11 @@ _hash_insertonpg(Relation rel,
while (PageGetFreeSpace(page) < itemsz)
{
/*
* no space on this page; check for an overflow page
*/
if (BlockNumberIsValid(pageopaque->hasho_nextblkno))
{
/*
* ovfl page exists; go get it. if it doesn't have room,
* we'll find out next pass through the loop test above.
@ -152,7 +150,6 @@ _hash_insertonpg(Relation rel,
}
else
{
/*
* we're at the end of the bucket chain and we haven't found a
* page with enough room. allocate a new overflow page.
@ -184,7 +181,6 @@ _hash_insertonpg(Relation rel,
if (res != NULL)
{
/*
* Increment the number of keys in the table. We switch lock
* access type just for a moment to allow greater accessibility to

3
src/backend/access/hash/hashovfl.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.30 2001/07/15 22:48:15 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.31 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* Overflow pages look like ordinary relation pages.
@ -208,7 +208,6 @@ _hash_getovfladdr(Relation rel, Buffer *metabufp)
}
else
{
/*
* Free_bit addresses the last used bit. Bump it to address the
* first available bit.

16
src/backend/access/hash/hashpage.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.32 2001/07/15 22:48:15 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.33 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* Postgres hash pages look like ordinary relation pages. The opaque
@ -50,7 +50,7 @@ static void _hash_splitpage(Relation rel, Buffer metabuf, Bucket obucket, Bucket
* system catalogs anyway.
*
* Note that our page locks are actual lockmanager locks, not buffer
* locks (as are used by btree, for example). This is a good idea because
* locks (as are used by btree, for example). This is a good idea because
* the algorithms are not deadlock-free, and we'd better be able to detect
* and recover from deadlocks.
*
@ -325,7 +325,7 @@ _hash_setpagelock(Relation rel,
{
switch (access)
{
case HASH_WRITE:
case HASH_WRITE:
LockPage(rel, blkno, ExclusiveLock);
break;
case HASH_READ:
@ -349,7 +349,7 @@ _hash_unsetpagelock(Relation rel,
{
switch (access)
{
case HASH_WRITE:
case HASH_WRITE:
UnlockPage(rel, blkno, ExclusiveLock);
break;
case HASH_READ:
@ -369,7 +369,7 @@ _hash_unsetpagelock(Relation rel,
* It is safe to delete an item after acquiring a regular WRITE lock on
* the page, because no other backend can hold a READ lock on the page,
* and that means no other backend currently has an indexscan stopped on
* any item of the item being deleted. Our own backend might have such
* any item of the item being deleted. Our own backend might have such
* an indexscan (in fact *will*, since that's how VACUUM found the item
* in the first place), but _hash_adjscans will fix the scan position.
*/
@ -532,7 +532,6 @@ _hash_splitpage(Relation rel,
_hash_relbuf(rel, obuf, HASH_WRITE);
if (!BlockNumberIsValid(oblkno))
{
/*
* the old bucket is completely empty; of course, the new
* bucket will be as well, but since it's a base bucket page
@ -559,7 +558,6 @@ _hash_splitpage(Relation rel,
omaxoffnum = PageGetMaxOffsetNumber(opage);
for (;;)
{
/*
* at each iteration through this loop, each of these variables
* should be up-to-date: obuf opage oopaque ooffnum omaxoffnum
@ -572,7 +570,6 @@ _hash_splitpage(Relation rel,
oblkno = oopaque->hasho_nextblkno;
if (BlockNumberIsValid(oblkno))
{
/*
* we ran out of tuples on this particular page, but we
* have more overflow pages; re-init values.
@ -594,7 +591,6 @@ _hash_splitpage(Relation rel,
}
else
{
/*
* we're at the end of the bucket chain, so now we're
* really done with everything. before quitting, call
@ -618,7 +614,6 @@ _hash_splitpage(Relation rel,
if (bucket == nbucket)
{
/*
* insert the tuple into the new bucket. if it doesn't fit on
* the current page in the new bucket, we must allocate a new
@ -695,7 +690,6 @@ _hash_splitpage(Relation rel,
}
else
{
/*
* the tuple stays on this page. we didn't move anything, so
* we didn't delete anything and therefore we don't have to

3
src/backend/access/hash/hashsearch.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.26 2001/03/23 04:49:51 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.27 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -36,7 +36,6 @@ _hash_search(Relation rel,
if (scankey == (ScanKey) NULL ||
(keyDatum = scankey[0].sk_argument) == (Datum) NULL)
{
/*
* If the scankey argument is NULL, all tuples will satisfy the
* scan so we start the scan at the first bucket (bucket 0).

5
src/backend/access/hash/hashstrat.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.18 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.19 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -46,7 +46,6 @@ static StrategyEvaluationData HTEvaluationData = {
(StrategyTransformMap) HTNegateCommute,
HTEvaluationExpressions
};
#endif
/* ----------------------------------------------------------------
@ -68,7 +67,6 @@ _hash_getstrat(Relation rel,
return strat;
}
#endif
#ifdef NOT_USED
@ -82,5 +80,4 @@ _hash_invokestrat(Relation rel,
return (RelationInvokeStrategy(rel, &HTEvaluationData, attno, strat,
left, right));
}
#endif

85
src/backend/access/heap/heapam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.125 2001/08/23 23:06:37 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.126 2001/10/25 05:49:21 momjian Exp $
*
*
* INTERFACE ROUTINES
@ -116,8 +116,8 @@ heapgettup(Relation relation,
{
ItemId lpp;
Page dp;
BlockNumber page;
BlockNumber pages;
BlockNumber page;
BlockNumber pages;
int lines;
OffsetNumber lineoff;
int linesleft;
@ -350,7 +350,7 @@ heapgettup(Relation relation,
/*
* return NULL if we've exhausted all the pages
*/
if ((dir < 0) ? (page == 0) : (page+1 >= pages))
if ((dir < 0) ? (page == 0) : (page + 1 >= pages))
{
if (BufferIsValid(*buffer))
ReleaseBuffer(*buffer);
@ -429,9 +429,8 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
(
(Datum) NULL
)
);
);
}
#endif /* defined(DISABLE_COMPLEX_MACRO) */
@ -1045,12 +1044,13 @@ heap_insert(Relation relation, HeapTuple tup)
if (relation->rd_rel->relhasoids)
{
/*
* If the object id of this tuple has already been assigned, trust the
* caller. There are a couple of ways this can happen. At initial db
* creation, the backend program sets oids for tuples. When we define
* an index, we set the oid. Finally, in the future, we may allow
* users to set their own object ids in order to support a persistent
* object store (objects need to contain pointers to one another).
* If the object id of this tuple has already been assigned, trust
* the caller. There are a couple of ways this can happen. At
* initial db creation, the backend program sets oids for tuples.
* When we define an index, we set the oid. Finally, in the
* future, we may allow users to set their own object ids in order
* to support a persistent object store (objects need to contain
* pointers to one another).
*/
if (!OidIsValid(tup->t_data->t_oid))
tup->t_data->t_oid = newoid();
@ -1478,21 +1478,22 @@ l2:
}
/*
* Now, do we need a new page for the tuple, or not? This is a bit
* tricky since someone else could have added tuples to the page
* while we weren't looking. We have to recheck the available space
* after reacquiring the buffer lock. But don't bother to do that
* if the former amount of free space is still not enough; it's
* unlikely there's more free now than before.
* Now, do we need a new page for the tuple, or not? This is a
* bit tricky since someone else could have added tuples to the
* page while we weren't looking. We have to recheck the
* available space after reacquiring the buffer lock. But don't
* bother to do that if the former amount of free space is still
* not enough; it's unlikely there's more free now than before.
*
* What's more, if we need to get a new page, we will need to acquire
* buffer locks on both old and new pages. To avoid deadlock against
* some other backend trying to get the same two locks in the other
* order, we must be consistent about the order we get the locks in.
* We use the rule "lock the lower-numbered page of the relation
* first". To implement this, we must do RelationGetBufferForTuple
* while not holding the lock on the old page, and we must rely on it
* to get the locks on both pages in the correct order.
* buffer locks on both old and new pages. To avoid deadlock
* against some other backend trying to get the same two locks in
* the other order, we must be consistent about the order we get
* the locks in. We use the rule "lock the lower-numbered page of
* the relation first". To implement this, we must do
* RelationGetBufferForTuple while not holding the lock on the old
* page, and we must rely on it to get the locks on both pages in
* the correct order.
*/
if (newtupsize > pagefree)
{
@ -1510,8 +1511,8 @@ l2:
{
/*
* Rats, it doesn't fit anymore. We must now unlock and
* relock to avoid deadlock. Fortunately, this path should
* seldom be taken.
* relock to avoid deadlock. Fortunately, this path
* should seldom be taken.
*/
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
newbuf = RelationGetBufferForTuple(relation, newtup->t_len,
@ -1534,9 +1535,9 @@ l2:
pgstat_count_heap_update(&relation->pgstat_info);
/*
* At this point newbuf and buffer are both pinned and locked,
* and newbuf has enough space for the new tuple. If they are
* the same buffer, only one pin is held.
* At this point newbuf and buffer are both pinned and locked, and
* newbuf has enough space for the new tuple. If they are the same
* buffer, only one pin is held.
*/
/* NO ELOG(ERROR) from here till changes are logged */
@ -1865,12 +1866,14 @@ log_heap_update(Relation reln, Buffer oldbuf, ItemPointerData from,
* Note: xlhdr is declared to have adequate size and correct alignment
* for an xl_heap_header. However the two tids, if present at all,
* will be packed in with no wasted space after the xl_heap_header;
* they aren't necessarily aligned as implied by this struct declaration.
* they aren't necessarily aligned as implied by this struct
* declaration.
*/
struct {
xl_heap_header hdr;
TransactionId tid1;
TransactionId tid2;
struct
{
xl_heap_header hdr;
TransactionId tid1;
TransactionId tid2;
} xlhdr;
int hsize = SizeOfHeapHeader;
xl_heap_update xlrec;
@ -1972,7 +1975,7 @@ heap_xlog_clean(bool redo, XLogRecPtr lsn, XLogRecord *record)
if (record->xl_len > SizeOfHeapClean)
{
OffsetNumber unbuf[BLCKSZ/sizeof(OffsetNumber)];
OffsetNumber unbuf[BLCKSZ / sizeof(OffsetNumber)];
OffsetNumber *unused = unbuf;
char *unend;
ItemId lp;
@ -2084,9 +2087,10 @@ heap_xlog_insert(bool redo, XLogRecPtr lsn, XLogRecord *record)
if (redo)
{
struct {
struct
{
HeapTupleHeaderData hdr;
char data[MaxTupleSize];
char data[MaxTupleSize];
} tbuf;
HeapTupleHeader htup;
xl_heap_header xlhdr;
@ -2251,9 +2255,10 @@ newsame:;
if (redo)
{
struct {
struct
{
HeapTupleHeaderData hdr;
char data[MaxTupleSize];
char data[MaxTupleSize];
} tbuf;
xl_heap_header xlhdr;
int hsize;

61
src/backend/access/heap/hio.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Id: hio.c,v 1.42 2001/07/13 22:52:58 tgl Exp $
* $Id: hio.c,v 1.43 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -83,7 +83,7 @@ RelationPutHeapTuple(Relation relation,
* NOTE: it is unlikely, but not quite impossible, for otherBuffer to be the
* same buffer we select for insertion of the new tuple (this could only
* happen if space is freed in that page after heap_update finds there's not
* enough there). In that case, the page will be pinned and locked only once.
* enough there). In that case, the page will be pinned and locked only once.
*
* Note that we use LockPage(rel, 0) to lock relation for extension.
* We can do this as long as in all other places we use page-level locking
@ -115,17 +115,19 @@ RelationGetBufferForTuple(Relation relation, Size len,
if (otherBuffer != InvalidBuffer)
otherBlock = BufferGetBlockNumber(otherBuffer);
else
otherBlock = InvalidBlockNumber; /* just to keep compiler quiet */
otherBlock = InvalidBlockNumber; /* just to keep compiler
* quiet */
/*
* We first try to put the tuple on the same page we last inserted a
* tuple on, as cached in the relcache entry. If that doesn't work,
* we ask the shared Free Space Map to locate a suitable page. Since
* we ask the shared Free Space Map to locate a suitable page. Since
* the FSM's info might be out of date, we have to be prepared to loop
* around and retry multiple times. (To insure this isn't an infinite
* loop, we must update the FSM with the correct amount of free space on
* each page that proves not to be suitable.) If the FSM has no record of
* a page with enough free space, we give up and extend the relation.
* loop, we must update the FSM with the correct amount of free space
* on each page that proves not to be suitable.) If the FSM has no
* record of a page with enough free space, we give up and extend the
* relation.
*/
targetBlock = relation->rd_targblock;
@ -137,6 +139,7 @@ RelationGetBufferForTuple(Relation relation, Size len,
* target.
*/
targetBlock = GetPageWithFreeSpace(&relation->rd_node, len);
/*
* If the FSM knows nothing of the rel, try the last page before
* we give up and extend. This avoids one-tuple-per-page syndrome
@ -144,7 +147,7 @@ RelationGetBufferForTuple(Relation relation, Size len,
*/
if (targetBlock == InvalidBlockNumber)
{
BlockNumber nblocks = RelationGetNumberOfBlocks(relation);
BlockNumber nblocks = RelationGetNumberOfBlocks(relation);
if (nblocks > 0)
targetBlock = nblocks - 1;
@ -154,9 +157,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
while (targetBlock != InvalidBlockNumber)
{
/*
* Read and exclusive-lock the target block, as well as the
* other block if one was given, taking suitable care with
* lock ordering and the possibility they are the same block.
* Read and exclusive-lock the target block, as well as the other
* block if one was given, taking suitable care with lock ordering
* and the possibility they are the same block.
*/
if (otherBuffer == InvalidBuffer)
{
@ -184,9 +187,10 @@ RelationGetBufferForTuple(Relation relation, Size len,
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
}
/*
* Now we can check to see if there's enough free space here.
* If so, we're done.
* Now we can check to see if there's enough free space here. If
* so, we're done.
*/
pageHeader = (Page) BufferGetPage(buffer);
pageFreeSpace = PageGetFreeSpace(pageHeader);
@ -196,22 +200,22 @@ RelationGetBufferForTuple(Relation relation, Size len,
relation->rd_targblock = targetBlock;
return buffer;
}
/*
* Not enough space, so we must give up our page locks and
* pin (if any) and prepare to look elsewhere. We don't care
* which order we unlock the two buffers in, so this can be
* slightly simpler than the code above.
* Not enough space, so we must give up our page locks and pin (if
* any) and prepare to look elsewhere. We don't care which order
* we unlock the two buffers in, so this can be slightly simpler
* than the code above.
*/
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
if (otherBuffer == InvalidBuffer)
{
ReleaseBuffer(buffer);
}
else if (otherBlock != targetBlock)
{
LockBuffer(otherBuffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer);
}
/*
* Update FSM as to condition of this page, and ask for another
* page to try.
@ -225,9 +229,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
/*
* Have to extend the relation.
*
* We have to use a lock to ensure no one else is extending the
* rel at the same time, else we will both try to initialize the
* same new page.
* We have to use a lock to ensure no one else is extending the rel at
* the same time, else we will both try to initialize the same new
* page.
*/
if (!relation->rd_myxactonly)
LockPage(relation, 0, ExclusiveLock);
@ -236,20 +240,21 @@ RelationGetBufferForTuple(Relation relation, Size len,
* XXX This does an lseek - rather expensive - but at the moment it is
* the only way to accurately determine how many blocks are in a
* relation. Is it worth keeping an accurate file length in shared
* memory someplace, rather than relying on the kernel to do it for us?
* memory someplace, rather than relying on the kernel to do it for
* us?
*/
buffer = ReadBuffer(relation, P_NEW);
/*
* Release the file-extension lock; it's now OK for someone else
* to extend the relation some more.
* Release the file-extension lock; it's now OK for someone else to
* extend the relation some more.
*/
if (!relation->rd_myxactonly)
UnlockPage(relation, 0, ExclusiveLock);
/*
* We can be certain that locking the otherBuffer first is OK,
* since it must have a lower page number.
* We can be certain that locking the otherBuffer first is OK, since
* it must have a lower page number.
*/
if (otherBuffer != InvalidBuffer)
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
@ -273,7 +278,7 @@ RelationGetBufferForTuple(Relation relation, Size len,
*
* XXX should we enter the new page into the free space map immediately,
* or just keep it for this backend's exclusive use in the short run
* (until VACUUM sees it)? Seems to depend on whether you expect the
* (until VACUUM sees it)? Seems to depend on whether you expect the
* current backend to make more insertions or not, which is probably a
* good bet most of the time. So for now, don't add it to FSM yet.
*/

8
src/backend/access/heap/stats.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.24 2001/03/22 06:16:07 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.25 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* initam should be moved someplace else.
@ -164,7 +164,6 @@ ResetHeapAccessStatistics()
time(&stats->local_reset_timestamp);
time(&stats->last_request_timestamp);
}
#endif
#ifdef NOT_USED
@ -200,7 +199,6 @@ GetHeapAccessStatistics()
return stats;
}
#endif
#ifdef NOT_USED
@ -211,7 +209,6 @@ GetHeapAccessStatistics()
void
PrintHeapAccessStatistics(HeapAccessStatistics stats)
{
/*
* return nothing if stats aren't valid
*/
@ -302,7 +299,6 @@ PrintHeapAccessStatistics(HeapAccessStatistics stats)
printf("\n");
}
#endif
#ifdef NOT_USED
@ -317,7 +313,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats)
if (stats != NULL)
pfree(stats);
}
#endif
/* ----------------------------------------------------------------
@ -331,7 +326,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats)
void
initam(void)
{
/*
* initialize heap statistics.
*/

40
src/backend/access/heap/tuptoaster.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.24 2001/08/10 18:57:33 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.25 2001/10/25 05:49:21 momjian Exp $
*
*
* INTERFACE ROUTINES
@ -74,14 +74,13 @@ heap_tuple_toast_attrs(Relation rel, HeapTuple newtup, HeapTuple oldtup)
* external storage (possibly still in compressed format).
* ----------
*/
varattrib *
varattrib *
heap_tuple_fetch_attr(varattrib *attr)
{
varattrib *result;
if (VARATT_IS_EXTERNAL(attr))
{
/*
* This is an external stored plain value
*/
@ -89,7 +88,6 @@ heap_tuple_fetch_attr(varattrib *attr)
}
else
{
/*
* This is a plain value inside of the main tuple - why am I
* called?
@ -108,7 +106,7 @@ heap_tuple_fetch_attr(varattrib *attr)
* or external storage.
* ----------
*/
varattrib *
varattrib *
heap_tuple_untoast_attr(varattrib *attr)
{
varattrib *result;
@ -135,7 +133,6 @@ heap_tuple_untoast_attr(varattrib *attr)
}
else
{
/*
* This is an external stored plain value
*/
@ -144,7 +141,6 @@ heap_tuple_untoast_attr(varattrib *attr)
}
else if (VARATT_IS_COMPRESSED(attr))
{
/*
* This is a compressed value inside of the main tuple
*/
@ -181,8 +177,8 @@ toast_raw_datum_size(Datum value)
if (VARATT_IS_COMPRESSED(attr))
{
/*
* va_rawsize shows the original data size, whether the datum
* is external or not.
* va_rawsize shows the original data size, whether the datum is
* external or not.
*/
result = attr->va_content.va_compressed.va_rawsize + VARHDRSZ;
}
@ -301,7 +297,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
if (oldtup != NULL)
{
/*
* For UPDATE get the old and new values of this attribute
*/
@ -324,7 +319,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
old_value->va_content.va_external.va_toastrelid !=
new_value->va_content.va_external.va_toastrelid)
{
/*
* The old external store value isn't needed any more
* after the update
@ -334,7 +328,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* This attribute isn't changed by this update so we
* reuse the original reference to the old value in
@ -348,7 +341,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* For INSERT simply get the new value
*/
@ -372,7 +364,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
*/
if (att[i]->attlen == -1)
{
/*
* If the table's attribute says PLAIN always, force it so.
*/
@ -400,7 +391,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* Not a variable size attribute, plain storage always
*/
@ -475,7 +465,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* incompressible data, ignore on subsequent compression
* passes
@ -588,7 +577,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
}
else
{
/*
* incompressible data, ignore on subsequent compression
* passes
@ -776,9 +764,10 @@ toast_save_datum(Relation rel, Datum value)
Datum t_values[3];
char t_nulls[3];
varattrib *result;
struct {
struct varlena hdr;
char data[TOAST_MAX_CHUNK_SIZE];
struct
{
struct varlena hdr;
char data[TOAST_MAX_CHUNK_SIZE];
} chunk_data;
int32 chunk_size;
int32 chunk_seq = 0;
@ -851,12 +840,12 @@ toast_save_datum(Relation rel, Datum value)
heap_insert(toastrel, toasttup);
/*
* Create the index entry. We cheat a little here by not using
* Create the index entry. We cheat a little here by not using
* FormIndexDatum: this relies on the knowledge that the index
* columns are the same as the initial columns of the table.
*
* Note also that there had better not be any user-created index
* on the TOAST table, since we don't bother to update anything else.
* Note also that there had better not be any user-created index on
* the TOAST table, since we don't bother to update anything else.
*/
idxres = index_insert(toastidx, t_values, t_nulls,
&(toasttup->t_self),
@ -916,8 +905,8 @@ toast_delete_datum(Relation rel, Datum value)
toastidx = index_open(toastrel->rd_rel->reltoastidxid);
/*
* Setup a scan key to fetch from the index by va_valueid
* (we don't particularly care whether we see them in sequence or not)
* Setup a scan key to fetch from the index by va_valueid (we don't
* particularly care whether we see them in sequence or not)
*/
ScanKeyEntryInitialize(&toastkey,
(bits16) 0,
@ -1096,5 +1085,4 @@ toast_fetch_datum(varattrib *attr)
return result;
}
#endif /* TUPLE_TOASTER_ACTIVE */

3
src/backend/access/index/genam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.28 2001/06/22 19:16:21 wieck Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.29 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* many of the old access method routines have been turned into
@ -240,5 +240,4 @@ IndexScanRestorePosition(IndexScanDesc scan)
scan->flags = 0x0; /* XXX should have a symbolic name */
}
#endif

16
src/backend/access/index/indexam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.53 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.54 2001/10/25 05:49:21 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
@ -241,9 +241,9 @@ index_beginscan(Relation relation,
pgstat_initstats(&scan->xs_pgstat_info, relation);
/*
* We want to look up the amgettuple procedure just once per scan,
* not once per index_getnext call. So do it here and save
* the fmgr info result in the scan descriptor.
* We want to look up the amgettuple procedure just once per scan, not
* once per index_getnext call. So do it here and save the fmgr info
* result in the scan descriptor.
*/
GET_SCAN_PROCEDURE(beginscan, amgettuple);
fmgr_info(procedure, &scan->fn_getnext);
@ -342,8 +342,8 @@ index_getnext(IndexScanDesc scan,
pgstat_count_index_scan(&scan->xs_pgstat_info);
/*
* have the am's gettuple proc do all the work.
* index_beginscan already set up fn_getnext.
* have the am's gettuple proc do all the work. index_beginscan
* already set up fn_getnext.
*/
result = (RetrieveIndexResult)
DatumGetPointer(FunctionCall2(&scan->fn_getnext,
@ -378,8 +378,8 @@ index_bulk_delete(Relation relation,
result = (IndexBulkDeleteResult *)
DatumGetPointer(OidFunctionCall3(procedure,
PointerGetDatum(relation),
PointerGetDatum((Pointer) callback),
PointerGetDatum(callback_state)));
PointerGetDatum((Pointer) callback),
PointerGetDatum(callback_state)));
return result;
}

20
src/backend/access/index/istrat.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.53 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.54 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -120,9 +120,9 @@ StrategyOperatorIsValid(StrategyOperator operator,
StrategyNumber maxStrategy)
{
return (bool)
(PointerIsValid(operator) &&
StrategyNumberIsInBounds(operator->strategy, maxStrategy) &&
!(operator->flags & ~(SK_NEGATE | SK_COMMUTE)));
(PointerIsValid(operator) &&
StrategyNumberIsInBounds(operator->strategy, maxStrategy) &&
!(operator->flags & ~(SK_NEGATE | SK_COMMUTE)));
}
/* ----------------
@ -196,7 +196,6 @@ StrategyEvaluationIsValid(StrategyEvaluation evaluation)
}
return true;
}
#endif
#ifdef NOT_USED
@ -255,7 +254,6 @@ StrategyTermEvaluate(StrategyTerm term,
return result;
}
#endif
/* ----------------
@ -453,7 +451,6 @@ RelationInvokeStrategy(Relation relation,
/* not reached, just to make compiler happy */
return FALSE;
}
#endif
/* ----------------
@ -552,7 +549,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
{
for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
{
Oid opclass = operatorClassObjectId[attIndex];
Oid opclass = operatorClassObjectId[attIndex];
RegProcedure *loc;
StrategyNumber support;
@ -562,7 +559,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
{
tuple = SearchSysCache(AMPROCNUM,
ObjectIdGetDatum(opclass),
Int16GetDatum(support+1),
Int16GetDatum(support + 1),
0, 0);
if (HeapTupleIsValid(tuple))
{
@ -581,7 +578,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
/* Now load the strategy information for the index operators */
for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
{
Oid opclass = operatorClassObjectId[attIndex];
Oid opclass = operatorClassObjectId[attIndex];
StrategyMap map;
StrategyNumber strategy;
@ -591,7 +588,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
for (strategy = 1; strategy <= maxStrategyNumber; strategy++)
{
ScanKey mapentry = StrategyMapGetScanKeyEntry(map, strategy);
ScanKey mapentry = StrategyMapGetScanKeyEntry(map, strategy);
tuple = SearchSysCache(AMOPSTRATEGY,
ObjectIdGetDatum(opclass),
@ -643,5 +640,4 @@ IndexStrategyDisplay(IndexStrategy indexStrategy,
}
}
}
#endif /* defined(ISTRATDEBUG) */

4
src/backend/access/nbtree/nbtcompare.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.42 2001/05/03 19:00:36 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.43 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
*
@ -25,7 +25,7 @@
* NOTE: although any negative int32 is acceptable for reporting "<",
* and any positive int32 is acceptable for reporting ">", routines
* that work on 32-bit or wider datatypes can't just return "a - b".
* That could overflow and give the wrong answer. Also, one should not
* That could overflow and give the wrong answer. Also, one should not
* return INT_MIN to report "<", since some callers will negate the result.
*
* NOTE: it is critical that the comparison function impose a total order

8
src/backend/access/nbtree/nbtinsert.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.86 2001/09/29 23:49:51 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.87 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -1100,7 +1100,7 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright,
* If we are not on the leaf level, we will be able to discard the key
* data from the first item that winds up on the right page.
*/
if (! state->is_leaf)
if (!state->is_leaf)
rightfree += (int) firstrightitemsz -
(int) (MAXALIGN(sizeof(BTItemData)) + sizeof(ItemIdData));
@ -1115,7 +1115,8 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright,
{
/*
* On a rightmost page, try to equalize right free space with
* twice the left free space. See comments for _bt_findsplitloc.
* twice the left free space. See comments for
* _bt_findsplitloc.
*/
delta = (2 * leftfree) - rightfree;
}
@ -1618,7 +1619,6 @@ _bt_fixlevel(Relation rel, Buffer buf, BlockNumber limit)
for (;;)
{
/*
* Read up to 2 more child pages and look for pointers to them in
* *saved* parent page

6
src/backend/access/nbtree/nbtpage.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.53 2001/07/15 22:48:16 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.54 2001/10/25 05:49:21 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
@ -153,7 +153,6 @@ _bt_getroot(Relation rel, int access)
*/
if (metad->btm_root == P_NONE)
{
/*
* Get, initialize, write, and leave a lock of the appropriate
* type on the new root page. Since this is the first page in
@ -209,7 +208,6 @@ _bt_getroot(Relation rel, int access)
}
else
{
/*
* Metadata initialized by someone else. In order to
* guarantee no deadlocks, we have to release the metadata
@ -237,7 +235,6 @@ _bt_getroot(Relation rel, int access)
if (!P_ISROOT(rootopaque))
{
/*
* It happened, but if root page splitter failed to create new
* root page then we'll go in loop trying to call _bt_getroot
@ -402,7 +399,6 @@ _bt_wrtnorelbuf(Relation rel, Buffer buf)
void
_bt_pageinit(Page page, Size size)
{
/*
* Cargo_cult programming -- don't really need this to be zero, but
* creating new pages is an infrequent occurrence and it makes me feel

64
src/backend/access/nbtree/nbtree.c
View File

@ -12,7 +12,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.82 2001/07/15 22:48:16 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.83 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -37,6 +37,7 @@ typedef struct
bool haveDead;
Relation heapRel;
BTSpool *spool;
/*
* spool2 is needed only when the index is an unique index. Dead
* tuples are put into spool2 instead of spool in order to avoid
@ -58,11 +59,11 @@ bool FixBTree = true;
static void _bt_restscan(IndexScanDesc scan);
static void btbuildCallback(Relation index,
HeapTuple htup,
Datum *attdata,
char *nulls,
bool tupleIsAlive,
void *state);
HeapTuple htup,
Datum *attdata,
char *nulls,
bool tupleIsAlive,
void *state);
/*
@ -134,6 +135,7 @@ btbuild(PG_FUNCTION_ARGS)
if (buildstate.usefast)
{
buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique);
/*
* Different from spool, the uniqueness isn't checked for spool2.
*/
@ -214,7 +216,7 @@ btbuildCallback(Relation index,
bool tupleIsAlive,
void *state)
{
BTBuildState *buildstate = (BTBuildState *) state;
BTBuildState *buildstate = (BTBuildState *) state;
IndexTuple itup;
BTItem btitem;
InsertIndexResult res;
@ -226,9 +228,9 @@ btbuildCallback(Relation index,
btitem = _bt_formitem(itup);
/*
* if we are doing bottom-up btree build, we insert the index into
* a spool file for subsequent processing. otherwise, we insert
* into the btree.
* if we are doing bottom-up btree build, we insert the index into a
* spool file for subsequent processing. otherwise, we insert into
* the btree.
*/
if (buildstate->usefast)
{
@ -305,7 +307,6 @@ btgettuple(PG_FUNCTION_ARGS)
if (ItemPointerIsValid(&(scan->currentItemData)))
{
/*
* Restore scan position using heap TID returned by previous call
* to btgettuple(). _bt_restscan() re-grabs the read lock on the
@ -321,7 +322,7 @@ btgettuple(PG_FUNCTION_ARGS)
* Save heap TID to use it in _bt_restscan. Then release the read
* lock on the buffer so that we aren't blocking other backends.
*
* NOTE: we do keep the pin on the buffer! This is essential to ensure
* NOTE: we do keep the pin on the buffer! This is essential to ensure
* that someone else doesn't delete the index entry we are stopped on.
*/
if (res)
@ -362,7 +363,6 @@ btrescan(PG_FUNCTION_ARGS)
#ifdef NOT_USED /* XXX surely it's wrong to ignore this? */
bool fromEnd = PG_GETARG_BOOL(1);
#endif
ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2);
ItemPointer iptr;
@ -547,7 +547,7 @@ btbulkdelete(PG_FUNCTION_ARGS)
IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1);
void *callback_state = (void *) PG_GETARG_POINTER(2);
IndexBulkDeleteResult *result;
BlockNumber num_pages;
BlockNumber num_pages;
double tuples_removed;
double num_index_tuples;
RetrieveIndexResult res;
@ -559,15 +559,16 @@ btbulkdelete(PG_FUNCTION_ARGS)
num_index_tuples = 0;
/*
* We use a standard IndexScanDesc scan object, but to speed up the loop,
* we skip most of the wrapper layers of index_getnext and instead call
* _bt_step directly. This implies holding buffer lock on a target page
* throughout the loop over the page's tuples. Initially, we have a read
* lock acquired by _bt_step when we stepped onto the page. If we find
* a tuple we need to delete, we trade in the read lock for an exclusive
* write lock; after that, we hold the write lock until we step off the
* page (fortunately, _bt_relbuf doesn't care which kind of lock it's
* releasing). This should minimize the amount of work needed per page.
* We use a standard IndexScanDesc scan object, but to speed up the
* loop, we skip most of the wrapper layers of index_getnext and
* instead call _bt_step directly. This implies holding buffer lock
* on a target page throughout the loop over the page's tuples.
* Initially, we have a read lock acquired by _bt_step when we stepped
* onto the page. If we find a tuple we need to delete, we trade in
* the read lock for an exclusive write lock; after that, we hold the
* write lock until we step off the page (fortunately, _bt_relbuf
* doesn't care which kind of lock it's releasing). This should
* minimize the amount of work needed per page.
*/
scan = index_beginscan(rel, false, 0, (ScanKey) NULL);
so = (BTScanOpaque) scan->opaque;
@ -579,7 +580,7 @@ btbulkdelete(PG_FUNCTION_ARGS)
if (res != NULL)
{
Buffer buf;
BlockNumber lockedBlock = InvalidBlockNumber;
BlockNumber lockedBlock = InvalidBlockNumber;
pfree(res);
/* we have the buffer pinned and locked */
@ -589,11 +590,11 @@ btbulkdelete(PG_FUNCTION_ARGS)
do
{
Page page;
BlockNumber blkno;
BlockNumber blkno;
OffsetNumber offnum;
BTItem btitem;
IndexTuple itup;
ItemPointer htup;
ItemPointer htup;
/* current is the next index tuple */
blkno = ItemPointerGetBlockNumber(current);
@ -607,9 +608,10 @@ btbulkdelete(PG_FUNCTION_ARGS)
{
/*
* If this is first deletion on this page, trade in read
* lock for a really-exclusive write lock. Then, step back
* one and re-examine the item, because someone else might
* have inserted an item while we weren't holding the lock!
* lock for a really-exclusive write lock. Then, step
* back one and re-examine the item, because someone else
* might have inserted an item while we weren't holding
* the lock!
*/
if (blkno != lockedBlock)
{
@ -632,8 +634,8 @@ btbulkdelete(PG_FUNCTION_ARGS)
* We need to back up the scan one item so that the next
* cycle will re-examine the same offnum on this page.
*
* For now, just hack the current-item index. Will need
* to be smarter when deletion includes removal of empty
* For now, just hack the current-item index. Will need to
* be smarter when deletion includes removal of empty
* index pages.
*/
current->ip_posid--;

10
src/backend/access/nbtree/nbtsearch.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.68 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.69 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -589,10 +589,10 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
/*
* At this point we are positioned at the first item >= scan key, or
* possibly at the end of a page on which all the existing items are
* greater than the scan key and we know that everything on later pages
* is less than or equal to scan key.
*
* possibly at the end of a page on which all the existing items are
* greater than the scan key and we know that everything on later
* pages is less than or equal to scan key.
*
* We could step forward in the latter case, but that'd be a waste of
* time if we want to scan backwards. So, it's now time to examine
* the scan strategy to find the exact place to start the scan.

6
src/backend/access/nbtree/nbtsort.c
View File

@ -35,7 +35,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.60 2001/03/22 03:59:15 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.61 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -108,7 +108,7 @@ static void _bt_load(Relation index, BTSpool *btspool, BTSpool *btspool2);
/*
* create and initialize a spool structure
*/
BTSpool *
BTSpool *
_bt_spoolinit(Relation index, bool isunique)
{
BTSpool *btspool = (BTSpool *) palloc(sizeof(BTSpool));
@ -354,7 +354,6 @@ _bt_buildadd(Relation index, BTPageState *state, BTItem bti)
if (pgspc < btisz || pgspc < state->btps_full)
{
/*
* Item won't fit on this page, or we feel the page is full enough
* already. Finish off the page and write it out.
@ -544,7 +543,6 @@ _bt_load(Relation index, BTSpool *btspool, BTSpool *btspool2)
if (merge)
{
/*
* Another BTSpool for dead tuples exists. Now we have to merge
* btspool and btspool2.

3
src/backend/access/nbtree/nbtstrat.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.14 2001/05/30 19:53:40 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.15 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -134,5 +134,4 @@ _bt_invokestrat(Relation rel,
return (RelationInvokeStrategy(rel, &BTEvaluationData, attno, strat,
left, right));
}
#endif

4
src/backend/access/nbtree/nbtutils.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.46 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.47 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -221,7 +221,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so)
/* We can short-circuit most of the work if there's just one key */
if (numberOfKeys == 1)
{
/*
* We don't use indices for 'A is null' and 'A is not null'
* currently and 'A < = > <> NULL' will always fail - so qual is
@ -317,7 +316,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so)
}
else
{
/*
* No "=" for this key, so we're done with required keys
*/

167
src/backend/access/rtree/rtree.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.65 2001/10/06 23:21:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.66 2001/10/25 05:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -58,9 +58,9 @@ typedef struct SPLITVEC
/* for sorting tuples by cost, for picking split */
typedef struct SPLITCOST
{
OffsetNumber offset_number;
float cost_differential;
bool choose_left;
OffsetNumber offset_number;
float cost_differential;
bool choose_left;
} SPLITCOST;
typedef struct RTSTATE
@ -79,11 +79,11 @@ typedef struct
/* non-export function prototypes */
static void rtbuildCallback(Relation index,
HeapTuple htup,
Datum *attdata,
char *nulls,
bool tupleIsAlive,
void *state);
HeapTuple htup,
Datum *attdata,
char *nulls,
bool tupleIsAlive,
void *state);
static InsertIndexResult rtdoinsert(Relation r, IndexTuple itup,
RTSTATE *rtstate);
static void rttighten(Relation r, RTSTACK *stk, Datum datum, int att_size,
@ -100,7 +100,7 @@ static OffsetNumber choose(Relation r, Page p, IndexTuple it,
RTSTATE *rtstate);
static int nospace(Page p, IndexTuple it);
static void initRtstate(RTSTATE *rtstate, Relation index);
static int qsort_comp_splitcost(const void *a, const void *b);
static int qsort_comp_splitcost(const void *a, const void *b);
/*
@ -178,7 +178,7 @@ rtbuildCallback(Relation index,
bool tupleIsAlive,
void *state)
{
RTBuildState *buildstate = (RTBuildState *) state;
RTBuildState *buildstate = (RTBuildState *) state;
IndexTuple itup;
InsertIndexResult res;
@ -194,11 +194,11 @@ rtbuildCallback(Relation index,
}
/*
* Since we already have the index relation locked, we call
* rtdoinsert directly. Normal access method calls dispatch
* through rtinsert, which locks the relation for write. This is
* the right thing to do if you're inserting single tups, but not
* when you're initializing the whole index at once.
* Since we already have the index relation locked, we call rtdoinsert
* directly. Normal access method calls dispatch through rtinsert,
* which locks the relation for write. This is the right thing to do
* if you're inserting single tups, but not when you're initializing
* the whole index at once.
*/
res = rtdoinsert(index, itup, &buildstate->rtState);
@ -223,6 +223,7 @@ rtinsert(PG_FUNCTION_ARGS)
Datum *datum = (Datum *) PG_GETARG_POINTER(1);
char *nulls = (char *) PG_GETARG_POINTER(2);
ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3);
#ifdef NOT_USED
Relation heapRel = (Relation) PG_GETARG_POINTER(4);
#endif
@ -249,7 +250,7 @@ rtinsert(PG_FUNCTION_ARGS)
/*
* Since rtree is not marked "amconcurrent" in pg_am, caller should
* have acquired exclusive lock on index relation. We need no locking
* have acquired exclusive lock on index relation. We need no locking
* here.
*/
@ -376,9 +377,8 @@ rttighten(Relation r,
PointerGetDatum(&newd_size));
/*
* If newd_size == 0 we have degenerate rectangles, so we
* don't know if there was any change, so we have to
* assume there was.
* If newd_size == 0 we have degenerate rectangles, so we don't know
* if there was any change, so we have to assume there was.
*/
if ((newd_size == 0) || (newd_size != old_size))
{
@ -386,7 +386,6 @@ rttighten(Relation r,
if (td->attrs[0]->attlen < 0)
{
/*
* This is an internal page, so 'oldud' had better be a union
* (constant-length) key, too. (See comment below.)
@ -500,10 +499,10 @@ rtdosplit(Relation r,
res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData));
/*
* spl_left contains a list of the offset numbers of the
* tuples that will go to the left page. For each offset
* number, get the tuple item, then add the item to the
* left page. Similarly for the right side.
* spl_left contains a list of the offset numbers of the tuples that
* will go to the left page. For each offset number, get the tuple
* item, then add the item to the left page. Similarly for the right
* side.
*/
/* fill left node */
@ -527,7 +526,7 @@ rtdosplit(Relation r,
if (i == newitemoff)
ItemPointerSet(&(res->pointerData), lbknum, leftoff);
spl_left++; /* advance in left split vector */
spl_left++; /* advance in left split vector */
}
/* fill right node */
@ -551,7 +550,7 @@ rtdosplit(Relation r,
if (i == newitemoff)
ItemPointerSet(&(res->pointerData), rbknum, rightoff);
spl_right++; /* advance in right split vector */
spl_right++; /* advance in right split vector */
}
/* Make sure we consumed all of the split vectors, and release 'em */
@ -764,9 +763,10 @@ rtpicksplit(Relation r,
right_avail_space;
int total_num_tuples,
num_tuples_without_seeds,
max_after_split; /* in Guttman's lingo, (M - m) */
float diff; /* diff between cost of putting tuple left or right */
SPLITCOST *cost_vector;
max_after_split; /* in Guttman's lingo, (M - m) */
float diff; /* diff between cost of putting tuple left
* or right */
SPLITCOST *cost_vector;
int n;
/*
@ -852,7 +852,6 @@ rtpicksplit(Relation r,
if (firsttime)
{
/*
* There is no possible split except to put the new item on its
* own page. Since we still have to compute the union rectangles,
@ -885,25 +884,25 @@ rtpicksplit(Relation r,
/*
* Now split up the regions between the two seeds.
*
* The cost_vector array will contain hints for determining where
* each tuple should go. Each record in the array will contain
* a boolean, choose_left, that indicates which node the tuple
* prefers to be on, and the absolute difference in cost between
* putting the tuple in its favored node and in the other node.
* The cost_vector array will contain hints for determining where each
* tuple should go. Each record in the array will contain a boolean,
* choose_left, that indicates which node the tuple prefers to be on,
* and the absolute difference in cost between putting the tuple in
* its favored node and in the other node.
*
* Later, we will sort the cost_vector in descending order by cost
* difference, and consider the tuples in that order for
* placement. That way, the tuples that *really* want to be in
* one node or the other get to choose first, and the tuples that
* don't really care choose last.
* difference, and consider the tuples in that order for placement.
* That way, the tuples that *really* want to be in one node or the
* other get to choose first, and the tuples that don't really care
* choose last.
*
* First, build the cost_vector array. The new index tuple will
* also be handled in this loop, and represented in the array,
* with i==newitemoff.
* First, build the cost_vector array. The new index tuple will also be
* handled in this loop, and represented in the array, with
* i==newitemoff.
*
* In the case of variable size tuples it is possible that we only
* have the two seeds and no other tuples, in which case we don't
* do any of this cost_vector stuff.
* In the case of variable size tuples it is possible that we only have
* the two seeds and no other tuples, in which case we don't do any of
* this cost_vector stuff.
*/
/* to keep compiler quiet */
@ -943,21 +942,21 @@ rtpicksplit(Relation r,
}
/*
* Sort the array. The function qsort_comp_splitcost is
* set up "backwards", to provided descending order.
* Sort the array. The function qsort_comp_splitcost is set up
* "backwards", to provided descending order.
*/
qsort(cost_vector, num_tuples_without_seeds, sizeof(SPLITCOST),
&qsort_comp_splitcost);
}
/*
* Now make the final decisions about where each tuple will go,
* and build the vectors to return in the SPLITVEC record.
* Now make the final decisions about where each tuple will go, and
* build the vectors to return in the SPLITVEC record.
*
* The cost_vector array contains (descriptions of) all the
* tuples, in the order that we want to consider them, so we
* we just iterate through it and place each tuple in left
* or right nodes, according to the criteria described below.
* The cost_vector array contains (descriptions of) all the tuples, in
* the order that we want to consider them, so we we just iterate
* through it and place each tuple in left or right nodes, according
* to the criteria described below.
*/
left = v->spl_left;
@ -965,9 +964,9 @@ rtpicksplit(Relation r,
right = v->spl_right;
v->spl_nright = 0;
/* Place the seeds first.
* left avail space, left union, right avail space, and right
* union have already been adjusted for the seeds.
/*
* Place the seeds first. left avail space, left union, right avail
* space, and right union have already been adjusted for the seeds.
*/
*left++ = seed_1;
@ -983,8 +982,8 @@ rtpicksplit(Relation r,
choose_left;
/*
* We need to figure out which page needs the least
* enlargement in order to store the item.
* We need to figure out which page needs the least enlargement in
* order to store the item.
*/
i = cost_vector[n].offset_number;
@ -1019,22 +1018,22 @@ rtpicksplit(Relation r,
* the new item.)
*
* Guttman's algorithm actually has two factors to consider (in
* order): 1. if one node has so many tuples already assigned to
* order): 1. if one node has so many tuples already assigned to
* it that the other needs all the rest in order to satisfy the
* condition that neither node has fewer than m tuples, then
* that is decisive; 2. otherwise, choose the page that shows
* the smaller enlargement of its union area.
* condition that neither node has fewer than m tuples, then that
* is decisive; 2. otherwise, choose the page that shows the
* smaller enlargement of its union area.
*
* I have chosen m = M/2, where M is the maximum number of
* tuples on a page. (Actually, this is only strictly
* true for fixed size tuples. For variable size tuples,
* there still might have to be only one tuple on a page,
* if it is really big. But even with variable size
* tuples we still try to get m as close as possible to M/2.)
* I have chosen m = M/2, where M is the maximum number of tuples on
* a page. (Actually, this is only strictly true for fixed size
* tuples. For variable size tuples, there still might have to be
* only one tuple on a page, if it is really big. But even with
* variable size tuples we still try to get m as close as possible
* to M/2.)
*
* The question of which page shows the smaller enlargement of
* its union area has already been answered, and the answer
* stored in the choose_left field of the SPLITCOST record.
* The question of which page shows the smaller enlargement of its
* union area has already been answered, and the answer stored in
* the choose_left field of the SPLITCOST record.
*/
left_feasible = (left_avail_space >= item_1_sz &&
((left_avail_space - item_1_sz) >= newitemsz ||
@ -1045,10 +1044,10 @@ rtpicksplit(Relation r,
if (left_feasible && right_feasible)
{
/*
* Both feasible, use Guttman's algorithm.
* First check the m condition described above, and if
* that doesn't apply, choose the page with the smaller
* enlargement of its union area.
* Both feasible, use Guttman's algorithm. First check the m
* condition described above, and if that doesn't apply,
* choose the page with the smaller enlargement of its union
* area.
*/
if (v->spl_nleft > max_after_split)
choose_left = false;
@ -1064,7 +1063,7 @@ rtpicksplit(Relation r,
else
{
elog(ERROR, "rtpicksplit: failed to find a workable page split");
choose_left = false;/* keep compiler quiet */
choose_left = false; /* keep compiler quiet */
}
if (choose_left)
@ -1090,9 +1089,7 @@ rtpicksplit(Relation r,
}
if (num_tuples_without_seeds > 0)
{
pfree(cost_vector);
}
*left = *right = InvalidOffsetNumber; /* add ending sentinels */
@ -1189,7 +1186,7 @@ rtbulkdelete(PG_FUNCTION_ARGS)
IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1);
void *callback_state = (void *) PG_GETARG_POINTER(2);
IndexBulkDeleteResult *result;
BlockNumber num_pages;
BlockNumber num_pages;
double tuples_removed;
double num_index_tuples;
RetrieveIndexResult res;
@ -1200,7 +1197,7 @@ rtbulkdelete(PG_FUNCTION_ARGS)
/*
* Since rtree is not marked "amconcurrent" in pg_am, caller should
* have acquired exclusive lock on index relation. We need no locking
* have acquired exclusive lock on index relation. We need no locking
* here.
*/
@ -1279,9 +1276,10 @@ initRtstate(RTSTATE *rtstate, Relation index)
static int
qsort_comp_splitcost(const void *a, const void *b)
{
float diff =
((SPLITCOST *)a)->cost_differential -
((SPLITCOST *)b)->cost_differential;
float diff =
((SPLITCOST *) a)->cost_differential -
((SPLITCOST *) b)->cost_differential;
if (diff < 0)
return 1;
else if (diff > 0)
@ -1342,7 +1340,6 @@ _rtdump(Relation r)
ReleaseBuffer(buf);
}
}
#endif /* defined RTDEBUG */
void

Some files were not shown because too many files have changed in this diff Show More