diff options
Diffstat (limited to 'contrib')
70 files changed, 5560 insertions, 4622 deletions
diff --git a/contrib/array/array_iterator.h b/contrib/array/array_iterator.h index 68da385c9a..7889fdc0b2 100644 --- a/contrib/array/array_iterator.h +++ b/contrib/array/array_iterator.h @@ -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 /* diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c index 999d199ff2..4235c0a5d9 100644 --- a/contrib/btree_gist/btree_gist.c +++ b/contrib/btree_gist/btree_gist.c @@ -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); + entry->offset, sizeof(INT4KEY), FALSE); - } else { - retval = entry; } - 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; - - 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); + 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); } Datum gint4_union(PG_FUNCTION_ARGS) { - 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); - - 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; - } + 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); + + 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; + } - 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 ); - - PG_RETURN_POINTER( result ); + 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); + + 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 ); - - b1->lower = ( b1->lower > b2->lower ) ? - b2->lower : b1->lower; - b1->upper = ( b1->upper > b2->upper ) ? - b1->upper : b2->upper; - } + 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); + + 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); - - 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); + 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); + + 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)); - - 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; - - 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; - } + 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); + + 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; + } - 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); - - 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); + 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); } -static void +static void gts_binary_union(Datum *r1, char *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 ); - - b1->lower = ( TSGT( &b1->lower, &b2->lower) ) ? - b2->lower : b1->lower; - b1->upper = ( TSGT( &b1->upper, &b2->upper) ) ? - b1->upper : b2->upper; - } + 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); + + 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; - - 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); - - return( v ); + 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); + + 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 ); + + 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 ); +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); } Datum -tskey_in(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) { +tskey_out(PG_FUNCTION_ARGS) +{ elog(ERROR, "Not implemented"); - PG_RETURN_POINTER( NULL ); + PG_RETURN_POINTER(NULL); } diff --git a/contrib/chkpass/chkpass.c b/contrib/chkpass/chkpass.c index 2c5974162b..c7c3197c92 100644 --- a/contrib/chkpass/chkpass.c +++ b/contrib/chkpass/chkpass.c @@ -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); } - diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c index 72f6e5a069..c97e86d3b4 100644 --- a/contrib/cube/cube.c +++ b/contrib/cube/cube.c @@ -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 diff --git a/contrib/dbase/dbf.c b/contrib/dbase/dbf.c index 9ed0c475d1..053e9adffb 100644 --- a/contrib/dbase/dbf.c +++ b/contrib/dbase/dbf.c @@ -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 :) */ - - 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; + /* + * 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; } - 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; + return (dbhead *) DBF_ERROR; } - } else { - if ((dbh->db_fd = open(name, flags)) == -1) { + } + else + { + if ((dbh->db_fd = open(name, flags)) == -1) + { free(dbh); - return (dbhead *)DBF_ERROR; + 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); - - 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; - - 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'; - } + read(dbh->db_fd, data, dbh->db_rlen); + + 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; + + 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]; - -/* offset: offset in file for this record +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 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 (strlen(foo) > rec[t].db_flen) { - length = rec[t].db_flen; - } else { - length = strlen(foo); + 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); } - 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; } diff --git a/contrib/dbase/dbf.h b/contrib/dbase/dbf.h index a6e92517ea..b54093bace 100644 --- a/contrib/dbase/dbf.h +++ b/contrib/dbase/dbf.h @@ -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 */ diff --git a/contrib/dbase/dbf2pg.c b/contrib/dbase/dbf2pg.c index 839bb7211f..e2393de542 100644 --- a/contrib/dbase/dbf2pg.c +++ b/contrib/dbase/dbf2pg.c @@ -22,146 +22,178 @@ #include "libpq-fe.h" #include "dbf.h" -int verbose = 0, upper = 0, lower = 0, create = 0, fieldlow = 0; -int del = 0; -unsigned int begin = 0, end = 0; +int verbose = 0, + upper = 0, + lower = 0, + create = 0, + fieldlow = 0; +int del = 0; +unsigned int begin = 0, + end = 0; unsigned int t_block = 0; #ifdef HAVE_ICONV_H -char *charset_from=NULL; -char *charset_to="ISO-8859-1"; -iconv_t iconv_d; -char convert_charset_buff[8192]; +char *charset_from = NULL; +char *charset_to = "ISO-8859-1"; +iconv_t iconv_d; +char convert_charset_buff[8192]; #endif -char *host = NULL; -char *dbase = "test"; -char *table = "test"; -char *username = NULL; -char *password = NULL; -char *subarg = NULL; -char escape_buff[8192]; +char *host = NULL; +char *dbase = "test"; +char *table = "test"; +char *username = NULL; +char *password = NULL; +char *subarg = NULL; +char escape_buff[8192]; -void do_substitute(char *subarg, dbhead *dbh); +void do_substitute(char *subarg, dbhead * dbh); inline void strtoupper(char *string); inline void strtolower(char *string); -void do_create(PGconn *, char*, dbhead*); -void do_inserts(PGconn *, char*, dbhead*); -int check_table(PGconn *, char*); +void do_create(PGconn *, char *, dbhead *); +void do_inserts(PGconn *, char *, dbhead *); +int check_table(PGconn *, char *); + +char *Escape(char *); -char *Escape(char*); #ifdef HAVE_ICONV_H -char *convert_charset(char *string); +char *convert_charset(char *string); #endif -void usage(void); +void usage(void); unsigned int isinteger(char *); -char *simple_prompt(const char *prompt, int maxlen, bool echo); +char *simple_prompt(const char *prompt, int maxlen, bool echo); -unsigned int isinteger(char *buff) { - char *i=buff; +unsigned int +isinteger(char *buff) +{ + char *i = buff; - while (*i != '\0') { - if (i==buff) + while (*i != '\0') + { + if (i == buff) if ((*i == '-') || - (*i == '+')) { - i++; continue; + (*i == '+')) + { + i++; + continue; } - if (!isdigit((int)*i)) return 0; + if (!isdigit((int) *i)) + return 0; i++; } return 1; } -inline void strtoupper(char *string) { - while(*string != '\0') { +inline void +strtoupper(char *string) +{ + while (*string != '\0') + { *string = toupper(*string); string++; } } -inline void strtolower(char *string) { - while(*string != '\0') { +inline void +strtolower(char *string) +{ + while (*string != '\0') + { *string = tolower(*string); string++; } } /* FIXME: should this check for overflow? */ -char *Escape(char *string) { - char *foo, *bar; - - foo = escape_buff; - - bar = string; - while (*bar != '\0') { - if ((*bar == '\t') || - (*bar == '\n') || - (*bar == '\\')) { - *foo++ = '\\'; - } - *foo++ = *bar++; - } - *foo = '\0'; - - return escape_buff; -} +char * +Escape(char *string) +{ + char *foo, + *bar; -#ifdef HAVE_ICONV_H -char *convert_charset(char *string) { - size_t in_size, out_size, nconv; - char *in_ptr,*out_ptr; + foo = escape_buff; - in_size=strlen(string)+1; - out_size=sizeof(convert_charset_buff); - in_ptr=string; - out_ptr=convert_charset_buff; + bar = string; + while (*bar != '\0') + { + if ((*bar == '\t') || + (*bar == '\n') || + (*bar == '\\')) + *foo++ = '\\'; + *foo++ = *bar++; + } + *foo = '\0'; + + return escape_buff; +} - iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset state information */ - while(in_size>0) +#ifdef HAVE_ICONV_H +char * +convert_charset(char *string) +{ + size_t in_size, + out_size, + nconv; + char *in_ptr, + *out_ptr; + + in_size = strlen(string) + 1; + out_size = sizeof(convert_charset_buff); + in_ptr = string; + out_ptr = convert_charset_buff; + + iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset + * state information */ + while (in_size > 0) { nconv = iconv(iconv_d, &in_ptr, &in_size, &out_ptr, &out_size); - if(nconv == (size_t) -1) + if (nconv == (size_t) -1) { printf("WARNING: cannot convert charset of string \"%s\".\n", - string); - strcpy(convert_charset_buff,string); + string); + strcpy(convert_charset_buff, string); return convert_charset_buff; } } - *out_ptr = 0; /* terminate output string */ + *out_ptr = 0; /* terminate output string */ return convert_charset_buff; } #endif -int check_table(PGconn *conn, char *table) { - char *q = "select relname from pg_class where " - "relkind='r' and relname !~* '^pg'"; - PGresult *res; - int i = 0; +int +check_table(PGconn *conn, char *table) +{ + char *q = "select relname from pg_class where " + "relkind='r' and relname !~* '^pg'"; + PGresult *res; + int i = 0; - if (!(res = PQexec(conn, q))) { + if (!(res = PQexec(conn, q))) + { printf("%s\n", PQerrorMessage(conn)); return 0; } - for (i = 0; i < PQntuples(res); i++) { - if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) { + for (i = 0; i < PQntuples(res); i++) + { + if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) return 1; - } } return 0; } -void usage(void){ +void +usage(void) +{ printf("dbf2pg\n" -"usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n" -" [-B transaction_size] [-F charset_from [-T charset_to]]\n" -" [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n" -" [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n"); + "usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n" + " [-B transaction_size] [-F charset_from [-T charset_to]]\n" + " [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n" + " [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n"); } /* patch submitted by Jeffrey Y. Sue <jysue@aloha.net> */ @@ -169,66 +201,80 @@ void usage(void){ /* Mainly for avoiding conflicts between fieldnames and SQL-reserved */ /* keywords */ -void do_substitute(char *subarg, dbhead *dbh) +void +do_substitute(char *subarg, dbhead * dbh) { - /* NOTE: subarg is modified in this function */ - int i,bad; - char *p,*oldname,*newname; - if (!subarg) { - return; - } - if (verbose>1) { - printf("Substituting new field names\n"); - } - /* use strstr instead of strtok because of possible empty tokens */ - oldname = subarg; - while (oldname && strlen(oldname) && (p=strstr(oldname,"=")) ) { - *p = '\0'; /* mark end of oldname */ - newname = ++p; /* point past \0 of oldname */ - if (strlen(newname)) { /* if not an empty string */ - p = strstr(newname,","); - if (p) { - *p = '\0'; /* mark end of newname */ - p++; /* point past where the comma was */ - } - } - if (strlen(newname)>=DBF_NAMELEN) { - printf("Truncating new field name %s to %d chars\n", - newname,DBF_NAMELEN-1); - newname[DBF_NAMELEN-1] = '\0'; - } - bad = 1; - for (i=0;i<dbh->db_nfields;i++) { - if (strcmp(dbh->db_fields[i].db_name,oldname)==0) { - bad = 0; - strcpy(dbh->db_fields[i].db_name,newname); - if (verbose>1) { - printf("Substitute old:%s new:%s\n", - oldname,newname); - } - break; - } - } - if (bad) { - printf("Warning: old field name %s not found\n", - oldname); - } - oldname = p; - } -} /* do_substitute */ - -void do_create(PGconn *conn, char *table, dbhead *dbh) { - char *query; - char t[20]; - int i, length; - PGresult *res; - - if (verbose > 1) { - printf("Building CREATE-clause\n"); + /* NOTE: subarg is modified in this function */ + int i, + bad; + char *p, + *oldname, + *newname; + + if (!subarg) + return; + if (verbose > 1) + printf("Substituting new field names\n"); + /* use strstr instead of strtok because of possible empty tokens */ + oldname = subarg; + while (oldname && strlen(oldname) && (p = strstr(oldname, "="))) + { + *p = '\0'; /* mark end of oldname */ + newname = ++p; /* point past \0 of oldname */ + if (strlen(newname)) + { /* if not an empty string */ + p = strstr(newname, ","); + if (p) + { + *p = '\0'; /* mark end of newname */ + p++; /* point past where the comma was */ + } + } + if (strlen(newname) >= DBF_NAMELEN) + { + printf("Truncating new field name %s to %d chars\n", + newname, DBF_NAMELEN - 1); + newname[DBF_NAMELEN - 1] = '\0'; + } + bad = 1; + for (i = 0; i < dbh->db_nfields; i++) + { + if (strcmp(dbh->db_fields[i].db_name, oldname) == 0) + { + bad = 0; + strcpy(dbh->db_fields[i].db_name, newname); + if (verbose > 1) + { + printf("Substitute old:%s new:%s\n", + oldname, newname); + } + break; + } + } + if (bad) + { + printf("Warning: old field name %s not found\n", + oldname); + } + oldname = p; } +} /* do_substitute */ - if (!(query = (char *)malloc( - (dbh->db_nfields * 40) + 29 + strlen(table)))) { +void +do_create(PGconn *conn, char *table, dbhead * dbh) +{ + char *query; + char t[20]; + int i, + length; + PGresult *res; + + if (verbose > 1) + printf("Building CREATE-clause\n"); + + if (!(query = (char *) malloc( + (dbh->db_nfields * 40) + 29 + strlen(table)))) + { fprintf(stderr, "Memory allocation error in function do_create\n"); PQfinish(conn); close(dbh->db_fd); @@ -238,61 +284,65 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) { sprintf(query, "CREATE TABLE %s (", table); length = strlen(query); - for ( i = 0; i < dbh->db_nfields; i++) { - if (!strlen(dbh->db_fields[i].db_name)) { - continue; - /* skip field if length of name == 0 */ - } - if ((strlen(query) != length)) { - strcat(query, ","); - } - - if (fieldlow) - strtolower(dbh->db_fields[i].db_name); - - strcat(query, dbh->db_fields[i].db_name); - switch(dbh->db_fields[i].db_type) { - case 'D': - strcat(query, " date"); - break; - case 'C': - if (dbh->db_fields[i].db_flen > 1) { - strcat(query, " varchar"); - sprintf(t, "(%d)", - dbh->db_fields[i].db_flen); - strcat(query, t); - } else { - strcat(query, " char"); - } - break; - case 'N': - if (dbh->db_fields[i].db_dec != 0) { - strcat(query, " real"); - } else { - strcat(query, " int"); - } - break; - case 'L': - strcat(query, " char"); - break; - } + for (i = 0; i < dbh->db_nfields; i++) + { + if (!strlen(dbh->db_fields[i].db_name)) + { + continue; + /* skip field if length of name == 0 */ + } + if ((strlen(query) != length)) + strcat(query, ","); + + if (fieldlow) + strtolower(dbh->db_fields[i].db_name); + + strcat(query, dbh->db_fields[i].db_name); + switch (dbh->db_fields[i].db_type) + { + case 'D': + strcat(query, " date"); + break; + case 'C': + if (dbh->db_fields[i].db_flen > 1) + { + strcat(query, " varchar"); + sprintf(t, "(%d)", + dbh->db_fields[i].db_flen); + strcat(query, t); + } + else + strcat(query, " char"); + break; + case 'N': + if (dbh->db_fields[i].db_dec != 0) + strcat(query, " real"); + else + strcat(query, " int"); + break; + case 'L': + strcat(query, " char"); + break; + } } strcat(query, ")"); - if (verbose > 1) { + if (verbose > 1) + { printf("Sending create-clause\n"); printf("%s\n", query); } - if ((res = PQexec(conn, query)) == NULL) { + if ((res = PQexec(conn, query)) == NULL) + { fprintf(stderr, "Error creating table!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); - close(dbh->db_fd); - free(dbh); - free(query); - PQfinish(conn); - exit(1); + close(dbh->db_fd); + free(dbh); + free(query); + PQfinish(conn); + exit(1); } PQclear(res); @@ -300,148 +350,179 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) { } /* FIXME: can be optimized to not use strcat, but it is worth the effort? */ -void do_inserts(PGconn *conn, char *table, dbhead *dbh) { - PGresult *res; - field *fields; - int i, h, result; - char *query, *foo; +void +do_inserts(PGconn *conn, char *table, dbhead * dbh) +{ + PGresult *res; + field *fields; + int i, + h, + result; + char *query, + *foo; char pgdate[10]; - if (verbose > 1) { + if (verbose > 1) printf("Inserting records\n"); - } - h = 2; /* 2 because of terminating \n\0 */ + h = 2; /* 2 because of terminating \n\0 */ - for ( i = 0 ; i < dbh->db_nfields ; i++ ) { + for (i = 0; i < dbh->db_nfields; i++) + { h += dbh->db_fields[i].db_flen > 2 ? - dbh->db_fields[i].db_flen : - 2; /* account for possible NULL values (\N) */ - h += 1; /* the delimiter */ + dbh->db_fields[i].db_flen : + 2; /* account for possible NULL values (\N) */ + h += 1; /* the delimiter */ } - /* make sure we can build the COPY query, note that we don't need to just - add this value, since the COPY query is a separate query (see below) */ - if (h < 17+strlen(table)) h = 17+strlen(table); + /* + * make sure we can build the COPY query, note that we don't need to + * just add this value, since the COPY query is a separate query (see + * below) + */ + if (h < 17 + strlen(table)) + h = 17 + strlen(table); - if (!(query = (char *)malloc(h))) { + if (!(query = (char *) malloc(h))) + { PQfinish(conn); fprintf(stderr, - "Memory allocation error in function do_inserts (query)\n"); + "Memory allocation error in function do_inserts (query)\n"); close(dbh->db_fd); free(dbh); exit(1); } - if ((fields = dbf_build_record(dbh)) == (field *)DBF_ERROR) { - fprintf(stderr, - "Couldn't allocate memory for record in do_insert\n"); + if ((fields = dbf_build_record(dbh)) == (field *) DBF_ERROR) + { + fprintf(stderr, + "Couldn't allocate memory for record in do_insert\n"); PQfinish(conn); - free(query); - dbf_close(dbh); - exit(1); - } - - if (end == 0) /* "end" is a user option, if not specified, */ - end = dbh->db_records; /* then all records are processed. */ - - if (t_block == 0) /* user not specified transaction block size */ - t_block = end-begin; /* then we set it to be the full data */ - - for (i = begin; i < end; i++) { + free(query); + dbf_close(dbh); + exit(1); + } + + if (end == 0) /* "end" is a user option, if not + * specified, */ + end = dbh->db_records; /* then all records are processed. */ + + if (t_block == 0) /* user not specified transaction block + * size */ + t_block = end - begin; /* then we set it to be the full data */ + + for (i = begin; i < end; i++) + { /* we need to start a new transaction and COPY statement */ - if (((i-begin) % t_block) == 0) { + if (((i - begin) % t_block) == 0) + { if (verbose > 1) fprintf(stderr, "Transaction: START\n"); res = PQexec(conn, "BEGIN"); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error starting transaction!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); - exit(1); + exit(1); } sprintf(query, "COPY %s FROM stdin", table); res = PQexec(conn, query); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error starting COPY!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); - exit(1); + exit(1); } } /* build line and submit */ - result = dbf_get_record(dbh, fields, i); - if (result == DBF_VALID) { + result = dbf_get_record(dbh, fields, i); + if (result == DBF_VALID) + { query[0] = '\0'; - for (h = 0; h < dbh->db_nfields; h++) { - if (!strlen(fields[h].db_name)) { + for (h = 0; h < dbh->db_nfields; h++) + { + if (!strlen(fields[h].db_name)) continue; - } - if (h!=0) /* not for the first field! */ - strcat(query, "\t"); /* COPY statement field separator */ + if (h != 0) /* not for the first field! */ + strcat(query, "\t"); /* COPY statement field + * separator */ - if (upper) { - strtoupper(fields[h].db_contents); - } - if (lower) { + if (upper) + strtoupper(fields[h].db_contents); + if (lower) strtolower(fields[h].db_contents); - } foo = fields[h].db_contents; #ifdef HAVE_ICONV_H - if(charset_from) + if (charset_from) foo = convert_charset(foo); #endif foo = Escape(foo); /* handle the date first - liuk */ - if(fields[h].db_type=='D') { - if((strlen(foo)==8) && isinteger(foo)) { - sprintf(pgdate,"%c%c%c%c-%c%c-%c%c", - foo[0],foo[1],foo[2],foo[3], - foo[4],foo[5],foo[6],foo[7]); - strcat(query,pgdate); - } else { - /* empty field must be inserted as NULL value in this - way */ - strcat(query,"\\N"); + if (fields[h].db_type == 'D') + { + if ((strlen(foo) == 8) && isinteger(foo)) + { + sprintf(pgdate, "%c%c%c%c-%c%c-%c%c", + foo[0], foo[1], foo[2], foo[3], + foo[4], foo[5], foo[6], foo[7]); + strcat(query, pgdate); + } + else + { + /* + * empty field must be inserted as NULL value in + * this way + */ + strcat(query, "\\N"); } } else if ((fields[h].db_type == 'N') && - (fields[h].db_dec == 0)){ - if (isinteger(foo)) { + (fields[h].db_dec == 0)) + { + if (isinteger(foo)) strcat(query, foo); - } else { + else + { strcat(query, "\\N"); if (verbose) fprintf(stderr, "Illegal numeric value found " - "in record %d, field \"%s\"\n", - i, fields[h].db_name); + "in record %d, field \"%s\"\n", + i, fields[h].db_name); } - } else { + } + else + { strcat(query, foo); /* must be character */ } } strcat(query, "\n"); - if ((verbose > 1) && (( i % 100) == 0)) {/* Only show every 100 */ - printf("Inserting record %d\n", i); /* records. */ + if ((verbose > 1) && ((i % 100) == 0)) + { /* Only show every 100 */ + printf("Inserting record %d\n", i); /* records. */ } PQputline(conn, query); } /* we need to end this copy and transaction */ - if (((i-begin) % t_block) == t_block-1) { + if (((i - begin) % t_block) == t_block - 1) + { if (verbose > 1) fprintf(stderr, "Transaction: END\n"); PQputline(conn, "\\.\n"); - if (PQendcopy(conn) != 0) { + if (PQendcopy(conn) != 0) + { fprintf(stderr, "Something went wrong while copying. Check " - "your tables!\n"); + "your tables!\n"); exit(1); } res = PQexec(conn, "END"); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error committing work!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); exit(1); @@ -451,17 +532,20 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) { /* last row copied in, end copy and transaction */ /* remember, i is now 1 greater then when we left the loop */ - if (((i-begin) % t_block) != 0) { + if (((i - begin) % t_block) != 0) + { if (verbose > 1) fprintf(stderr, "Transaction: END\n"); PQputline(conn, "\\.\n"); - if (PQendcopy(conn) != 0) { + if (PQendcopy(conn) != 0) + { fprintf(stderr, "Something went wrong while copying. Check " - "your tables!\n"); + "your tables!\n"); } res = PQexec(conn, "END"); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error committing work!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); exit(1); @@ -492,7 +576,9 @@ simple_prompt(const char *prompt, int maxlen, bool echo) { int length; char *destination; - FILE *termin, *termout; + FILE *termin, + *termout; + #ifdef HAVE_TERMIOS_H struct termios t_orig, t; @@ -505,8 +591,8 @@ simple_prompt(const char *prompt, int maxlen, bool echo) prompt_state = true; /* disable SIGINT */ /* - * Do not try to collapse these into one "w+" mode file. - * Doesn't work on some platforms (eg, HPUX 10.20). + * Do not try to collapse these into one "w+" mode file. Doesn't work + * on some platforms (eg, HPUX 10.20). */ termin = fopen("/dev/tty", "r"); termout = fopen("/dev/tty", "w"); @@ -529,7 +615,7 @@ simple_prompt(const char *prompt, int maxlen, bool echo) tcsetattr(fileno(termin), TCSAFLUSH, &t); } #endif - + if (prompt) { fputs(gettext(prompt), termout); @@ -579,19 +665,23 @@ simple_prompt(const char *prompt, int maxlen, bool echo) } -int main(int argc, char **argv) +int +main(int argc, char **argv) { - PGconn *conn; + PGconn *conn; int i; - extern int optind; - extern char *optarg; - char *query; - dbhead *dbh; + extern int optind; + extern char *optarg; + char *query; + dbhead *dbh; - while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) { - switch (i) { + while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) + { + switch (i) + { case 'D': - if (create) { + if (create) + { usage(); printf("Can't use -c and -D at the same time!\n"); exit(1); @@ -599,32 +689,34 @@ int main(int argc, char **argv) del = 1; break; case 'W': - password=simple_prompt("Password: ",100,0); + password = simple_prompt("Password: ", 100, 0); break; case 'f': - fieldlow=1; + fieldlow = 1; break; case 'v': verbose++; break; case 'c': - if (del) { + if (del) + { usage(); printf("Can't use -c and -D at the same time!\n"); exit(1); } - create=1; + create = 1; break; case 'l': - lower=1; + lower = 1; break; case 'u': - if (lower) { + if (lower) + { usage(); printf("Can't use -u and -l at the same time!\n"); exit(1); } - upper=1; + upper = 1; break; case 'b': begin = atoi(optarg); @@ -633,28 +725,28 @@ int main(int argc, char **argv) end = atoi(optarg); break; case 'h': - host = (char *)strdup(optarg); + host = (char *) strdup(optarg); break; case 'd': - dbase = (char *)strdup(optarg); + dbase = (char *) strdup(optarg); break; case 't': - table = (char *)strdup(optarg); - break; + table = (char *) strdup(optarg); + break; case 's': - subarg = (char *)strdup(optarg); + subarg = (char *) strdup(optarg); break; case 'B': t_block = atoi(optarg); break; case 'U': - username = (char *)strdup(optarg); + username = (char *) strdup(optarg); break; case 'F': - charset_from = (char *)strdup(optarg); + charset_from = (char *) strdup(optarg); break; case 'T': - charset_to = (char *)strdup(optarg); + charset_to = (char *) strdup(optarg); break; case ':': usage(); @@ -663,7 +755,11 @@ int main(int argc, char **argv) break; case '?': usage(); - /* FIXME: Ivan thinks this is bad: printf("unknown argument: %s\n", argv[0]); */ + + /* + * FIXME: Ivan thinks this is bad: printf("unknown + * argument: %s\n", argv[0]); + */ exit(1); break; default: @@ -674,80 +770,83 @@ int main(int argc, char **argv) argc -= optind; argv = &argv[optind]; - if (argc != 1) { + if (argc != 1) + { usage(); - if(username) + if (username) free(username); - if(password) + if (password) free(password); exit(1); } #ifdef HAVE_ICONV_H - if(charset_from) + if (charset_from) { - if(verbose>1) + if (verbose > 1) printf("Setting conversion from charset \"%s\" to \"%s\".\n", - charset_from,charset_to); - iconv_d = iconv_open(charset_to,charset_from); - if(iconv_d == (iconv_t) -1) + charset_from, charset_to); + iconv_d = iconv_open(charset_to, charset_from); + if (iconv_d == (iconv_t) - 1) { printf("Cannot convert from charset \"%s\" to charset \"%s\".\n", - charset_from,charset_to); + charset_from, charset_to); exit(1); } } #endif - if (verbose > 1) { + if (verbose > 1) printf("Opening dbf-file\n"); - } - if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *)-1) { + if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *) - 1) + { fprintf(stderr, "Couldn't open xbase-file %s\n", argv[0]); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } if (fieldlow) - for ( i = 0 ; i < dbh->db_nfields ; i++ ) - strtolower(dbh->db_fields[i].db_name); + for (i = 0; i < dbh->db_nfields; i++) + strtolower(dbh->db_fields[i].db_name); - if (verbose) { + if (verbose) + { printf("dbf-file: %s, PG-dbase: %s, PG-table: %s\n", argv[0], - dbase, - table); + dbase, + table); printf("Number of records: %ld\n", dbh->db_records); printf("NAME:\t\tLENGTH:\t\tTYPE:\n"); printf("-------------------------------------\n"); - for (i = 0; i < dbh->db_nfields ; i++) { - printf("%-12s\t%7d\t\t%5c\n",dbh->db_fields[i].db_name, - dbh->db_fields[i].db_flen, - dbh->db_fields[i].db_type); + for (i = 0; i < dbh->db_nfields; i++) + { + printf("%-12s\t%7d\t\t%5c\n", dbh->db_fields[i].db_name, + dbh->db_fields[i].db_flen, + dbh->db_fields[i].db_type); } } - if (verbose > 1) { + if (verbose > 1) printf("Making connection to PG-server\n"); - } - conn = PQsetdbLogin(host,NULL,NULL,NULL, dbase, username, password); - if (PQstatus(conn) != CONNECTION_OK) { + conn = PQsetdbLogin(host, NULL, NULL, NULL, dbase, username, password); + if (PQstatus(conn) != CONNECTION_OK) + { fprintf(stderr, "Couldn't get a connection with the "); fprintf(stderr, "designated host!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); close(dbh->db_fd); free(dbh); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } @@ -756,55 +855,60 @@ int main(int argc, char **argv) do_substitute(subarg, dbh); /* create table if specified, else check if target table exists */ - if (!create) { - if (!check_table(conn, table)) { + if (!create) + { + if (!check_table(conn, table)) + { printf("Table does not exist!\n"); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } - if (del) { - if (!(query = (char *)malloc(13 + strlen(table)))) { + if (del) + { + if (!(query = (char *) malloc(13 + strlen(table)))) + { printf("Memory-allocation error in main (delete)!\n"); close(dbh->db_fd); free(dbh); PQfinish(conn); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } - if (verbose > 1) { + if (verbose > 1) printf("Deleting from original table\n"); - } sprintf(query, "DELETE FROM %s", table); PQexec(conn, query); free(query); } - } else { - if (!(query = (char *)malloc(12 + strlen(table)))) { + } + else + { + if (!(query = (char *) malloc(12 + strlen(table)))) + { printf("Memory-allocation error in main (drop)!\n"); close(dbh->db_fd); free(dbh); PQfinish(conn); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } - if (verbose > 1) { + if (verbose > 1) printf("Dropping original table (if one exists)\n"); - } sprintf(query, "DROP TABLE %s", table); PQexec(conn, query); free(query); @@ -819,18 +923,17 @@ int main(int argc, char **argv) PQexec(conn, "SET DATESTYLE TO 'ISO';"); do_inserts(conn, table, dbh); - if (verbose > 1) { + if (verbose > 1) printf("Closing up....\n"); - } - close(dbh->db_fd); - free(dbh); - PQfinish(conn); - if(username) + close(dbh->db_fd); + free(dbh); + PQfinish(conn); + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(0); } diff --git a/contrib/dbase/endian.c b/contrib/dbase/endian.c index 55c53d8980..5bc6a186a0 100644 --- a/contrib/dbase/endian.c +++ b/contrib/dbase/endian.c @@ -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; } diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c index e858cfd0ba..4ab1315fa7 100644 --- a/contrib/dblink/dblink.c +++ b/contrib/dblink/dblink.c @@ -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; - - if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) { + 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)) 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; - - if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) { + dblink_results *results; + int fldnum; + text *result_text; + char *result; + int nfields = 0; + int text_len = 0; + + 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); diff --git a/contrib/dblink/dblink.h b/contrib/dblink/dblink.h index 1b2a48e9fb..f4de437e3d 100644 --- a/contrib/dblink/dblink.h +++ b/contrib/dblink/dblink.h @@ -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 */ diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c index 8fd568d720..a259e4b08b 100644 --- a/contrib/fulltextindex/fti.c +++ b/contrib/fulltextindex/fti.c @@ -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); } diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.c b/contrib/fuzzystrmatch/fuzzystrmatch.c index d6ec0f5c30..94b9e9de77 100644 --- a/contrib/fuzzystrmatch/fuzzystrmatch.c +++ b/contrib/fuzzystrmatch/fuzzystrmatch.c @@ -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)) - - -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 */ - +#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 */ + /*-- 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. + 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 */ /* diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.h b/contrib/fuzzystrmatch/fuzzystrmatch.h index 9a9be1e9a0..9c53981843 100644 --- a/contrib/fuzzystrmatch/fuzzystrmatch.h +++ b/contrib/fuzzystrmatch/fuzzystrmatch.h @@ -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 */ diff --git a/contrib/lo/lo.c b/contrib/lo/lo.c index 1dcdc35850..431756e9a7 100644 --- a/contrib/lo/lo.c +++ b/contrib/lo/lo.c @@ -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)) diff --git a/contrib/mSQL-interface/mpgsql.c b/contrib/mSQL-interface/mpgsql.c index 5b35fe1638..8b59485471 100644 --- a/contrib/mSQL-interface/mpgsql.c +++ b/contrib/mSQL-interface/mpgsql.c @@ -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) diff --git a/contrib/miscutil/misc_utils.h b/contrib/miscutil/misc_utils.h index f4577f49de..0fb07012df 100644 --- a/contrib/miscutil/misc_utils.h +++ b/contrib/miscutil/misc_utils.h @@ -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 diff --git a/contrib/pg_controldata/pg_controldata.c b/contrib/pg_controldata/pg_controldata.c index bf7209cb29..1cbd352caf 100644 --- a/contrib/pg_controldata/pg_controldata.c +++ b/contrib/pg_controldata/pg_controldata.c @@ -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"; diff --git a/contrib/pg_dumplo/lo_export.c b/contrib/pg_dumplo/lo_export.c index ef62549791..adb216fee2 100644 --- a/contrib/pg_dumplo/lo_export.c +++ b/contrib/pg_dumplo/lo_export.c @@ -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", diff --git a/contrib/pg_dumplo/lo_import.c b/contrib/pg_dumplo/lo_import.c index a75e905be1..aec2aa0cee 100644 --- a/contrib/pg_dumplo/lo_import.c +++ b/contrib/pg_dumplo/lo_import.c @@ -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", diff --git a/contrib/pg_dumplo/main.c b/contrib/pg_dumplo/main.c index 211753b605..45f5dc6312 100644 --- a/contrib/pg_dumplo/main.c +++ b/contrib/pg_dumplo/main.c @@ -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( diff --git a/contrib/pg_dumplo/pg_dumplo.h b/contrib/pg_dumplo/pg_dumplo.h index 3ab25495cb..1c76cfb624 100644 --- a/contrib/pg_dumplo/pg_dumplo.h +++ b/contrib/pg_dumplo/pg_dumplo.h @@ -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 */ diff --git a/contrib/pg_resetxlog/pg_resetxlog.c b/contrib/pg_resetxlog/pg_resetxlog.c index 20db41ccf4..b6981345e2 100644 --- a/contrib/pg_resetxlog/pg_resetxlog.c +++ b/contrib/pg_resetxlog/pg_resetxlog.c @@ -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 /* diff --git a/contrib/pgbench/pgbench.c b/contrib/pgbench/pgbench.c index 5fc18fe688..c8aa0c14b7 100644 --- a/contrib/pgbench/pgbench.c +++ b/contrib/pgbench/pgbench.c @@ -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; - - 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); - - if (PQerrorMessage(con)) - fprintf(stderr, "%s", PQerrorMessage(con)); - else - fprintf(stderr, "No explanation from the backend\n"); + 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); + + if (PQerrorMessage(con)) + fprintf(stderr, "%s", PQerrorMessage(con)); + else + fprintf(stderr, "No explanation from the backend\n"); - return(NULL); - } - return (con); + 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 */ diff --git a/contrib/pgcrypto/blf.c b/contrib/pgcrypto/blf.c index 28d44d9de9..aae5b6033a 100644 --- a/contrib/pgcrypto/blf.c +++ b/contrib/pgcrypto/blf.c @@ -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; diff --git a/contrib/pgcrypto/blf.h b/contrib/pgcrypto/blf.h index daf9703b77..37d4021803 100644 --- a/contrib/pgcrypto/blf.h +++ b/contrib/pgcrypto/blf.h @@ -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 diff --git a/contrib/pgcrypto/crypt-blowfish.c b/contrib/pgcrypto/crypt-blowfish.c index d60807f241..3bc8e19fa9 100644 --- a/contrib/pgcrypto/crypt-blowfish.c +++ b/contrib/pgcrypto/crypt-blowfish.c @@ -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; - - do { + unsigned char *sptr = (unsigned char *) src; + unsigned int tmp, + c1, + c2, + c3, + c4; + + 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; - - if (size < 7 + 22 + 31 + 1) { + 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) + { __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; } - diff --git a/contrib/pgcrypto/crypt-des.c b/contrib/pgcrypto/crypt-des.c index de6b1865e3..eacb192ad0 100644 --- a/contrib/pgcrypto/crypt-des.c +++ b/contrib/pgcrypto/crypt-des.c @@ -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... */ diff --git a/contrib/pgcrypto/crypt-gensalt.c b/contrib/pgcrypto/crypt-gensalt.c index 6913826842..9c017b0e4d 100644 --- a/contrib/pgcrypto/crypt-gensalt.c +++ b/contrib/pgcrypto/crypt-gensalt.c @@ -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; } - diff --git a/contrib/pgcrypto/crypt-md5.c b/contrib/pgcrypto/crypt-md5.c index 02fba69496..7b45bb2151 100644 --- a/contrib/pgcrypto/crypt-md5.c +++ b/contrib/pgcrypto/crypt-md5.c @@ -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++) { diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c index 421f5f1739..00ff81e5b7 100644 --- a/contrib/pgcrypto/internal.c +++ b/contrib/pgcrypto/internal.c @@ -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; + 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_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); + 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) +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_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) +static PX_Cipher * +bf_load(int mode) { - PX_Cipher *c; + 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; } - - diff --git a/contrib/pgcrypto/md5.c b/contrib/pgcrypto/md5.c index d022d61627..4b03f19606 100644 --- a/contrib/pgcrypto/md5.c +++ b/contrib/pgcrypto/md5.c @@ -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; diff --git a/contrib/pgcrypto/mhash.c b/contrib/pgcrypto/mhash.c index 36d70471a9..8811232c37 100644 --- a/contrib/pgcrypto/mhash.c +++ b/contrib/pgcrypto/mhash.c @@ -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; } - diff --git a/contrib/pgcrypto/misc.c b/contrib/pgcrypto/misc.c index 7a3c429708..5c803c0d5b 100644 --- a/contrib/pgcrypto/misc.c +++ b/contrib/pgcrypto/misc.c @@ -33,7 +33,7 @@ #include "px-crypt.h" char px_crypt_a64[] = - "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; /* 0000000000111111111122222222223333333333444444444455555555556666 */ /* 0123456789012345678901234567890123456789012345678901234567890123 */ diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c index 6b2ae9c98a..f9769b7e20 100644 --- a/contrib/pgcrypto/openssl.c +++ b/contrib/pgcrypto/openssl.c @@ -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; } - diff --git a/contrib/pgcrypto/pgcrypto.c b/contrib/pgcrypto/pgcrypto.c index 2bd9b21e16..a6424e61fb 100644 --- a/contrib/pgcrypto/pgcrypto.c +++ b/contrib/pgcrypto/pgcrypto.c @@ -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) { diff --git a/contrib/pgcrypto/pgcrypto.h b/contrib/pgcrypto/pgcrypto.h index 1b49c8d895..26d04c5dc4 100644 --- a/contrib/pgcrypto/pgcrypto.h +++ b/contrib/pgcrypto/pgcrypto.h @@ -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 - diff --git a/contrib/pgcrypto/px-crypt.c b/contrib/pgcrypto/px-crypt.c index 7d767279b1..c082140808 100644 --- a/contrib/pgcrypto/px-crypt.c +++ b/contrib/pgcrypto/px-crypt.c @@ -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; } - diff --git a/contrib/pgcrypto/px-crypt.h b/contrib/pgcrypto/px-crypt.h index 5edebb3d3b..7265d41491 100644 --- a/contrib/pgcrypto/px-crypt.h +++ b/contrib/pgcrypto/px-crypt.h @@ -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 */ diff --git a/contrib/pgcrypto/px-hmac.c b/contrib/pgcrypto/px-hmac.c index d635aba124..147a559238 100644 --- a/contrib/pgcrypto/px-hmac.c +++ b/contrib/pgcrypto/px-hmac.c @@ -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, diff --git a/contrib/pgcrypto/px.c b/contrib/pgcrypto/px.c index 9c18f6f250..20550bf100 100644 --- a/contrib/pgcrypto/px.c +++ b/contrib/pgcrypto/px.c @@ -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; } - diff --git a/contrib/pgcrypto/px.h b/contrib/pgcrypto/px.h index d4cffc3c06..d2a87b26e1 100644 --- a/contrib/pgcrypto/px.h +++ b/contrib/pgcrypto/px.h @@ -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); - - PX_Cipher *cipher; - uint padding; +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; }; -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 */ diff --git a/contrib/pgcrypto/random.c b/contrib/pgcrypto/random.c index 179d450ef9..559e40c456 100644 --- a/contrib/pgcrypto/random.c +++ b/contrib/pgcrypto/random.c @@ -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 */ diff --git a/contrib/pgcrypto/rijndael.c b/contrib/pgcrypto/rijndael.c index 258202fa99..cca8759e8b 100644 --- a/contrib/pgcrypto/rijndael.c +++ b/contrib/pgcrypto/rijndael.c @@ -1,40 +1,40 @@ -/* $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 */ +/* $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 */ /* 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 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 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) #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. */ - - 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; + /* 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 = 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; - - 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; + 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; + + 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); - - 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]); + 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]); } -/* 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); - - 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]); + 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]); } /* @@ -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; - - while (len >= bs) { - d[0] ^= iv[0]; d[1] ^= iv[1]; - d[2] ^= iv[2]; d[3] ^= iv[3]; - + 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]; + 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 - diff --git a/contrib/pgcrypto/rijndael.h b/contrib/pgcrypto/rijndael.h index bdefda828f..2f54e0c738 100644 --- a/contrib/pgcrypto/rijndael.h +++ b/contrib/pgcrypto/rijndael.h @@ -1,57 +1,57 @@ -/* $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 */ +/* $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 */ /* 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_ */ diff --git a/contrib/pgcrypto/sha1.c b/contrib/pgcrypto/sha1.c index 20c6230540..2609569790 100644 --- a/contrib/pgcrypto/sha1.c +++ b/contrib/pgcrypto/sha1.c @@ -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; diff --git a/contrib/pgcrypto/sha1.h b/contrib/pgcrypto/sha1.h index c83bd7191a..03c6443ccc 100644 --- a/contrib/pgcrypto/sha1.h +++ b/contrib/pgcrypto/sha1.h @@ -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_ */ diff --git a/contrib/pgstattuple/pgstattuple.c b/contrib/pgstattuple/pgstattuple.c index e88be90501..45e9229810 100644 --- a/contrib/pgstattuple/pgstattuple.c +++ b/contrib/pgstattuple/pgstattuple.c @@ -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); - - 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 % */ - - 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)) + 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; + + 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); + + 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); + } } - else + heap_endscan(scan); + heap_close(rel, NoLock); + + table_len = (double) nblocks *BLCKSZ; + + if (nblocks == 0) { - dead_tuple_len += tuple->t_len; - dead_tuple_count++; + tuple_percent = 0.0; + dead_tuple_percent = 0.0; + free_percent = 0.0; } - - if (!BlockNumberIsValid(block) || - block != BlockIdGetBlockNumber(&tuple->t_self.ip_blkid)) + else { - block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid); - buffer = ReadBuffer(rel, block); - free_space += PageGetFreeSpace((Page)BufferGetPage(buffer)); - ReleaseBuffer(buffer); + 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; } - } - 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 - { - 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; - } - elog(NOTICE,"physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%", + elog(NOTICE, "physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%", - table_len/1024/1024, /* phsical length in MB */ + table_len / 1024 / 1024, /* phsical length in MB */ - tuple_count, /* number of live tuples */ - (double)tuple_len/1024/1024, /* live tuples in MB */ - tuple_percent, /* live tuples in % */ + tuple_count, /* number of live tuples */ + (double) tuple_len / 1024 / 1024, /* live tuples in MB */ + tuple_percent, /* live tuples in % */ - dead_tuple_count, /* number of dead tuples */ - (double)dead_tuple_len/1024/1024, /* dead tuples in MB */ - dead_tuple_percent, /* dead tuples in % */ + dead_tuple_count, /* number of dead tuples */ + (double) dead_tuple_len / 1024 / 1024, /* dead tuples in MB */ + dead_tuple_percent, /* dead tuples in % */ - (double)free_space/1024/1024, /* free/available space in MB */ + (double) free_space / 1024 / 1024, /* free/available space in + * MB */ - free_percent, /* free/available space in % */ + free_percent, /* free/available space in % */ - /* overhead in % */ - (nblocks == 0)?0.0: 100.0 - - tuple_percent - - dead_tuple_percent - - free_percent); + /* 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); } diff --git a/contrib/rserv/rserv.c b/contrib/rserv/rserv.c index 02c71220d6..be4a136a1b 100644 --- a/contrib/rserv/rserv.c +++ b/contrib/rserv/rserv.c @@ -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; diff --git a/contrib/rtree_gist/rtree_gist.c b/contrib/rtree_gist/rtree_gist.c index ca6263fc9e..cbbe024c03 100644 --- a/contrib/rtree_gist/rtree_gist.c +++ b/contrib/rtree_gist/rtree_gist.c @@ -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); - - /* - ** if entry is not leaf, use gbox_internal_consistent, - ** else use gbox_leaf_consistent - */ - if ( ! (DatumGetPointer(entry->key) != NULL && query) ) + 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)) 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; - - 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); - - PG_RETURN_POINTER(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); + + 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)); - - *result = tmp1 - size_box( origentry->key ); - PG_RETURN_POINTER(result); + 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)); + + *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; - - 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; } - } - - 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++; - } + 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; } - v->spl_ldatum = BoxPGetDatum( unionL ); - v->spl_rdatum = BoxPGetDatum( unionR ); + 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; + } + } - PG_RETURN_POINTER( v ); + 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) ); + 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 ) + 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 + 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'; + } + + 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); } - 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); + 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; - - 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); + 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); } -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; - - /* - ** if entry is not leaf, use gbox_internal_consistent, - ** else use gbox_leaf_consistent - */ - if ( ! (DatumGetPointer(entry->key) != NULL && query) ) + 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)) 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; - - 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); + 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); } /* diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c index 124299ab44..097304b638 100644 --- a/contrib/seg/seg.c +++ b/contrib/seg/seg.c @@ -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 diff --git a/contrib/spi/refint.c b/contrib/spi/refint.c index dcc9f54daf..441c1e884d 100644 --- a/contrib/spi/refint.c +++ b/contrib/spi/refint.c @@ -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. diff --git a/contrib/string/string_io.c b/contrib/string/string_io.c index 840782dd51..fdc6da1915 100644 --- a/contrib/string/string_io.c +++ b/contrib/string/string_io.c @@ -359,7 +359,6 @@ c_charin(unsigned char *str) { return (string_input(str, 1, 0, NULL)); } - #endif /* end of file */ diff --git a/contrib/string/string_io.h b/contrib/string/string_io.h index 556c33660c..b6a368698a 100644 --- a/contrib/string/string_io.h +++ b/contrib/string/string_io.h @@ -13,7 +13,6 @@ struct varlena *c_textin(unsigned char *str); int32 * c_charin(unsigned char *str) #endif - #endif /* diff --git a/contrib/tsearch/crc32.c b/contrib/tsearch/crc32.c index 61cb6ed3ed..dc93db727c 100644 --- a/contrib/tsearch/crc32.c +++ b/contrib/tsearch/crc32.c @@ -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; } diff --git a/contrib/tsearch/crc32.h b/contrib/tsearch/crc32.h index c4f5ed703c..b08065d8c8 100644 --- a/contrib/tsearch/crc32.h +++ b/contrib/tsearch/crc32.h @@ -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 diff --git a/contrib/tsearch/deflex.h b/contrib/tsearch/deflex.h index 8c74595a68..7fbd84adf1 100644 --- a/contrib/tsearch/deflex.h +++ b/contrib/tsearch/deflex.h @@ -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 - diff --git a/contrib/tsearch/gistidx.h b/contrib/tsearch/gistidx.h index dc991ab0d7..f4576a1d24 100644 --- a/contrib/tsearch/gistidx.h +++ b/contrib/tsearch/gistidx.h @@ -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 - diff --git a/contrib/tsearch/morph.c b/contrib/tsearch/morph.c index a31946ac86..3a66ecbbc6 100644 --- a/contrib/tsearch/morph.c +++ b/contrib/tsearch/morph.c @@ -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; } diff --git a/contrib/tsearch/morph.h b/contrib/tsearch/morph.h index 1e8f361ed9..1c64227fae 100644 --- a/contrib/tsearch/morph.h +++ b/contrib/tsearch/morph.h @@ -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 diff --git a/contrib/tsearch/parser.h b/contrib/tsearch/parser.h index 780cb587d5..0e43e675fb 100644 --- a/contrib/tsearch/parser.h +++ b/contrib/tsearch/parser.h @@ -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 diff --git a/contrib/tsearch/query.c b/contrib/tsearch/query.c index 238432ea43..90687d38cf 100644 --- a/contrib/tsearch/query.c +++ b/contrib/tsearch/query.c @@ -31,112 +31,131 @@ #include "parser.h" PG_FUNCTION_INFO_V1(mqtxt_in); -Datum mqtxt_in(PG_FUNCTION_ARGS); +Datum mqtxt_in(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(qtxt_in); -Datum qtxt_in(PG_FUNCTION_ARGS); +Datum qtxt_in(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(qtxt_out); -Datum qtxt_out(PG_FUNCTION_ARGS); +Datum qtxt_out(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(execqtxt); -Datum execqtxt(PG_FUNCTION_ARGS); +Datum execqtxt(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(rexecqtxt); -Datum rexecqtxt(PG_FUNCTION_ARGS); +Datum rexecqtxt(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(querytree); -Datum querytree(PG_FUNCTION_ARGS); - -#define END 0 -#define ERR 1 -#define VAL 2 -#define OPR 3 -#define OPEN 4 -#define CLOSE 5 -#define VALTRUE 6 /* for stop words */ +Datum querytree(PG_FUNCTION_ARGS); + +#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 /* parser's states */ -#define WAITOPERAND 1 +#define WAITOPERAND 1 #define WAITOPERATOR 2 /* * node of query tree, also used * for storing polish notation in parser */ -typedef struct NODE { - int4 type; - int4 val; - int2 distance; - int2 length; - struct NODE *next; -} NODE; - -typedef struct { - char *buf; - int4 state; - int4 count; - /* reverse polish notation in list (for temprorary usage)*/ - NODE *str; +typedef struct NODE +{ + int4 type; + int4 val; + int2 distance; + int2 length; + struct NODE *next; +} NODE; + +typedef struct +{ + char *buf; + int4 state; + int4 count; + /* reverse polish notation in list (for temprorary usage) */ + NODE *str; /* number in str */ - int4 num; + int4 num; /* user-friendly operand */ - int4 lenop; - int4 sumlen; - char *op; - char *curop; + int4 lenop; + int4 sumlen; + char *op; + char *curop; /* state for value's parser */ - TI_IN_STATE valstate; -} QPRS_STATE; + TI_IN_STATE valstate; +} QPRS_STATE; /* * get token from query string */ -static int4 -gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) { - while(1) { - switch(state->state) { - case WAITOPERAND: - if ( *(state->buf) == '!' ) { +static int4 +gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval) +{ + while (1) + { + switch (state->state) + { + case WAITOPERAND: + if (*(state->buf) == '!') + { (state->buf)++; - *val = (int4)'!'; + *val = (int4) '!'; return OPR; - } else if ( *(state->buf) == '(' ) { + } + else if (*(state->buf) == '(') + { state->count++; (state->buf)++; return OPEN; - } else if ( *(state->buf) != ' ' ) { + } + else if (*(state->buf) != ' ') + { state->valstate.prsbuf = state->buf; state->state = WAITOPERATOR; - if ( gettoken_txtidx( &(state->valstate) ) ) { + if (gettoken_txtidx(&(state->valstate))) + { *strval = state->valstate.word; *lenval = state->valstate.curpos - state->valstate.word; state->buf = state->valstate.prsbuf; return VAL; - } else + } + else elog(ERROR, "No operand"); } break; case WAITOPERATOR: - if ( *(state->buf) == '&' || *(state->buf) == '|' ) { + if (*(state->buf) == '&' || *(state->buf) == '|') + { state->state = WAITOPERAND; *val = (int4) *(state->buf); - (state->buf)++; + (state->buf)++; return OPR; - } else if ( *(state->buf) == ')' ) { + } + else if (*(state->buf) == ')') + { (state->buf)++; state->count--; - return ( state->count <0 ) ? ERR : CLOSE; - } else if ( *(state->buf) == '\0' ) { - return ( state->count ) ? ERR : END; - } else if ( *(state->buf) != ' ' ) + return (state->count < 0) ? ERR : CLOSE; + } + else if (*(state->buf) == '\0') + return (state->count) ? ERR : END; + else if (*(state->buf) != ' ') return ERR; break; - default: + default: return ERR; break; - } - (state->buf)++; + } + (state->buf)++; } return END; } @@ -145,16 +164,18 @@ gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) { * push new one in polish notation reverse view */ static void -pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) { - NODE *tmp = (NODE*)palloc(sizeof(NODE)); - tmp->type=type; - tmp->val =val; - if ( distance>0xffff ) - elog(ERROR,"Value is too big"); - if ( lenval > 0xffff ) - elog(ERROR,"Operand is too long"); - tmp->distance=distance; - tmp->length=lenval; +pushquery(QPRS_STATE * state, int4 type, int4 val, int4 distance, int4 lenval) +{ + NODE *tmp = (NODE *) palloc(sizeof(NODE)); + + tmp->type = type; + tmp->val = val; + if (distance > 0xffff) + elog(ERROR, "Value is too big"); + if (lenval > 0xffff) + elog(ERROR, "Operand is too long"); + tmp->distance = distance; + tmp->length = lenval; tmp->next = state->str; state->str = tmp; state->num++; @@ -164,20 +185,23 @@ pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) { * This function is used for query_txt parsing */ static void -pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) { - if ( lenval>0xffff ) +pushval_asis(QPRS_STATE * state, int type, char *strval, int lenval) +{ + if (lenval > 0xffff) elog(ERROR, "Word is too long"); - pushquery(state, type, crc32_sz( (uint8*)strval, lenval ), - state->curop - state->op, lenval); + pushquery(state, type, crc32_sz((uint8 *) strval, lenval), + state->curop - state->op, lenval); + + while (state->curop - state->op + lenval + 1 >= state->lenop) + { + int4 tmp = state->curop - state->op; - while ( state->curop - state->op + lenval + 1 >= state->lenop ) { - int4 tmp = state->curop - state->op; state->lenop *= 2; - state->op = (char*)repalloc( (void*)state->op, state->lenop ); + state->op = (char *) repalloc((void *) state->op, state->lenop); state->curop = state->op + tmp; } - memcpy( (void*)state->curop, (void*)strval, lenval ); + memcpy((void *) state->curop, (void *) strval, lenval); state->curop += lenval; *(state->curop) = '\0'; state->curop++; @@ -189,28 +213,34 @@ pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) { * This function is used for mquery_txt parsing */ static void -pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) { - int4 type, lenlemm; - int4 count = 0; - char *lemm; - - start_parse_str( strval, lenval ); - while( (type=tsearch_yylex()) != 0 ) { - if ( tokenlen>0xffff ) { +pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval) +{ + int4 type, + lenlemm; + int4 count = 0; + char *lemm; + + start_parse_str(strval, lenval); + while ((type = tsearch_yylex()) != 0) + { + if (tokenlen > 0xffff) + { end_parse(); elog(ERROR, "Word is too long"); } lenlemm = tokenlen; - lemm = lemmatize( token, &lenlemm, type ); - if ( lemm ) { - pushval_asis(state,VAL,lemm,lenlemm); - if ( lemm != token ) pfree(lemm); - } else { - pushval_asis(state,VALTRUE,0,0); + lemm = lemmatize(token, &lenlemm, type); + if (lemm) + { + pushval_asis(state, VAL, lemm, lenlemm); + if (lemm != token) + pfree(lemm); } - if ( count ) - pushquery(state, OPR, (int4)'&', 0,0); - count++; + else + pushval_asis(state, VALTRUE, 0, 0); + if (count) + pushquery(state, OPR, (int4) '&', 0, 0); + count++; } end_parse(); } @@ -219,100 +249,114 @@ pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) { /* * make polish notaion of query */ -static int4 -makepol(QPRS_STATE *state, void (*pushval)(QPRS_STATE*,int,char*,int)) { - int4 val,type; - int4 lenval; - char *strval; - int4 stack[STACKDEPTH]; - int4 lenstack=0; - - while( (type=gettoken_query(state, &val, &lenval, &strval))!=END ) { - switch(type) { +static int4 +makepol(QPRS_STATE * state, void (*pushval) (QPRS_STATE *, int, char *, int)) +{ + int4 val, + type; + int4 lenval; + char *strval; + int4 stack[STACKDEPTH]; + int4 lenstack = 0; + + while ((type = gettoken_query(state, &val, &lenval, &strval)) != END) + { + switch (type) + { case VAL: - (*pushval)(state, VAL, strval, lenval); - while ( lenstack && (stack[ lenstack-1 ] == (int4)'&' || - stack[ lenstack-1 ] == (int4)'!') ) { + (*pushval) (state, VAL, strval, lenval); + while (lenstack && (stack[lenstack - 1] == (int4) '&' || + stack[lenstack - 1] == (int4) '!')) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ], 0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); } break; case OPR: - if ( lenstack && val == (int4) '|' ) { - pushquery(state, OPR, val, 0,0); - } else { - if ( lenstack == STACKDEPTH ) - elog(ERROR,"Stack too short"); - stack[ lenstack ] = val; + if (lenstack && val == (int4) '|') + pushquery(state, OPR, val, 0, 0); + else + { + if (lenstack == STACKDEPTH) + elog(ERROR, "Stack too short"); + stack[lenstack] = val; lenstack++; } break; case OPEN: - if ( makepol( state, pushval ) == ERR ) return ERR; - if ( lenstack && (stack[ lenstack-1 ] == (int4)'&' || - stack[ lenstack-1 ] == (int4)'!') ) { + if (makepol(state, pushval) == ERR) + return ERR; + if (lenstack && (stack[lenstack - 1] == (int4) '&' || + stack[lenstack - 1] == (int4) '!')) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ], 0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); } break; case CLOSE: - while ( lenstack ) { + while (lenstack) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ], 0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); }; return END; break; case ERR: default: - elog(ERROR,"Syntax error"); + elog(ERROR, "Syntax error"); return ERR; - + } } - while (lenstack) { + while (lenstack) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ],0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); }; return END; } -typedef struct { - WordEntry *arrb; - WordEntry *arre; - char *values; - char *operand; -} CHKVAL; +typedef struct +{ + WordEntry *arrb; + WordEntry *arre; + char *values; + char *operand; +} CHKVAL; /* * compare 2 string values */ static int4 -ValCompare( CHKVAL *chkval, WordEntry *ptr, ITEM *item ) { - if ( ptr->len == item->length ) +ValCompare(CHKVAL * chkval, WordEntry * ptr, ITEM * item) +{ + if (ptr->len == item->length) return strncmp( - &(chkval->values[ ptr->pos ]), - &(chkval->operand[item->distance]), - item->length ); + &(chkval->values[ptr->pos]), + &(chkval->operand[item->distance]), + item->length); - return ( ptr->len > item->length ) ? 1 : -1; -} + return (ptr->len > item->length) ? 1 : -1; +} /* * is there value 'val' in array or not ? */ static bool -checkcondition_str( void *checkval, ITEM* val ) { - WordEntry *StopLow = ((CHKVAL*)checkval)->arrb; - WordEntry *StopHigh = ((CHKVAL*)checkval)->arre; - WordEntry *StopMiddle; - int difference; - - /* Loop invariant: StopLow <= val < StopHigh */ - - while (StopLow < StopHigh) { +checkcondition_str(void *checkval, ITEM * val) +{ + WordEntry *StopLow = ((CHKVAL *) checkval)->arrb; + WordEntry *StopHigh = ((CHKVAL *) checkval)->arre; + WordEntry *StopMiddle; + int difference; + + /* Loop invariant: StopLow <= val < StopHigh */ + + while (StopLow < StopHigh) + { StopMiddle = StopLow + (StopHigh - StopLow) / 2; - difference = ValCompare((CHKVAL*)checkval, StopMiddle, val); - if (difference == 0) + difference = ValCompare((CHKVAL *) checkval, StopMiddle, val); + if (difference == 0) return (true); else if (difference < 0) StopLow = StopMiddle + 1; @@ -320,27 +364,33 @@ checkcondition_str( void *checkval, ITEM* val ) { StopHigh = StopMiddle; } - return (false); + return (false); } /* * check for boolean condition */ bool -execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *checkval, ITEM *val )) { - if ( curitem->type == VAL ) { - return (*chkcond)( checkval, curitem ); - } else if ( curitem->val == (int4)'!' ) { - return ( calcnot ) ? - ( ( execute(curitem + 1, checkval, calcnot, chkcond) ) ? false : true ) - : true; - } else if ( curitem->val == (int4)'&' ) { - if ( execute(curitem + curitem->left, checkval, calcnot, chkcond) ) +execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * val)) +{ + if (curitem->type == VAL) + return (*chkcond) (checkval, curitem); + else if (curitem->val == (int4) '!') + { + return (calcnot) ? + ((execute(curitem + 1, checkval, calcnot, chkcond)) ? false : true) + : true; + } + else if (curitem->val == (int4) '&') + { + if (execute(curitem + curitem->left, checkval, calcnot, chkcond)) return execute(curitem + 1, checkval, calcnot, chkcond); else return false; - } else { /* |-operator */ - if ( execute(curitem + curitem->left, checkval, calcnot, chkcond) ) + } + else + { /* |-operator */ + if (execute(curitem + curitem->left, checkval, calcnot, chkcond)) return true; else return execute(curitem + 1, checkval, calcnot, chkcond); @@ -349,69 +399,79 @@ execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *chec } /* - * boolean operations + * boolean operations */ Datum -rexecqtxt(PG_FUNCTION_ARGS) { +rexecqtxt(PG_FUNCTION_ARGS) +{ return DirectFunctionCall2( - execqtxt, - PG_GETARG_DATUM(1), - PG_GETARG_DATUM(0) + execqtxt, + PG_GETARG_DATUM(1), + PG_GETARG_DATUM(0) ); } Datum -execqtxt(PG_FUNCTION_ARGS) { - txtidx *val = ( txtidx * )DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - QUERYTYPE *query = ( QUERYTYPE * )DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); - CHKVAL chkval; - bool result; - - if ( ! val->size ) { - PG_FREE_IF_COPY(val,0); - PG_FREE_IF_COPY(query,1); - PG_RETURN_BOOL( false ); +execqtxt(PG_FUNCTION_ARGS) +{ + txtidx *val = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); + CHKVAL chkval; + bool result; + + if (!val->size) + { + PG_FREE_IF_COPY(val, 0); + PG_FREE_IF_COPY(query, 1); + PG_RETURN_BOOL(false); } chkval.arrb = ARRPTR(val); chkval.arre = chkval.arrb + val->size; chkval.values = STRPTR(val); - chkval.operand = GETOPERAND( query ); - result = execute( - GETQUERY(query), - &chkval, - true, - checkcondition_str - ); - - PG_FREE_IF_COPY(val,0); - PG_FREE_IF_COPY(query,1); - PG_RETURN_BOOL( result ); + chkval.operand = GETOPERAND(query); + result = execute( + GETQUERY(query), + &chkval, + true, + checkcondition_str + ); + + PG_FREE_IF_COPY(val, 0); + PG_FREE_IF_COPY(query, 1); + PG_RETURN_BOOL(result); } /* * find left operand in polish notation view */ static void -findoprnd( ITEM *ptr, int4 *pos ) { +findoprnd(ITEM * ptr, int4 *pos) +{ #ifdef BS_DEBUG - elog(NOTICE, ( ptr[*pos].type == OPR ) ? - "%d %c" : "%d %d ", *pos, ptr[*pos].val ); + elog(NOTICE, (ptr[*pos].type == OPR) ? + "%d %c" : "%d %d ", *pos, ptr[*pos].val); #endif - if ( ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE ) { + if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE) + { ptr[*pos].left = 0; (*pos)++; - } else if ( ptr[*pos].val == (int4)'!' ) { + } + else if (ptr[*pos].val == (int4) '!') + { ptr[*pos].left = 1; (*pos)++; - findoprnd( ptr, pos ); - } else { - ITEM *curitem = &ptr[*pos]; - int4 tmp = *pos; + findoprnd(ptr, pos); + } + else + { + ITEM *curitem = &ptr[*pos]; + int4 tmp = *pos; + (*pos)++; - findoprnd(ptr,pos); + findoprnd(ptr, pos); curitem->left = *pos - tmp; - findoprnd(ptr,pos); + findoprnd(ptr, pos); } } @@ -419,16 +479,20 @@ findoprnd( ITEM *ptr, int4 *pos ) { /* * input */ -static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) ) { - QPRS_STATE state; - int4 i; - QUERYTYPE *query; - int4 commonlen; - ITEM *ptr; - NODE *tmp; - int4 pos=0; +static QUERYTYPE * +queryin(char *buf, void (*pushval) (QPRS_STATE *, int, char *, int)) +{ + QPRS_STATE state; + int4 i; + QUERYTYPE *query; + int4 commonlen; + ITEM *ptr; + NODE *tmp; + int4 pos = 0; + #ifdef BS_DEBUG - char pbuf[16384],*cur; + char pbuf[16384], + *cur; #endif /* init state */ @@ -436,62 +500,64 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) state.state = WAITOPERAND; state.count = 0; state.num = 0; - state.str=NULL; + state.str = NULL; /* init value parser's state */ state.valstate.oprisdelim = true; - state.valstate.len=32; - state.valstate.word = (char*)palloc( state.valstate.len ); + state.valstate.len = 32; + state.valstate.word = (char *) palloc(state.valstate.len); /* init list of operand */ - state.sumlen=0; - state.lenop=64; - state.curop = state.op = (char*)palloc( state.lenop ); + state.sumlen = 0; + state.lenop = 64; + state.curop = state.op = (char *) palloc(state.lenop); *(state.curop) = '\0'; - + /* parse query & make polish notation (postfix, but in reverse order) */ - makepol( &state, pushval ); - pfree( state.valstate.word ); - if (!state.num) - elog( ERROR,"Empty query"); + makepol(&state, pushval); + pfree(state.valstate.word); + if (!state.num) + elog(ERROR, "Empty query"); /* make finish struct */ commonlen = COMPUTESIZE(state.num, state.sumlen); - query = (QUERYTYPE*) palloc( commonlen ); + query = (QUERYTYPE *) palloc(commonlen); query->len = commonlen; query->size = state.num; ptr = GETQUERY(query); /* set item in polish notation */ - for(i=0; i<state.num; i++ ) { - ptr[i].type = state.str->type; + for (i = 0; i < state.num; i++) + { + ptr[i].type = state.str->type; ptr[i].val = state.str->val; - ptr[i].distance = state.str->distance; + ptr[i].distance = state.str->distance; ptr[i].length = state.str->length; tmp = state.str->next; - pfree( state.str ); + pfree(state.str); state.str = tmp; } - /* set user friendly-operand view */ - memcpy( (void*)GETOPERAND(query), (void*)state.op, state.sumlen ); - pfree( state.op ); + /* set user friendly-operand view */ + memcpy((void *) GETOPERAND(query), (void *) state.op, state.sumlen); + pfree(state.op); - /* set left operand's position for every operator */ + /* set left operand's position for every operator */ pos = 0; - findoprnd( ptr, &pos ); + findoprnd(ptr, &pos); #ifdef BS_DEBUG cur = pbuf; *cur = '\0'; - for( i=0;i<query->size;i++ ) { - if ( ptr[i].type == OPR ) + for (i = 0; i < query->size; i++) + { + if (ptr[i].type == OPR) sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left); - else - sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance ); - cur = strchr(cur,'\0'); + else + sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance); + cur = strchr(cur, '\0'); } - elog(NOTICE,"POR: %s", pbuf); + elog(NOTICE, "POR: %s", pbuf); #endif return query; @@ -501,59 +567,66 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) * in without morphology */ Datum -qtxt_in(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER( queryin((char*)PG_GETARG_POINTER(0),pushval_asis) ); +qtxt_in(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(queryin((char *) PG_GETARG_POINTER(0), pushval_asis)); } /* * in with morphology */ Datum -mqtxt_in(PG_FUNCTION_ARGS) { - QUERYTYPE *query; - ITEM* res; - int4 len; -#ifdef BS_DEBUG - ITEM *ptr; - int4 i; - char pbuf[16384],*cur; +mqtxt_in(PG_FUNCTION_ARGS) +{ + QUERYTYPE *query; + ITEM *res; + int4 len; + +#ifdef BS_DEBUG + ITEM *ptr; + int4 i; + char pbuf[16384], + *cur; #endif initmorph(); - query = queryin((char*)PG_GETARG_POINTER(0),pushval_morph); - res = clean_fakeval( GETQUERY(query), &len ); - if ( ! res ) { + query = queryin((char *) PG_GETARG_POINTER(0), pushval_morph); + res = clean_fakeval(GETQUERY(query), &len); + if (!res) + { pfree(query); PG_RETURN_NULL(); } - memcpy( (void*)GETQUERY(query), (void*)res, len*sizeof(ITEM) ); + memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(ITEM)); #ifdef BS_DEBUG cur = pbuf; *cur = '\0'; ptr = GETQUERY(query); - for( i=0;i<len;i++ ) { - if ( ptr[i].type == OPR ) + for (i = 0; i < len; i++) + { + if (ptr[i].type == OPR) sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left); - else - sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance ); - cur = strchr(cur,'\0'); + else + sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance); + cur = strchr(cur, '\0'); } - elog(NOTICE,"POR: %s", pbuf); + elog(NOTICE, "POR: %s", pbuf); #endif pfree(res); - PG_RETURN_POINTER( query ); + PG_RETURN_POINTER(query); } /* * out function */ -typedef struct { - ITEM *curpol; - char *buf; - char *cur; - char *op; - int4 buflen; -} INFIX; +typedef struct +{ + ITEM *curpol; + char *buf; + char *cur; + char *op; + int4 buflen; +} INFIX; #define RESIZEBUF(inf,addsize) \ while( ( inf->cur - inf->buf ) + addsize + 1 >= inf->buflen ) \ @@ -565,98 +638,117 @@ while( ( inf->cur - inf->buf ) + addsize + 1 >= inf->buflen ) \ } /* - * recursive walk on tree and print it in + * recursive walk on tree and print it in * infix (human-readable) view */ static void -infix(INFIX *in, bool first) { - if ( in->curpol->type == VAL ) { - char *op = in->op + in->curpol->distance; - RESIZEBUF(in, in->curpol->length*2 + 2); - *(in->cur) = '\''; in->cur++; - while( *op ) { - if ( *op == '\'' ) { - *(in->cur) = '\\'; in->cur++; +infix(INFIX * in, bool first) +{ + if (in->curpol->type == VAL) + { + char *op = in->op + in->curpol->distance; + + RESIZEBUF(in, in->curpol->length * 2 + 2); + *(in->cur) = '\''; + in->cur++; + while (*op) + { + if (*op == '\'') + { + *(in->cur) = '\\'; + in->cur++; } *(in->cur) = *op; - op++; in->cur++; - } - *(in->cur) = '\''; in->cur++; + op++; + in->cur++; + } + *(in->cur) = '\''; + in->cur++; *(in->cur) = '\0'; in->curpol++; - } else if ( in->curpol->val == (int4)'!' ) { - bool isopr = false; + } + else if (in->curpol->val == (int4) '!') + { + bool isopr = false; + RESIZEBUF(in, 1); *(in->cur) = '!'; in->cur++; *(in->cur) = '\0'; in->curpol++; - if ( in->curpol->type == OPR ) { + if (in->curpol->type == OPR) + { isopr = true; RESIZEBUF(in, 2); sprintf(in->cur, "( "); - in->cur = strchr( in->cur, '\0' ); - } - infix( in, isopr ); - if ( isopr ) { + in->cur = strchr(in->cur, '\0'); + } + infix(in, isopr); + if (isopr) + { RESIZEBUF(in, 2); sprintf(in->cur, " )"); - in->cur = strchr( in->cur, '\0' ); - } - } else { - int4 op = in->curpol->val; - INFIX nrm; - + in->cur = strchr(in->cur, '\0'); + } + } + else + { + int4 op = in->curpol->val; + INFIX nrm; + in->curpol++; - if ( op == (int4)'|' && ! first) { + if (op == (int4) '|' && !first) + { RESIZEBUF(in, 2); sprintf(in->cur, "( "); - in->cur = strchr( in->cur, '\0' ); + in->cur = strchr(in->cur, '\0'); } nrm.curpol = in->curpol; nrm.op = in->op; nrm.buflen = 16; - nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); - + nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen); + /* get right operand */ - infix( &nrm, false ); - + infix(&nrm, false); + /* get & print left operand */ in->curpol = nrm.curpol; - infix( in, false ); + infix(in, false); - /* print operator & right operand*/ - RESIZEBUF(in, 3 + (nrm.cur - nrm.buf) ); + /* print operator & right operand */ + RESIZEBUF(in, 3 + (nrm.cur - nrm.buf)); sprintf(in->cur, " %c %s", op, nrm.buf); - in->cur = strchr( in->cur, '\0' ); - pfree( nrm.buf ); + in->cur = strchr(in->cur, '\0'); + pfree(nrm.buf); - if ( op == (int4)'|' && ! first) { + if (op == (int4) '|' && !first) + { RESIZEBUF(in, 2); sprintf(in->cur, " )"); - in->cur = strchr( in->cur, '\0' ); + in->cur = strchr(in->cur, '\0'); } } } Datum -qtxt_out(PG_FUNCTION_ARGS) { - QUERYTYPE *query = (QUERYTYPE*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - INFIX nrm; +qtxt_out(PG_FUNCTION_ARGS) +{ + QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + INFIX nrm; - if ( query->size == 0 ) - elog(ERROR,"Empty"); + if (query->size == 0) + elog(ERROR, "Empty"); nrm.curpol = GETQUERY(query); nrm.buflen = 32; - nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); + nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen); *(nrm.cur) = '\0'; nrm.op = GETOPERAND(query); - infix( &nrm, true ); - - PG_FREE_IF_COPY(query,0); - PG_RETURN_POINTER( nrm.buf ); + infix(&nrm, true); + + PG_FREE_IF_COPY(query, 0); + PG_RETURN_POINTER(nrm.buf); } /* @@ -664,38 +756,42 @@ qtxt_out(PG_FUNCTION_ARGS) { * which will be executed in non-leaf pages in index */ Datum -querytree(PG_FUNCTION_ARGS) { - QUERYTYPE *query = (QUERYTYPE*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - INFIX nrm; - text *res; - ITEM *q; - int4 len; +querytree(PG_FUNCTION_ARGS) +{ + QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + INFIX nrm; + text *res; + ITEM *q; + int4 len; - if ( query->size == 0 ) - elog(ERROR,"Empty"); + if (query->size == 0) + elog(ERROR, "Empty"); q = clean_NOT(GETQUERY(query), &len); - if ( ! q ) { - res = (text*) palloc( 1 + VARHDRSZ ); + if (!q) + { + res = (text *) palloc(1 + VARHDRSZ); VARATT_SIZEP(res) = 1 + VARHDRSZ; - *((char*)VARDATA(res)) = 'T'; - } else { + *((char *) VARDATA(res)) = 'T'; + } + else + { nrm.curpol = q; nrm.buflen = 32; - nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); + nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen); *(nrm.cur) = '\0'; nrm.op = GETOPERAND(query); - infix( &nrm, true ); + infix(&nrm, true); - res = (text*) palloc( nrm.cur-nrm.buf + VARHDRSZ ); - VARATT_SIZEP(res) = nrm.cur-nrm.buf + VARHDRSZ; - strncpy( VARDATA(res), nrm.buf, nrm.cur-nrm.buf ); + res = (text *) palloc(nrm.cur - nrm.buf + VARHDRSZ); + VARATT_SIZEP(res) = nrm.cur - nrm.buf + VARHDRSZ; + strncpy(VARDATA(res), nrm.buf, nrm.cur - nrm.buf); pfree(q); } - PG_FREE_IF_COPY(query,0); + PG_FREE_IF_COPY(query, 0); - PG_RETURN_POINTER( res ); + PG_RETURN_POINTER(res); } diff --git a/contrib/tsearch/query.h b/contrib/tsearch/query.h index 96117e78c8..a5f8d7deb8 100644 --- a/contrib/tsearch/query.h +++ b/contrib/tsearch/query.h @@ -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 diff --git a/contrib/tsearch/rewrite.c b/contrib/tsearch/rewrite.c index 590b15e7ca..9ad7a0a86a 100644 --- a/contrib/tsearch/rewrite.c +++ b/contrib/tsearch/rewrite.c @@ -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; + 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 ) { + } + 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; + *result = V_TRUE; return NULL; - } else if ( lresult == V_FALSE && rresult == V_FALSE ) { + } + else if (lresult == V_FALSE && rresult == V_FALSE) + { freetree(node); - *result=V_FALSE; + *result = V_FALSE; return NULL; - } else if ( lresult == V_FALSE ) { + } + else if (lresult == V_FALSE) + { res = node->right; pfree(node); - } else if ( rresult == V_FALSE ) { + } + 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 ) { + 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; + *result = V_FALSE; return NULL; - } else if ( lresult == V_TRUE && rresult == V_TRUE ) { + } + else if (lresult == V_TRUE && rresult == V_TRUE) + { freetree(node); - *result=V_TRUE; + *result = V_TRUE; return NULL; - } else if ( lresult == V_TRUE ) { + } + else if (lresult == V_TRUE) + { res = node->right; pfree(node); - } else if ( rresult == V_TRUE ) { + } + else if (rresult == V_TRUE) + { res = node->left; pfree(node); } - return res; + return res; } - return node; + 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); +} diff --git a/contrib/tsearch/rewrite.h b/contrib/tsearch/rewrite.h index 863ff9b672..c53e1c6dac 100644 --- a/contrib/tsearch/rewrite.h +++ b/contrib/tsearch/rewrite.h @@ -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 diff --git a/contrib/tsearch/txtidx.c b/contrib/tsearch/txtidx.c index e1abd54d3b..6e1fe0edae 100644 --- a/contrib/tsearch/txtidx.c +++ b/contrib/tsearch/txtidx.c @@ -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; - - curout = outbuf = (char*) palloc( lenbuf ); - for(i=0;i<out->size;i++) { +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++) + { 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; - - start_parse_str( buf, buflen ); - while( (type=tsearch_yylex()) != 0 ) { - if ( prs->curwords == prs->lenwords ) { +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) + { 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; - - prs->curwords = uniqueWORD( prs->words, prs->curwords ); - for(i=0;i<prs->curwords;i++) +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++) 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); } - diff --git a/contrib/tsearch/txtidx.h b/contrib/tsearch/txtidx.h index 9a586ce518..d33bdf9d6d 100644 --- a/contrib/tsearch/txtidx.h +++ b/contrib/tsearch/txtidx.h @@ -14,33 +14,34 @@ #include "utils/builtins.h" #include "storage/bufpage.h" -typedef struct { - uint16 len; - uint16 pos; -} WordEntry; - -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 ) ) - -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 +{ + uint16 len; + uint16 pos; +} WordEntry; + +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 ) ) + +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 - diff --git a/contrib/userlock/user_locks.h b/contrib/userlock/user_locks.h index 82ecb3b9ea..526e864661 100644 --- a/contrib/userlock/user_locks.h +++ b/contrib/userlock/user_locks.h @@ -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 /* diff --git a/contrib/xml/pgxml.c b/contrib/xml/pgxml.c index 4728903157..3939250e25 100644 --- a/contrib/xml/pgxml.c +++ b/contrib/xml/pgxml.c @@ -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; - - pgxml_mhs_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 */ - } - - 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); + /* 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_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 */ + } + + 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); } /* 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); - - /* Set the handlers */ - - 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); - - return NULL; - } + 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 */ + + 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); + + 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(); - if (ind >= (xpresults->rescount)) - { - PG_RETURN_NULL(); - } - - restext = (text *) palloc(xpresults->reslens[ind]+VARHDRSZ); - memcpy(VARDATA(restext),xpresults->results[ind],xpresults->reslens[ind]); + restext = (text *) palloc(xpresults->reslens[ind] + VARHDRSZ); + memcpy(VARDATA(restext), xpresults->results[ind], xpresults->reslens[ind]); - VARATT_SIZEP(restext) = xpresults->reslens[ind]+VARHDRSZ; + VARATT_SIZEP(restext) = xpresults->reslens[ind] + VARHDRSZ; - pfree(xpresults->resbuf); - pfree(xpresults); + pfree(xpresults->resbuf); + pfree(xpresults); - PG_RETURN_TEXT_P(restext); + PG_RETURN_TEXT_P(restext); } -static void pgxml_pathcompare(void *userData) +static void +pgxml_pathcompare(void *userData) { - char *matchpos; - - 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; + char *matchpos; + + 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; } - } 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[]="/"; - - 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); - } + 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); } -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 */ - - 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 */ - } - - if (UD->textgrab) { - pgxml_pathcompare(userData); - } + /* + * Start by removing the current element off the end of the + * currentpath + */ + + 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 */ + } + + 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++; - - /* This effectively concatenates all the results together but we - do know where one ends and the next begins */ + /* 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 + */ } - - - diff --git a/contrib/xml/pgxml.h b/contrib/xml/pgxml.h index 848264c23d..605031861d 100644 --- a/contrib/xml/pgxml.h +++ b/contrib/xml/pgxml.h @@ -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) - - - - - - - - - - - - - - - - - - - - diff --git a/contrib/xml/pgxml_dom.c b/contrib/xml/pgxml_dom.c index b01368a52c..f2f9973b89 100644 --- a/contrib/xml/pgxml_dom.c +++ b/contrib/xml/pgxml_dom.c @@ -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; - - 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); + /* called as pgxml_parse(document) */ + xmlDocPtr doctree; + text *t = PG_GETARG_TEXT_P(0); /* document buffer */ + int32 docsize = VARSIZE(t) - VARHDRSZ; + + 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); } -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?? */ - - xmlBufferPtr buf; - xmlChar *result; - int i; - - 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; + /* 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?? */ + + xmlBufferPtr buf; + xmlChar *result; + int i; + + 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; - - txsize=VARSIZE(textstring)-VARHDRSZ; - res = (xmlChar *) palloc(txsize+1); - memcpy((char *)res, VARDATA(textstring), txsize); - res[txsize]='\0'; - return res; +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; } @@ -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; - - 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; - - pgxml_parser_init(); - - doctree = xmlParseMemory((char *) VARDATA(t), docsize); - if (doctree == NULL) { /* not well-formed */ - PG_RETURN_NULL(); - } - - ctxt = xmlXPathNewContext(doctree); - ctxt->node = xmlDocGetRootElement(doctree); - - /* compile the path */ - comppath = xmlXPathCompile(xpath); - if (comppath == NULL) { - elog(NOTICE, "XPath syntax error"); - xmlFreeDoc(doctree); - pfree((void *) xpath); - PG_RETURN_NULL(); - } - - /* Now evaluate the path expression. */ - res = xmlXPathCompiledEval(comppath,ctxt); - xmlXPathFreeCompExpr(comppath); - - 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 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); + xmlDocPtr doctree; + xmlXPathContextPtr ctxt; + xmlXPathObjectPtr res; + xmlChar *xpath, + *xpresstr, + *toptag, + *septag; + xmlXPathCompExprPtr comppath; + + 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; + + pgxml_parser_init(); + + doctree = xmlParseMemory((char *) VARDATA(t), docsize); + if (doctree == NULL) + { /* not well-formed */ + PG_RETURN_NULL(); + } + + ctxt = xmlXPathNewContext(doctree); + ctxt->node = xmlDocGetRootElement(doctree); + + /* compile the path */ + comppath = xmlXPathCompile(xpath); + if (comppath == NULL) + { + elog(NOTICE, "XPath syntax error"); + xmlFreeDoc(doctree); + pfree((void *) xpath); + PG_RETURN_NULL(); + } + + /* Now evaluate the path expression. */ + res = xmlXPathCompiledEval(comppath, ctxt); + xmlXPathFreeCompExpr(comppath); + + 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 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); } - - - - |