provided by Andrew.
PG_MODULE_MAGIC;
/* GUC variables */
-static int auto_explain_log_min_duration = -1; /* msec or -1 */
+static int auto_explain_log_min_duration = -1; /* msec or -1 */
static bool auto_explain_log_analyze = false;
static bool auto_explain_log_verbose = false;
static bool auto_explain_log_nested_statements = false;
static int nesting_level = 0;
/* Saved hook values in case of unload */
-static ExecutorStart_hook_type prev_ExecutorStart = NULL;
-static ExecutorRun_hook_type prev_ExecutorRun = NULL;
-static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+static ExecutorStart_hook_type prev_ExecutorStart = NULL;
+static ExecutorRun_hook_type prev_ExecutorRun = NULL;
+static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
#define auto_explain_enabled() \
(auto_explain_log_min_duration >= 0 && \
(nesting_level == 0 || auto_explain_log_nested_statements))
-void _PG_init(void);
-void _PG_fini(void);
+void _PG_init(void);
+void _PG_fini(void);
static void explain_ExecutorStart(QueryDesc *queryDesc, int eflags);
static void explain_ExecutorRun(QueryDesc *queryDesc,
- ScanDirection direction,
- long count);
+ ScanDirection direction,
+ long count);
static void explain_ExecutorEnd(QueryDesc *queryDesc);
{
/* Define custom GUC variables. */
DefineCustomIntVariable("auto_explain.log_min_duration",
- "Sets the minimum execution time above which plans will be logged.",
- "Zero prints all plans. -1 turns this feature off.",
+ "Sets the minimum execution time above which plans will be logged.",
+ "Zero prints all plans. -1 turns this feature off.",
&auto_explain_log_min_duration,
-1,
-1, INT_MAX / 1000,
if (auto_explain_enabled())
{
/*
- * Set up to track total elapsed time in ExecutorRun. Make sure
- * the space is allocated in the per-query context so it will go
- * away at ExecutorEnd.
+ * Set up to track total elapsed time in ExecutorRun. Make sure the
+ * space is allocated in the per-query context so it will go away at
+ * ExecutorEnd.
*/
if (queryDesc->totaltime == NULL)
{
{
if (queryDesc->totaltime && auto_explain_enabled())
{
- double msec;
+ double msec;
/*
- * Make sure stats accumulation is done. (Note: it's okay if
- * several levels of hook all do this.)
+ * Make sure stats accumulation is done. (Note: it's okay if several
+ * levels of hook all do this.)
*/
InstrEndLoop(queryDesc->totaltime);
msec = queryDesc->totaltime->total * 1000.0;
if (msec >= auto_explain_log_min_duration)
{
- StringInfoData buf;
+ StringInfoData buf;
initStringInfo(&buf);
ExplainPrintPlan(&buf, queryDesc,
- queryDesc->doInstrument && auto_explain_log_analyze,
+ queryDesc->doInstrument && auto_explain_log_analyze,
auto_explain_log_verbose);
/* Remove last line break */
typedef struct TypeInfo
{
- bool is_varlena;
- Datum (*leftmostvalue)(void);
- Datum (*typecmp)(FunctionCallInfo);
+ bool is_varlena;
+ Datum (*leftmostvalue) (void);
+ Datum (*typecmp) (FunctionCallInfo);
} TypeInfo;
typedef struct QueryInfo
{
- StrategyNumber strategy;
- Datum datum;
+ StrategyNumber strategy;
+ Datum datum;
} QueryInfo;
#define GIN_EXTRACT_VALUE(type) \
PG_FUNCTION_INFO_V1(gin_extract_value_##type); \
-Datum gin_extract_value_##type(PG_FUNCTION_ARGS); \
+Datum gin_extract_value_##type(PG_FUNCTION_ARGS); \
Datum \
gin_extract_value_##type(PG_FUNCTION_ARGS) \
{ \
#define GIN_EXTRACT_QUERY(type) \
PG_FUNCTION_INFO_V1(gin_extract_query_##type); \
-Datum gin_extract_query_##type(PG_FUNCTION_ARGS); \
+Datum gin_extract_query_##type(PG_FUNCTION_ARGS); \
Datum \
gin_extract_query_##type(PG_FUNCTION_ARGS) \
{ \
int32 *nentries = (int32 *) PG_GETARG_POINTER(1); \
StrategyNumber strategy = PG_GETARG_UINT16(2); \
bool **partialmatch = (bool **) PG_GETARG_POINTER(3); \
- Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4); \
+ Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4); \
Datum *entries = (Datum *) palloc(sizeof(Datum)); \
QueryInfo *data = (QueryInfo *) palloc(sizeof(QueryInfo)); \
bool *ptr_partialmatch; \
*/
#define GIN_COMPARE_PREFIX(type) \
PG_FUNCTION_INFO_V1(gin_compare_prefix_##type); \
-Datum gin_compare_prefix_##type(PG_FUNCTION_ARGS); \
+Datum gin_compare_prefix_##type(PG_FUNCTION_ARGS); \
Datum \
gin_compare_prefix_##type(PG_FUNCTION_ARGS) \
{ \
cmp; \
\
cmp = DatumGetInt32(DirectFunctionCall2( \
- TypeInfo_##type.typecmp, \
- (data->strategy == BTLessStrategyNumber || \
+ TypeInfo_##type.typecmp, \
+ (data->strategy == BTLessStrategyNumber || \
data->strategy == BTLessEqualStrategyNumber) \
- ? data->datum : a, \
+ ? data->datum : a, \
b)); \
\
switch (data->strategy) \
res = 1; \
break; \
default: \
- elog(ERROR, "unrecognized strategy number: %d", \
+ elog(ERROR, "unrecognized strategy number: %d", \
data->strategy); \
res = 0; \
} \
PG_FUNCTION_INFO_V1(gin_btree_consistent);
-Datum gin_btree_consistent(PG_FUNCTION_ARGS);
+Datum gin_btree_consistent(PG_FUNCTION_ARGS);
Datum
gin_btree_consistent(PG_FUNCTION_ARGS)
{
- bool *recheck = (bool *) PG_GETARG_POINTER(5);
+ bool *recheck = (bool *) PG_GETARG_POINTER(5);
*recheck = false;
PG_RETURN_BOOL(true);
return Int16GetDatum(SHRT_MIN);
}
static TypeInfo TypeInfo_int2 = {false, leftmostvalue_int2, btint2cmp};
+
GIN_SUPPORT(int2)
static Datum
return Int32GetDatum(INT_MIN);
}
static TypeInfo TypeInfo_int4 = {false, leftmostvalue_int4, btint4cmp};
+
GIN_SUPPORT(int4)
static Datum
leftmostvalue_int8(void)
{
/*
- * Use sequence's definition to keep compatibility.
- * Another way may make a problem with INT64_IS_BUSTED
+ * Use sequence's definition to keep compatibility. Another way may make a
+ * problem with INT64_IS_BUSTED
*/
return Int64GetDatum(SEQ_MINVALUE);
}
static TypeInfo TypeInfo_int8 = {false, leftmostvalue_int8, btint8cmp};
+
GIN_SUPPORT(int8)
static Datum
return Float4GetDatum(-get_float4_infinity());
}
static TypeInfo TypeInfo_float4 = {false, leftmostvalue_float4, btfloat4cmp};
+
GIN_SUPPORT(float4)
static Datum
return Float8GetDatum(-get_float8_infinity());
}
static TypeInfo TypeInfo_float8 = {false, leftmostvalue_float8, btfloat8cmp};
+
GIN_SUPPORT(float8)
static Datum
leftmostvalue_money(void)
{
/*
- * Use sequence's definition to keep compatibility.
- * Another way may make a problem with INT64_IS_BUSTED
+ * Use sequence's definition to keep compatibility. Another way may make a
+ * problem with INT64_IS_BUSTED
*/
return Int64GetDatum(SEQ_MINVALUE);
}
static TypeInfo TypeInfo_money = {false, leftmostvalue_money, cash_cmp};
+
GIN_SUPPORT(money)
static Datum
return ObjectIdGetDatum(0);
}
static TypeInfo TypeInfo_oid = {false, leftmostvalue_oid, btoidcmp};
+
GIN_SUPPORT(oid)
static Datum
return TimestampGetDatum(DT_NOBEGIN);
}
static TypeInfo TypeInfo_timestamp = {false, leftmostvalue_timestamp, timestamp_cmp};
+
GIN_SUPPORT(timestamp)
static TypeInfo TypeInfo_timestamptz = {false, leftmostvalue_timestamp, timestamp_cmp};
+
GIN_SUPPORT(timestamptz)
static Datum
return TimeADTGetDatum(0);
}
static TypeInfo TypeInfo_time = {false, leftmostvalue_time, time_cmp};
+
GIN_SUPPORT(time)
static Datum
leftmostvalue_timetz(void)
{
- TimeTzADT *v = palloc(sizeof(TimeTzADT));
+ TimeTzADT *v = palloc(sizeof(TimeTzADT));
v->time = 0;
- v->zone = -24*3600; /* XXX is that true? */
+ v->zone = -24 * 3600; /* XXX is that true? */
return TimeTzADTPGetDatum(v);
}
static TypeInfo TypeInfo_timetz = {false, leftmostvalue_timetz, timetz_cmp};
+
GIN_SUPPORT(timetz)
static Datum
return DateADTGetDatum(DATEVAL_NOBEGIN);
}
static TypeInfo TypeInfo_date = {false, leftmostvalue_date, date_cmp};
+
GIN_SUPPORT(date)
static Datum
leftmostvalue_interval(void)
{
- Interval *v = palloc(sizeof(Interval));
+ Interval *v = palloc(sizeof(Interval));
v->time = DT_NOBEGIN;
v->day = 0;
return IntervalPGetDatum(v);
}
static TypeInfo TypeInfo_interval = {false, leftmostvalue_interval, interval_cmp};
+
GIN_SUPPORT(interval)
static Datum
leftmostvalue_macaddr(void)
{
- macaddr *v = palloc0(sizeof(macaddr));
+ macaddr *v = palloc0(sizeof(macaddr));
return MacaddrPGetDatum(v);
}
static TypeInfo TypeInfo_macaddr = {false, leftmostvalue_macaddr, macaddr_cmp};
+
GIN_SUPPORT(macaddr)
static Datum
Int32GetDatum(-1));
}
static TypeInfo TypeInfo_inet = {true, leftmostvalue_inet, network_cmp};
+
GIN_SUPPORT(inet)
static TypeInfo TypeInfo_cidr = {true, leftmostvalue_inet, network_cmp};
+
GIN_SUPPORT(cidr)
static Datum
return PointerGetDatum(cstring_to_text_with_len("", 0));
}
static TypeInfo TypeInfo_text = {true, leftmostvalue_text, bttextcmp};
+
GIN_SUPPORT(text)
static Datum
return CharGetDatum(SCHAR_MIN);
}
static TypeInfo TypeInfo_char = {false, leftmostvalue_char, btcharcmp};
+
GIN_SUPPORT(char)
static TypeInfo TypeInfo_bytea = {true, leftmostvalue_text, byteacmp};
+
GIN_SUPPORT(bytea)
static Datum
Int32GetDatum(-1));
}
static TypeInfo TypeInfo_bit = {true, leftmostvalue_bit, bitcmp};
+
GIN_SUPPORT(bit)
static Datum
Int32GetDatum(-1));
}
static TypeInfo TypeInfo_varbit = {true, leftmostvalue_varbit, bitcmp};
+
GIN_SUPPORT(varbit)
/*
#define NUMERIC_IS_LEFTMOST(x) ((x) == NULL)
PG_FUNCTION_INFO_V1(gin_numeric_cmp);
-Datum gin_numeric_cmp(PG_FUNCTION_ARGS);
+Datum gin_numeric_cmp(PG_FUNCTION_ARGS);
Datum
gin_numeric_cmp(PG_FUNCTION_ARGS)
{
- Numeric a = (Numeric)PG_GETARG_POINTER(0);
- Numeric b = (Numeric)PG_GETARG_POINTER(1);
- int res = 0;
+ Numeric a = (Numeric) PG_GETARG_POINTER(0);
+ Numeric b = (Numeric) PG_GETARG_POINTER(1);
+ int res = 0;
- if ( NUMERIC_IS_LEFTMOST(a) )
+ if (NUMERIC_IS_LEFTMOST(a))
{
- res = ( NUMERIC_IS_LEFTMOST(b) ) ? 0 : -1;
+ res = (NUMERIC_IS_LEFTMOST(b)) ? 0 : -1;
}
- else if ( NUMERIC_IS_LEFTMOST(b) )
+ else if (NUMERIC_IS_LEFTMOST(b))
{
res = 1;
}
}
static TypeInfo TypeInfo_numeric = {true, leftmostvalue_numeric, gin_numeric_cmp};
+
GIN_SUPPORT(numeric)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_var.h"
static GBT_VARKEY *
-gbt_bit_l2n(GBT_VARKEY * leaf)
+gbt_bit_l2n(GBT_VARKEY *leaf)
{
GBT_VARKEY *out = leaf;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval = FALSE;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_var.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Cash lower;
Cash upper;
-} cashKEY;
+} cashKEY;
/*
** Cash ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Cash query = PG_GETARG_CASH(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
cashKEY *kkk = (cashKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
DateADT lower;
DateADT upper;
-} dateKEY;
+} dateKEY;
/*
** date ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
DateADT query = PG_GETARG_DATEADT(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
dateKEY *kkk = (dateKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
float4 lower;
float4 upper;
-} float4KEY;
+} float4KEY;
/*
** float4 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
float4 query = PG_GETARG_FLOAT4(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
float4KEY *kkk = (float4KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
float8 lower;
float8 upper;
-} float8KEY;
+} float8KEY;
/*
** float8 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
float8 query = PG_GETARG_FLOAT8(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
float8KEY *kkk = (float8KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef __BTREE_GIST_H__
#define __BTREE_GIST_H__
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
double lower;
double upper;
-} inetKEY;
+} inetKEY;
/*
** inet ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
double query = convert_network_to_scalar(PG_GETARG_DATUM(1), INETOID);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
inetKEY *kkk = (inetKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are inexact */
*recheck = true;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query,
&strategy, GIST_LEAF(entry), &tinfo));
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
int16 lower;
int16 upper;
-} int16KEY;
+} int16KEY;
/*
** int16 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int16 query = PG_GETARG_INT16(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
int16KEY *kkk = (int16KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
int32 lower;
int32 upper;
-} int32KEY;
+} int32KEY;
/*
** int32 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int32 query = PG_GETARG_INT32(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
int32KEY *kkk = (int32KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
int64 lower;
int64 upper;
-} int64KEY;
+} int64KEY;
/*
** int64 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int64 query = PG_GETARG_INT64(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
int64KEY *kkk = (int64KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Interval lower,
upper;
-} intvKEY;
+} intvKEY;
/*
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Interval *query = PG_GETARG_INTERVAL_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
macaddr lower;
macaddr upper;
-} macKEY;
+} macKEY;
/*
** OID ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
macaddr *query = (macaddr *) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
macKEY *kkk = (macKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetNumeric(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Oid lower;
Oid upper;
-} oidKEY;
+} oidKEY;
/*
** OID ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Oid query = PG_GETARG_OID(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_var.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetTextP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
TimeADT lower;
TimeADT upper;
-} timeKEY;
+} timeKEY;
/*
** time ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeADT query = PG_GETARG_TIMEADT(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeTzADT *query = PG_GETARG_TIMETZADT_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
qqq = (query->time + query->zone);
#endif
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &qqq, &strategy, GIST_LEAF(entry), &tinfo)
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
- TimeADTGetDatumFast(newentry->upper),
- TimeADTGetDatumFast(origentry->upper)));
+ TimeADTGetDatumFast(newentry->upper),
+ TimeADTGetDatumFast(origentry->upper)));
res = INTERVAL_TO_SEC(intr);
res = Max(res, 0);
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
- TimeADTGetDatumFast(origentry->lower),
- TimeADTGetDatumFast(newentry->lower)));
+ TimeADTGetDatumFast(origentry->lower),
+ TimeADTGetDatumFast(newentry->lower)));
res2 = INTERVAL_TO_SEC(intr);
res2 = Max(res2, 0);
{
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
- TimeADTGetDatumFast(origentry->upper),
- TimeADTGetDatumFast(origentry->lower)));
+ TimeADTGetDatumFast(origentry->upper),
+ TimeADTGetDatumFast(origentry->lower)));
*result += FLT_MIN;
*result += (float) (res / (res + INTERVAL_TO_SEC(intr)));
*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Timestamp lower;
Timestamp upper;
-} tsKEY;
+} tsKEY;
/*
** timestamp ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Timestamp query = PG_GETARG_TIMESTAMP(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
gbt_tstz_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- TimestampTz query = PG_GETARG_TIMESTAMPTZ(1);
+ TimestampTz query = PG_GETARG_TIMESTAMPTZ(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
char *kkk = (char *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk[0];
- key.upper = (GBT_NUMKEY *) & kkk[MAXALIGN(tinfo.size)];
+ key.lower = (GBT_NUMKEY *) &kkk[0];
+ key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)];
qqq = tstz_to_ts_gmt(query);
PG_RETURN_BOOL(
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
GISTENTRY *
-gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, const gbtree_ninfo * tinfo)
+gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, const gbtree_ninfo *tinfo)
{
if (entry->leafkey)
{
*/
void *
-gbt_num_union(GBT_NUMKEY * out, const GistEntryVector *entryvec, const gbtree_ninfo * tinfo)
+gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo)
{
int i,
numranges;
*/
bool
-gbt_num_same(const GBT_NUMKEY * a, const GBT_NUMKEY * b, const gbtree_ninfo * tinfo)
+gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo)
{
GBT_NUMKEY_R b1,
void
-gbt_num_bin_union(Datum *u, GBT_NUMKEY * e, const gbtree_ninfo * tinfo)
+gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo)
{
GBT_NUMKEY_R rd;
bool
gbt_num_consistent(
- const GBT_NUMKEY_R * key,
+ const GBT_NUMKEY_R *key,
const void *query,
const StrategyNumber *strategy,
bool is_leaf,
- const gbtree_ninfo * tinfo
+ const gbtree_ninfo *tinfo
)
{
GIST_SPLITVEC *
gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
- const gbtree_ninfo * tinfo)
+ const gbtree_ninfo *tinfo)
{
OffsetNumber i,
maxoff = entryvec->n - 1;
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#ifndef __BTREE_UTILS_NUM_H__
#define __BTREE_UTILS_NUM_H__
{
const GBT_NUMKEY *lower,
*upper;
-} GBT_NUMKEY_R;
+} GBT_NUMKEY_R;
/* for sorting */
{
int i;
GBT_NUMKEY *t;
-} Nsrt;
+} Nsrt;
/* type description */
bool (*f_le) (const void *, const void *); /* less equal */
bool (*f_lt) (const void *, const void *); /* less then */
int (*f_cmp) (const void *, const void *); /* key compare function */
-} gbtree_ninfo;
+} gbtree_ninfo;
/*
#endif
-extern bool gbt_num_consistent(const GBT_NUMKEY_R * key, const void *query,
+extern bool gbt_num_consistent(const GBT_NUMKEY_R *key, const void *query,
const StrategyNumber *strategy, bool is_leaf,
- const gbtree_ninfo * tinfo);
+ const gbtree_ninfo *tinfo);
extern GIST_SPLITVEC *gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
- const gbtree_ninfo * tinfo);
+ const gbtree_ninfo *tinfo);
extern GISTENTRY *gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry,
- const gbtree_ninfo * tinfo);
+ const gbtree_ninfo *tinfo);
-extern void *gbt_num_union(GBT_NUMKEY * out, const GistEntryVector *entryvec,
- const gbtree_ninfo * tinfo);
+extern void *gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec,
+ const gbtree_ninfo *tinfo);
-extern bool gbt_num_same(const GBT_NUMKEY * a, const GBT_NUMKEY * b,
- const gbtree_ninfo * tinfo);
+extern bool gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b,
+ const gbtree_ninfo *tinfo);
-extern void gbt_num_bin_union(Datum *u, GBT_NUMKEY * e,
- const gbtree_ninfo * tinfo);
+extern void gbt_num_bin_union(Datum *u, GBT_NUMKEY *e,
+ const gbtree_ninfo *tinfo);
#endif
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
/* Returns a better readable representaion of variable key ( sets pointer ) */
GBT_VARKEY_R
-gbt_var_key_readable(const GBT_VARKEY * k)
+gbt_var_key_readable(const GBT_VARKEY *k)
{
GBT_VARKEY_R r;
GBT_VARKEY *
-gbt_var_key_copy(const GBT_VARKEY_R * u, bool force_node)
+gbt_var_key_copy(const GBT_VARKEY_R *u, bool force_node)
{
GBT_VARKEY *r = NULL;
static GBT_VARKEY *
-gbt_var_leaf2node(GBT_VARKEY * leaf, const gbtree_vinfo * tinfo)
+gbt_var_leaf2node(GBT_VARKEY *leaf, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *out = leaf;
* returns the common prefix length of a node key
*/
static int32
-gbt_var_node_cp_len(const GBT_VARKEY * node, const gbtree_vinfo * tinfo)
+gbt_var_node_cp_len(const GBT_VARKEY *node, const gbtree_vinfo *tinfo)
{
GBT_VARKEY_R r = gbt_var_key_readable(node);
* returns true, if query matches prefix ( common prefix )
*/
static bool
-gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo * tinfo)
+gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo *tinfo)
{
bool out = FALSE;
*/
static bool
-gbt_var_node_pf_match(const GBT_VARKEY_R * node, const bytea *query, const gbtree_vinfo * tinfo)
+gbt_var_node_pf_match(const GBT_VARKEY_R *node, const bytea *query, const gbtree_vinfo *tinfo)
{
return (tinfo->trnc && (
* cpf_length .. common prefix length
*/
static GBT_VARKEY *
-gbt_var_node_truncate(const GBT_VARKEY * node, int32 cpf_length, const gbtree_vinfo * tinfo)
+gbt_var_node_truncate(const GBT_VARKEY *node, int32 cpf_length, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *out = NULL;
GBT_VARKEY_R r = gbt_var_key_readable(node);
void
-gbt_var_bin_union(Datum *u, GBT_VARKEY * e, const gbtree_vinfo * tinfo)
+gbt_var_bin_union(Datum *u, GBT_VARKEY *e, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *nk = NULL;
GISTENTRY *
-gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo * tinfo)
+gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo)
{
GISTENTRY *retval;
GBT_VARKEY *
-gbt_var_union(const GistEntryVector *entryvec, int32 *size, const gbtree_vinfo * tinfo)
+gbt_var_union(const GistEntryVector *entryvec, int32 *size, const gbtree_vinfo *tinfo)
{
int i = 0,
bool
-gbt_var_same(bool *result, const Datum d1, const Datum d2, const gbtree_vinfo * tinfo)
+gbt_var_same(bool *result, const Datum d1, const Datum d2, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *t1 = (GBT_VARKEY *) DatumGetPointer(d1);
float *
-gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, const gbtree_vinfo * tinfo)
+gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *orge = (GBT_VARKEY *) DatumGetPointer(o->key);
}
GIST_SPLITVEC *
-gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo * tinfo)
+gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo *tinfo)
{
OffsetNumber i,
maxoff = entryvec->n - 1;
*/
bool
gbt_var_consistent(
- GBT_VARKEY_R * key,
+ GBT_VARKEY_R *key,
const void *query,
const StrategyNumber *strategy,
bool is_leaf,
- const gbtree_vinfo * tinfo
+ const gbtree_vinfo *tinfo
)
{
bool retval = FALSE;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef __BTREE_UTILS_VAR_H__
#define __BTREE_UTILS_VAR_H__
{
bytea *lower,
*upper;
-} GBT_VARKEY_R;
+} GBT_VARKEY_R;
/* used for key sorting */
typedef struct
{
int i;
GBT_VARKEY *t;
-} Vsrt;
+} Vsrt;
/*
type description
bool (*f_lt) (const void *, const void *); /* less then */
int32 (*f_cmp) (const bytea *, const bytea *); /* node compare */
GBT_VARKEY *(*f_l2n) (GBT_VARKEY *); /* convert leaf to node */
-} gbtree_vinfo;
+} gbtree_vinfo;
-extern GBT_VARKEY_R gbt_var_key_readable(const GBT_VARKEY * k);
+extern GBT_VARKEY_R gbt_var_key_readable(const GBT_VARKEY *k);
-extern GBT_VARKEY *gbt_var_key_copy(const GBT_VARKEY_R * u, bool force_node);
+extern GBT_VARKEY *gbt_var_key_copy(const GBT_VARKEY_R *u, bool force_node);
-extern GISTENTRY *gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo * tinfo);
+extern GISTENTRY *gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo);
extern GBT_VARKEY *gbt_var_union(const GistEntryVector *entryvec, int32 *size,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
extern bool gbt_var_same(bool *result, const Datum d1, const Datum d2,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
extern float *gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
-extern bool gbt_var_consistent(GBT_VARKEY_R * key, const void *query,
+extern bool gbt_var_consistent(GBT_VARKEY_R *key, const void *query,
const StrategyNumber *strategy, bool is_leaf,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
extern GIST_SPLITVEC *gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
- const gbtree_vinfo * tinfo);
-extern void gbt_var_bin_union(Datum *u, GBT_VARKEY * e,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
+extern void gbt_var_bin_union(Datum *u, GBT_VARKEY *e,
+ const gbtree_vinfo *tinfo);
#endif
typedef struct chkpass
{
char password[16];
-} chkpass;
+} chkpass;
/*
* Various forward declarations:
#endif
/*
- * ====================
- * FORWARD DECLARATIONS
- * ====================
+ * ====================
+ * FORWARD DECLARATIONS
+ * ====================
*/
-static int32 citextcmp (text *left, text *right);
-extern Datum citext_cmp (PG_FUNCTION_ARGS);
-extern Datum citext_hash (PG_FUNCTION_ARGS);
-extern Datum citext_eq (PG_FUNCTION_ARGS);
-extern Datum citext_ne (PG_FUNCTION_ARGS);
-extern Datum citext_gt (PG_FUNCTION_ARGS);
-extern Datum citext_ge (PG_FUNCTION_ARGS);
-extern Datum citext_lt (PG_FUNCTION_ARGS);
-extern Datum citext_le (PG_FUNCTION_ARGS);
-extern Datum citext_smaller (PG_FUNCTION_ARGS);
-extern Datum citext_larger (PG_FUNCTION_ARGS);
+static int32 citextcmp(text *left, text *right);
+extern Datum citext_cmp(PG_FUNCTION_ARGS);
+extern Datum citext_hash(PG_FUNCTION_ARGS);
+extern Datum citext_eq(PG_FUNCTION_ARGS);
+extern Datum citext_ne(PG_FUNCTION_ARGS);
+extern Datum citext_gt(PG_FUNCTION_ARGS);
+extern Datum citext_ge(PG_FUNCTION_ARGS);
+extern Datum citext_lt(PG_FUNCTION_ARGS);
+extern Datum citext_le(PG_FUNCTION_ARGS);
+extern Datum citext_smaller(PG_FUNCTION_ARGS);
+extern Datum citext_larger(PG_FUNCTION_ARGS);
/*
- * =================
- * UTILITY FUNCTIONS
- * =================
+ * =================
+ * UTILITY FUNCTIONS
+ * =================
*/
/*
* Returns int32 negative, zero, or positive.
*/
static int32
-citextcmp (text *left, text *right)
+citextcmp(text *left, text *right)
{
- char *lcstr, *rcstr;
- int32 result;
+ char *lcstr,
+ *rcstr;
+ int32 result;
- lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
- rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
+ lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
+ rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
- result = varstr_cmp(lcstr, strlen(lcstr),
- rcstr, strlen(rcstr));
+ result = varstr_cmp(lcstr, strlen(lcstr),
+ rcstr, strlen(rcstr));
- pfree(lcstr);
- pfree(rcstr);
+ pfree(lcstr);
+ pfree(rcstr);
- return result;
+ return result;
}
/*
- * ==================
- * INDEXING FUNCTIONS
- * ==================
+ * ==================
+ * INDEXING FUNCTIONS
+ * ==================
*/
PG_FUNCTION_INFO_V1(citext_cmp);
Datum
citext_cmp(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- int32 result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ int32 result;
- result = citextcmp(left, right);
+ result = citextcmp(left, right);
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_INT32(result);
+ PG_RETURN_INT32(result);
}
PG_FUNCTION_INFO_V1(citext_hash);
Datum
citext_hash(PG_FUNCTION_ARGS)
{
- text *txt = PG_GETARG_TEXT_PP(0);
- char *str;
- Datum result;
+ text *txt = PG_GETARG_TEXT_PP(0);
+ char *str;
+ Datum result;
- str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt));
- result = hash_any((unsigned char *) str, strlen(str));
- pfree(str);
+ str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt));
+ result = hash_any((unsigned char *) str, strlen(str));
+ pfree(str);
- /* Avoid leaking memory for toasted inputs */
- PG_FREE_IF_COPY(txt, 0);
+ /* Avoid leaking memory for toasted inputs */
+ PG_FREE_IF_COPY(txt, 0);
- PG_RETURN_DATUM(result);
+ PG_RETURN_DATUM(result);
}
/*
- * ==================
- * OPERATOR FUNCTIONS
- * ==================
+ * ==================
+ * OPERATOR FUNCTIONS
+ * ==================
*/
PG_FUNCTION_INFO_V1(citext_eq);
Datum
citext_eq(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- char *lcstr, *rcstr;
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ char *lcstr,
+ *rcstr;
+ bool result;
- /* We can't compare lengths in advance of downcasing ... */
+ /* We can't compare lengths in advance of downcasing ... */
- lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
- rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
+ lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
+ rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
- /*
- * Since we only care about equality or not-equality, we can
- * avoid all the expense of strcoll() here, and just do bitwise
- * comparison.
- */
- result = (strcmp(lcstr, rcstr) == 0);
+ /*
+ * Since we only care about equality or not-equality, we can avoid all the
+ * expense of strcoll() here, and just do bitwise comparison.
+ */
+ result = (strcmp(lcstr, rcstr) == 0);
- pfree(lcstr);
- pfree(rcstr);
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ pfree(lcstr);
+ pfree(rcstr);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_ne);
Datum
citext_ne(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- char *lcstr, *rcstr;
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ char *lcstr,
+ *rcstr;
+ bool result;
- /* We can't compare lengths in advance of downcasing ... */
+ /* We can't compare lengths in advance of downcasing ... */
- lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
- rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
+ lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
+ rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
- /*
- * Since we only care about equality or not-equality, we can
- * avoid all the expense of strcoll() here, and just do bitwise
- * comparison.
- */
- result = (strcmp(lcstr, rcstr) != 0);
+ /*
+ * Since we only care about equality or not-equality, we can avoid all the
+ * expense of strcoll() here, and just do bitwise comparison.
+ */
+ result = (strcmp(lcstr, rcstr) != 0);
- pfree(lcstr);
- pfree(rcstr);
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ pfree(lcstr);
+ pfree(rcstr);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_lt);
Datum
citext_lt(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) < 0;
+ result = citextcmp(left, right) < 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_le);
Datum
citext_le(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) <= 0;
+ result = citextcmp(left, right) <= 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_gt);
Datum
citext_gt(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) > 0;
+ result = citextcmp(left, right) > 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_ge);
Datum
citext_ge(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) >= 0;
+ result = citextcmp(left, right) >= 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
/*
- * ===================
- * AGGREGATE FUNCTIONS
- * ===================
+ * ===================
+ * AGGREGATE FUNCTIONS
+ * ===================
*/
PG_FUNCTION_INFO_V1(citext_smaller);
Datum
citext_smaller(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- text *result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ text *result;
- result = citextcmp(left, right) < 0 ? left : right;
- PG_RETURN_TEXT_P(result);
+ result = citextcmp(left, right) < 0 ? left : right;
+ PG_RETURN_TEXT_P(result);
}
PG_FUNCTION_INFO_V1(citext_larger);
Datum
citext_larger(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- text *result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ text *result;
- result = citextcmp(left, right) > 0 ? left : right;
- PG_RETURN_TEXT_P(result);
+ result = citextcmp(left, right) > 0 ? left : right;
+ PG_RETURN_TEXT_P(result);
}
/*
** For internal use only
*/
-int32 cube_cmp_v0(NDBOX * a, NDBOX * b);
-bool cube_contains_v0(NDBOX * a, NDBOX * b);
-bool cube_overlap_v0(NDBOX * a, NDBOX * b);
-NDBOX *cube_union_v0(NDBOX * a, NDBOX * b);
-void rt_cube_size(NDBOX * a, double *sz);
-NDBOX *g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep);
-bool g_cube_leaf_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
-bool g_cube_internal_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
+int32 cube_cmp_v0(NDBOX *a, NDBOX *b);
+bool cube_contains_v0(NDBOX *a, NDBOX *b);
+bool cube_overlap_v0(NDBOX *a, NDBOX *b);
+NDBOX *cube_union_v0(NDBOX *a, NDBOX *b);
+void rt_cube_size(NDBOX *a, double *sz);
+NDBOX *g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep);
+bool g_cube_leaf_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy);
+bool g_cube_internal_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy);
/*
** Auxiliary funxtions
dur = ARRPTR(ur);
dll = ARRPTR(ll);
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
dur = ARRPTR(ur);
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
dx = (int4 *) ARR_DATA_PTR(idx);
dim = ARRNELEMS(idx);
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
NDBOX *query = PG_GETARG_NDBOX(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool res;
** SUPPORT ROUTINES
*/
bool
-g_cube_leaf_consistent(NDBOX * key,
- NDBOX * query,
+g_cube_leaf_consistent(NDBOX *key,
+ NDBOX *query,
StrategyNumber strategy)
{
bool retval;
}
bool
-g_cube_internal_consistent(NDBOX * key,
- NDBOX * query,
+g_cube_internal_consistent(NDBOX *key,
+ NDBOX *query,
StrategyNumber strategy)
{
bool retval;
}
NDBOX *
-g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep)
+g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep)
{
NDBOX *retval;
/* cube_union_v0 */
NDBOX *
-cube_union_v0(NDBOX * a, NDBOX * b)
+cube_union_v0(NDBOX *a, NDBOX *b)
{
int i;
NDBOX *result;
}
void
-rt_cube_size(NDBOX * a, double *size)
+rt_cube_size(NDBOX *a, double *size)
{
int i,
j;
/* make up a metric in which one box will be 'lower' than the other
-- this can be useful for sorting and to determine uniqueness */
int32
-cube_cmp_v0(NDBOX * a, NDBOX * b)
+cube_cmp_v0(NDBOX *a, NDBOX *b)
{
int i;
int dim;
/* Contains */
/* Box(A) CONTAINS Box(B) IFF pt(A) < pt(B) */
bool
-cube_contains_v0(NDBOX * a, NDBOX * b)
+cube_contains_v0(NDBOX *a, NDBOX *b)
{
int i;
/* Overlap */
/* Box(A) Overlap Box(B) IFF (pt(a)LL < pt(B)UR) && (pt(b)LL < pt(a)UR) */
bool
-cube_overlap_v0(NDBOX * a, NDBOX * b)
+cube_overlap_v0(NDBOX *a, NDBOX *b)
{
int i;
dim = n;
if (a->dim > dim)
dim = a->dim;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * dim * 2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
NDBOX *result;
int size;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = 1;
NDBOX *result;
int size;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = 1;
int size;
int i;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * (c->dim + 1) *2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = c->dim + 1;
int size;
int i;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * (c->dim + 1) *2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = c->dim + 1;
int32 vl_len_; /* varlena header (do not touch directly!) */
unsigned int dim;
double x[1];
-} NDBOX;
+} NDBOX;
#define DatumGetNDBOX(x) ((NDBOX*)DatumGetPointer(x))
#define PG_GETARG_NDBOX(x) DatumGetNDBOX( PG_DETOAST_DATUM(PG_GETARG_DATUM(x)) )
PGconn *conn; /* Hold the remote connection */
int openCursorCount; /* The number of open cursors */
bool newXactForCursor; /* Opened a transaction for a cursor */
-} remoteConn;
+} remoteConn;
/*
* Internal declarations
static Datum dblink_record_internal(FunctionCallInfo fcinfo, bool is_async);
static remoteConn *getConnectionByName(const char *name);
static HTAB *createConnHash(void);
-static void createNewConnection(const char *name, remoteConn * rconn);
+static void createNewConnection(const char *name, remoteConn *rconn);
static void deleteConnection(const char *name);
static char **get_pkey_attnames(Oid relid, int16 *numatts);
static char **get_text_array_contents(ArrayType *array, int *numitems);
{
char name[NAMEDATALEN];
remoteConn *rconn;
-} remoteConnHashEnt;
+} remoteConnHashEnt;
/* initial number of connection hashes */
#define NUMCONN 16
funcctx = SRF_FIRSTCALL_INIT();
/*
- * Try to execute the query. Note that since libpq uses malloc,
- * the PGresult will be long-lived even though we are still in
- * a short-lived memory context.
+ * Try to execute the query. Note that since libpq uses malloc, the
+ * PGresult will be long-lived even though we are still in a
+ * short-lived memory context.
*/
res = PQexec(conn, buf.data);
if (!res ||
"the specified FROM clause rowtype")));
/*
- * fast track when no results. We could exit earlier, but then
- * we'd not report error if the result tuple type is wrong.
+ * fast track when no results. We could exit earlier, but then we'd
+ * not report error if the result tuple type is wrong.
*/
if (funcctx->max_calls < 1)
{
/* shouldn't happen */
elog(ERROR, "wrong number of arguments");
}
- else /* is_async */
+ else /* is_async */
{
/* get async result */
if (PG_NARGS() == 2)
if (!conn)
DBLINK_CONN_NOT_AVAIL;
- /* synchronous query, or async result retrieval */
- if (!is_async)
- res = PQexec(conn, sql);
- else
- {
- res = PQgetResult(conn);
- /* NULL means we're all done with the async results */
- if (!res)
- {
- MemoryContextSwitchTo(oldcontext);
- SRF_RETURN_DONE(funcctx);
- }
- }
-
- if (!res ||
- (PQresultStatus(res) != PGRES_COMMAND_OK &&
- PQresultStatus(res) != PGRES_TUPLES_OK))
+ /* synchronous query, or async result retrieval */
+ if (!is_async)
+ res = PQexec(conn, sql);
+ else
+ {
+ res = PQgetResult(conn);
+ /* NULL means we're all done with the async results */
+ if (!res)
{
- dblink_res_error(conname, res, "could not execute query", fail);
- if (freeconn)
- PQfinish(conn);
MemoryContextSwitchTo(oldcontext);
SRF_RETURN_DONE(funcctx);
}
+ }
- if (PQresultStatus(res) == PGRES_COMMAND_OK)
- {
- is_sql_cmd = true;
-
- /* need a tuple descriptor representing one TEXT column */
- tupdesc = CreateTemplateTupleDesc(1, false);
- TupleDescInitEntry(tupdesc, (AttrNumber) 1, "status",
- TEXTOID, -1, 0);
-
- /*
- * and save a copy of the command status string to return as
- * our result tuple
- */
- sql_cmd_status = PQcmdStatus(res);
- funcctx->max_calls = 1;
- }
- else
- funcctx->max_calls = PQntuples(res);
-
- /* got results, keep track of them */
- funcctx->user_fctx = res;
-
- /* if needed, close the connection to the database and cleanup */
+ if (!res ||
+ (PQresultStatus(res) != PGRES_COMMAND_OK &&
+ PQresultStatus(res) != PGRES_TUPLES_OK))
+ {
+ dblink_res_error(conname, res, "could not execute query", fail);
if (freeconn)
PQfinish(conn);
+ MemoryContextSwitchTo(oldcontext);
+ SRF_RETURN_DONE(funcctx);
+ }
- if (!is_sql_cmd)
- {
- /* get a tuple descriptor for our result type */
- switch (get_call_result_type(fcinfo, NULL, &tupdesc))
- {
- case TYPEFUNC_COMPOSITE:
- /* success */
- break;
- case TYPEFUNC_RECORD:
- /* failed to determine actual type of RECORD */
- ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("function returning record called in context "
- "that cannot accept type record")));
- break;
- default:
- /* result type isn't composite */
- elog(ERROR, "return type must be a row type");
- break;
- }
+ if (PQresultStatus(res) == PGRES_COMMAND_OK)
+ {
+ is_sql_cmd = true;
- /* make sure we have a persistent copy of the tupdesc */
- tupdesc = CreateTupleDescCopy(tupdesc);
- }
+ /* need a tuple descriptor representing one TEXT column */
+ tupdesc = CreateTemplateTupleDesc(1, false);
+ TupleDescInitEntry(tupdesc, (AttrNumber) 1, "status",
+ TEXTOID, -1, 0);
/*
- * check result and tuple descriptor have the same number of
- * columns
+ * and save a copy of the command status string to return as our
+ * result tuple
*/
- if (PQnfields(res) != tupdesc->natts)
- ereport(ERROR,
- (errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("remote query result rowtype does not match "
- "the specified FROM clause rowtype")));
+ sql_cmd_status = PQcmdStatus(res);
+ funcctx->max_calls = 1;
+ }
+ else
+ funcctx->max_calls = PQntuples(res);
- /* fast track when no results */
- if (funcctx->max_calls < 1)
+ /* got results, keep track of them */
+ funcctx->user_fctx = res;
+
+ /* if needed, close the connection to the database and cleanup */
+ if (freeconn)
+ PQfinish(conn);
+
+ if (!is_sql_cmd)
+ {
+ /* get a tuple descriptor for our result type */
+ switch (get_call_result_type(fcinfo, NULL, &tupdesc))
{
- if (res)
- PQclear(res);
- MemoryContextSwitchTo(oldcontext);
- SRF_RETURN_DONE(funcctx);
+ case TYPEFUNC_COMPOSITE:
+ /* success */
+ break;
+ case TYPEFUNC_RECORD:
+ /* failed to determine actual type of RECORD */
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("function returning record called in context "
+ "that cannot accept type record")));
+ break;
+ default:
+ /* result type isn't composite */
+ elog(ERROR, "return type must be a row type");
+ break;
}
- /* store needed metadata for subsequent calls */
- attinmeta = TupleDescGetAttInMetadata(tupdesc);
- funcctx->attinmeta = attinmeta;
+ /* make sure we have a persistent copy of the tupdesc */
+ tupdesc = CreateTupleDescCopy(tupdesc);
+ }
+ /*
+ * check result and tuple descriptor have the same number of columns
+ */
+ if (PQnfields(res) != tupdesc->natts)
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("remote query result rowtype does not match "
+ "the specified FROM clause rowtype")));
+
+ /* fast track when no results */
+ if (funcctx->max_calls < 1)
+ {
+ if (res)
+ PQclear(res);
MemoryContextSwitchTo(oldcontext);
+ SRF_RETURN_DONE(funcctx);
+ }
+
+ /* store needed metadata for subsequent calls */
+ attinmeta = TupleDescGetAttInMetadata(tupdesc);
+ funcctx->attinmeta = attinmeta;
+
+ MemoryContextSwitchTo(oldcontext);
}
rawstr_text = cstring_to_text(rawstr);
result_text = DatumGetTextP(DirectFunctionCall1(quote_literal,
- PointerGetDatum(rawstr_text)));
+ PointerGetDatum(rawstr_text)));
result = text_to_cstring(result_text);
return result;
rawstr_text = cstring_to_text(rawstr);
result_text = DatumGetTextP(DirectFunctionCall1(quote_ident,
- PointerGetDatum(rawstr_text)));
+ PointerGetDatum(rawstr_text)));
result = text_to_cstring(result_text);
return result;
}
static void
-createNewConnection(const char *name, remoteConn * rconn)
+createNewConnection(const char *name, remoteConn *rconn)
{
remoteConnHashEnt *hentry;
bool found;
}
/*
- * For non-superusers, insist that the connstr specify a password. This
+ * For non-superusers, insist that the connstr specify a password. This
* prevents a password from being picked up from .pgpass, a service file,
* the environment, etc. We don't want the postgres user's passwords
* to be accessible to non-superusers.
{
if (!superuser())
{
- PQconninfoOption *options;
- PQconninfoOption *option;
- bool connstr_gives_password = false;
+ PQconninfoOption *options;
+ PQconninfoOption *option;
+ bool connstr_gives_password = false;
options = PQconninfoParse(connstr, NULL);
if (options)
if (!connstr_gives_password)
ereport(ERROR,
- (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
- errmsg("password is required"),
- errdetail("Non-superusers must provide a password in the connection string.")));
+ (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
+ errmsg("password is required"),
+ errdetail("Non-superusers must provide a password in the connection string.")));
}
}
dblink_context_conname = conname;
ereport(level,
- (errcode(sqlstate),
- message_primary ? errmsg("%s", message_primary) : errmsg("unknown error"),
- message_detail ? errdetail("%s", message_detail) : 0,
- message_hint ? errhint("%s", message_hint) : 0,
- message_context ? errcontext("%s", message_context) : 0,
- errcontext("Error occurred on dblink connection named \"%s\": %s.",
- dblink_context_conname, dblink_context_msg)));
+ (errcode(sqlstate),
+ message_primary ? errmsg("%s", message_primary) : errmsg("unknown error"),
+ message_detail ? errdetail("%s", message_detail) : 0,
+ message_hint ? errhint("%s", message_hint) : 0,
+ message_context ? errcontext("%s", message_context) : 0,
+ errcontext("Error occurred on dblink connection named \"%s\": %s.",
+ dblink_context_conname, dblink_context_msg)));
}
/*
static char *
get_connect_string(const char *servername)
{
- ForeignServer *foreign_server = NULL;
- UserMapping *user_mapping;
- ListCell *cell;
- StringInfo buf = makeStringInfo();
+ ForeignServer *foreign_server = NULL;
+ UserMapping *user_mapping;
+ ListCell *cell;
+ StringInfo buf = makeStringInfo();
ForeignDataWrapper *fdw;
- AclResult aclresult;
+ AclResult aclresult;
/* first gather the server connstr options */
if (strlen(servername) < NAMEDATALEN)
if (foreign_server)
{
- Oid serverid = foreign_server->serverid;
- Oid fdwid = foreign_server->fdwid;
- Oid userid = GetUserId();
+ Oid serverid = foreign_server->serverid;
+ Oid fdwid = foreign_server->fdwid;
+ Oid userid = GetUserId();
user_mapping = GetUserMapping(userid, serverid);
- fdw = GetForeignDataWrapper(fdwid);
+ fdw = GetForeignDataWrapper(fdwid);
/* Check permissions, user must have usage on the server. */
aclresult = pg_foreign_server_aclcheck(serverid, userid, ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_FOREIGN_SERVER, foreign_server->servername);
- foreach (cell, fdw->options)
+ foreach(cell, fdw->options)
{
- DefElem *def = lfirst(cell);
+ DefElem *def = lfirst(cell);
appendStringInfo(buf, "%s='%s' ", def->defname,
escape_param_str(strVal(def->arg)));
}
- foreach (cell, foreign_server->options)
+ foreach(cell, foreign_server->options)
{
- DefElem *def = lfirst(cell);
-
+ DefElem *def = lfirst(cell);
+
appendStringInfo(buf, "%s='%s' ", def->defname,
escape_param_str(strVal(def->arg)));
}
-
- foreach (cell, user_mapping->options)
+
+ foreach(cell, user_mapping->options)
{
-
- DefElem *def = lfirst(cell);
-
+
+ DefElem *def = lfirst(cell);
+
appendStringInfo(buf, "%s='%s' ", def->defname,
escape_param_str(strVal(def->arg)));
}
static char *
escape_param_str(const char *str)
{
- const char *cp;
- StringInfo buf = makeStringInfo();
+ const char *cp;
+ StringInfo buf = makeStringInfo();
for (cp = str; *cp; cp++)
{
{
int maxlen;
bool rejectlong;
-} DictInt;
+} DictInt;
PG_FUNCTION_INFO_V1(dintdict_init);
* distance between the points in miles on earth's surface
*
* If float8 is passed-by-value, the oldstyle version-0 calling convention
- * is unportable, so we use version-1. However, if it's passed-by-reference,
+ * is unportable, so we use version-1. However, if it's passed-by-reference,
* continue to use oldstyle. This is just because we'd like earthdistance
* to serve as a canary for any unintentional breakage of version-0 functions
* with float8 results.
#ifdef USE_FLOAT8_BYVAL
Datum geo_distance(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(geo_distance);
Datum
result = geo_distance_internal(pt1, pt2);
PG_RETURN_FLOAT8(result);
}
-
-#else /* !USE_FLOAT8_BYVAL */
+#else /* !USE_FLOAT8_BYVAL */
double *geo_distance(Point *pt1, Point *pt2);
return resultp;
}
-#endif /* USE_FLOAT8_BYVAL */
+#endif /* USE_FLOAT8_BYVAL */
int free_string_on_destroy;
}
- metastring;
+metastring;
/*
* remaining perl module funcs unchanged except for declaring them static
static void
-DestroyMetaString(metastring * s)
+DestroyMetaString(metastring *s)
{
if (s == NULL)
return;
static void
-IncreaseBuffer(metastring * s, int chars_needed)
+IncreaseBuffer(metastring *s, int chars_needed)
{
META_REALLOC(s->str, (s->bufsize + chars_needed + 10), char);
assert(s->str != NULL);
static void
-MakeUpper(metastring * s)
+MakeUpper(metastring *s)
{
char *i;
static int
-IsVowel(metastring * s, int pos)
+IsVowel(metastring *s, int pos)
{
char c;
static int
-SlavoGermanic(metastring * s)
+SlavoGermanic(metastring *s)
{
if ((char *) strstr(s->str, "W"))
return 1;
static char
-GetAt(metastring * s, int pos)
+GetAt(metastring *s, int pos)
{
if ((pos < 0) || (pos >= s->length))
return '\0';
static void
-SetAt(metastring * s, int pos, char c)
+SetAt(metastring *s, int pos, char c)
{
if ((pos < 0) || (pos >= s->length))
return;
Caveats: the START value is 0 based
*/
static int
-StringAt(metastring * s, int start, int length,...)
+StringAt(metastring *s, int start, int length,...)
{
char *test;
char *pos;
static void
-MetaphAdd(metastring * s, char *new_str)
+MetaphAdd(metastring *s, char *new_str)
{
int add_length;
*/
#define MAX_LEVENSHTEIN_STRLEN 255
-static int levenshtein_internal(const char *s, const char *t,
- int ins_c, int del_c, int sub_c);
+static int levenshtein_internal(const char *s, const char *t,
+ int ins_c, int del_c, int sub_c);
/*
/*
* levenshtein_internal - Calculates Levenshtein distance metric
- * between supplied strings. Generally
- * (1, 1, 1) penalty costs suffices common
- * cases, but your mileage may vary.
+ * between supplied strings. Generally
+ * (1, 1, 1) penalty costs suffices common
+ * cases, but your mileage may vary.
*/
static int
levenshtein_internal(const char *s, const char *t,
int ins_c, int del_c, int sub_c)
{
- int m, n;
- int *prev;
- int *curr;
- int i, j;
+ int m,
+ n;
+ int *prev;
+ int *curr;
+ int i,
+ j;
const char *x;
const char *y;
n = strlen(t);
/*
- * If either m or n is 0, the answer is the other value. This makes
- * sense since it would take that many insertions to build a matching
- * string
+ * If either m or n is 0, the answer is the other value. This makes sense
+ * since it would take that many insertions to build a matching string
*/
if (!m)
return n;
++n;
/*
- * Instead of building an (m+1)x(n+1) array, we'll use two
- * different arrays of size m+1 for storing accumulated values.
- * At each step one represents the "previous" row and one is the
- * "current" row of the notional large array.
+ * Instead of building an (m+1)x(n+1) array, we'll use two different
+ * arrays of size m+1 for storing accumulated values. At each step one
+ * represents the "previous" row and one is the "current" row of the
+ * notional large array.
*/
prev = (int *) palloc(2 * m * sizeof(int));
curr = prev + m;
/* Loop through rows of the notional array */
for (y = t, j = 1; j < n; y++, j++)
{
- int *temp;
+ int *temp;
/*
- * First cell must increment sequentially, as we're on the
- * j'th row of the (m+1)x(n+1) array.
+ * First cell must increment sequentially, as we're on the j'th row of
+ * the (m+1)x(n+1) array.
*/
curr[0] = j;
-
+
for (x = s, i = 1; i < m; x++, i++)
{
- int ins;
- int del;
- int sub;
+ int ins;
+ int del;
+ int sub;
/* Calculate costs for probable operations. */
- ins = prev[i] + ins_c; /* Insertion */
- del = curr[i-1] + del_c; /* Deletion */
- sub = prev[i-1] + ((*x == *y) ? 0 : sub_c); /* Substitution */
+ ins = prev[i] + ins_c; /* Insertion */
+ del = curr[i - 1] + del_c; /* Deletion */
+ sub = prev[i - 1] + ((*x == *y) ? 0 : sub_c); /* Substitution */
/* Take the one with minimum cost. */
curr[i] = Min(ins, del);
}
/*
- * Because the final value was swapped from the previous row to
- * the current row, that's where we'll find it.
+ * Because the final value was swapped from the previous row to the
+ * current row, that's where we'll find it.
*/
- return prev[m-1];
+ return prev[m - 1];
}
Datum
levenshtein_with_costs(PG_FUNCTION_ARGS)
{
- char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
- char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
- int ins_c = PG_GETARG_INT32(2);
- int del_c = PG_GETARG_INT32(3);
- int sub_c = PG_GETARG_INT32(4);
+ char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
+ char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
+ int ins_c = PG_GETARG_INT32(2);
+ int del_c = PG_GETARG_INT32(3);
+ int sub_c = PG_GETARG_INT32(4);
PG_RETURN_INT32(levenshtein_internal(src, dst, ins_c, del_c, sub_c));
}
Datum
levenshtein(PG_FUNCTION_ARGS)
{
- char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
- char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
+ char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
+ char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
PG_RETURN_INT32(levenshtein_internal(src, dst, 1, 1, 1));
}
static int
-_metaphone(char *word, /* IN */
+_metaphone(char *word, /* IN */
int max_phonemes,
- char **phoned_word) /* OUT */
+ char **phoned_word) /* OUT */
{
int w_idx = 0; /* point in the phonization we're at. */
int p_idx = 0; /* end of the phoned phrase */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Both POSIX and CRC32 checksums */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef _CRC32_H
#define _CRC32_H
uint32
valisnull:1,
pos:31;
-} HEntry;
+} HEntry;
/* these are determined by the sizes of the keylen and vallen fields */
/* in struct HEntry and struct Pairs */
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 size;
char data[1];
-} HStore;
+} HStore;
#define HSHRDSIZE (VARHDRSZ + sizeof(int4))
#define CALCDATASIZE(x, lenstr) ( (x) * sizeof(HEntry) + HSHRDSIZE + (lenstr) )
uint16 vallen;
bool isnull;
bool needfree;
-} Pairs;
+} Pairs;
int comparePairs(const void *a, const void *b);
-int uniquePairs(Pairs * a, int4 l, int4 *buflen);
+int uniquePairs(Pairs *a, int4 l, int4 *buflen);
-size_t hstoreCheckKeyLen(size_t len);
-size_t hstoreCheckValLen(size_t len);
+size_t hstoreCheckKeyLen(size_t len);
+size_t hstoreCheckValLen(size_t len);
#define HStoreContainsStrategyNumber 7
#define HStoreExistsStrategyNumber 9
-#endif /* __HSTORE_H__ */
+#endif /* __HSTORE_H__ */
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
HStore *query = PG_GETARG_HS(2);
+
/* int32 nkeys = PG_GETARG_INT32(3); */
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
bool *recheck = (bool *) PG_GETARG_POINTER(5);
int i;
/*
- * Index lost information about correspondence of keys
- * and values, so we need recheck
+ * Index lost information about correspondence of keys and values, so
+ * we need recheck
*/
*recheck = true;
for (i = 0; res && i < 2 * query->size; i++)
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 flag;
char data[1];
-} GISTTYPE;
+} GISTTYPE;
#define ALLISTRUE 0x04
}
static int
-hemdist(GISTTYPE * a, GISTTYPE * b)
+hemdist(GISTTYPE *a, GISTTYPE *b)
{
if (ISALLTRUE(a))
{
}
static int4
-unionkey(BITVECP sbase, GISTTYPE * add)
+unionkey(BITVECP sbase, GISTTYPE *add)
{
int4 i;
BITVECP sadd = GETSIGN(add);
{
GISTTYPE *entry = (GISTTYPE *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool res = true;
Pairs *pairs;
int pcur;
int plen;
-} HSParser;
+} HSParser;
#define RESIZEPRSBUF \
do { \
#define GV_WAITESCESCIN 4
static bool
-get_val(HSParser * state, bool ignoreeq, bool *escaped)
+get_val(HSParser *state, bool ignoreeq, bool *escaped)
{
int st = GV_WAITVAL;
static void
-parse_hstore(HSParser * state)
+parse_hstore(HSParser *state)
{
int st = WKEY;
bool escaped = false;
}
int
-uniquePairs(Pairs * a, int4 l, int4 *buflen)
+uniquePairs(Pairs *a, int4 l, int4 *buflen)
{
Pairs *ptr,
*res;
}
static void
-freeHSParse(HSParser * state)
+freeHSParse(HSParser *state)
{
int i;
HStore *in = PG_GETARG_HS(0);
int buflen,
i,
- nnulls=0;
+ nnulls = 0;
char *out,
*ptr;
char *base = STRPTR(in);
if (entries[i].valisnull)
nnulls++;
- buflen = (4 /* " */ + 2 /* => */ ) * ( in->size - nnulls ) +
- ( 2 /* " */ + 2 /* => */ + 4 /* NULL */ ) * nnulls +
- 2 /* , */ * ( in->size - 1 ) +
- 2 /* esc */ * (VARSIZE(in) - CALCDATASIZE(in->size, 0)) +
- 1 /* \0 */;
+ buflen = (4 /* " */ + 2 /* => */ ) * (in->size - nnulls) +
+ (2 /* " */ + 2 /* => */ + 4 /* NULL */ ) * nnulls +
+ 2 /* , */ * (in->size - 1) +
+ 2 /* esc */ * (VARSIZE(in) - CALCDATASIZE(in->size, 0)) +
+ 1 /* \0 */ ;
out = ptr = palloc(buflen);
for (i = 0; i < in->size; i++)
static HEntry *
-findkey(HStore * hs, char *key, int keylen)
+findkey(HStore *hs, char *key, int keylen)
{
HEntry *StopLow = ARRPTR(hs);
HEntry *StopHigh = StopLow + hs->size;
{
HStore *hs;
int i;
-} AKStore;
+} AKStore;
static void
-setup_firstcall(FuncCallContext *funcctx, HStore * hs)
+setup_firstcall(FuncCallContext *funcctx, HStore *hs)
{
MemoryContext oldcontext;
AKStore *st;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef ___INT_H__
#define ___INT_H__
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 flag;
char data[1];
-} GISTTYPE;
+} GISTTYPE;
#define ALLISTRUE 0x04
int2 type;
int2 left;
int4 val;
-} ITEM;
+} ITEM;
typedef struct
{
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 size;
char data[1];
-} QUERYTYPE;
+} QUERYTYPE;
#define HDRSIZEQT (VARHDRSZ + sizeof(int4))
#define COMPUTESIZE(size) ( HDRSIZEQT + size * sizeof(ITEM) )
#define OPEN 4
#define CLOSE 5
-bool signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot);
-bool execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot);
-bool ginconsistent(QUERYTYPE * query, bool *check);
-int4 shorterquery(ITEM * q, int4 len);
+bool signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot);
+bool execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot);
+bool ginconsistent(QUERYTYPE *query, bool *check);
+int4 shorterquery(ITEM *q, int4 len);
int compASC(const void *a, const void *b);
qsort((void*)ARRPTR(a), ARRNELEMS(a),sizeof(int4), \
(direction) ? compASC : compDESC )
-#endif /* ___INT_H__ */
+#endif /* ___INT_H__ */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
NODE *str;
/* number in str */
int4 num;
-} WORKSTATE;
+} WORKSTATE;
/*
* get token from query string
*/
static int4
-gettoken(WORKSTATE * state, int4 *val)
+gettoken(WORKSTATE *state, int4 *val)
{
char nnn[16],
*curnnn;
* push new one in polish notation reverse view
*/
static void
-pushquery(WORKSTATE * state, int4 type, int4 val)
+pushquery(WORKSTATE *state, int4 type, int4 val)
{
NODE *tmp = (NODE *) palloc(sizeof(NODE));
* make polish notation of query
*/
static int4
-makepol(WORKSTATE * state)
+makepol(WORKSTATE *state)
{
int4 val,
type;
* is there value 'val' in array or not ?
*/
static bool
-checkcondition_arr(void *checkval, ITEM * item)
+checkcondition_arr(void *checkval, ITEM *item)
{
int4 *StopLow = ((CHKVAL *) checkval)->arrb;
int4 *StopHigh = ((CHKVAL *) checkval)->arre;
}
static bool
-checkcondition_bit(void *checkval, ITEM * item)
+checkcondition_bit(void *checkval, ITEM *item)
{
return GETBIT(checkval, HASHVAL(item->val));
}
* check for boolean condition
*/
static bool
-execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * item))
+execute(ITEM *curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM *item))
{
if (curitem->type == VAL)
* signconsistent & execconsistent called by *_consistent
*/
bool
-signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot)
+signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot)
{
return execute(
GETQUERY(query) + query->size - 1,
}
bool
-execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot)
+execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot)
{
CHKVAL chkval;
} GinChkVal;
static bool
-checkcondition_gin(void *checkval, ITEM * item)
+checkcondition_gin(void *checkval, ITEM *item)
{
GinChkVal *gcv = (GinChkVal *) checkval;
}
bool
-ginconsistent(QUERYTYPE * query, bool *check)
+ginconsistent(QUERYTYPE *query, bool *check)
{
GinChkVal gcv;
ITEM *items = GETQUERY(query);
}
static void
-findoprnd(ITEM * ptr, int4 *pos)
+findoprnd(ITEM *ptr, int4 *pos)
{
#ifdef BS_DEBUG
elog(DEBUG3, (ptr[*pos].type == OPR) ?
}
static int4
-countdroptree(ITEM * q, int4 pos)
+countdroptree(ITEM *q, int4 pos)
{
if (q[pos].type == VAL)
return 1;
* we can modify query tree for clearing
*/
int4
-shorterquery(ITEM * q, int4 len)
+shorterquery(ITEM *q, int4 len)
{
int4 index,
posnot,
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "postgres.h"
{
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
+
/* int32 nkeys = PG_GETARG_INT32(3); */
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
bool *recheck = (bool *) PG_GETARG_POINTER(5);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
ArrayType *query = (ArrayType *) PG_DETOAST_DATUM_COPY(PG_GETARG_POINTER(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
** intbig functions
*********************************************************************/
static bool
-_intbig_overlap(GISTTYPE * a, ArrayType *b)
+_intbig_overlap(GISTTYPE *a, ArrayType *b)
{
int num = ARRNELEMS(b);
int4 *ptr = ARRPTR(b);
}
static bool
-_intbig_contains(GISTTYPE * a, ArrayType *b)
+_intbig_contains(GISTTYPE *a, ArrayType *b)
{
int num = ARRNELEMS(b);
int4 *ptr = ARRPTR(b);
}
static int
-hemdist(GISTTYPE * a, GISTTYPE * b)
+hemdist(GISTTYPE *a, GISTTYPE *b)
{
if (ISALLTRUE(a))
{
}
static int4
-unionkey(BITVECP sbase, GISTTYPE * add)
+unionkey(BITVECP sbase, GISTTYPE *add)
{
int4 i;
BITVECP sadd = GETSIGN(add);
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
ArrayType *query = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_POINTER(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC
};
-static const char * const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"};
+static const char *const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"};
static bool g_weak = false;
static bool g_initialized = false;
* If errorOK is true, just return "false" for bad input.
*/
static bool
-ean2isn(ean13 ean, bool errorOK, ean13 * result, enum isn_type accept)
+ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept)
{
enum isn_type type = INVALID;
* (even if the check digit is valid)
*/
static bool
-string2ean(const char *str, bool errorOK, ean13 * result,
+string2ean(const char *str, bool errorOK, ean13 *result,
enum isn_type accept)
{
bool digit,
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* GiST support for ltree[]
static void
-hashing(BITVECP sign, ltree * t)
+hashing(BITVECP sign, ltree *t)
{
int tlen = t->numlevel;
ltree_level *cur = LTREE_FIRST(t);
}
static int4
-unionkey(BITVECP sbase, ltree_gist * add)
+unionkey(BITVECP sbase, ltree_gist *add)
{
int4 i;
BITVECP sadd = LTG_SIGN(add);
}
static int
-hemdist(ltree_gist * a, ltree_gist * b)
+hemdist(ltree_gist *a, ltree_gist *b)
{
if (LTG_ISALLTRUE(a))
{
}
static bool
-gist_te(ltree_gist * key, ltree * query)
+gist_te(ltree_gist *key, ltree *query)
{
ltree_level *curq = LTREE_FIRST(query);
BITVECP sign = LTG_SIGN(key);
}
static bool
-checkcondition_bit(void *checkval, ITEM * val)
+checkcondition_bit(void *checkval, ITEM *val)
{
return (FLG_CANLOOKSIGN(val->flag)) ? GETBIT(checkval, AHASHVAL(val->val)) : true;
}
static bool
-gist_qtxt(ltree_gist * key, ltxtquery * query)
+gist_qtxt(ltree_gist *key, ltxtquery *query)
{
if (LTG_ISALLTRUE(key))
return true;
}
static bool
-gist_qe(ltree_gist * key, lquery * query)
+gist_qe(ltree_gist *key, lquery *query)
{
lquery_level *curq = LQUERY_FIRST(query);
BITVECP sign = LTG_SIGN(key);
}
static bool
-_arrq_cons(ltree_gist * key, ArrayType *_query)
+_arrq_cons(ltree_gist *key, ArrayType *_query)
{
lquery *query = (lquery *) ARR_DATA_PTR(_query);
int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
char *query = (char *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
ltree_gist *key = (ltree_gist *) DatumGetPointer(entry->key);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* op function for ltree[]
#define NEXTVAL(x) ( (ltree*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
static bool
-array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree ** found)
+array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree **found)
{
int num = ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la));
ltree *item = (ltree *) ARR_DATA_PTR(la);
int nt;
int posq;
int post;
-} FieldNot;
+} FieldNot;
static char *
getlexeme(char *start, char *end, int *len)
{
char *ptr;
- int charlen;
-
- while (start < end && (charlen = pg_mblen(start)) == 1 && t_iseq(start,'_') )
+ int charlen;
+
+ while (start < end && (charlen = pg_mblen(start)) == 1 && t_iseq(start, '_'))
start += charlen;
ptr = start;
if (ptr >= end)
return NULL;
- while (ptr < end && !( (charlen = pg_mblen(ptr)) == 1 && t_iseq(ptr, '_') ) )
+ while (ptr < end && !((charlen = pg_mblen(ptr)) == 1 && t_iseq(ptr, '_')))
ptr += charlen;
*len = ptr - start;
}
bool
-compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
+ compare_subnode(ltree_level *t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
{
char *endt = t->name + t->len;
char *endq = qn + len;
int
ltree_strncasecmp(const char *a, const char *b, size_t s)
{
- char *al = str_tolower(a, s);
- char *bl = str_tolower(b, s);
- int res;
-
- res = strncmp(al, bl,s);
+ char *al = str_tolower(a, s);
+ char *bl = str_tolower(b, s);
+ int res;
+
+ res = strncmp(al, bl, s);
pfree(al);
pfree(bl);
}
static bool
-checkLevel(lquery_level * curq, ltree_level * curt)
+checkLevel(lquery_level *curq, ltree_level *curt)
{
int (*cmpptr) (const char *, const char *, size_t);
lquery_variant *curvar = LQL_FIRST(curq);
};
static bool
-checkCond(lquery_level * curq, int query_numlevel, ltree_level * curt, int tree_numlevel, FieldNot * ptr)
+checkCond(lquery_level *curq, int query_numlevel, ltree_level *curt, int tree_numlevel, FieldNot *ptr)
{
uint32 low_pos = 0,
high_pos = 0,
{
uint16 len;
char name[1];
-} ltree_level;
+} ltree_level;
#define LEVEL_HDRSIZE (offsetof(ltree_level,name))
#define LEVEL_NEXT(x) ( (ltree_level*)( ((char*)(x)) + MAXALIGN(((ltree_level*)(x))->len + LEVEL_HDRSIZE) ) )
int32 vl_len_; /* varlena header (do not touch directly!) */
uint16 numlevel;
char data[1];
-} ltree;
+} ltree;
#define LTREE_HDRSIZE MAXALIGN( offsetof(ltree, data) )
#define LTREE_FIRST(x) ( (ltree_level*)( ((char*)(x))+LTREE_HDRSIZE ) )
uint16 len;
uint8 flag;
char name[1];
-} lquery_variant;
+} lquery_variant;
#define LVAR_HDRSIZE MAXALIGN(offsetof(lquery_variant, name))
#define LVAR_NEXT(x) ( (lquery_variant*)( ((char*)(x)) + MAXALIGN(((lquery_variant*)(x))->len) + LVAR_HDRSIZE ) )
uint16 low;
uint16 high;
char variants[1];
-} lquery_level;
+} lquery_level;
#define LQL_HDRSIZE MAXALIGN( offsetof(lquery_level,variants) )
#define LQL_NEXT(x) ( (lquery_level*)( ((char*)(x)) + MAXALIGN(((lquery_level*)(x))->totallen) ) )
uint16 firstgood;
uint16 flag;
char data[1];
-} lquery;
+} lquery;
#define LQUERY_HDRSIZE MAXALIGN( offsetof(lquery, data) )
#define LQUERY_FIRST(x) ( (lquery_level*)( ((char*)(x))+LQUERY_HDRSIZE ) )
#define LQUERY_HASNOT 0x01
-#define ISALNUM(x) ( t_isalpha(x) || t_isdigit(x) || ( pg_mblen(x) == 1 && t_iseq((x), '_') ) )
+#define ISALNUM(x) ( t_isalpha(x) || t_isdigit(x) || ( pg_mblen(x) == 1 && t_iseq((x), '_') ) )
/* full text query */
/* user-friendly value */
uint8 length;
uint16 distance;
-} ITEM;
+} ITEM;
/*
*Storage:
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 size;
char data[1];
-} ltxtquery;
+} ltxtquery;
#define HDRSIZEQT MAXALIGN(VARHDRSZ + sizeof(int4))
#define COMPUTESIZE(size,lenofoperand) ( HDRSIZEQT + (size) * sizeof(ITEM) + (lenofoperand) )
/* Util function */
Datum ltree_in(PG_FUNCTION_ARGS);
-bool ltree_execute(ITEM * curitem, void *checkval,
- bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
+bool ltree_execute(ITEM *curitem, void *checkval,
+ bool calcnot, bool (*chkcond) (void *checkval, ITEM *val));
-int ltree_compare(const ltree * a, const ltree * b);
-bool inner_isparent(const ltree * c, const ltree * p);
-bool compare_subnode(ltree_level * t, char *q, int len,
- int (*cmpptr) (const char *, const char *, size_t), bool anyend);
-ltree *lca_inner(ltree ** a, int len);
-int ltree_strncasecmp(const char *a, const char *b, size_t s);
+int ltree_compare(const ltree *a, const ltree *b);
+bool inner_isparent(const ltree *c, const ltree *p);
+bool compare_subnode(ltree_level *t, char *q, int len,
+ int (*cmpptr) (const char *, const char *, size_t), bool anyend);
+ltree *lca_inner(ltree **a, int len);
+int ltree_strncasecmp(const char *a, const char *b, size_t s);
#define PG_GETARG_LTREE(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
#define PG_GETARG_LTREE_COPY(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x))))
int32 vl_len_; /* varlena header (do not touch directly!) */
uint32 flag;
char data[1];
-} ltree_gist;
+} ltree_gist;
#define LTG_ONENODE 0x01
#define LTG_ALLTRUE 0x02
}
static void
-hashing(BITVECP sign, ltree * t)
+hashing(BITVECP sign, ltree *t)
{
int tlen = t->numlevel;
ltree_level *cur = LTREE_FIRST(t);
{
int index;
ltree *r;
-} RIX;
+} RIX;
static int
treekey_cmp(const void *a, const void *b)
}
static bool
-gist_isparent(ltree_gist * key, ltree * query)
+gist_isparent(ltree_gist *key, ltree *query)
{
int4 numlevel = query->numlevel;
int i;
}
static ltree *
-copy_ltree(ltree * src)
+copy_ltree(ltree *src)
{
ltree *dst = (ltree *) palloc(VARSIZE(src));
}
static bool
-gist_ischild(ltree_gist * key, ltree * query)
+gist_ischild(ltree_gist *key, ltree *query)
{
ltree *left = copy_ltree(LTG_GETLNODE(key));
ltree *right = copy_ltree(LTG_GETRNODE(key));
}
static bool
-gist_qe(ltree_gist * key, lquery * query)
+gist_qe(ltree_gist *key, lquery *query)
{
lquery_level *curq = LQUERY_FIRST(query);
BITVECP sign = LTG_SIGN(key);
}
static int
-gist_tqcmp(ltree * t, lquery * q)
+gist_tqcmp(ltree *t, lquery *q)
{
ltree_level *al = LTREE_FIRST(t);
lquery_level *ql = LQUERY_FIRST(q);
}
static bool
-gist_between(ltree_gist * key, lquery * query)
+gist_between(ltree_gist *key, lquery *query)
{
if (query->firstgood == 0)
return true;
}
static bool
-checkcondition_bit(void *checkval, ITEM * val)
+checkcondition_bit(void *checkval, ITEM *val)
{
return (FLG_CANLOOKSIGN(val->flag)) ? GETBIT(checkval, HASHVAL(val->val)) : true;
}
static bool
-gist_qtxt(ltree_gist * key, ltxtquery * query)
+gist_qtxt(ltree_gist *key, ltxtquery *query)
{
if (LTG_ISALLTRUE(key))
return true;
}
static bool
-arrq_cons(ltree_gist * key, ArrayType *_query)
+arrq_cons(ltree_gist *key, ArrayType *_query)
{
lquery *query = (lquery *) ARR_DATA_PTR(_query);
int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
ltree_gist *key = (ltree_gist *) DatumGetPointer(entry->key);
typedef struct
{
char *start;
- int len; /* length in bytes */
+ int len; /* length in bytes */
int flag;
- int wlen; /* length in characters */
-} nodeitem;
+ int wlen; /* length in characters */
+} nodeitem;
#define LTPRS_WAITNAME 0
#define LTPRS_WAITDELIM 1
int state = LTPRS_WAITNAME;
ltree *result;
ltree_level *curlevel;
- int charlen;
- int pos=0;
+ int charlen;
+ int pos = 0;
ptr = buf;
while (*ptr)
{
charlen = pg_mblen(ptr);
- if ( charlen == 1 && t_iseq(ptr, '.') )
+ if (charlen == 1 && t_iseq(ptr, '.'))
num++;
- ptr+=charlen;
+ ptr += charlen;
}
list = lptr = (nodeitem *) palloc(sizeof(nodeitem) * (num + 1));
}
else if (state == LTPRS_WAITDELIM)
{
- if ( charlen == 1 && t_iseq(ptr, '.') )
+ if (charlen == 1 && t_iseq(ptr, '.'))
{
lptr->len = ptr - lptr->start;
if (lptr->wlen > 255)
errmsg("name of level is too long"),
errdetail("Name length is %d, must "
"be < 256, in position %d.",
- lptr->wlen, pos)));
+ lptr->wlen, pos)));
totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
lptr++;
/* internal error */
elog(ERROR, "internal error in parser");
- ptr+=charlen;
+ ptr += charlen;
lptr->wlen++;
pos++;
}
bool hasnot = false;
bool wasbad = false;
int charlen;
- int pos=0;
+ int pos = 0;
ptr = buf;
while (*ptr)
{
charlen = pg_mblen(ptr);
- if ( charlen == 1 )
+ if (charlen == 1)
{
if (t_iseq(ptr, '.'))
num++;
numOR++;
}
- ptr+=charlen;
+ ptr += charlen;
}
num++;
state = LQPRS_WAITDELIM;
curqlevel->numvar = 1;
}
- else if (charlen==1 && t_iseq(ptr, '!'))
+ else if (charlen == 1 && t_iseq(ptr, '!'))
{
GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
lptr->start = ptr + 1;
curqlevel->flag |= LQL_NOT;
hasnot = true;
}
- else if (charlen==1 && t_iseq(ptr, '*'))
+ else if (charlen == 1 && t_iseq(ptr, '*'))
state = LQPRS_WAITOPEN;
else
UNCHAR;
}
else if (state == LQPRS_WAITDELIM)
{
- if (charlen==1 && t_iseq(ptr, '@'))
+ if (charlen == 1 && t_iseq(ptr, '@'))
{
if (lptr->start == ptr)
UNCHAR;
lptr->flag |= LVAR_INCASE;
curqlevel->flag |= LVAR_INCASE;
}
- else if (charlen==1 && t_iseq(ptr, '*'))
+ else if (charlen == 1 && t_iseq(ptr, '*'))
{
if (lptr->start == ptr)
UNCHAR;
lptr->flag |= LVAR_ANYEND;
curqlevel->flag |= LVAR_ANYEND;
}
- else if (charlen==1 && t_iseq(ptr, '%'))
+ else if (charlen == 1 && t_iseq(ptr, '%'))
{
if (lptr->start == ptr)
UNCHAR;
lptr->flag |= LVAR_SUBLEXEME;
curqlevel->flag |= LVAR_SUBLEXEME;
}
- else if (charlen==1 && t_iseq(ptr, '|'))
+ else if (charlen == 1 && t_iseq(ptr, '|'))
{
lptr->len = ptr - lptr->start -
((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
errmsg("name of level is too long"),
errdetail("Name length is %d, must "
"be < 256, in position %d.",
- lptr->wlen, pos)));
+ lptr->wlen, pos)));
state = LQPRS_WAITVAR;
}
- else if (charlen==1 && t_iseq(ptr, '.'))
+ else if (charlen == 1 && t_iseq(ptr, '.'))
{
lptr->len = ptr - lptr->start -
((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
errmsg("name of level is too long"),
errdetail("Name length is %d, must "
"be < 256, in position %d.",
- lptr->wlen, pos)));
+ lptr->wlen, pos)));
state = LQPRS_WAITLEVEL;
curqlevel = NEXTLEV(curqlevel);
}
else if (state == LQPRS_WAITOPEN)
{
- if (charlen==1 && t_iseq(ptr, '{'))
+ if (charlen == 1 && t_iseq(ptr, '{'))
state = LQPRS_WAITFNUM;
- else if (charlen==1 && t_iseq(ptr, '.'))
+ else if (charlen == 1 && t_iseq(ptr, '.'))
{
curqlevel->low = 0;
curqlevel->high = 0xffff;
}
else if (state == LQPRS_WAITFNUM)
{
- if (charlen==1 && t_iseq(ptr, ','))
+ if (charlen == 1 && t_iseq(ptr, ','))
state = LQPRS_WAITSNUM;
else if (t_isdigit(ptr))
{
curqlevel->high = atoi(ptr);
state = LQPRS_WAITCLOSE;
}
- else if (charlen==1 && t_iseq(ptr, '}'))
+ else if (charlen == 1 && t_iseq(ptr, '}'))
{
curqlevel->high = 0xffff;
state = LQPRS_WAITEND;
}
else if (state == LQPRS_WAITCLOSE)
{
- if (charlen==1 && t_iseq(ptr, '}'))
+ if (charlen == 1 && t_iseq(ptr, '}'))
state = LQPRS_WAITEND;
else if (!t_isdigit(ptr))
UNCHAR;
}
else if (state == LQPRS_WAITND)
{
- if (charlen==1 && t_iseq(ptr, '}'))
+ if (charlen == 1 && t_iseq(ptr, '}'))
{
curqlevel->high = curqlevel->low;
state = LQPRS_WAITEND;
}
- else if (charlen==1 && t_iseq(ptr, ','))
+ else if (charlen == 1 && t_iseq(ptr, ','))
state = LQPRS_WAITSNUM;
else if (!t_isdigit(ptr))
UNCHAR;
}
else if (state == LQPRS_WAITEND)
{
- if (charlen==1 && t_iseq(ptr, '.'))
+ if (charlen == 1 && t_iseq(ptr, '.'))
{
state = LQPRS_WAITLEVEL;
curqlevel = NEXTLEV(curqlevel);
/* internal error */
elog(ERROR, "internal error in parser");
- ptr+=charlen;
- if ( state == LQPRS_WAITDELIM )
+ ptr += charlen;
+ if (state == LQPRS_WAITDELIM)
lptr->wlen++;
pos++;
}
Datum ltreeparentsel(PG_FUNCTION_ARGS);
int
-ltree_compare(const ltree * a, const ltree * b)
+ltree_compare(const ltree *a, const ltree *b)
{
ltree_level *al = LTREE_FIRST(a);
ltree_level *bl = LTREE_FIRST(b);
}
bool
-inner_isparent(const ltree * c, const ltree * p)
+inner_isparent(const ltree *c, const ltree *p)
{
ltree_level *cl = LTREE_FIRST(c);
ltree_level *pl = LTREE_FIRST(p);
static ltree *
-inner_subltree(ltree * t, int4 startpos, int4 endpos)
+inner_subltree(ltree *t, int4 startpos, int4 endpos)
{
char *start = NULL,
*end = NULL;
}
static ltree *
-ltree_concat(ltree * a, ltree * b)
+ltree_concat(ltree *a, ltree *b)
{
ltree *r;
}
ltree *
-lca_inner(ltree ** a, int len)
+lca_inner(ltree **a, int len)
{
int tmp,
num = ((*a)->numlevel) ? (*a)->numlevel - 1 : 0;
else if (hist_size < 100)
{
/*
- * For histogram sizes from 10 to 100, we combine the
- * histogram and default selectivities, putting increasingly
- * more trust in the histogram for larger sizes.
+ * For histogram sizes from 10 to 100, we combine the histogram
+ * and default selectivities, putting increasingly more trust in
+ * the histogram for larger sizes.
*/
- double hist_weight = hist_size / 100.0;
+ double hist_weight = hist_size / 100.0;
selec = selec * hist_weight +
DEFAULT_PARENT_SEL * (1.0 - hist_weight);
int4 sumlen;
char *op;
char *curop;
-} QPRS_STATE;
+} QPRS_STATE;
/*
* get token from query string
*/
static int4
-gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval, uint16 *flag)
+gettoken_query(QPRS_STATE *state, int4 *val, int4 *lenval, char **strval, uint16 *flag)
{
- int charlen;
+ int charlen;
- for(;;)
+ for (;;)
{
charlen = pg_mblen(state->buf);
switch (state->state)
{
case WAITOPERAND:
- if (charlen==1 && t_iseq(state->buf, '!'))
+ if (charlen == 1 && t_iseq(state->buf, '!'))
{
(state->buf)++;
*val = (int4) '!';
return OPR;
}
- else if (charlen==1 && t_iseq(state->buf, '('))
+ else if (charlen == 1 && t_iseq(state->buf, '('))
{
state->count++;
(state->buf)++;
errmsg("modificators syntax error")));
*lenval += charlen;
}
- else if (charlen==1 && t_iseq(state->buf, '%'))
+ else if (charlen == 1 && t_iseq(state->buf, '%'))
*flag |= LVAR_SUBLEXEME;
- else if (charlen==1 && t_iseq(state->buf, '@'))
+ else if (charlen == 1 && t_iseq(state->buf, '@'))
*flag |= LVAR_INCASE;
- else if (charlen==1 && t_iseq(state->buf, '*'))
+ else if (charlen == 1 && t_iseq(state->buf, '*'))
*flag |= LVAR_ANYEND;
else
{
}
break;
case WAITOPERATOR:
- if (charlen==1 && ( t_iseq(state->buf, '&') || t_iseq(state->buf, '|') ))
+ if (charlen == 1 && (t_iseq(state->buf, '&') || t_iseq(state->buf, '|')))
{
state->state = WAITOPERAND;
*val = (int4) *(state->buf);
(state->buf)++;
return OPR;
}
- else if (charlen==1 && t_iseq(state->buf, ')'))
+ else if (charlen == 1 && t_iseq(state->buf, ')'))
{
(state->buf)++;
state->count--;
}
else if (*(state->buf) == '\0')
return (state->count) ? ERR : END;
- else if (charlen==1 && !t_iseq(state->buf, ' '))
+ else if (charlen == 1 && !t_iseq(state->buf, ' '))
return ERR;
break;
default:
* push new one in polish notation reverse view
*/
static void
-pushquery(QPRS_STATE * state, int4 type, int4 val, int4 distance, int4 lenval, uint16 flag)
+pushquery(QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval, uint16 flag)
{
NODE *tmp = (NODE *) palloc(sizeof(NODE));
* This function is used for query_txt parsing
*/
static void
-pushval_asis(QPRS_STATE * state, int type, char *strval, int lenval, uint16 flag)
+pushval_asis(QPRS_STATE *state, int type, char *strval, int lenval, uint16 flag)
{
if (lenval > 0xffff)
ereport(ERROR,
* make polish notaion of query
*/
static int4
-makepol(QPRS_STATE * state)
+makepol(QPRS_STATE *state)
{
int4 val = 0,
type;
}
static void
-findoprnd(ITEM * ptr, int4 *pos)
+findoprnd(ITEM *ptr, int4 *pos)
{
if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE)
{
* check for boolean condition
*/
bool
-ltree_execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * val))
+ltree_execute(ITEM *curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM *val))
{
if (curitem->type == VAL)
return (*chkcond) (checkval, curitem);
} CHKVAL;
static bool
-checkcondition_str(void *checkval, ITEM * val)
+checkcondition_str(void *checkval, ITEM *val)
{
ltree_level *level = LTREE_FIRST(((CHKVAL *) checkval)->node);
int tlen = ((CHKVAL *) checkval)->node->numlevel;
char **array;
int num;
int alloc;
-} eary;
+} eary;
/* these are the opts structures for command line params */
struct options
void get_opts(int, char **, struct options *);
void *myalloc(size_t size);
char *mystrdup(const char *str);
-void add_one_elt(char *eltname, eary * eary);
-char *get_comma_elts(eary * eary);
+void add_one_elt(char *eltname, eary *eary);
+char *get_comma_elts(eary *eary);
PGconn *sql_conn(struct options *);
int sql_exec(PGconn *, const char *sql, bool quiet);
void sql_exec_dumpalldbs(PGconn *, struct options *);
* Add one element to a (possibly empty) eary struct.
*/
void
-add_one_elt(char *eltname, eary * eary)
+add_one_elt(char *eltname, eary *eary)
{
if (eary->alloc == 0)
{
- eary->alloc = 8;
- eary->array = (char **) myalloc(8 * sizeof(char *));
+ eary ->alloc = 8;
+ eary ->array = (char **) myalloc(8 * sizeof(char *));
}
else if (eary->num >= eary->alloc)
{
- eary->alloc *= 2;
- eary->array = (char **)
- realloc(eary->array, eary->alloc * sizeof(char *));
+ eary ->alloc *= 2;
+ eary ->array = (char **)
+ realloc(eary->array, eary->alloc * sizeof(char *));
+
if (!eary->array)
{
fprintf(stderr, "out of memory");
}
}
- eary->array[eary->num] = mystrdup(eltname);
- eary->num++;
+ eary ->array[eary->num] = mystrdup(eltname);
+ eary ->num++;
}
/*
* SQL statement.
*/
char *
-get_comma_elts(eary * eary)
+get_comma_elts(eary *eary)
{
char *ret,
*ptr;
new_pass = false;
conn = PQsetdbLogin(my_opts->hostname,
my_opts->port,
- NULL, /* options */
- NULL, /* tty */
+ NULL, /* options */
+ NULL, /* tty */
my_opts->dbname,
my_opts->username,
password);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* btreefuncs.c
} btpo;
uint16 btpo_flags;
BTCycleId btpo_cycleid;
-} BTPageStat;
+} BTPageStat;
/* -------------------------------------------------
* -------------------------------------------------
*/
static void
-GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat * stat)
+GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
{
Page page = BufferGetPage(buffer);
PageHeader phdr = (PageHeader) page;
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the
* owning session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot access temporary tables of other sessions")));
+ errmsg("cannot access temporary tables of other sessions")));
if (blkno == 0)
elog(ERROR, "block 0 is a meta page");
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
#include "miscadmin.h"
#include "funcapi.h"
-Datum fsm_page_contents(PG_FUNCTION_ARGS);
+Datum fsm_page_contents(PG_FUNCTION_ARGS);
/*
* Dumps the contents of a FSM page.
initStringInfo(&sinfo);
- for(i=0; i < NodesPerPage; i++)
+ for (i = 0; i < NodesPerPage; i++)
{
if (fsmpage->fp_nodes[i] != 0)
appendStringInfo(&sinfo, "%d: %d\n", i, fsmpage->fp_nodes[i]);
TupleDesc tupd;
Page page;
uint16 offset;
-} heap_page_items_state;
+} heap_page_items_state;
Datum
heap_page_items(PG_FUNCTION_ARGS)
(((char *) tuphdr->t_bits) -((char *) tuphdr));
values[11] = CStringGetTextDatum(
- bits_to_text(tuphdr->t_bits, bits_len * 8));
+ bits_to_text(tuphdr->t_bits, bits_len * 8));
}
else
nulls[11] = true;
Datum page_header(PG_FUNCTION_ARGS);
static bytea *get_raw_page_internal(text *relname, ForkNumber forknum,
- BlockNumber blkno);
+ BlockNumber blkno);
/*
RelationGetRelationName(rel))));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
bool isvalid;
bool isdirty;
uint16 usagecount;
-} BufferCachePagesRec;
+} BufferCachePagesRec;
/*
{
TupleDesc tupdesc;
BufferCachePagesRec *record;
-} BufferCachePagesContext;
+} BufferCachePagesContext;
/*
Datum
pg_freespace(PG_FUNCTION_ARGS)
{
- Oid relid = PG_GETARG_OID(0);
- int64 blkno = PG_GETARG_INT64(1);
- int16 freespace;
- Relation rel;
+ Oid relid = PG_GETARG_OID(0);
+ int64 blkno = PG_GETARG_INT64(1);
+ int16 freespace;
+ Relation rel;
rel = relation_open(relid, AccessShareLock);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* pg_standby.c
#define SmartFailover 1
#define FastFailover 2
-static int Failover = NoFailover;
+static int Failover = NoFailover;
#define RESTORE_COMMAND_COPY 0
#define RESTORE_COMMAND_LINK 1
/*
* Windows 'cp' sets the final file size before the copy is
- * complete, and not yet ready to be opened by pg_standby.
- * So we wait for sleeptime secs before attempting to restore.
- * If that is not enough, we will rely on the retry/holdoff
- * mechanism. GNUWin32's cp does not have this problem.
+ * complete, and not yet ready to be opened by pg_standby. So we
+ * wait for sleeptime secs before attempting to restore. If that
+ * is not enough, we will rely on the retry/holdoff mechanism.
+ * GNUWin32's cp does not have this problem.
*/
pg_usleep(sleeptime * 1000000L);
#endif
if (restartWALFileName)
{
/*
- * Don't do cleanup if the restartWALFileName provided
- * is later than the xlog file requested. This is an error
- * and we must not remove these files from archive.
- * This shouldn't happen, but better safe than sorry.
+ * Don't do cleanup if the restartWALFileName provided is later than
+ * the xlog file requested. This is an error and we must not remove
+ * these files from archive. This shouldn't happen, but better safe
+ * than sorry.
*/
if (strcmp(restartWALFileName, nextWALFileName) > 0)
return false;
* CheckForExternalTrigger()
*
* Is there a trigger file? Sets global 'Failover' variable to indicate
- * what kind of a trigger file it was. A "fast" trigger file is turned
- * into a "smart" file as a side-effect.
+ * what kind of a trigger file it was. A "fast" trigger file is turned
+ * into a "smart" file as a side-effect.
*/
static void
CheckForExternalTrigger(void)
{
- char buf[32];
- int fd;
- int len;
+ char buf[32];
+ int fd;
+ int len;
/*
* Look for a trigger file, if that option has been selected
/*
* An empty trigger file performs smart failover. There's a little race
- * condition here: if the writer of the trigger file has just created
- * the file, but not yet written anything to it, we'll treat that as
- * smart shutdown even if the other process was just about to write "fast"
- * to it. But that's fine: we'll restore one more WAL file, and when we're
+ * condition here: if the writer of the trigger file has just created the
+ * file, but not yet written anything to it, we'll treat that as smart
+ * shutdown even if the other process was just about to write "fast" to
+ * it. But that's fine: we'll restore one more WAL file, and when we're
* invoked next time, we'll see the word "fast" and fail over immediately.
*/
if (stat_buf.st_size == 0)
fflush(stderr);
return;
}
-
+
if ((len = read(fd, buf, sizeof(buf))) < 0)
{
fprintf(stderr, "WARNING: could not read \"%s\": %s\n",
return;
}
buf[len] = '\0';
-
+
if (strncmp(buf, "smart", 5) == 0)
{
Failover = SmartFailover;
close(fd);
return;
}
-
+
if (strncmp(buf, "fast", 4) == 0)
{
Failover = FastFailover;
fflush(stderr);
/*
- * Turn it into a "smart" trigger by truncating the file. Otherwise
- * if the server asks us again to restore a segment that was restored
+ * Turn it into a "smart" trigger by truncating the file. Otherwise if
+ * the server asks us again to restore a segment that was restored
* restored already, we would return "not found" and upset the server.
*/
if (ftruncate(fd, 0) < 0)
return;
}
close(fd);
-
+
fprintf(stderr, "WARNING: invalid content in \"%s\"\n", triggerPath);
fflush(stderr);
return;
printf("Usage:\n");
printf(" %s [OPTION]... ARCHIVELOCATION NEXTWALFILE XLOGFILEPATH [RESTARTWALFILE]\n", progname);
printf("\n"
- "with main intended use as a restore_command in the recovery.conf:\n"
+ "with main intended use as a restore_command in the recovery.conf:\n"
" restore_command = 'pg_standby [OPTION]... ARCHIVELOCATION %%f %%p %%r'\n"
"e.g.\n"
" restore_command = 'pg_standby -l /mnt/server/archiverdir %%f %%p %%r'\n");
* You can send SIGUSR1 to trigger failover.
*
* Postmaster uses SIGQUIT to request immediate shutdown. The default
- * action is to core dump, but we don't want that, so trap it and
- * commit suicide without core dump.
+ * action is to core dump, but we don't want that, so trap it and commit
+ * suicide without core dump.
*
- * We used to use SIGINT and SIGQUIT to trigger failover, but that
- * turned out to be a bad idea because postmaster uses SIGQUIT to
- * request immediate shutdown. We still trap SIGINT, but that may
- * change in a future release.
+ * We used to use SIGINT and SIGQUIT to trigger failover, but that turned
+ * out to be a bad idea because postmaster uses SIGQUIT to request
+ * immediate shutdown. We still trap SIGINT, but that may change in a
+ * future release.
*/
(void) signal(SIGUSR1, sighandler);
- (void) signal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
+ (void) signal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
#ifndef WIN32
(void) signal(SIGQUIT, sigquit_handler);
#endif
{
/*
* Once we have restored this file successfully we can remove some
- * prior WAL files. If this restore fails we musn't remove any file
- * because some of them will be requested again immediately after
- * the failed restore, or when we restart recovery.
+ * prior WAL files. If this restore fails we musn't remove any
+ * file because some of them will be requested again immediately
+ * after the failed restore, or when we restart recovery.
*/
if (RestoreWALFileForRecovery())
{
*/
typedef struct pgssEntry
{
- pgssHashKey key; /* hash key of entry - MUST BE FIRST */
+ pgssHashKey key; /* hash key of entry - MUST BE FIRST */
Counters counters; /* the statistics for this query */
slock_t mutex; /* protects the counters only */
char query[1]; /* VARIABLE LENGTH ARRAY - MUST BE LAST */
/*---- Local variables ----*/
/* Current nesting depth of ExecutorRun calls */
-static int nested_level = 0;
+static int nested_level = 0;
+
/* Saved hook values in case of unload */
-static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
-static ExecutorStart_hook_type prev_ExecutorStart = NULL;
-static ExecutorRun_hook_type prev_ExecutorRun = NULL;
-static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
+static ExecutorStart_hook_type prev_ExecutorStart = NULL;
+static ExecutorRun_hook_type prev_ExecutorRun = NULL;
+static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+
/* Links to shared memory state */
-static pgssSharedState *pgss = NULL;
-static HTAB *pgss_hash = NULL;
+static pgssSharedState *pgss = NULL;
+static HTAB *pgss_hash = NULL;
/*---- GUC variables ----*/
/*---- Function declarations ----*/
-void _PG_init(void);
-void _PG_fini(void);
+void _PG_init(void);
+void _PG_fini(void);
-Datum pg_stat_statements_reset(PG_FUNCTION_ARGS);
-Datum pg_stat_statements(PG_FUNCTION_ARGS);
+Datum pg_stat_statements_reset(PG_FUNCTION_ARGS);
+Datum pg_stat_statements(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(pg_stat_statements_reset);
PG_FUNCTION_INFO_V1(pg_stat_statements);
static void pgss_shmem_shutdown(int code, Datum arg);
static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags);
static void pgss_ExecutorRun(QueryDesc *queryDesc,
- ScanDirection direction,
- long count);
+ ScanDirection direction,
+ long count);
static void pgss_ExecutorEnd(QueryDesc *queryDesc);
static uint32 pgss_hash_fn(const void *key, Size keysize);
-static int pgss_match_fn(const void *key1, const void *key2, Size keysize);
+static int pgss_match_fn(const void *key1, const void *key2, Size keysize);
static void pgss_store(const char *query,
- const Instrumentation *instr, uint32 rows);
-static Size pgss_memsize(void);
+ const Instrumentation *instr, uint32 rows);
+static Size pgss_memsize(void);
static pgssEntry *entry_alloc(pgssHashKey *key);
static void entry_dealloc(void);
static void entry_reset(void);
{
/*
* In order to create our shared memory area, we have to be loaded via
- * shared_preload_libraries. If not, fall out without hooking into
- * any of the main system. (We don't throw error here because it seems
- * useful to allow the pg_stat_statements functions to be created even
- * when the module isn't active. The functions must protect themselves
- * against being called then, however.)
+ * shared_preload_libraries. If not, fall out without hooking into any of
+ * the main system. (We don't throw error here because it seems useful to
+ * allow the pg_stat_statements functions to be created even when the
+ * module isn't active. The functions must protect themselves against
+ * being called then, however.)
*/
if (!process_shared_preload_libraries_in_progress)
return;
* Define (or redefine) custom GUC variables.
*/
DefineCustomIntVariable("pg_stat_statements.max",
- "Sets the maximum number of statements tracked by pg_stat_statements.",
+ "Sets the maximum number of statements tracked by pg_stat_statements.",
NULL,
&pgss_max,
1000,
NULL);
DefineCustomEnumVariable("pg_stat_statements.track",
- "Selects which statements are tracked by pg_stat_statements.",
+ "Selects which statements are tracked by pg_stat_statements.",
NULL,
&pgss_track,
PGSS_TRACK_TOP,
NULL);
DefineCustomBoolVariable("pg_stat_statements.save",
- "Save pg_stat_statements statistics across server shutdowns.",
+ "Save pg_stat_statements statistics across server shutdowns.",
NULL,
&pgss_save,
true,
static void
pgss_shmem_startup(void)
{
- bool found;
+ bool found;
HASHCTL info;
FILE *file;
uint32 header;
elog(ERROR, "out of shared memory");
if (!found)
- {
+ {
/* First time through ... */
pgss->lock = LWLockAssign();
pgss->query_size = pgstat_track_activity_query_size;
memset(&info, 0, sizeof(info));
info.keysize = sizeof(pgssHashKey);
- info.entrysize = offsetof(pgssEntry, query) + query_size;
+ info.entrysize = offsetof(pgssEntry, query) +query_size;
info.hash = pgss_hash_fn;
info.match = pgss_match_fn;
pgss_hash = ShmemInitHash("pg_stat_statements hash",
LWLockRelease(AddinShmemInitLock);
/*
- * If we're in the postmaster (or a standalone backend...), set up a
- * shmem exit hook to dump the statistics to disk.
+ * If we're in the postmaster (or a standalone backend...), set up a shmem
+ * exit hook to dump the statistics to disk.
*/
if (!IsUnderPostmaster)
on_shmem_exit(pgss_shmem_shutdown, (Datum) 0);
/*
* Attempt to load old statistics from the dump file.
*
- * Note: we don't bother with locks here, because there should be no
- * other processes running when this is called.
+ * Note: we don't bother with locks here, because there should be no other
+ * processes running when this is called.
*/
if (!pgss_save)
return;
for (i = 0; i < num; i++)
{
pgssEntry temp;
- pgssEntry *entry;
+ pgssEntry *entry;
if (fread(&temp, offsetof(pgssEntry, mutex), 1, file) != 1)
goto error;
static void
pgss_shmem_shutdown(int code, Datum arg)
{
- FILE *file;
- HASH_SEQ_STATUS hash_seq;
- int32 num_entries;
- pgssEntry *entry;
+ FILE *file;
+ HASH_SEQ_STATUS hash_seq;
+ int32 num_entries;
+ pgssEntry *entry;
/* Don't try to dump during a crash. */
if (code)
hash_seq_init(&hash_seq, pgss_hash);
while ((entry = hash_seq_search(&hash_seq)) != NULL)
{
- int len = entry->key.query_len;
+ int len = entry->key.query_len;
if (fwrite(entry, offsetof(pgssEntry, mutex), 1, file) != 1 ||
fwrite(entry->query, 1, len, file) != len)
if (pgss_enabled())
{
/*
- * Set up to track total elapsed time in ExecutorRun. Make sure
- * the space is allocated in the per-query context so it will go
- * away at ExecutorEnd.
+ * Set up to track total elapsed time in ExecutorRun. Make sure the
+ * space is allocated in the per-query context so it will go away at
+ * ExecutorEnd.
*/
if (queryDesc->totaltime == NULL)
{
if (queryDesc->totaltime && pgss_enabled())
{
/*
- * Make sure stats accumulation is done. (Note: it's okay if
- * several levels of hook all do this.)
+ * Make sure stats accumulation is done. (Note: it's okay if several
+ * levels of hook all do this.)
*/
InstrEndLoop(queryDesc->totaltime);
static void
pgss_store(const char *query, const Instrumentation *instr, uint32 rows)
{
- pgssHashKey key;
+ pgssHashKey key;
double usage;
- pgssEntry *entry;
+ pgssEntry *entry;
Assert(query != NULL);
Datum
pg_stat_statements(PG_FUNCTION_ARGS)
{
- ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- TupleDesc tupdesc;
- Tuplestorestate *tupstore;
- MemoryContext per_query_ctx;
- MemoryContext oldcontext;
- Oid userid = GetUserId();
- bool is_superuser = superuser();
- HASH_SEQ_STATUS hash_seq;
- pgssEntry *entry;
+ ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ TupleDesc tupdesc;
+ Tuplestorestate *tupstore;
+ MemoryContext per_query_ctx;
+ MemoryContext oldcontext;
+ Oid userid = GetUserId();
+ bool is_superuser = superuser();
+ HASH_SEQ_STATUS hash_seq;
+ pgssEntry *entry;
if (!pgss || !pgss_hash)
ereport(ERROR,
if (is_superuser || entry->key.userid == userid)
{
- char *qstr;
+ char *qstr;
qstr = (char *)
pg_do_encoding_conversion((unsigned char *) entry->query,
static Size
pgss_memsize(void)
{
- Size size;
- Size entrysize;
+ Size size;
+ Size entrysize;
size = MAXALIGN(sizeof(pgssSharedState));
- entrysize = offsetof(pgssEntry, query) + pgstat_track_activity_query_size;
+ entrysize = offsetof(pgssEntry, query) +pgstat_track_activity_query_size;
size = add_size(size, hash_estimate_size(pgss_max, entrysize));
return size;
* caller must hold an exclusive lock on pgss->lock
*
* Note: despite needing exclusive lock, it's not an error for the target
- * entry to already exist. This is because pgss_store releases and
+ * entry to already exist. This is because pgss_store releases and
* reacquires lock after failing to find a match; so someone else could
* have made the entry while we waited to get exclusive lock.
*/
entry_alloc(pgssHashKey *key)
{
pgssEntry *entry;
- bool found;
+ bool found;
/* Caller must have clipped query properly */
Assert(key->query_len < pgss->query_size);
static int
entry_cmp(const void *lhs, const void *rhs)
{
- double l_usage = (*(const pgssEntry **)lhs)->counters.usage;
- double r_usage = (*(const pgssEntry **)rhs)->counters.usage;
+ double l_usage = (*(const pgssEntry **) lhs)->counters.usage;
+ double r_usage = (*(const pgssEntry **) rhs)->counters.usage;
if (l_usage < r_usage)
return -1;
static void
entry_dealloc(void)
{
- HASH_SEQ_STATUS hash_seq;
- pgssEntry **entries;
- pgssEntry *entry;
- int nvictims;
- int i;
+ HASH_SEQ_STATUS hash_seq;
+ pgssEntry **entries;
+ pgssEntry *entry;
+ int nvictims;
+ int i;
/* Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them. */
static void
entry_reset(void)
{
- HASH_SEQ_STATUS hash_seq;
- pgssEntry *entry;
+ HASH_SEQ_STATUS hash_seq;
+ pgssEntry *entry;
LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#ifndef __TRGM_H__
#define __TRGM_H__
*(((char*)(a))+2) = *(((char*)(b))+2); \
} while(0);
-uint32 trgm2int(trgm *ptr);
+uint32 trgm2int(trgm *ptr);
#ifdef KEEPONLYALNUM
#define ISPRINTABLECHAR(a) ( isascii( *(unsigned char*)(a) ) && (isalnum( *(unsigned char*)(a) ) || *(unsigned char*)(a)==' ') )
int32 vl_len_; /* varlena header (do not touch directly!) */
uint8 flag;
char data[1];
-} TRGM;
+} TRGM;
#define TRGMHDRSIZE (VARHDRSZ + sizeof(uint8))
extern float4 trgm_limit;
TRGM *generate_trgm(char *str, int slen);
-float4 cnt_sml(TRGM * trg1, TRGM * trg2);
+float4 cnt_sml(TRGM *trg1, TRGM *trg2);
#endif
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "trgm.h"
/*
* Function called from query extracting
*/
- Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
+ Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
- *extra_data = (Pointer*) palloc0(sizeof(Pointer)*(*nentries));
+ *extra_data = (Pointer *) palloc0(sizeof(Pointer) * (*nentries));
- *(int32*)(*extra_data) = trglen;
+ *(int32 *) (*extra_data) = trglen;
}
}
gin_trgm_consistent(PG_FUNCTION_ARGS)
{
bool *check = (bool *) PG_GETARG_POINTER(0);
+
/* StrategyNumber strategy = PG_GETARG_UINT16(1); */
- /* text *query = PG_GETARG_TEXT_P(2); */
+ /* text *query = PG_GETARG_TEXT_P(2); */
/* int32 nkeys = PG_GETARG_INT32(3); */
Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
bool *recheck = (bool *) PG_GETARG_POINTER(5);
/* All cases served by this function are inexact */
*recheck = true;
- trglen = *(int32*)extra_data;
+ trglen = *(int32 *) extra_data;
for (i = 0; i < trglen; i++)
if (check[i])
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "trgm.h"
}
static void
-makesign(BITVECP sign, TRGM * a)
+makesign(BITVECP sign, TRGM *a)
{
int4 k,
len = ARRNELEM(a);
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
text *query = PG_GETARG_TEXT_P(1);
+
/* StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); */
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
TRGM *key = (TRGM *) DatumGetPointer(entry->key);
TRGM *qtrg;
bool res = false;
- char *cache = (char*) fcinfo->flinfo->fn_extra;
+ char *cache = (char *) fcinfo->flinfo->fn_extra;
/* All cases served by this function are exact */
*recheck = false;
- if ( cache == NULL || VARSIZE(cache) != VARSIZE(query) || memcmp( cache, query, VARSIZE(query) ) !=0 )
+ if (cache == NULL || VARSIZE(cache) != VARSIZE(query) || memcmp(cache, query, VARSIZE(query)) != 0)
{
- qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
+ qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
if (cache)
pfree(cache);
fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
- MAXALIGN(VARSIZE(query)) + VARSIZE(qtrg) );
- cache = (char*) fcinfo->flinfo->fn_extra;
+ MAXALIGN(VARSIZE(query)) + VARSIZE(qtrg));
+ cache = (char *) fcinfo->flinfo->fn_extra;
- memcpy( cache, query, VARSIZE(query) );
- memcpy( cache + MAXALIGN(VARSIZE(query)), qtrg, VARSIZE(qtrg) );
+ memcpy(cache, query, VARSIZE(query));
+ memcpy(cache + MAXALIGN(VARSIZE(query)), qtrg, VARSIZE(qtrg));
}
- qtrg = (TRGM*)( cache + MAXALIGN(VARSIZE(query)) );
+ qtrg = (TRGM *) (cache + MAXALIGN(VARSIZE(query)));
if (GIST_LEAF(entry))
{ /* all leafs contains orig trgm */
}
static int4
-unionkey(BITVECP sbase, TRGM * add)
+unionkey(BITVECP sbase, TRGM *add)
{
int4 i;
}
static int
-hemdist(TRGM * a, TRGM * b)
+hemdist(TRGM *a, TRGM *b)
{
if (ISALLTRUE(a))
{
} CACHESIGN;
static void
-fillcache(CACHESIGN *item, TRGM * key)
+fillcache(CACHESIGN *item, TRGM *key)
{
item->allistrue = false;
if (ISARRKEY(key))
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "trgm.h"
#include <ctype.h>
}
static int
-unique_array(trgm * a, int len)
+unique_array(trgm *a, int len)
{
trgm *curend,
*tmp;
}
#ifdef KEEPONLYALNUM
-#define iswordchr(c) (t_isalpha(c) || t_isdigit(c))
+#define iswordchr(c) (t_isalpha(c) || t_isdigit(c))
#else
#define iswordchr(c) (!t_isspace(c))
#endif
* Finds first word in string, returns pointer to the word,
* endword points to the character after word
*/
-static char*
-find_word(char *str, int lenstr, char **endword, int *charlen)
+static char *
+find_word(char *str, int lenstr, char **endword, int *charlen)
{
- char *beginword = str;
+ char *beginword = str;
- while( beginword - str < lenstr && !iswordchr(beginword) )
+ while (beginword - str < lenstr && !iswordchr(beginword))
beginword += pg_mblen(beginword);
if (beginword - str >= lenstr)
*endword = beginword;
*charlen = 0;
- while( *endword - str < lenstr && iswordchr(*endword) )
+ while (*endword - str < lenstr && iswordchr(*endword))
{
*endword += pg_mblen(*endword);
(*charlen)++;
#ifdef USE_WIDE_UPPER_LOWER
static void
-cnt_trigram(trgm *tptr, char *str, int bytelen)
+cnt_trigram(trgm *tptr, char *str, int bytelen)
{
- if ( bytelen == 3 )
+ if (bytelen == 3)
{
- CPTRGM(tptr, str);
+ CPTRGM(tptr, str);
}
else
{
FIN_CRC32(crc);
/*
- * use only 3 upper bytes from crc, hope, it's
- * good enough hashing
+ * use only 3 upper bytes from crc, hope, it's good enough hashing
*/
CPTRGM(tptr, &crc);
}
/*
* Adds trigramm from words (already padded).
*/
-static trgm*
-make_trigrams( trgm *tptr, char *str, int bytelen, int charlen )
+static trgm *
+make_trigrams(trgm *tptr, char *str, int bytelen, int charlen)
{
- char *ptr = str;
+ char *ptr = str;
- if ( charlen < 3 )
+ if (charlen < 3)
return tptr;
#ifdef USE_WIDE_UPPER_LOWER
if (pg_database_encoding_max_length() > 1)
{
- int lenfirst = pg_mblen(str),
- lenmiddle = pg_mblen(str + lenfirst),
- lenlast = pg_mblen(str + lenfirst + lenmiddle);
+ int lenfirst = pg_mblen(str),
+ lenmiddle = pg_mblen(str + lenfirst),
+ lenlast = pg_mblen(str + lenfirst + lenmiddle);
- while( (ptr - str) + lenfirst + lenmiddle + lenlast <= bytelen )
+ while ((ptr - str) + lenfirst + lenmiddle + lenlast <= bytelen)
{
cnt_trigram(tptr, ptr, lenfirst + lenmiddle + lenlast);
ptr += lenfirst;
tptr++;
- lenfirst = lenmiddle;
- lenmiddle = lenlast;
- lenlast = pg_mblen(ptr + lenfirst + lenmiddle);
+ lenfirst = lenmiddle;
+ lenmiddle = lenlast;
+ lenlast = pg_mblen(ptr + lenfirst + lenmiddle);
}
}
else
#endif
{
- Assert( bytelen == charlen );
+ Assert(bytelen == charlen);
while (ptr - str < bytelen - 2 /* number of trigrams = strlen - 2 */ )
{
tptr++;
}
}
-
+
return tptr;
}
int len,
charlen,
bytelen;
- char *bword, *eword;
+ char *bword,
+ *eword;
- trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) * 3);
+ trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) *3);
trg->flag = ARRKEY;
SET_VARSIZE(trg, TRGMHDRSIZE);
}
eword = str;
- while( (bword=find_word(eword, slen - (eword-str), &eword, &charlen)) != NULL )
+ while ((bword = find_word(eword, slen - (eword - str), &eword, &charlen)) != NULL)
{
#ifdef IGNORECASE
bword = lowerstr_with_len(bword, eword - bword);
#ifdef IGNORECASE
pfree(bword);
#endif
- buf[LPADDING+bytelen] = ' ';
- buf[LPADDING+bytelen+1] = ' ';
+ buf[LPADDING + bytelen] = ' ';
+ buf[LPADDING + bytelen + 1] = ' ';
/*
* count trigrams
*/
- tptr = make_trigrams( tptr, buf, bytelen + LPADDING + RPADDING,
- charlen + LPADDING + RPADDING );
+ tptr = make_trigrams(tptr, buf, bytelen + LPADDING + RPADDING,
+ charlen + LPADDING + RPADDING);
}
pfree(buf);
uint32
trgm2int(trgm *ptr)
{
- uint32 val = 0;
+ uint32 val = 0;
- val |= *( ((unsigned char*)ptr) );
+ val |= *(((unsigned char *) ptr));
val <<= 8;
- val |= *( ((unsigned char*)ptr) + 1 );
+ val |= *(((unsigned char *) ptr) + 1);
val <<= 8;
- val |= *( ((unsigned char*)ptr) + 2 );
+ val |= *(((unsigned char *) ptr) + 2);
return val;
}
for (i = 0, ptr = GETARR(trg); i < ARRNELEM(trg); i++, ptr++)
{
- text *item = (text *) palloc(VARHDRSZ + Max(12, pg_database_encoding_max_length()*3) );
+ text *item = (text *) palloc(VARHDRSZ + Max(12, pg_database_encoding_max_length() * 3));
- if ( pg_database_encoding_max_length() > 1 && !ISPRINTABLETRGM(ptr) )
+ if (pg_database_encoding_max_length() > 1 && !ISPRINTABLETRGM(ptr))
{
snprintf(VARDATA(item), 12, "0x%06x", trgm2int(ptr));
SET_VARSIZE(item, VARHDRSZ + strlen(VARDATA(item)));
}
float4
-cnt_sml(TRGM * trg1, TRGM * trg2)
+cnt_sml(TRGM *trg1, TRGM *trg2)
{
trgm *ptr1,
*ptr2;
char *login = NULL;
char *dbName;
-volatile bool timer_exceeded = false; /* flag from signal handler */
+volatile bool timer_exceeded = false; /* flag from signal handler */
/* variable definitions */
typedef struct
{
char *name; /* variable name */
char *value; /* its value */
-} Variable;
+} Variable;
#define MAX_FILES 128 /* max number of SQL script files allowed */
struct timeval txn_begin; /* used for measuring latencies */
int use_file; /* index in sql_files for this client */
bool prepared[MAX_FILES];
-} CState;
+} CState;
/*
* queries read from files
typedef enum QueryMode
{
- QUERY_SIMPLE, /* simple query */
- QUERY_EXTENDED, /* extended query */
- QUERY_PREPARED, /* extended query with prepared statements */
+ QUERY_SIMPLE, /* simple query */
+ QUERY_EXTENDED, /* extended query */
+ QUERY_PREPARED, /* extended query with prepared statements */
NUM_QUERYMODE
} QueryMode;
-static QueryMode querymode = QUERY_SIMPLE;
-static const char *QUERYMODE[] = { "simple", "extended", "prepared" };
+static QueryMode querymode = QUERY_SIMPLE;
+static const char *QUERYMODE[] = {"simple", "extended", "prepared"};
typedef struct
{
int type; /* command type (SQL_COMMAND or META_COMMAND) */
int argc; /* number of commands */
char *argv[MAX_ARGS]; /* command list */
-} Command;
+} Command;
Command **sql_files[MAX_FILES]; /* SQL script files */
int num_files; /* number of script files */
/* Calculate total time */
static void
-addTime(struct timeval *t1, struct timeval *t2, struct timeval *result)
+addTime(struct timeval * t1, struct timeval * t2, struct timeval * result)
{
- int sec = t1->tv_sec + t2->tv_sec;
- int usec = t1->tv_usec + t2->tv_usec;
+ int sec = t1->tv_sec + t2->tv_sec;
+ int usec = t1->tv_usec + t2->tv_usec;
+
if (usec >= 1000000)
{
usec -= 1000000;
/* Calculate time difference */
static void
-diffTime(struct timeval *t1, struct timeval *t2, struct timeval *result)
+diffTime(struct timeval * t1, struct timeval * t2, struct timeval * result)
{
- int sec = t1->tv_sec - t2->tv_sec;
- int usec = t1->tv_usec - t2->tv_usec;
+ int sec = t1->tv_sec - t2->tv_sec;
+ int usec = t1->tv_usec - t2->tv_usec;
+
if (usec < 0)
{
usec += 1000000;
" -F NUM fill factor\n"
" -s NUM scaling factor\n"
"\nBenchmarking options:\n"
- " -c NUM number of concurrent database clients (default: 1)\n"
+ " -c NUM number of concurrent database clients (default: 1)\n"
" -C establish new connection for each transaction\n"
" -D VARNAME=VALUE\n"
" define variable for use by custom script\n"
" -N do not update tables \"pgbench_tellers\" and \"pgbench_branches\"\n"
" -s NUM report this scale factor in output\n"
" -S perform SELECT-only transactions\n"
- " -t NUM number of transactions each client runs (default: 10)\n"
+ " -t NUM number of transactions each client runs (default: 10)\n"
" -T NUM duration of benchmark test in seconds\n"
" -v vacuum all four standard tables before tests\n"
"\nCommon options:\n"
/* throw away response from backend */
static void
-discard_response(CState * state)
+discard_response(CState *state)
{
PGresult *res;
/* check to see if the SQL result was good */
static int
-check(CState * state, PGresult *res, int n)
+check(CState *state, PGresult *res, int n)
{
CState *st = &state[n];
}
static char *
-getVariable(CState * st, char *name)
+getVariable(CState *st, char *name)
{
Variable key,
*var;
}
static int
-putVariable(CState * st, char *name, char *value)
+putVariable(CState *st, char *name, char *value)
{
Variable key,
*var;
static char *
parseVariable(const char *sql, int *eaten)
{
- int i = 0;
- char *name;
+ int i = 0;
+ char *name;
do
{
static char *
replaceVariable(char **sql, char *param, int len, char *value)
{
- int valueln = strlen(value);
+ int valueln = strlen(value);
if (valueln > len)
{
- char *tmp;
- size_t offset = param - *sql;
+ char *tmp;
+ size_t offset = param - *sql;
tmp = realloc(*sql, strlen(*sql) - len + valueln + 1);
if (tmp == NULL)
}
static char *
-assignVariables(CState * st, char *sql)
+assignVariables(CState *st, char *sql)
{
char *p,
*name,
p = sql;
while ((p = strchr(p, ':')) != NULL)
{
- int eaten;
+ int eaten;
name = parseVariable(p, &eaten);
if (name == NULL)
{
- while (*p == ':') { p++; }
+ while (*p == ':')
+ {
+ p++;
+ }
continue;
}
static void
getQueryParams(CState *st, const Command *command, const char **params)
{
- int i;
+ int i;
for (i = 0; i < command->argc - 1; i++)
- params[i] = getVariable(st, command->argv[i+1]);
+ params[i] = getVariable(st, command->argv[i + 1]);
}
#define MAX_PREPARE_NAME 32
}
static void
-doCustom(CState * state, int n, int debug)
+doCustom(CState *state, int n, int debug)
{
PGresult *res;
CState *st = &state[n];
if (st->con == NULL)
{
- struct timeval t1, t2, t3;
+ struct timeval t1,
+ t2,
+ t3;
gettimeofday(&t1, NULL);
if ((st->con = doConnect()) == NULL)
if (commands[st->state]->type == SQL_COMMAND)
{
- const Command *command = commands[st->state];
- int r;
+ const Command *command = commands[st->state];
+ int r;
if (querymode == QUERY_SIMPLE)
{
}
else if (querymode == QUERY_EXTENDED)
{
- const char *sql = command->argv[0];
- const char *params[MAX_ARGS];
+ const char *sql = command->argv[0];
+ const char *params[MAX_ARGS];
getQueryParams(st, command, params);
if (debug)
fprintf(stderr, "client %d sending %s\n", n, sql);
r = PQsendQueryParams(st->con, sql, command->argc - 1,
- NULL, params, NULL, NULL, 0);
+ NULL, params, NULL, NULL, 0);
}
else if (querymode == QUERY_PREPARED)
{
if (!st->prepared[st->use_file])
{
- int j;
+ int j;
for (j = 0; commands[j] != NULL; j++)
{
continue;
preparedStatementName(name, st->use_file, j);
res = PQprepare(st->con, name,
- commands[j]->argv[0], commands[j]->argc - 1, NULL);
+ commands[j]->argv[0], commands[j]->argc - 1, NULL);
if (PQresultStatus(res) != PGRES_COMMAND_OK)
fprintf(stderr, "%s", PQerrorMessage(st->con));
PQclear(res);
if (debug)
fprintf(stderr, "client %d sending %s\n", n, name);
r = PQsendQueryPrepared(st->con, name, command->argc - 1,
- params, NULL, NULL, 0);
+ params, NULL, NULL, 0);
}
- else /* unknown sql mode */
+ else /* unknown sql mode */
r = 0;
if (r == 0)
/* discard connections */
static void
-disconnect_all(CState * state)
+disconnect_all(CState *state)
{
int i;
/*
* Note: TPC-B requires at least 100 bytes per row, and the "filler"
* fields in these table declarations were intended to comply with that.
- * But because they default to NULLs, they don't actually take any
- * space. We could fix that by giving them non-null default values.
- * However, that would completely break comparability of pgbench
- * results with prior versions. Since pgbench has never pretended
- * to be fully TPC-B compliant anyway, we stick with the historical
- * behavior.
+ * But because they default to NULLs, they don't actually take any space.
+ * We could fix that by giving them non-null default values. However, that
+ * would completely break comparability of pgbench results with prior
+ * versions. Since pgbench has never pretended to be fully TPC-B
+ * compliant anyway, we stick with the historical behavior.
*/
static char *DDLs[] = {
"drop table if exists pgbench_branches",
p = sql;
while ((p = strchr(p, ':')) != NULL)
{
- char var[12];
- char *name;
- int eaten;
+ char var[12];
+ char *name;
+ int eaten;
name = parseVariable(p, &eaten);
if (name == NULL)
{
- while (*p == ':') { p++; }
+ while (*p == ':')
+ {
+ p++;
+ }
continue;
}
/* print out results */
static void
printResults(
- int ttype, CState * state,
+ int ttype, CState *state,
struct timeval * start_time, struct timeval * end_time)
{
double t1,
CState *state; /* status of clients */
- struct timeval start_time; /* start up time */
- struct timeval end_time; /* end time */
+ struct timeval start_time; /* start up time */
+ struct timeval end_time; /* end time */
int i;
{
if (duration <= 0)
printf("pghost: %s pgport: %s nclients: %d nxacts: %d dbName: %s\n",
- pghost, pgport, nclients, nxacts, dbName);
+ pghost, pgport, nclients, nxacts, dbName);
else
printf("pghost: %s pgport: %s nclients: %d duration: %d dbName: %s\n",
- pghost, pgport, nclients, duration, dbName);
+ pghost, pgport, nclients, duration, dbName);
}
/* opening connection... */
/* warn if we override user-given -s switch */
if (scale_given)
fprintf(stderr,
- "Scale option ignored, using pgbench_branches table count = %d\n",
+ "Scale option ignored, using pgbench_branches table count = %d\n",
scale);
}
if (is_connect == 0)
{
- struct timeval t, now;
+ struct timeval t,
+ now;
/* make connections to the database */
for (i = 0; i < nclients; i++)
if (this_usec > 0 && (min_usec == 0 || this_usec < min_usec))
min_usec = this_usec;
- FD_SET(sock, &input_mask);
+ FD_SET (sock, &input_mask);
+
if (maxsock < sock)
maxsock = sock;
}
disconnect_all(state);
exit(1);
}
- FD_SET(sock, &input_mask);
+ FD_SET (sock, &input_mask);
+
if (maxsock < sock)
maxsock = sock;
}
pqsignal(SIGALRM, handle_sig_alarm);
alarm(seconds);
}
-
-#else /* WIN32 */
+#else /* WIN32 */
static VOID CALLBACK
win32_timer_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
static void
setalarm(int seconds)
{
- HANDLE queue;
- HANDLE timer;
+ HANDLE queue;
+ HANDLE timer;
/* This function will be called at most once, so we can cheat a bit. */
queue = CreateTimerQueue();
- if (seconds > ((DWORD)-1) / 1000 ||
+ if (seconds > ((DWORD) -1) / 1000 ||
!CreateTimerQueueTimer(&timer, queue,
win32_timer_callback, NULL, seconds * 1000, 0,
WT_EXECUTEINTIMERTHREAD | WT_EXECUTEONLYONCE))
}
}
-#endif /* WIN32 */
+#endif /* WIN32 */
static void
blowfish_encrypt(uint32 xL, uint32 xR, uint32 *output,
- BlowfishContext * ctx)
+ BlowfishContext *ctx)
{
uint32 *S0 = ctx->S0;
uint32 *S1 = ctx->S1;
static void
blowfish_decrypt(uint32 xL, uint32 xR, uint32 *output,
- BlowfishContext * ctx)
+ BlowfishContext *ctx)
{
uint32 *S0 = ctx->S0;
uint32 *S1 = ctx->S1;
}
void
-blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_setkey(BlowfishContext * ctx,
+blowfish_setkey(BlowfishContext *ctx,
const uint8 *key, short keybytes)
{
uint32 *S0 = ctx->S0;
}
void
-blowfish_setiv(BlowfishContext * ctx, const uint8 *iv)
+blowfish_setiv(BlowfishContext *ctx, const uint8 *iv)
{
ctx->iv0 = GET_32BIT_MSB_FIRST(iv);
ctx->iv1 = GET_32BIT_MSB_FIRST(iv + 4);
P[18];
uint32 iv0,
iv1; /* for CBC mode */
-} BlowfishContext;
+} BlowfishContext;
-void blowfish_setkey(BlowfishContext * ctx, const uint8 *key, short keybytes);
-void blowfish_setiv(BlowfishContext * ctx, const uint8 *iv);
-void blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx);
-void blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx);
-void blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx);
-void blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx);
+void blowfish_setkey(BlowfishContext *ctx, const uint8 *key, short keybytes);
+void blowfish_setiv(BlowfishContext *ctx, const uint8 *iv);
+void blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx);
+void blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx);
+void blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx);
+void blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx);
{
BF_word S[4][0x100];
BF_key P;
-} BF_ctx;
+} BF_ctx;
/*
* Magic IV for 64 Blowfish encryptions that we do at the end.
} while (0)
static int
-BF_decode(BF_word * dst, const char *src, int size)
+BF_decode(BF_word *dst, const char *src, int size)
{
unsigned char *dptr = (unsigned char *) dst;
unsigned char *end = dptr + size;
}
static void
-BF_encode(char *dst, const BF_word * src, int size)
+BF_encode(char *dst, const BF_word *src, int size)
{
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
}
static void
-BF_swap(BF_word * x, int count)
+BF_swap(BF_word *x, int count)
{
/* Swap on little-endian hardware, else do nothing */
#ifndef WORDS_BIGENDIAN
#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);
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static void
-BF_encode(char *dst, const BF_word * src, int size)
+BF_encode(char *dst, const BF_word *src, int size)
{
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
* initialize state
*/
static void
-init_state(FState * st)
+init_state(FState *st)
{
int i;
* It just needs to change without repeating.
*/
static void
-inc_counter(FState * st)
+inc_counter(FState *st)
{
uint32 *val = (uint32 *) st->counter;
* This is called 'cipher in counter mode'.
*/
static void
-encrypt_counter(FState * st, uint8 *dst)
+encrypt_counter(FState *st, uint8 *dst)
{
ciph_encrypt(&st->ciph, st->counter, dst);
inc_counter(st);
* microseconds.
*/
static int
-enough_time_passed(FState * st)
+enough_time_passed(FState *st)
{
int ok;
struct timeval tv;
* generate new key from all the pools
*/
static void
-reseed(FState * st)
+reseed(FState *st)
{
unsigned k;
unsigned n;
* Pick a random pool. This uses key bytes as random source.
*/
static unsigned
-get_rand_pool(FState * st)
+get_rand_pool(FState *st)
{
unsigned rnd;
* update pools
*/
static void
-add_entropy(FState * st, const uint8 *data, unsigned len)
+add_entropy(FState *st, const uint8 *data, unsigned len)
{
unsigned pos;
uint8 hash[BLOCK];
* Just take 2 next blocks as new key
*/
static void
-rekey(FState * st)
+rekey(FState *st)
{
encrypt_counter(st, st->key);
encrypt_counter(st, st->key + CIPH_BLOCK);
* entropy over all of the components.
*/
static void
-startup_tricks(FState * st)
+startup_tricks(FState *st)
{
int i;
uint8 buf[BLOCK];
}
static void
-extract_data(FState * st, unsigned count, uint8 *dst)
+extract_data(FState *st, unsigned count, uint8 *dst)
{
unsigned n;
unsigned block_nr = 0;
static void s_fake(mp_int z, int value, mp_digit vbuf[]);
/* Compare two runs of digits of given length, returns <0, 0, >0 */
-static int s_cdig(mp_digit * da, mp_digit * db, mp_size len);
+static int s_cdig(mp_digit *da, mp_digit *db, mp_size len);
/* Pack the unsigned digits of v into array t */
static int s_vpack(int v, mp_digit t[]);
/* Unsigned magnitude addition; assumes dc is big enough.
Carry out is returned (no memory allocated). */
-static mp_digit s_uadd(mp_digit * da, mp_digit * db, mp_digit * dc,
+static mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned magnitude subtraction. Assumes dc is big enough. */
-static void s_usub(mp_digit * da, mp_digit * db, mp_digit * dc,
+static void s_usub(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned recursive multiplication. Assumes dc is big enough. */
-static int s_kmul(mp_digit * da, mp_digit * db, mp_digit * dc,
+static int s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned magnitude multiplication. Assumes dc is big enough. */
-static void s_umul(mp_digit * da, mp_digit * db, mp_digit * dc,
+static void s_umul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned recursive squaring. Assumes dc is big enough. */
-static int s_ksqr(mp_digit * da, mp_digit * dc, mp_size size_a);
+static int s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a);
/* Unsigned magnitude squaring. Assumes dc is big enough. */
-static void s_usqr(mp_digit * da, mp_digit * dc, mp_size size_a);
+static void s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a);
/* Single digit addition. Assumes a is big enough. */
static void s_dadd(mp_int a, mp_digit b);
static void s_dmul(mp_int a, mp_digit b);
/* Single digit multiplication on buffers; assumes dc is big enough. */
-static void s_dbmul(mp_digit * da, mp_digit b, mp_digit * dc,
+static void s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc,
mp_size size_a);
/* Single digit division. Replaces a with the quotient,
#if 0
/* Dump a representation of the mp_int to standard output */
void s_print(char *tag, mp_int z);
-void s_print_buf(char *tag, mp_digit * buf, mp_size num);
+void s_print_buf(char *tag, mp_digit *buf, mp_size num);
#endif
/* {{{ get_default_precision() */
/* {{{ s_realloc(old, num) */
static mp_digit *
-s_realloc(mp_digit * old, mp_size num)
+s_realloc(mp_digit *old, mp_size num)
{
mp_digit *new = px_realloc(old, num * sizeof(mp_digit));
/* {{{ s_cdig(da, db, len) */
static int
-s_cdig(mp_digit * da, mp_digit * db, mp_size len)
+s_cdig(mp_digit *da, mp_digit *db, mp_size len)
{
mp_digit *dat = da + len - 1,
*dbt = db + len - 1;
/* {{{ s_uadd(da, db, dc, size_a, size_b) */
static mp_digit
-s_uadd(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size pos;
/* Add corresponding digits until the shorter number runs out */
for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc)
{
- w = w + (mp_word) * da + (mp_word) * db;
+ w = w + (mp_word) *da + (mp_word) *db;
*dc = LOWER_HALF(w);
w = UPPER_HALF(w);
}
/* {{{ s_usub(da, db, dc, size_a, size_b) */
static void
-s_usub(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_usub(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size pos;
for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc)
{
w = ((mp_word) MP_DIGIT_MAX + 1 + /* MP_RADIX */
- (mp_word) * da) - w - (mp_word) * db;
+ (mp_word) *da) - w - (mp_word) *db;
*dc = LOWER_HALF(w);
w = (UPPER_HALF(w) == 0);
for ( /* */ ; pos < size_a; ++pos, ++da, ++dc)
{
w = ((mp_word) MP_DIGIT_MAX + 1 + /* MP_RADIX */
- (mp_word) * da) - w;
+ (mp_word) *da) - w;
*dc = LOWER_HALF(w);
w = (UPPER_HALF(w) == 0);
/* {{{ s_kmul(da, db, dc, size_a, size_b) */
static int
-s_kmul(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size bot_size;
/* {{{ s_umul(da, db, dc, size_a, size_b) */
static void
-s_umul(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_umul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size a,
w = 0;
for (b = 0; b < size_b; ++b, ++dbt, ++dct)
{
- w = (mp_word) * da * (mp_word) * dbt + w + (mp_word) * dct;
+ w = (mp_word) *da * (mp_word) *dbt + w + (mp_word) *dct;
*dct = LOWER_HALF(w);
w = UPPER_HALF(w);
/* {{{ s_ksqr(da, dc, size_a) */
static int
-s_ksqr(mp_digit * da, mp_digit * dc, mp_size size_a)
+s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a)
{
if (multiply_threshold && size_a > multiply_threshold)
{
/* {{{ s_usqr(da, dc, size_a) */
static void
-s_usqr(mp_digit * da, mp_digit * dc, mp_size size_a)
+s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a)
{
mp_size i,
j;
continue;
/* Take care of the first digit, no rollover */
- w = (mp_word) * dat * (mp_word) * dat + (mp_word) * dct;
+ w = (mp_word) *dat * (mp_word) *dat + (mp_word) *dct;
*dct = LOWER_HALF(w);
w = UPPER_HALF(w);
++dat;
for (j = i + 1; j < size_a; ++j, ++dat, ++dct)
{
- mp_word t = (mp_word) * da * (mp_word) * dat;
- mp_word u = w + (mp_word) * dct,
+ mp_word t = (mp_word) *da * (mp_word) *dat;
+ mp_word u = w + (mp_word) *dct,
ov = 0;
/* Check if doubling t will overflow a word */
mp_digit *da = MP_DIGITS(a);
mp_size ua = MP_USED(a);
- w = (mp_word) * da + b;
+ w = (mp_word) *da + b;
*da++ = LOWER_HALF(w);
w = UPPER_HALF(w);
for (ua -= 1; ua > 0; --ua, ++da)
{
- w = (mp_word) * da + w;
+ w = (mp_word) *da + w;
*da = LOWER_HALF(w);
w = UPPER_HALF(w);
while (ua > 0)
{
- w = (mp_word) * da * b + w;
+ w = (mp_word) *da * b + w;
*da++ = LOWER_HALF(w);
w = UPPER_HALF(w);
--ua;
/* {{{ s_dbmul(da, b, dc, size_a) */
static void
-s_dbmul(mp_digit * da, mp_digit b, mp_digit * dc, mp_size size_a)
+s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, mp_size size_a)
{
mp_word w = 0;
while (size_a > 0)
{
- w = (mp_word) * da++ * (mp_word) b + w;
+ w = (mp_word) *da++ * (mp_word) b + w;
*dc++ = LOWER_HALF(w);
w = UPPER_HALF(w);
for (pos = 0, zp = MP_DIGITS(z); pos < tdig; ++pos, ++zp)
{
- w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word) * zp;
+ w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word) *zp;
*zp = LOWER_HALF(w);
w = UPPER_HALF(w) ? 0 : 1;
}
- w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word) * zp;
+ w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word) *zp;
*zp = LOWER_HALF(w);
assert(UPPER_HALF(w) != 0); /* no borrow out should be possible */
}
void
-s_print_buf(char *tag, mp_digit * buf, mp_size num)
+s_print_buf(char *tag, mp_digit *buf, mp_size num)
{
int i;
mp_size alloc;
mp_size used;
mp_sign sign;
-} mpz_t, *mp_int;
+} mpz_t ,
+ *mp_int;
#define MP_DIGITS(Z) ((Z)->digits)
#define MP_ALLOC(Z) ((Z)->alloc)
mp_result mp_int_sqr(mp_int a, mp_int c); /* c = a * a */
mp_result
-mp_int_div(mp_int a, mp_int b, /* q = a / b */
+mp_int_div(mp_int a, mp_int b, /* q = a / b */
mp_int q, mp_int r); /* r = a % b */
mp_result
-mp_int_div_value(mp_int a, int value, /* q = a / value */
+mp_int_div_value(mp_int a, int value, /* q = a / value */
mp_int q, int *r); /* r = a % value */
mp_result
mp_int_div_pow2(mp_int a, int p2, /* q = a / 2^p2 */
#if 0
void s_print(char *tag, mp_int z);
-void s_print_buf(char *tag, mp_digit * buf, mp_size num);
+void s_print_buf(char *tag, mp_digit *buf, mp_size num);
#endif
#endif /* end IMATH_H_ */
#include "px.h"
#include "sha2.h"
-void init_sha224(PX_MD * h);
-void init_sha256(PX_MD * h);
-void init_sha384(PX_MD * h);
-void init_sha512(PX_MD * h);
+void init_sha224(PX_MD *h);
+void init_sha256(PX_MD *h);
+void init_sha384(PX_MD *h);
+void init_sha512(PX_MD *h);
/* SHA224 */
static unsigned
-int_sha224_len(PX_MD * h)
+int_sha224_len(PX_MD *h)
{
return SHA224_DIGEST_LENGTH;
}
static unsigned
-int_sha224_block_len(PX_MD * h)
+int_sha224_block_len(PX_MD *h)
{
return SHA224_BLOCK_LENGTH;
}
static void
-int_sha224_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha224_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
}
static void
-int_sha224_reset(PX_MD * h)
+int_sha224_reset(PX_MD *h)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
}
static void
-int_sha224_finish(PX_MD * h, uint8 *dst)
+int_sha224_finish(PX_MD *h, uint8 *dst)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
}
static void
-int_sha224_free(PX_MD * h)
+int_sha224_free(PX_MD *h)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
/* SHA256 */
static unsigned
-int_sha256_len(PX_MD * h)
+int_sha256_len(PX_MD *h)
{
return SHA256_DIGEST_LENGTH;
}
static unsigned
-int_sha256_block_len(PX_MD * h)
+int_sha256_block_len(PX_MD *h)
{
return SHA256_BLOCK_LENGTH;
}
static void
-int_sha256_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha256_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
}
static void
-int_sha256_reset(PX_MD * h)
+int_sha256_reset(PX_MD *h)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
}
static void
-int_sha256_finish(PX_MD * h, uint8 *dst)
+int_sha256_finish(PX_MD *h, uint8 *dst)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
}
static void
-int_sha256_free(PX_MD * h)
+int_sha256_free(PX_MD *h)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
/* SHA384 */
static unsigned
-int_sha384_len(PX_MD * h)
+int_sha384_len(PX_MD *h)
{
return SHA384_DIGEST_LENGTH;
}
static unsigned
-int_sha384_block_len(PX_MD * h)
+int_sha384_block_len(PX_MD *h)
{
return SHA384_BLOCK_LENGTH;
}
static void
-int_sha384_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha384_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
}
static void
-int_sha384_reset(PX_MD * h)
+int_sha384_reset(PX_MD *h)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
}
static void
-int_sha384_finish(PX_MD * h, uint8 *dst)
+int_sha384_finish(PX_MD *h, uint8 *dst)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
}
static void
-int_sha384_free(PX_MD * h)
+int_sha384_free(PX_MD *h)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
/* SHA512 */
static unsigned
-int_sha512_len(PX_MD * h)
+int_sha512_len(PX_MD *h)
{
return SHA512_DIGEST_LENGTH;
}
static unsigned
-int_sha512_block_len(PX_MD * h)
+int_sha512_block_len(PX_MD *h)
{
return SHA512_BLOCK_LENGTH;
}
static void
-int_sha512_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha512_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
}
static void
-int_sha512_reset(PX_MD * h)
+int_sha512_reset(PX_MD *h)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
}
static void
-int_sha512_finish(PX_MD * h, uint8 *dst)
+int_sha512_finish(PX_MD *h, uint8 *dst)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
}
static void
-int_sha512_free(PX_MD * h)
+int_sha512_free(PX_MD *h)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
/* init functions */
void
-init_sha224(PX_MD * md)
+init_sha224(PX_MD *md)
{
SHA224_CTX *ctx;
}
void
-init_sha256(PX_MD * md)
+init_sha256(PX_MD *md)
{
SHA256_CTX *ctx;
}
void
-init_sha384(PX_MD * md)
+init_sha384(PX_MD *md)
{
SHA384_CTX *ctx;
}
void
-init_sha512(PX_MD * md)
+init_sha512(PX_MD *md)
{
SHA512_CTX *ctx;
#define SHA1_BLOCK_SIZE 64
#define MD5_BLOCK_SIZE 64
-static void init_md5(PX_MD * h);
-static void init_sha1(PX_MD * h);
+static void init_md5(PX_MD *h);
+static void init_sha1(PX_MD *h);
-void init_sha224(PX_MD * h);
-void init_sha256(PX_MD * h);
-void init_sha384(PX_MD * h);
-void init_sha512(PX_MD * h);
+void init_sha224(PX_MD *h);
+void init_sha256(PX_MD *h);
+void init_sha384(PX_MD *h);
+void init_sha512(PX_MD *h);
struct int_digest
{
char *name;
- void (*init) (PX_MD * h);
+ void (*init) (PX_MD *h);
};
static const struct int_digest
/* MD5 */
static unsigned
-int_md5_len(PX_MD * h)
+int_md5_len(PX_MD *h)
{
return MD5_DIGEST_LENGTH;
}
static unsigned
-int_md5_block_len(PX_MD * h)
+int_md5_block_len(PX_MD *h)
{
return MD5_BLOCK_SIZE;
}
static void
-int_md5_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_md5_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
}
static void
-int_md5_reset(PX_MD * h)
+int_md5_reset(PX_MD *h)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
}
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;
}
static void
-int_md5_free(PX_MD * h)
+int_md5_free(PX_MD *h)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
/* SHA1 */
static unsigned
-int_sha1_len(PX_MD * h)
+int_sha1_len(PX_MD *h)
{
return SHA1_DIGEST_LENGTH;
}
static unsigned
-int_sha1_block_len(PX_MD * h)
+int_sha1_block_len(PX_MD *h)
{
return SHA1_BLOCK_SIZE;
}
static void
-int_sha1_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha1_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
}
static void
-int_sha1_reset(PX_MD * h)
+int_sha1_reset(PX_MD *h)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
}
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;
}
static void
-int_sha1_free(PX_MD * h)
+int_sha1_free(PX_MD *h)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
/* init functions */
static void
-init_md5(PX_MD * md)
+init_md5(PX_MD *md)
{
MD5_CTX *ctx;
}
static void
-init_sha1(PX_MD * md)
+init_sha1(PX_MD *md)
{
SHA1_CTX *ctx;
};
static void
-intctx_free(PX_Cipher * c)
+intctx_free(PX_Cipher *c)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
#define MODE_CBC 1
static unsigned
-rj_block_size(PX_Cipher * c)
+rj_block_size(PX_Cipher *c)
{
return 128 / 8;
}
static unsigned
-rj_key_size(PX_Cipher * c)
+rj_key_size(PX_Cipher *c)
{
return 256 / 8;
}
static unsigned
-rj_iv_size(PX_Cipher * c)
+rj_iv_size(PX_Cipher *c)
{
return 128 / 8;
}
static int
-rj_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+rj_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
}
static int
-rj_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+rj_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
}
static int
-rj_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+rj_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
*/
static unsigned
-bf_block_size(PX_Cipher * c)
+bf_block_size(PX_Cipher *c)
{
return 8;
}
static unsigned
-bf_key_size(PX_Cipher * c)
+bf_key_size(PX_Cipher *c)
{
return 448 / 8;
}
static unsigned
-bf_iv_size(PX_Cipher * c)
+bf_iv_size(PX_Cipher *c)
{
return 8;
}
static int
-bf_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+bf_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
}
static int
-bf_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
BlowfishContext *bfctx = &cx->ctx.bf;
}
static int
-bf_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
BlowfishContext *bfctx = &cx->ctx.bf;
/* PUBLIC FUNCTIONS */
int
-px_find_digest(const char *name, PX_MD ** res)
+px_find_digest(const char *name, PX_MD **res)
{
const struct int_digest *p;
PX_MD *h;
}
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
-mbuf_avail(MBuf * mbuf)
+mbuf_avail(MBuf *mbuf)
{
return mbuf->data_end - mbuf->read_pos;
}
int
-mbuf_size(MBuf * mbuf)
+mbuf_size(MBuf *mbuf)
{
return mbuf->data_end - mbuf->data;
}
int
-mbuf_tell(MBuf * mbuf)
+mbuf_tell(MBuf *mbuf)
{
return mbuf->read_pos - mbuf->data;
}
int
-mbuf_free(MBuf * mbuf)
+mbuf_free(MBuf *mbuf)
{
if (mbuf->own_data)
{
}
static void
-prepare_room(MBuf * mbuf, int block_len)
+prepare_room(MBuf *mbuf, int block_len)
{
uint8 *newbuf;
unsigned newlen;
}
int
-mbuf_append(MBuf * dst, const uint8 *buf, int len)
+mbuf_append(MBuf *dst, const uint8 *buf, int len)
{
if (dst->no_write)
{
int
-mbuf_grab(MBuf * mbuf, int len, uint8 **data_p)
+mbuf_grab(MBuf *mbuf, int len, uint8 **data_p)
{
if (len > mbuf_avail(mbuf))
len = mbuf_avail(mbuf);
}
int
-mbuf_rewind(MBuf * mbuf)
+mbuf_rewind(MBuf *mbuf)
{
mbuf->read_pos = mbuf->data;
return 0;
}
int
-mbuf_steal_data(MBuf * mbuf, uint8 **data_p)
+mbuf_steal_data(MBuf *mbuf, uint8 **data_p)
{
int len = mbuf_size(mbuf);
};
int
-pullf_create(PullFilter ** pf_p, const PullFilterOps * op, void *init_arg, PullFilter * src)
+pullf_create(PullFilter **pf_p, const PullFilterOps *op, void *init_arg, PullFilter *src)
{
PullFilter *pf;
void *priv;
}
void
-pullf_free(PullFilter * pf)
+pullf_free(PullFilter *pf)
{
if (pf->op->free)
pf->op->free(pf->priv);
/* may return less data than asked, 0 means eof */
int
-pullf_read(PullFilter * pf, int len, uint8 **data_p)
+pullf_read(PullFilter *pf, int len, uint8 **data_p)
{
int res;
}
int
-pullf_read_max(PullFilter * pf, int len, uint8 **data_p, uint8 *tmpbuf)
+pullf_read_max(PullFilter *pf, int len, uint8 **data_p, uint8 *tmpbuf)
{
int res,
total;
* caller wants exatly len bytes and dont bother with references
*/
int
-pullf_read_fixed(PullFilter * src, int len, uint8 *dst)
+pullf_read_fixed(PullFilter *src, int len, uint8 *dst)
{
int res;
uint8 *p;
* read from MBuf
*/
static int
-pull_from_mbuf(void *arg, PullFilter * src, int len,
+pull_from_mbuf(void *arg, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
MBuf *mbuf = arg;
};
int
-pullf_create_mbuf_reader(PullFilter ** mp_p, MBuf * src)
+pullf_create_mbuf_reader(PullFilter **mp_p, MBuf *src)
{
return pullf_create(mp_p, &mbuf_reader, src, NULL);
}
};
int
-pushf_create(PushFilter ** mp_p, const PushFilterOps * op, void *init_arg, PushFilter * next)
+pushf_create(PushFilter **mp_p, const PushFilterOps *op, void *init_arg, PushFilter *next)
{
PushFilter *mp;
void *priv;
}
void
-pushf_free(PushFilter * mp)
+pushf_free(PushFilter *mp)
{
if (mp->op->free)
mp->op->free(mp->priv);
}
void
-pushf_free_all(PushFilter * mp)
+pushf_free_all(PushFilter *mp)
{
PushFilter *tmp;
}
static int
-wrap_process(PushFilter * mp, const uint8 *data, int len)
+wrap_process(PushFilter *mp, const uint8 *data, int len)
{
int res;
/* consumes all data, returns len on success */
int
-pushf_write(PushFilter * mp, const uint8 *data, int len)
+pushf_write(PushFilter *mp, const uint8 *data, int len)
{
int need,
res;
}
int
-pushf_flush(PushFilter * mp)
+pushf_flush(PushFilter *mp)
{
int res;
* write to MBuf
*/
static int
-push_into_mbuf(PushFilter * next, void *arg, const uint8 *data, int len)
+push_into_mbuf(PushFilter *next, void *arg, const uint8 *data, int len)
{
int res = 0;
MBuf *mbuf = arg;
};
int
-pushf_create_mbuf_writer(PushFilter ** res, MBuf * dst)
+pushf_create_mbuf_writer(PushFilter **res, MBuf *dst)
{
return pushf_create(res, &mbuf_filter, dst, NULL);
}
* should return needed buffer size, 0- no buffering, <0 on error if NULL,
* no buffering, and priv=init_arg
*/
- int (*init) (PushFilter * next, void *init_arg, void **priv_p);
+ int (*init) (PushFilter *next, void *init_arg, void **priv_p);
/*
* send data to next. should consume all? if null, it will be simply
* copied (in-place) returns 0 on error
*/
- int (*push) (PushFilter * next, void *priv,
+ int (*push) (PushFilter *next, void *priv,
const uint8 *src, int len);
- int (*flush) (PushFilter * next, void *priv);
+ int (*flush) (PushFilter *next, void *priv);
void (*free) (void *priv);
};
* should return needed buffer size, 0- no buffering, <0 on error if NULL,
* no buffering, and priv=init_arg
*/
- int (*init) (void **priv_p, void *init_arg, PullFilter * src);
+ int (*init) (void **priv_p, void *init_arg, PullFilter *src);
/*
* request data from src, put result ptr to data_p can use ptr from src or
* use buf as work area if NULL in-place copy
*/
- int (*pull) (void *priv, PullFilter * src, int len,
+ int (*pull) (void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen);
void (*free) (void *priv);
};
*/
MBuf *mbuf_create(int len);
MBuf *mbuf_create_from_data(const uint8 *data, int len);
-int mbuf_tell(MBuf * mbuf);
-int mbuf_avail(MBuf * mbuf);
-int mbuf_size(MBuf * mbuf);
-int mbuf_grab(MBuf * mbuf, int len, uint8 **data_p);
-int mbuf_steal_data(MBuf * mbuf, uint8 **data_p);
-int mbuf_append(MBuf * dst, const uint8 *buf, int cnt);
-int mbuf_rewind(MBuf * mbuf);
-int mbuf_free(MBuf * mbuf);
+int mbuf_tell(MBuf *mbuf);
+int mbuf_avail(MBuf *mbuf);
+int mbuf_size(MBuf *mbuf);
+int mbuf_grab(MBuf *mbuf, int len, uint8 **data_p);
+int mbuf_steal_data(MBuf *mbuf, uint8 **data_p);
+int mbuf_append(MBuf *dst, const uint8 *buf, int cnt);
+int mbuf_rewind(MBuf *mbuf);
+int mbuf_free(MBuf *mbuf);
/*
* Push filter
*/
-int pushf_create(PushFilter ** res, const PushFilterOps * ops, void *init_arg,
- PushFilter * next);
-int pushf_write(PushFilter * mp, const uint8 *data, int len);
-void pushf_free_all(PushFilter * mp);
-void pushf_free(PushFilter * mp);
-int pushf_flush(PushFilter * mp);
+int pushf_create(PushFilter **res, const PushFilterOps *ops, void *init_arg,
+ PushFilter *next);
+int pushf_write(PushFilter *mp, const uint8 *data, int len);
+void pushf_free_all(PushFilter *mp);
+void pushf_free(PushFilter *mp);
+int pushf_flush(PushFilter *mp);
-int pushf_create_mbuf_writer(PushFilter ** mp_p, MBuf * mbuf);
+int pushf_create_mbuf_writer(PushFilter **mp_p, MBuf *mbuf);
/*
* Pull filter
*/
-int pullf_create(PullFilter ** res, const PullFilterOps * ops,
- void *init_arg, PullFilter * src);
-int pullf_read(PullFilter * mp, int len, uint8 **data_p);
-int pullf_read_max(PullFilter * mp, int len,
+int pullf_create(PullFilter **res, const PullFilterOps *ops,
+ void *init_arg, PullFilter *src);
+int pullf_read(PullFilter *mp, int len, uint8 **data_p);
+int pullf_read_max(PullFilter *mp, int len,
uint8 **data_p, uint8 *tmpbuf);
-void pullf_free(PullFilter * mp);
-int pullf_read_fixed(PullFilter * src, int len, uint8 *dst);
+void pullf_free(PullFilter *mp);
+int pullf_read_fixed(PullFilter *src, int len, uint8 *dst);
-int pullf_create_mbuf_reader(PullFilter ** pf_p, MBuf * mbuf);
+int pullf_create_mbuf_reader(PullFilter **pf_p, MBuf *mbuf);
#define GETBYTE(pf, dst) \
do { \
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;
}
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;
}
void
-md5_pad(md5_ctxt * ctxt)
+md5_pad(md5_ctxt *ctxt)
{
unsigned int gap;
}
void
-md5_result(uint8 *digest, md5_ctxt * ctxt)
+md5_result(uint8 *digest, md5_ctxt *ctxt)
{
/* 4 byte words */
#ifndef WORDS_BIGENDIAN
#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;
unsigned int md5_i;
uint8 md5_buf[MD5_BUFLEN];
-} md5_ctxt;
+} md5_ctxt;
extern void md5_init(md5_ctxt *);
extern void md5_loop(md5_ctxt *, const uint8 *, unsigned int);
#include "sha2.c"
#include "internal-sha2.c"
-typedef void (*init_f) (PX_MD * md);
+typedef void (*init_f) (PX_MD *md);
static int
-compat_find_digest(const char *name, PX_MD ** res)
+compat_find_digest(const char *name, PX_MD **res)
{
init_f init = NULL;
{
const EVP_MD *algo;
EVP_MD_CTX ctx;
-} OSSLDigest;
+} OSSLDigest;
static unsigned
-digest_result_size(PX_MD * h)
+digest_result_size(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static unsigned
-digest_block_size(PX_MD * h)
+digest_block_size(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_reset(PX_MD * h)
+digest_reset(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_update(PX_MD * h, const uint8 *data, unsigned dlen)
+digest_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_finish(PX_MD * h, uint8 *dst)
+digest_finish(PX_MD *h, uint8 *dst)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_free(PX_MD * h)
+digest_free(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
/* 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;
PX_MD *h;
struct ossl_cipher
{
- int (*init) (PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv);
- int (*encrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
- int (*decrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
+ int (*init) (PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv);
+ int (*encrypt) (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res);
+ int (*decrypt) (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res);
int block_size;
int max_key_size;
unsigned klen;
unsigned init;
const struct ossl_cipher *ciph;
-} ossldata;
+} ossldata;
/* generic */
static unsigned
-gen_ossl_block_size(PX_Cipher * c)
+gen_ossl_block_size(PX_Cipher *c)
{
ossldata *od = (ossldata *) c->ptr;
}
static unsigned
-gen_ossl_key_size(PX_Cipher * c)
+gen_ossl_key_size(PX_Cipher *c)
{
ossldata *od = (ossldata *) c->ptr;
}
static unsigned
-gen_ossl_iv_size(PX_Cipher * c)
+gen_ossl_iv_size(PX_Cipher *c)
{
unsigned ivlen;
ossldata *od = (ossldata *) c->ptr;
}
static void
-gen_ossl_free(PX_Cipher * c)
+gen_ossl_free(PX_Cipher *c)
{
ossldata *od = (ossldata *) c->ptr;
}
static int
-bf_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+bf_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
static int bf_is_strong = -1;
}
static int
-bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
unsigned i;
}
static int
-bf_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c),
i;
}
static int
-bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cfb64_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
/* DES */
static int
-ossl_des_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_des_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
DES_cblock xkey;
}
static int
-ossl_des_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_des_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
/* DES3 */
static int
-ossl_des3_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_des3_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
DES_cblock xkey1,
}
static int
-ossl_des3_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des3_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des3_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_des3_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
/* CAST5 */
static int
-ossl_cast_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_cast_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_cast_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
ossldata *od = c->ptr;
}
static int
-ossl_cast_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
ossldata *od = c->ptr;
}
static int
-ossl_cast_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_cast_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
/* AES */
static int
-ossl_aes_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_aes_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_aes_key_init(ossldata * od, int type)
+ossl_aes_key_init(ossldata *od, int type)
{
int err;
}
static int
-ossl_aes_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_aes_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_aes_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_aes_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
/* PUBLIC functions */
int
-px_find_cipher(const char *name, PX_Cipher ** res)
+px_find_cipher(const char *name, PX_Cipher **res)
{
const struct ossl_cipher_lookup *i;
PX_Cipher *c = NULL;
#include "px.h"
#include "pgp.h"
-typedef int (*mix_data_t) (PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
+typedef int (*mix_data_t) (PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
struct PGP_CFB
{
};
int
-pgp_cfb_create(PGP_CFB ** ctx_p, int algo, const uint8 *key, int key_len,
+pgp_cfb_create(PGP_CFB **ctx_p, int algo, const uint8 *key, int key_len,
int resync, uint8 *iv)
{
int res;
}
void
-pgp_cfb_free(PGP_CFB * ctx)
+pgp_cfb_free(PGP_CFB *ctx)
{
px_cipher_free(ctx->ciph);
memset(ctx, 0, sizeof(*ctx));
* Data processing for normal CFB. (PGP_PKT_SYMENCRYPTED_DATA_MDC)
*/
static int
-mix_encrypt_normal(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_encrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i;
}
static int
-mix_decrypt_normal(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_decrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i;
* thus its all concentrated here.
*/
static int
-mix_encrypt_resync(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_encrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i,
n;
}
static int
-mix_decrypt_resync(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_decrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i,
n;
* common code for both encrypt and decrypt.
*/
static int
-cfb_process(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst,
+cfb_process(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst,
mix_data_t mix_data)
{
int n;
*/
int
-pgp_cfb_encrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
mix_data_t mix = ctx->resync ? mix_encrypt_resync : mix_encrypt_normal;
}
int
-pgp_cfb_decrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
mix_data_t mix = ctx->resync ? mix_decrypt_resync : mix_decrypt_normal;
}
static int
-compress_init(PushFilter * next, void *init_arg, void **priv_p)
+compress_init(PushFilter *next, void *init_arg, void **priv_p)
{
int res;
struct ZipStat *st;
/* cant handle zero-len incoming data, but shouldnt */
static int
-compress_process(PushFilter * next, void *priv, const uint8 *data, int len)
+compress_process(PushFilter *next, void *priv, const uint8 *data, int len)
{
int res,
n_out;
}
static int
-compress_flush(PushFilter * next, void *priv)
+compress_flush(PushFilter *next, void *priv)
{
int res,
zres,
};
int
-pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst)
+pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
{
return pushf_create(res, &compress_filter, ctx, dst);
}
};
static int
-decompress_init(void **priv_p, void *arg, PullFilter * src)
+decompress_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
struct DecomprData *dec;
}
static int
-decompress_read(void *priv, PullFilter * src, int len,
+decompress_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
int res;
};
int
-pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src)
+pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
{
return pullf_create(res, &decompress_filter, ctx, src);
}
#else /* !HAVE_ZLIB */
int
-pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst)
+pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
{
return PXE_PGP_UNSUPPORTED_COMPR;
}
int
-pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src)
+pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
{
return PXE_PGP_UNSUPPORTED_COMPR;
}
#define MAX_CHUNK (16*1024*1024)
static int
-parse_new_len(PullFilter * src, int *len_p)
+parse_new_len(PullFilter *src, int *len_p)
{
uint8 b;
int len;
}
static int
-parse_old_len(PullFilter * src, int *len_p, int lentype)
+parse_old_len(PullFilter *src, int *len_p, int lentype)
{
uint8 b;
int len;
/* returns pkttype or 0 on eof */
int
-pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p, int allow_ctx)
+pgp_parse_pkt_hdr(PullFilter *src, uint8 *tag, int *len_p, int allow_ctx)
{
int lentype;
int res;
};
static int
-pktreader_pull(void *priv, PullFilter * src, int len,
+pktreader_pull(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
int res;
/* needs helper function to pass several parameters */
int
-pgp_create_pkt_reader(PullFilter ** pf_p, PullFilter * src, int len,
- int pkttype, PGP_Context * ctx)
+pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
+ int pkttype, PGP_Context *ctx)
{
int res;
struct PktData *pkt = px_alloc(sizeof(*pkt));
*/
static int
-prefix_init(void **priv_p, void *arg, PullFilter * src)
+prefix_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
int len;
*/
static int
-decrypt_init(void **priv_p, void *arg, PullFilter * src)
+decrypt_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_CFB *cfb = arg;
}
static int
-decrypt_read(void *priv, PullFilter * src, int len,
+decrypt_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
PGP_CFB *cfb = priv;
*/
static int
-mdc_init(void **priv_p, void *arg, PullFilter * src)
+mdc_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
}
static int
-mdc_finish(PGP_Context * ctx, PullFilter * src,
+mdc_finish(PGP_Context *ctx, PullFilter *src,
int len, uint8 **data_p)
{
int res;
}
static int
-mdc_read(void *priv, PullFilter * src, int len,
+mdc_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
int res;
};
static int
-mdcbuf_init(void **priv_p, void *arg, PullFilter * src)
+mdcbuf_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
struct MDCBufData *st;
}
static int
-mdcbuf_refill(struct MDCBufData * st, PullFilter * src)
+mdcbuf_refill(struct MDCBufData * st, PullFilter *src)
{
uint8 *data;
int res;
}
static int
-mdcbuf_read(void *priv, PullFilter * src, int len,
+mdcbuf_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
struct MDCBufData *st = priv;
* Decrypt separate session key
*/
static int
-decrypt_key(PGP_Context * ctx, const uint8 *src, int len)
+decrypt_key(PGP_Context *ctx, const uint8 *src, int len)
{
int res;
uint8 algo;
* Handle key packet
*/
static int
-parse_symenc_sesskey(PGP_Context * ctx, PullFilter * src)
+parse_symenc_sesskey(PGP_Context *ctx, PullFilter *src)
{
uint8 *p;
int res;
}
static int
-copy_crlf(MBuf * dst, uint8 *data, int len, int *got_cr)
+copy_crlf(MBuf *dst, uint8 *data, int len, int *got_cr)
{
uint8 *data_end = data + len;
uint8 tmpbuf[1024];
}
static int
-parse_literal_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
+parse_literal_data(PGP_Context *ctx, MBuf *dst, PullFilter *pkt)
{
int type;
int name_len;
}
/* process_data_packets and parse_compressed_data call each other */
-static int process_data_packets(PGP_Context * ctx, MBuf * dst,
- PullFilter * src, int allow_compr, int need_mdc);
+static int process_data_packets(PGP_Context *ctx, MBuf *dst,
+ PullFilter *src, int allow_compr, int need_mdc);
static int
-parse_compressed_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
+parse_compressed_data(PGP_Context *ctx, MBuf *dst, PullFilter *pkt)
{
int res;
uint8 type;
}
static int
-process_data_packets(PGP_Context * ctx, MBuf * dst, PullFilter * src,
+process_data_packets(PGP_Context *ctx, MBuf *dst, PullFilter *src,
int allow_compr, int need_mdc)
{
uint8 tag;
}
static int
-parse_symenc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
+parse_symenc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
{
int res;
PGP_CFB *cfb = NULL;
}
static int
-parse_symenc_mdc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
+parse_symenc_mdc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
{
int res;
PGP_CFB *cfb = NULL;
* skip over packet contents
*/
int
-pgp_skip_packet(PullFilter * pkt)
+pgp_skip_packet(PullFilter *pkt)
{
int res = 1;
uint8 *tmp;
* expect to be at packet end, any data is error
*/
int
-pgp_expect_packet_end(PullFilter * pkt)
+pgp_expect_packet_end(PullFilter *pkt)
{
int res = 1;
uint8 *tmp;
}
int
-pgp_decrypt(PGP_Context * ctx, MBuf * msrc, MBuf * mdst)
+pgp_decrypt(PGP_Context *ctx, MBuf *msrc, MBuf *mdst)
{
int res;
PullFilter *src = NULL;
}
static int
-write_tag_only(PushFilter * dst, int tag)
+write_tag_only(PushFilter *dst, int tag)
{
uint8 hdr = 0xC0 | tag;
}
static int
-write_normal_header(PushFilter * dst, int tag, int len)
+write_normal_header(PushFilter *dst, int tag, int len)
{
uint8 hdr[8];
uint8 *h = hdr;
*/
static int
-mdc_init(PushFilter * dst, void *init_arg, void **priv_p)
+mdc_init(PushFilter *dst, void *init_arg, void **priv_p)
{
int res;
PX_MD *md;
}
static int
-mdc_write(PushFilter * dst, void *priv, const uint8 *data, int len)
+mdc_write(PushFilter *dst, void *priv, const uint8 *data, int len)
{
PX_MD *md = priv;
}
static int
-mdc_flush(PushFilter * dst, void *priv)
+mdc_flush(PushFilter *dst, void *priv)
{
int res;
uint8 pkt[2 + MDC_DIGEST_LEN];
};
static int
-encrypt_init(PushFilter * next, void *init_arg, void **priv_p)
+encrypt_init(PushFilter *next, void *init_arg, void **priv_p)
{
struct EncStat *st;
PGP_Context *ctx = init_arg;
}
static int
-encrypt_process(PushFilter * next, void *priv, const uint8 *data, int len)
+encrypt_process(PushFilter *next, void *priv, const uint8 *data, int len)
{
int res;
struct EncStat *st = priv;
};
static int
-pkt_stream_init(PushFilter * next, void *init_arg, void **priv_p)
+pkt_stream_init(PushFilter *next, void *init_arg, void **priv_p)
{
struct PktStreamStat *st;
}
static int
-pkt_stream_process(PushFilter * next, void *priv, const uint8 *data, int len)
+pkt_stream_process(PushFilter *next, void *priv, const uint8 *data, int len)
{
int res;
uint8 hdr[8];
}
static int
-pkt_stream_flush(PushFilter * next, void *priv)
+pkt_stream_flush(PushFilter *next, void *priv)
{
int res;
uint8 hdr[8];
};
int
-pgp_create_pkt_writer(PushFilter * dst, int tag, PushFilter ** res_p)
+pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p)
{
int res;
*/
static int
-crlf_process(PushFilter * dst, void *priv, const uint8 *data, int len)
+crlf_process(PushFilter *dst, void *priv, const uint8 *data, int len)
{
const uint8 *data_end = data + len;
const uint8 *p2,
* Initialize literal data packet
*/
static int
-init_litdata_packet(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
+init_litdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
{
int res;
int hdrlen;
* Initialize compression filter
*/
static int
-init_compress(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
+init_compress(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
{
int res;
uint8 type = ctx->compress_algo;
* Initialize encdata packet
*/
static int
-init_encdata_packet(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
+init_encdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
{
int res;
int tag;
* write prefix
*/
static int
-write_prefix(PGP_Context * ctx, PushFilter * dst)
+write_prefix(PGP_Context *ctx, PushFilter *dst)
{
uint8 prefix[PGP_MAX_BLOCK + 2];
int res,
*/
static int
-symencrypt_sesskey(PGP_Context * ctx, uint8 *dst)
+symencrypt_sesskey(PGP_Context *ctx, uint8 *dst)
{
int res;
PGP_CFB *cfb;
/* 5.3: Symmetric-Key Encrypted Session-Key */
static int
-write_symenc_sesskey(PGP_Context * ctx, PushFilter * dst)
+write_symenc_sesskey(PGP_Context *ctx, PushFilter *dst)
{
uint8 pkt[256];
int pktlen;
* key setup
*/
static int
-init_s2k_key(PGP_Context * ctx)
+init_s2k_key(PGP_Context *ctx)
{
int res;
}
static int
-init_sess_key(PGP_Context * ctx)
+init_sess_key(PGP_Context *ctx)
{
int res;
* combine
*/
int
-pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst)
+pgp_encrypt(PGP_Context *ctx, MBuf *src, MBuf *dst)
{
int res;
int len;
#include "pgp.h"
static int
-read_pubkey_keyid(PullFilter * pkt, uint8 *keyid_buf)
+read_pubkey_keyid(PullFilter *pkt, uint8 *keyid_buf)
{
int res;
PGP_PubKey *pk = NULL;
}
static int
-read_pubenc_keyid(PullFilter * pkt, uint8 *keyid_buf)
+read_pubenc_keyid(PullFilter *pkt, uint8 *keyid_buf)
{
uint8 ver;
int res;
* dst should have room for 17 bytes
*/
int
-pgp_get_keyid(MBuf * pgp_data, char *dst)
+pgp_get_keyid(MBuf *pgp_data, char *dst)
{
int res;
PullFilter *src;
}
static void
-mp_clear_free(mpz_t * a)
+mp_clear_free(mpz_t *a)
{
if (!a)
return;
static int
-mp_px_rand(uint32 bits, mpz_t * res)
+mp_px_rand(uint32 bits, mpz_t *res)
{
int err;
unsigned bytes = (bits + 7) / 8;
}
static void
-mp_modmul(mpz_t * a, mpz_t * b, mpz_t * p, mpz_t * res)
+mp_modmul(mpz_t *a, mpz_t *b, mpz_t *p, mpz_t *res)
{
mpz_t *tmp = mp_new();
}
static mpz_t *
-mpi_to_bn(PGP_MPI * n)
+mpi_to_bn(PGP_MPI *n)
{
mpz_t *bn = mp_new();
}
static PGP_MPI *
-bn_to_mpi(mpz_t * bn)
+bn_to_mpi(mpz_t *bn)
{
int res;
PGP_MPI *n;
}
int
-pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * _m,
- PGP_MPI ** c1_p, PGP_MPI ** c2_p)
+pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
+ PGP_MPI **c1_p, PGP_MPI **c2_p)
{
int res = PXE_PGP_MATH_FAILED;
int k_bits;
}
int
-pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * _c1, PGP_MPI * _c2,
- PGP_MPI ** msg_p)
+pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
+ PGP_MPI **msg_p)
{
int res = PXE_PGP_MATH_FAILED;
mpz_t *c1 = mpi_to_bn(_c1);
}
int
-pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * _m, PGP_MPI ** c_p)
+pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
{
int res = PXE_PGP_MATH_FAILED;
mpz_t *m = mpi_to_bn(_m);
}
int
-pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * _c, PGP_MPI ** m_p)
+pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
{
int res = PXE_PGP_MATH_FAILED;
mpz_t *c = mpi_to_bn(_c);
#include "pgp.h"
static BIGNUM *
-mpi_to_bn(PGP_MPI * n)
+mpi_to_bn(PGP_MPI *n)
{
BIGNUM *bn = BN_bin2bn(n->data, n->bytes, NULL);
}
int
-pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * _m,
- PGP_MPI ** c1_p, PGP_MPI ** c2_p)
+pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
+ PGP_MPI **c1_p, PGP_MPI **c2_p)
{
int res = PXE_PGP_MATH_FAILED;
int k_bits;
}
int
-pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * _c1, PGP_MPI * _c2,
- PGP_MPI ** msg_p)
+pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
+ PGP_MPI **msg_p)
{
int res = PXE_PGP_MATH_FAILED;
BIGNUM *c1 = mpi_to_bn(_c1);
}
int
-pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * _m, PGP_MPI ** c_p)
+pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
{
int res = PXE_PGP_MATH_FAILED;
BIGNUM *m = mpi_to_bn(_m);
}
int
-pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * _c, PGP_MPI ** m_p)
+pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
{
int res = PXE_PGP_MATH_FAILED;
BIGNUM *c = mpi_to_bn(_c);
#include "pgp.h"
int
-pgp_mpi_alloc(int bits, PGP_MPI ** mpi)
+pgp_mpi_alloc(int bits, PGP_MPI **mpi)
{
PGP_MPI *n;
int len = (bits + 7) / 8;
}
int
-pgp_mpi_create(uint8 *data, int bits, PGP_MPI ** mpi)
+pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi)
{
int res;
PGP_MPI *n;
}
int
-pgp_mpi_free(PGP_MPI * mpi)
+pgp_mpi_free(PGP_MPI *mpi)
{
if (mpi == NULL)
return 0;
}
int
-pgp_mpi_read(PullFilter * src, PGP_MPI ** mpi)
+pgp_mpi_read(PullFilter *src, PGP_MPI **mpi)
{
int res;
uint8 hdr[2];
}
int
-pgp_mpi_write(PushFilter * dst, PGP_MPI * n)
+pgp_mpi_write(PushFilter *dst, PGP_MPI *n)
{
int res;
uint8 buf[2];
}
int
-pgp_mpi_hash(PX_MD * md, PGP_MPI * n)
+pgp_mpi_hash(PX_MD *md, PGP_MPI *n)
{
uint8 buf[2];
}
unsigned
-pgp_mpi_cksum(unsigned cksum, PGP_MPI * n)
+pgp_mpi_cksum(unsigned cksum, PGP_MPI *n)
{
int i;
* Mix a block of data into RNG.
*/
static void
-add_block_entropy(PX_MD * md, text *data)
+add_block_entropy(PX_MD *md, text *data)
{
uint8 sha1[20];
} while (0)
static void
-check_expect(PGP_Context * ctx, struct debug_expect * ex)
+check_expect(PGP_Context *ctx, struct debug_expect * ex)
{
EX_CHECK(cipher_algo);
EX_CHECK(s2k_mode);
}
static int
-set_arg(PGP_Context * ctx, char *key, char *val,
+set_arg(PGP_Context *ctx, char *key, char *val,
struct debug_expect * ex)
{
int res = 0;
}
static int
-parse_args(PGP_Context * ctx, uint8 *args, int arg_len,
+parse_args(PGP_Context *ctx, uint8 *args, int arg_len,
struct debug_expect * ex)
{
char *str = downcase_convert(args, arg_len);
}
static void
-init_work(PGP_Context ** ctx_p, int is_text,
+init_work(PGP_Context **ctx_p, int is_text,
text *args, struct debug_expect * ex)
{
int err = pgp_init(ctx_p);
}
static int
-decrypt_elgamal(PGP_PubKey * pk, PullFilter * pkt, PGP_MPI ** m_p)
+decrypt_elgamal(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
{
int res;
PGP_MPI *c1 = NULL;
}
static int
-decrypt_rsa(PGP_PubKey * pk, PullFilter * pkt, PGP_MPI ** m_p)
+decrypt_rsa(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
{
int res;
PGP_MPI *c;
any_key[] = {0, 0, 0, 0, 0, 0, 0, 0};
int
-pgp_parse_pubenc_sesskey(PGP_Context * ctx, PullFilter * pkt)
+pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt)
{
int ver;
int algo;
}
static int
-create_secmsg(PGP_Context * ctx, PGP_MPI ** msg_p, int full_bytes)
+create_secmsg(PGP_Context *ctx, PGP_MPI **msg_p, int full_bytes)
{
uint8 *secmsg;
int res,
}
static int
-encrypt_and_write_elgamal(PGP_Context * ctx, PGP_PubKey * pk, PushFilter * pkt)
+encrypt_and_write_elgamal(PGP_Context *ctx, PGP_PubKey *pk, PushFilter *pkt)
{
int res;
PGP_MPI *m = NULL,
}
static int
-encrypt_and_write_rsa(PGP_Context * ctx, PGP_PubKey * pk, PushFilter * pkt)
+encrypt_and_write_rsa(PGP_Context *ctx, PGP_PubKey *pk, PushFilter *pkt)
{
int res;
PGP_MPI *m = NULL,
}
int
-pgp_write_pubenc_sesskey(PGP_Context * ctx, PushFilter * dst)
+pgp_write_pubenc_sesskey(PGP_Context *ctx, PushFilter *dst)
{
int res;
PGP_PubKey *pk = ctx->pub_key;
#include "pgp.h"
int
-pgp_key_alloc(PGP_PubKey ** pk_p)
+pgp_key_alloc(PGP_PubKey **pk_p)
{
PGP_PubKey *pk;
}
void
-pgp_key_free(PGP_PubKey * pk)
+pgp_key_free(PGP_PubKey *pk)
{
if (pk == NULL)
return;
}
static int
-calc_key_id(PGP_PubKey * pk)
+calc_key_id(PGP_PubKey *pk)
{
int res;
PX_MD *md;
}
int
-_pgp_read_public_key(PullFilter * pkt, PGP_PubKey ** pk_p)
+_pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
{
int res;
PGP_PubKey *pk;
#define HIDE_SHA1 254
static int
-check_key_sha1(PullFilter * src, PGP_PubKey * pk)
+check_key_sha1(PullFilter *src, PGP_PubKey *pk)
{
int res;
uint8 got_sha1[20];
}
static int
-check_key_cksum(PullFilter * src, PGP_PubKey * pk)
+check_key_cksum(PullFilter *src, PGP_PubKey *pk)
{
int res;
unsigned got_cksum,
}
static int
-process_secret_key(PullFilter * pkt, PGP_PubKey ** pk_p,
+process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
const uint8 *key, int key_len)
{
int res;
}
static int
-internal_read_key(PullFilter * src, PGP_PubKey ** pk_p,
+internal_read_key(PullFilter *src, PGP_PubKey **pk_p,
const uint8 *psw, int psw_len, int pubtype)
{
PullFilter *pkt = NULL;
}
int
-pgp_set_pubkey(PGP_Context * ctx, MBuf * keypkt,
+pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt,
const uint8 *key, int key_len, int pubtype)
{
int res;
#include "pgp.h"
static int
-calc_s2k_simple(PGP_S2K * s2k, PX_MD * md, const uint8 *key,
+calc_s2k_simple(PGP_S2K *s2k, PX_MD *md, const uint8 *key,
unsigned key_len)
{
unsigned md_bs,
}
static int
-calc_s2k_salted(PGP_S2K * s2k, PX_MD * md, const uint8 *key, unsigned key_len)
+calc_s2k_salted(PGP_S2K *s2k, PX_MD *md, const uint8 *key, unsigned key_len)
{
unsigned md_bs,
md_rlen;
}
static int
-calc_s2k_iter_salted(PGP_S2K * s2k, PX_MD * md, const uint8 *key,
+calc_s2k_iter_salted(PGP_S2K *s2k, PX_MD *md, const uint8 *key,
unsigned key_len)
{
unsigned md_bs,
}
int
-pgp_s2k_fill(PGP_S2K * s2k, int mode, int digest_algo)
+pgp_s2k_fill(PGP_S2K *s2k, int mode, int digest_algo)
{
int res = 0;
uint8 tmp;
}
int
-pgp_s2k_read(PullFilter * src, PGP_S2K * s2k)
+pgp_s2k_read(PullFilter *src, PGP_S2K *s2k)
{
int res = 0;
}
int
-pgp_s2k_process(PGP_S2K * s2k, int cipher, const uint8 *key, int key_len)
+pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int key_len)
{
int res;
PX_MD *md;
}
int
-pgp_load_cipher(int code, PX_Cipher ** res)
+pgp_load_cipher(int code, PX_Cipher **res)
{
int err;
const struct cipher_info *i = get_cipher_info(code);
}
int
-pgp_load_digest(int code, PX_MD ** res)
+pgp_load_digest(int code, PX_MD **res)
{
int err;
const char *name = pgp_get_digest_name(code);
}
int
-pgp_init(PGP_Context ** ctx_p)
+pgp_init(PGP_Context **ctx_p)
{
PGP_Context *ctx;
}
int
-pgp_free(PGP_Context * ctx)
+pgp_free(PGP_Context *ctx)
{
if (ctx->pub_key)
pgp_key_free(ctx->pub_key);
}
int
-pgp_disable_mdc(PGP_Context * ctx, int disable)
+pgp_disable_mdc(PGP_Context *ctx, int disable)
{
ctx->disable_mdc = disable ? 1 : 0;
return 0;
}
int
-pgp_set_sess_key(PGP_Context * ctx, int use)
+pgp_set_sess_key(PGP_Context *ctx, int use)
{
ctx->use_sess_key = use ? 1 : 0;
return 0;
}
int
-pgp_set_convert_crlf(PGP_Context * ctx, int doit)
+pgp_set_convert_crlf(PGP_Context *ctx, int doit)
{
ctx->convert_crlf = doit ? 1 : 0;
return 0;
}
int
-pgp_set_s2k_mode(PGP_Context * ctx, int mode)
+pgp_set_s2k_mode(PGP_Context *ctx, int mode)
{
int err = PXE_OK;
}
int
-pgp_set_compress_algo(PGP_Context * ctx, int algo)
+pgp_set_compress_algo(PGP_Context *ctx, int algo)
{
switch (algo)
{
}
int
-pgp_set_compress_level(PGP_Context * ctx, int level)
+pgp_set_compress_level(PGP_Context *ctx, int level)
{
if (level >= 0 && level <= 9)
{
}
int
-pgp_set_text_mode(PGP_Context * ctx, int mode)
+pgp_set_text_mode(PGP_Context *ctx, int mode)
{
ctx->text_mode = mode;
return 0;
}
int
-pgp_set_cipher_algo(PGP_Context * ctx, const char *name)
+pgp_set_cipher_algo(PGP_Context *ctx, const char *name)
{
int code = pgp_get_cipher_code(name);
}
int
-pgp_set_s2k_cipher_algo(PGP_Context * ctx, const char *name)
+pgp_set_s2k_cipher_algo(PGP_Context *ctx, const char *name)
{
int code = pgp_get_cipher_code(name);
}
int
-pgp_set_s2k_digest_algo(PGP_Context * ctx, const char *name)
+pgp_set_s2k_digest_algo(PGP_Context *ctx, const char *name)
{
int code = pgp_get_digest_code(name);
}
int
-pgp_get_unicode_mode(PGP_Context * ctx)
+pgp_get_unicode_mode(PGP_Context *ctx)
{
return ctx->unicode_mode;
}
int
-pgp_set_unicode_mode(PGP_Context * ctx, int mode)
+pgp_set_unicode_mode(PGP_Context *ctx, int mode)
{
ctx->unicode_mode = mode ? 1 : 0;
return 0;
}
int
-pgp_set_symkey(PGP_Context * ctx, const uint8 *key, int len)
+pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int len)
{
if (key == NULL || len < 1)
return PXE_ARGUMENT_ERROR;
int can_encrypt;
};
-int pgp_init(PGP_Context ** ctx);
-int pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst);
-int pgp_decrypt(PGP_Context * ctx, MBuf * src, MBuf * dst);
-int pgp_free(PGP_Context * ctx);
+int pgp_init(PGP_Context **ctx);
+int pgp_encrypt(PGP_Context *ctx, MBuf *src, MBuf *dst);
+int pgp_decrypt(PGP_Context *ctx, MBuf *src, MBuf *dst);
+int pgp_free(PGP_Context *ctx);
int pgp_get_digest_code(const char *name);
int pgp_get_cipher_code(const char *name);
const char *pgp_get_digest_name(int code);
const char *pgp_get_cipher_name(int code);
-int pgp_set_cipher_algo(PGP_Context * ctx, const char *name);
-int pgp_set_s2k_mode(PGP_Context * ctx, int type);
-int pgp_set_s2k_cipher_algo(PGP_Context * ctx, const char *name);
-int pgp_set_s2k_digest_algo(PGP_Context * ctx, const char *name);
-int pgp_set_convert_crlf(PGP_Context * ctx, int doit);
-int pgp_disable_mdc(PGP_Context * ctx, int disable);
-int pgp_set_sess_key(PGP_Context * ctx, int use);
-int pgp_set_compress_algo(PGP_Context * ctx, int algo);
-int pgp_set_compress_level(PGP_Context * ctx, int level);
-int pgp_set_text_mode(PGP_Context * ctx, int mode);
-int pgp_set_unicode_mode(PGP_Context * ctx, int mode);
-int pgp_get_unicode_mode(PGP_Context * ctx);
-
-int pgp_set_symkey(PGP_Context * ctx, const uint8 *key, int klen);
-int pgp_set_pubkey(PGP_Context * ctx, MBuf * keypkt,
+int pgp_set_cipher_algo(PGP_Context *ctx, const char *name);
+int pgp_set_s2k_mode(PGP_Context *ctx, int type);
+int pgp_set_s2k_cipher_algo(PGP_Context *ctx, const char *name);
+int pgp_set_s2k_digest_algo(PGP_Context *ctx, const char *name);
+int pgp_set_convert_crlf(PGP_Context *ctx, int doit);
+int pgp_disable_mdc(PGP_Context *ctx, int disable);
+int pgp_set_sess_key(PGP_Context *ctx, int use);
+int pgp_set_compress_algo(PGP_Context *ctx, int algo);
+int pgp_set_compress_level(PGP_Context *ctx, int level);
+int pgp_set_text_mode(PGP_Context *ctx, int mode);
+int pgp_set_unicode_mode(PGP_Context *ctx, int mode);
+int pgp_get_unicode_mode(PGP_Context *ctx);
+
+int pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int klen);
+int pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt,
const uint8 *key, int klen, int pubtype);
-int pgp_get_keyid(MBuf * pgp_data, char *dst);
+int pgp_get_keyid(MBuf *pgp_data, char *dst);
/* internal functions */
-int pgp_load_digest(int c, PX_MD ** res);
-int pgp_load_cipher(int c, PX_Cipher ** res);
+int pgp_load_digest(int c, PX_MD **res);
+int pgp_load_cipher(int c, PX_Cipher **res);
int pgp_get_cipher_key_size(int c);
int pgp_get_cipher_block_size(int c);
-int pgp_s2k_fill(PGP_S2K * s2k, int mode, int digest_algo);
-int pgp_s2k_read(PullFilter * src, PGP_S2K * s2k);
-int pgp_s2k_process(PGP_S2K * s2k, int cipher, const uint8 *key, int klen);
+int pgp_s2k_fill(PGP_S2K *s2k, int mode, int digest_algo);
+int pgp_s2k_read(PullFilter *src, PGP_S2K *s2k);
+int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int klen);
typedef struct PGP_CFB PGP_CFB;
int
-pgp_cfb_create(PGP_CFB ** ctx_p, int algo,
+pgp_cfb_create(PGP_CFB **ctx_p, int algo,
const uint8 *key, int key_len, int recync, uint8 *iv);
-void pgp_cfb_free(PGP_CFB * ctx);
-int pgp_cfb_encrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
-int pgp_cfb_decrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
+void pgp_cfb_free(PGP_CFB *ctx);
+int pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
+int pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
int pgp_armor_encode(const uint8 *src, unsigned len, uint8 *dst);
int pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst);
unsigned pgp_armor_enc_len(unsigned len);
unsigned pgp_armor_dec_len(unsigned len);
-int pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst);
-int pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src);
+int pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst);
+int pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src);
-int pgp_key_alloc(PGP_PubKey ** pk_p);
-void pgp_key_free(PGP_PubKey * pk);
-int _pgp_read_public_key(PullFilter * pkt, PGP_PubKey ** pk_p);
+int pgp_key_alloc(PGP_PubKey **pk_p);
+void pgp_key_free(PGP_PubKey *pk);
+int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p);
-int pgp_parse_pubenc_sesskey(PGP_Context * ctx, PullFilter * pkt);
-int pgp_create_pkt_reader(PullFilter ** pf_p, PullFilter * src, int len,
- int pkttype, PGP_Context * ctx);
-int pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p,
+int pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt);
+int pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
+ int pkttype, PGP_Context *ctx);
+int pgp_parse_pkt_hdr(PullFilter *src, uint8 *tag, int *len_p,
int allow_ctx);
-int pgp_skip_packet(PullFilter * pkt);
-int pgp_expect_packet_end(PullFilter * pkt);
-
-int pgp_write_pubenc_sesskey(PGP_Context * ctx, PushFilter * dst);
-int pgp_create_pkt_writer(PushFilter * dst, int tag, PushFilter ** res_p);
-
-int pgp_mpi_alloc(int bits, PGP_MPI ** mpi);
-int pgp_mpi_create(uint8 *data, int bits, PGP_MPI ** mpi);
-int pgp_mpi_free(PGP_MPI * mpi);
-int pgp_mpi_read(PullFilter * src, PGP_MPI ** mpi);
-int
projects / users / simon / postgres.git / commitdiff