From 78f39bc072a0e228ea225b512d4a7940f9b74e63 Mon Sep 17 00:00:00 2001 From: jian he Date: Mon, 24 Nov 2025 16:38:23 +0800 Subject: [PATCH v11 18/20] error safe for casting geometry data type select castsource::regtype, casttarget::regtype, pp.prosrc from pg_cast pc join pg_proc pp on pp.oid = pc.castfunc join pg_type pt on pt.oid = castsource join pg_type pt1 on pt1.oid = casttarget and pc.castfunc > 0 and pt.typarray <> 0 and pt.typnamespace = 'pg_catalog'::regnamespace and pt1.typnamespace = 'pg_catalog'::regnamespace and (pt.typcategory = 'G' or pt1.typcategory = 'G') order by castsource::regtype, casttarget::regtype; castsource | casttarget | prosrc ------------+------------+--------------- point | box | point_box lseg | point | lseg_center path | polygon | path_poly box | point | box_center box | lseg | box_diagonal box | polygon | box_poly box | circle | box_circle polygon | point | poly_center polygon | path | poly_path polygon | box | poly_box polygon | circle | poly_circle circle | point | circle_center circle | box | circle_box circle | polygon | (14 rows) already error safe: point_box, box_diagonal, box_poly, poly_path, poly_box, circle_center almost error safe: path_poly can not error safe: cast circle to polygon, because it's a SQL function discussion: https://postgr.es/m/CACJufxHCMzrHOW=wRe8L30rMhB3sjwAv1LE928Fa7sxMu1Tx-g@mail.gmail.com --- src/backend/access/spgist/spgproc.c | 2 +- src/backend/utils/adt/geo_ops.c | 225 +++++++++++++++++++++++----- src/backend/utils/adt/geo_spgist.c | 2 +- src/include/utils/float.h | 77 ++++++++++ src/include/utils/geo_decls.h | 4 +- 5 files changed, 271 insertions(+), 39 deletions(-) diff --git a/src/backend/access/spgist/spgproc.c b/src/backend/access/spgist/spgproc.c index 660009291da..b3e0fbc59ba 100644 --- a/src/backend/access/spgist/spgproc.c +++ b/src/backend/access/spgist/spgproc.c @@ -51,7 +51,7 @@ point_box_distance(Point *point, BOX *box) else dy = 0.0; - return HYPOT(dx, dy); + return HYPOT(dx, dy, NULL); } /* diff --git a/src/backend/utils/adt/geo_ops.c b/src/backend/utils/adt/geo_ops.c index 377a1b3f3ad..bae8730c347 100644 --- a/src/backend/utils/adt/geo_ops.c +++ b/src/backend/utils/adt/geo_ops.c @@ -78,11 +78,14 @@ enum path_delim /* Routines for points */ static inline void point_construct(Point *result, float8 x, float8 y); static inline void point_add_point(Point *result, Point *pt1, Point *pt2); +static inline bool point_add_point_safe(Point *result, Point *pt1, Point *pt2, + Node *escontext); static inline void point_sub_point(Point *result, Point *pt1, Point *pt2); static inline void point_mul_point(Point *result, Point *pt1, Point *pt2); static inline void point_div_point(Point *result, Point *pt1, Point *pt2); static inline bool point_eq_point(Point *pt1, Point *pt2); static inline float8 point_dt(Point *pt1, Point *pt2); +static inline float8 point_dt_safe(Point *pt1, Point *pt2, Node *escontext); static inline float8 point_sl(Point *pt1, Point *pt2); static int point_inside(Point *p, int npts, Point *plist); @@ -109,6 +112,7 @@ static float8 lseg_closept_lseg(Point *result, LSEG *on_lseg, LSEG *to_lseg); /* Routines for boxes */ static inline void box_construct(BOX *result, Point *pt1, Point *pt2); static void box_cn(Point *center, BOX *box); +static bool box_cn_safe(Point *center, BOX *box, Node* escontext); static bool box_ov(BOX *box1, BOX *box2); static float8 box_ar(BOX *box); static float8 box_ht(BOX *box); @@ -125,7 +129,7 @@ static float8 circle_ar(CIRCLE *circle); /* Routines for polygons */ static void make_bound_box(POLYGON *poly); -static void poly_to_circle(CIRCLE *result, POLYGON *poly); +static bool poly_to_circle_safe(CIRCLE *result, POLYGON *poly, Node *escontext); static bool lseg_inside_poly(Point *a, Point *b, POLYGON *poly, int start); static bool poly_contain_poly(POLYGON *contains_poly, POLYGON *contained_poly); static bool plist_same(int npts, Point *p1, Point *p2); @@ -851,7 +855,8 @@ box_center(PG_FUNCTION_ARGS) BOX *box = PG_GETARG_BOX_P(0); Point *result = (Point *) palloc(sizeof(Point)); - box_cn(result, box); + if (!box_cn_safe(result, box, fcinfo->context)) + PG_RETURN_NULL(); PG_RETURN_POINT_P(result); } @@ -871,10 +876,33 @@ box_ar(BOX *box) static void box_cn(Point *center, BOX *box) { - center->x = float8_div(float8_pl(box->high.x, box->low.x), 2.0); - center->y = float8_div(float8_pl(box->high.y, box->low.y), 2.0); + (void) box_cn_safe(center, box, NULL); } +static bool +box_cn_safe(Point *center, BOX *box, Node* escontext) +{ + float8 x; + float8 y; + + x = float8_pl_safe(box->high.x, box->low.x, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + center->x = float8_div_safe(x, 2.0, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + y = float8_pl_safe(box->high.y, box->low.y, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + center->y = float8_div_safe(y, 2.0, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + return true; +} /* box_wd - returns the width (length) of the box * (horizontal magnitude). @@ -1276,7 +1304,7 @@ line_distance(PG_FUNCTION_ARGS) PG_RETURN_FLOAT8(float8_div(fabs(float8_mi(l1->C, float8_mul(ratio, l2->C))), - HYPOT(l1->A, l1->B))); + HYPOT(l1->A, l1->B, NULL))); } /* line_interpt() @@ -2001,9 +2029,27 @@ point_distance(PG_FUNCTION_ARGS) static inline float8 point_dt(Point *pt1, Point *pt2) { - return HYPOT(float8_mi(pt1->x, pt2->x), float8_mi(pt1->y, pt2->y)); + return point_dt_safe(pt1, pt2, NULL); } +static inline float8 +point_dt_safe(Point *pt1, Point *pt2, Node *escontext) +{ + float8 x; + float8 y; + + x = float8_mi_safe(pt1->x, pt2->x, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return 0.0; + + y = float8_mi_safe(pt1->y, pt2->y, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return 0.0; + + return HYPOT(x, y, escontext); +} + + Datum point_slope(PG_FUNCTION_ARGS) { @@ -2317,13 +2363,31 @@ lseg_center(PG_FUNCTION_ARGS) { LSEG *lseg = PG_GETARG_LSEG_P(0); Point *result; + float8 x; + float8 y; result = (Point *) palloc(sizeof(Point)); - result->x = float8_div(float8_pl(lseg->p[0].x, lseg->p[1].x), 2.0); - result->y = float8_div(float8_pl(lseg->p[0].y, lseg->p[1].y), 2.0); + x = float8_pl_safe(lseg->p[0].x, lseg->p[1].x, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + result->x = float8_div_safe(x, 2.0, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + y = float8_pl_safe(lseg->p[0].y, lseg->p[1].y, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + result->y = float8_div_safe(y, 2.0, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; PG_RETURN_POINT_P(result); + +fail: + PG_RETURN_NULL(); } @@ -4110,9 +4174,27 @@ construct_point(PG_FUNCTION_ARGS) static inline void point_add_point(Point *result, Point *pt1, Point *pt2) { - point_construct(result, - float8_pl(pt1->x, pt2->x), - float8_pl(pt1->y, pt2->y)); + (void) point_add_point_safe(result, pt1, pt2, NULL); +} + +static inline bool +point_add_point_safe(Point *result, Point *pt1, Point *pt2, + Node *escontext) +{ + float8 x; + float8 y; + + x = float8_pl_safe(pt1->x, pt2->x, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + y = float8_pl_safe(pt1->y, pt2->y, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + point_construct(result, x, y); + + return true; } Datum @@ -4458,7 +4540,7 @@ path_poly(PG_FUNCTION_ARGS) /* This is not very consistent --- other similar cases return NULL ... */ if (!path->closed) - ereport(ERROR, + ereturn(fcinfo->context, (Datum) 0, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("open path cannot be converted to polygon"))); @@ -4508,7 +4590,9 @@ poly_center(PG_FUNCTION_ARGS) result = (Point *) palloc(sizeof(Point)); - poly_to_circle(&circle, poly); + if (!poly_to_circle_safe(&circle, poly, fcinfo->context)) + PG_RETURN_NULL(); + *result = circle.center; PG_RETURN_POINT_P(result); @@ -5005,7 +5089,7 @@ circle_mul_pt(PG_FUNCTION_ARGS) result = (CIRCLE *) palloc(sizeof(CIRCLE)); point_mul_point(&result->center, &circle->center, point); - result->radius = float8_mul(circle->radius, HYPOT(point->x, point->y)); + result->radius = float8_mul(circle->radius, HYPOT(point->x, point->y, NULL)); PG_RETURN_CIRCLE_P(result); } @@ -5020,7 +5104,7 @@ circle_div_pt(PG_FUNCTION_ARGS) result = (CIRCLE *) palloc(sizeof(CIRCLE)); point_div_point(&result->center, &circle->center, point); - result->radius = float8_div(circle->radius, HYPOT(point->x, point->y)); + result->radius = float8_div(circle->radius, HYPOT(point->x, point->y, NULL)); PG_RETURN_CIRCLE_P(result); } @@ -5191,14 +5275,30 @@ circle_box(PG_FUNCTION_ARGS) box = (BOX *) palloc(sizeof(BOX)); - delta = float8_div(circle->radius, sqrt(2.0)); + delta = float8_div_safe(circle->radius, sqrt(2.0), fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; - box->high.x = float8_pl(circle->center.x, delta); - box->low.x = float8_mi(circle->center.x, delta); - box->high.y = float8_pl(circle->center.y, delta); - box->low.y = float8_mi(circle->center.y, delta); + box->high.x = float8_pl_safe(circle->center.x, delta, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + box->low.x = float8_mi_safe(circle->center.x, delta, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + box->high.y = float8_pl_safe(circle->center.y, delta, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + box->low.y = float8_mi_safe(circle->center.y, delta, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; PG_RETURN_BOX_P(box); + +fail: + PG_RETURN_NULL(); } /* box_circle() @@ -5209,15 +5309,35 @@ box_circle(PG_FUNCTION_ARGS) { BOX *box = PG_GETARG_BOX_P(0); CIRCLE *circle; + float8 x; + float8 y; circle = (CIRCLE *) palloc(sizeof(CIRCLE)); - circle->center.x = float8_div(float8_pl(box->high.x, box->low.x), 2.0); - circle->center.y = float8_div(float8_pl(box->high.y, box->low.y), 2.0); + x = float8_pl_safe(box->high.x, box->low.x, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; - circle->radius = point_dt(&circle->center, &box->high); + circle->center.x = float8_div_safe(x, 2.0, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + y = float8_pl_safe(box->high.y, box->low.y, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + circle->center.y = float8_div_safe(y, 2.0, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; + + circle->radius = point_dt_safe(&circle->center, &box->high, fcinfo->context); + if (SOFT_ERROR_OCCURRED(fcinfo->context)) + goto fail; PG_RETURN_CIRCLE_P(circle); + +fail: + PG_RETURN_NULL(); } @@ -5281,10 +5401,11 @@ circle_poly(PG_FUNCTION_ARGS) * XXX This algorithm should use weighted means of line segments * rather than straight average values of points - tgl 97/01/21. */ -static void -poly_to_circle(CIRCLE *result, POLYGON *poly) +static bool +poly_to_circle_safe(CIRCLE *result, POLYGON *poly, Node *escontext) { int i; + float8 x; Assert(poly->npts > 0); @@ -5293,14 +5414,42 @@ poly_to_circle(CIRCLE *result, POLYGON *poly) result->radius = 0; for (i = 0; i < poly->npts; i++) - point_add_point(&result->center, &result->center, &poly->p[i]); - result->center.x = float8_div(result->center.x, poly->npts); - result->center.y = float8_div(result->center.y, poly->npts); + { + if (!point_add_point_safe(&result->center, + &result->center, + &poly->p[i], + escontext)) + return false; + } + + result->center.x = float8_div_safe(result->center.x, + poly->npts, + escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + result->center.y = float8_div_safe(result->center.y, + poly->npts, + escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; for (i = 0; i < poly->npts; i++) - result->radius = float8_pl(result->radius, - point_dt(&poly->p[i], &result->center)); - result->radius = float8_div(result->radius, poly->npts); + { + x = point_dt_safe(&poly->p[i], &result->center, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + result->radius = float8_pl_safe(result->radius, x, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + } + + result->radius = float8_div_safe(result->radius, poly->npts, escontext); + if (SOFT_ERROR_OCCURRED(escontext)) + return false; + + return true; } Datum @@ -5311,7 +5460,8 @@ poly_circle(PG_FUNCTION_ARGS) result = (CIRCLE *) palloc(sizeof(CIRCLE)); - poly_to_circle(result, poly); + if (!poly_to_circle_safe(result, poly, fcinfo->context)) + PG_RETURN_NULL(); PG_RETURN_CIRCLE_P(result); } @@ -5516,7 +5666,7 @@ plist_same(int npts, Point *p1, Point *p2) *----------------------------------------------------------------------- */ float8 -pg_hypot(float8 x, float8 y) +pg_hypot(float8 x, float8 y, Node *escontext) { float8 yx, result; @@ -5554,9 +5704,14 @@ pg_hypot(float8 x, float8 y) result = x * sqrt(1.0 + (yx * yx)); if (unlikely(isinf(result))) - float_overflow_error(); + ereturn(escontext, 0.0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: overflow")); + if (unlikely(result == 0.0)) - float_underflow_error(); + ereturn(escontext, 0.0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: underflow")); return result; } diff --git a/src/backend/utils/adt/geo_spgist.c b/src/backend/utils/adt/geo_spgist.c index fec33e95372..ffffd3cd2de 100644 --- a/src/backend/utils/adt/geo_spgist.c +++ b/src/backend/utils/adt/geo_spgist.c @@ -390,7 +390,7 @@ pointToRectBoxDistance(Point *point, RectBox *rect_box) else dy = 0; - return HYPOT(dx, dy); + return HYPOT(dx, dy, NULL); } diff --git a/src/include/utils/float.h b/src/include/utils/float.h index fc2a9cf6475..aec376ffc56 100644 --- a/src/include/utils/float.h +++ b/src/include/utils/float.h @@ -121,6 +121,21 @@ float8_pl(const float8 val1, const float8 val2) return result; } +/* error safe version of float8_pl */ +static inline float8 +float8_pl_safe(const float8 val1, const float8 val2, struct Node *escontext) +{ + float8 result; + + result = val1 + val2; + if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2)) + ereturn(escontext, 0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: overflow")); + + return result; +} + static inline float4 float4_mi(const float4 val1, const float4 val2) { @@ -145,6 +160,21 @@ float8_mi(const float8 val1, const float8 val2) return result; } +/* error safe version of float8_mi */ +static inline float8 +float8_mi_safe(const float8 val1, const float8 val2, struct Node *escontext) +{ + float8 result; + + result = val1 - val2; + if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2)) + ereturn(escontext, 0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: overflow")); + + return result; +} + static inline float4 float4_mul(const float4 val1, const float4 val2) { @@ -173,6 +203,27 @@ float8_mul(const float8 val1, const float8 val2) return result; } +/* error safe version of float8_mul */ +static inline float8 +float8_mul_safe(const float8 val1, const float8 val2, struct Node *escontext) +{ + float8 result; + + result = val1 * val2; + + if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2)) + ereturn(escontext, 0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: overflow")); + + if (unlikely(result == 0.0) && val1 != 0.0 && val2 != 0.0) + ereturn(escontext, 0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: underflow")); + + return result; +} + static inline float4 float4_div(const float4 val1, const float4 val2) { @@ -205,6 +256,32 @@ float8_div(const float8 val1, const float8 val2) return result; } +/* error safe version of float8_div */ +static inline float8 +float8_div_safe(const float8 val1, const float8 val2, struct Node *escontext) +{ + float8 result; + + if (unlikely(val2 == 0.0) && !isnan(val1)) + ereturn(escontext, 0, + errcode(ERRCODE_DIVISION_BY_ZERO), + errmsg("division by zero")); + + result = val1 / val2; + + if (unlikely(isinf(result)) && !isinf(val1)) + ereturn(escontext, 0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: overflow")); + + if (unlikely(result == 0.0) && val1 != 0.0 && !isinf(val2)) + ereturn(escontext, 0, + errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value out of range: underflow")); + + return result; +} + /* * Routines for NaN-aware comparisons * diff --git a/src/include/utils/geo_decls.h b/src/include/utils/geo_decls.h index 8a9df75c93c..0056a26639f 100644 --- a/src/include/utils/geo_decls.h +++ b/src/include/utils/geo_decls.h @@ -88,7 +88,7 @@ FPge(double A, double B) #define FPge(A,B) ((A) >= (B)) #endif -#define HYPOT(A, B) pg_hypot(A, B) +#define HYPOT(A, B, escontext) pg_hypot(A, B, escontext) /*--------------------------------------------------------------------- * Point - (x,y) @@ -280,6 +280,6 @@ CirclePGetDatum(const CIRCLE *X) * in geo_ops.c */ -extern float8 pg_hypot(float8 x, float8 y); +extern float8 pg_hypot(float8 x, float8 y, Node *escontext); #endif /* GEO_DECLS_H */ -- 2.34.1