[CLIENT-4678] Warn if specific fields receives out of bounds constant value (represented as an enumeration in the C client)

src/include/cdt_operation_utils.h

@@ -74,8 +74,18 @@ as_status get_optional_int64_t(as_error *err, const char *key,
 as_status get_uint64_t(as_error *err, const char *key, PyObject *op_dict,
                        uint64_t *ui64_valptr);
 
+// This is used to validate enum arguments
+// In C99, enum values can be between INT_MIN and INT_MAX
+// So we define our min and max bound parameters as integer types
+// https://stackoverflow.com/a/366033
+// If is_optional is true, int_pointer does not get dereferenced.
+// min_bound and max_bound are inclusive
+as_status get_enum_from_py_dict(as_error *err, const char *key,
+                                PyObject *py_dict, int *int_pointer,
+                                int min_bound, int max_bound, bool is_optional);
+
 as_status get_int_from_py_dict(as_error *err, const char *key,
-                               PyObject *op_dict, int *int_pointer);
+                               PyObject *py_dict, int *int_pointer);
 
 as_status get_list_return_type(as_error *err, PyObject *op_dict,
                                int *return_type);

src/main/client/bit_operate.c

@@ -343,17 +343,15 @@ as_status add_new_bit_op(AerospikeClient *self, as_error *err,
 static as_status get_bit_resize_flags(as_error *err, PyObject *op_dict,
                                       as_bit_resize_flags *resize_flags)
 {
-    int64_t flags64;
-    bool found = false;
+    int tmp_value;
     *resize_flags = AS_BIT_RESIZE_DEFAULT;
 
-    if (get_optional_int64_t(err, RESIZE_FLAGS_KEY, op_dict, &flags64,
-                             &found) != AEROSPIKE_OK) {
+    if (get_enum_from_py_dict(
+            err, RESIZE_FLAGS_KEY, op_dict, &tmp_value, AS_BIT_RESIZE_DEFAULT,
+            AS_BIT_RESIZE_SHRINK_ONLY * 2 - 1, true) != AEROSPIKE_OK) {
         return err->code;
     }
-    if (found) {
-        *resize_flags = (as_bit_resize_flags)flags64;
-    }
+    *resize_flags = (as_bit_resize_flags)tmp_value;
 
     return AEROSPIKE_OK;
 }

src/main/client/cdt_operation_utils.c

@@ -196,22 +196,67 @@ as_status get_uint64_t(as_error *err, const char *key, PyObject *op_dict,
     return AEROSPIKE_OK;
 }
 
-as_status get_int_from_py_dict(as_error *err, const char *key,
-                               PyObject *op_dict, int *int_pointer)
+#define OUT_OF_BOUNDS_MESSAGE                                                  \
+    "%s must be inclusively between %d and %d, but received %" PRId64          \
+    " instead."
+
+static inline as_status
+get_bound_int_from_py_dict(as_error *err, const char *key, PyObject *py_dict,
+                           int *int_pointer, int min_bound, int max_bound,
+                           bool is_optional, bool warn_if_out_of_bounds)
 {
-    int64_t int64_to_return = -1;
+    int64_t int64 = -1;
+    bool found = false;
+    if (get_optional_int64_t(err, key, py_dict, &int64, &found) !=
+        AEROSPIKE_OK) {
+        goto exit_without_returning_int;
+    }
 
-    if (get_int64_t(err, key, op_dict, &int64_to_return) != AEROSPIKE_OK) {
-        return err->code;
+    if (!found) {
+        if (!is_optional) {
+            return as_error_update(err, AEROSPIKE_ERR_PARAM,
+                                   "Operation missing required entry %s", key);
+        }
+        else {
+            goto exit_without_returning_int;
+        }
     }
 
-    if (int64_to_return > INT_MAX || int64_to_return < INT_MIN) {
-        return as_error_update(err, AEROSPIKE_ERR_PARAM,
-                               "%s too large for C int.", key);
+    if (int64 >= min_bound && int64 <= max_bound) {
+        goto return_int;
     }
-    *int_pointer = int64_to_return;
 
-    return AEROSPIKE_OK;
+    if (warn_if_out_of_bounds) {
+        int retval = PyErr_WarnFormat(PyExc_DeprecationWarning, STACK_LEVEL,
+                                      OUT_OF_BOUNDS_MESSAGE, key, min_bound,
+                                      max_bound, int64);
+        if (retval == 0) {
+            goto return_int;
+        }
+    }
+
+    return as_error_update(err, AEROSPIKE_ERR_PARAM, OUT_OF_BOUNDS_MESSAGE, key,
+                           min_bound, max_bound, int64);
+
+return_int:
+    *int_pointer = int64;
+exit_without_returning_int:
+    return err->code;
+}
+
+as_status get_enum_from_py_dict(as_error *err, const char *key,
+                                PyObject *py_dict, int *int_pointer,
+                                int min_bound, int max_bound, bool is_optional)
+{
+    return get_bound_int_from_py_dict(err, key, py_dict, int_pointer, min_bound,
+                                      max_bound, is_optional, true);
+}
+
+as_status get_int_from_py_dict(as_error *err, const char *key,
+                               PyObject *py_dict, int *int_pointer)
+{
+    return get_bound_int_from_py_dict(err, key, py_dict, int_pointer, INT_MIN,
+                                      INT_MAX, false, false);
 }
 
 as_status get_list_return_type(as_error *err, PyObject *op_dict,

src/main/client/operate.c

@@ -37,6 +37,7 @@
 #include "hll_operations.h"
 #include "pythoncapi_compat.h"
 #include "expression_operations.h"
+#include "cdt_operation_utils.h"
 
 #include <aerospike/as_double.h>
 #include <aerospike/as_integer.h>
@@ -346,7 +347,6 @@ as_status add_op(AerospikeClient *self, as_error *err,
     PyObject *py_map_policy = NULL;
     PyObject *py_return_type = NULL;
     // For map_create operation
-    PyObject *py_map_order = NULL;
     PyObject *py_persist_index = NULL;
 
     Py_ssize_t pos = 0;
@@ -419,7 +419,7 @@ as_status add_op(AerospikeClient *self, as_error *err,
                 ctx_ref = (ctx_in_use ? &ctx : NULL);
             }
             else if (strcmp(name, "map_order") == 0) {
-                py_map_order = value;
+                continue;
             }
             else if (strcmp(name, "persist_index") == 0) {
                 py_persist_index = value;
@@ -744,7 +744,15 @@ as_status add_op(AerospikeClient *self, as_error *err,
         as_operations_map_set_policy(ops, bin, ctx_ref, &map_policy);
         break;
     case OP_MAP_CREATE:;
-        as_map_order order = (as_map_order)PyLong_AsLong(py_map_order);
+        int tmp_value;
+        if (get_enum_from_py_dict(err, "map_order", py_operation_dict,
+                                  &tmp_value, AS_MAP_UNORDERED,
+                                  AS_MAP_KEY_VALUE_ORDERED,
+                                  false) != AEROSPIKE_OK) {
+            return err->code;
+        }
+        as_map_order order = (as_map_order)tmp_value;
+
         bool persist_index = PyObject_IsTrue(py_persist_index);
         as_operations_map_create_all(ops, bin, ctx_ref, order, persist_index);
         break;

src/main/client/operate_helper.c

@@ -191,14 +191,17 @@ as_status as_operations_add_from_pyobject(AerospikeClient *self, as_error *err,
         break;
     }
 
-    int64_t order_type_int;
+    as_list_order list_order = AS_LIST_UNORDERED;
+    int tmp_value;
     switch (operation_code) {
     case OP_LIST_SET_ORDER:
     case OP_LIST_CREATE:
-        if (get_int64_t(err, AS_PY_LIST_ORDER, op_dict, &order_type_int) !=
-            AEROSPIKE_OK) {
+        if (get_enum_from_py_dict(err, AS_PY_LIST_ORDER, op_dict, &tmp_value,
+                                  AS_LIST_UNORDERED, AS_LIST_ORDERED,
+                                  false) != AEROSPIKE_OK) {
             goto exit;
         }
+        list_order = (as_list_order)tmp_value;
     }
 
     bool ctx_in_use = false;
@@ -330,20 +333,22 @@ as_status as_operations_add_from_pyobject(AerospikeClient *self, as_error *err,
 
     as_string_numeric_type numeric_type = AS_STRING_NUMERIC_ANY;
     as_string_regex_flags regex_flags = AS_STRING_REGEX_FLAGS_NONE;
-    int64_t tmp_value;
     switch (operation_code) {
     case OP_STRING_IS_NUMERIC: {
-        if (get_int64_t(err, "numeric_type", op_dict, &tmp_value) !=
-            AEROSPIKE_OK) {
+        if (get_enum_from_py_dict(
+                err, "numeric_type", op_dict, &tmp_value, AS_STRING_NUMERIC_ANY,
+                AS_STRING_NUMERIC_FLOAT, false) != AEROSPIKE_OK) {
             goto CLEANUP_VAL2_ON_ERROR;
         }
         numeric_type = (as_string_numeric_type)tmp_value;
         break;
     }
     case OP_STRING_REGEX_COMPARE:
     case OP_STRING_REGEX_REPLACE: {
-        if (get_int64_t(err, "regex_flags", op_dict, &tmp_value) !=
-            AEROSPIKE_OK) {
+        if (get_enum_from_py_dict(err, "regex_flags", op_dict, &tmp_value,
+                                  AS_STRING_REGEX_FLAGS_NONE,
+                                  AS_STRING_REGEX_FLAGS_GLOBAL * 2 - 1,
+                                  false) != AEROSPIKE_OK) {
             goto CLEANUP_VAL2_ON_ERROR;
         }
         regex_flags = (as_string_regex_flags)tmp_value;
@@ -557,18 +562,19 @@ as_status as_operations_add_from_pyobject(AerospikeClient *self, as_error *err,
             ops, bin, ctx_ref, val1, val2, return_type);
         break;
     case OP_LIST_SET_ORDER:
-        success = as_operations_list_set_order(ops, bin, ctx_ref,
-                                               (as_list_order)order_type_int);
+        success = as_operations_list_set_order(ops, bin, ctx_ref, list_order);
         break;
     case OP_LIST_SORT: {
-        int64_t sort_flags;
+        as_list_sort_flags sort_flags;
 
-        if (get_int64_t(err, AS_PY_LIST_SORT_FLAGS, op_dict, &sort_flags) !=
-            AEROSPIKE_OK) {
+        if (get_enum_from_py_dict(err, AS_PY_LIST_SORT_FLAGS, op_dict,
+                                  &tmp_value, AS_LIST_SORT_DEFAULT,
+                                  AS_LIST_SORT_DROP_DUPLICATES,
+                                  false) != AEROSPIKE_OK) {
             goto CLEANUP_VAL2_ON_ERROR;
         }
-        success = as_operations_list_sort(ops, bin, ctx_ref,
-                                          (as_list_sort_flags)sort_flags);
+        sort_flags = (as_list_sort_flags)tmp_value;
+        success = as_operations_list_sort(ops, bin, ctx_ref, sort_flags);
         break;
     }
     case OP_LIST_GET_BY_VALUE_RANK_RANGE_REL:
@@ -593,8 +599,7 @@ as_status as_operations_add_from_pyobject(AerospikeClient *self, as_error *err,
             goto CLEANUP_VAL2_ON_ERROR;
         }
 
-        success = as_operations_list_create_all(ops, bin, ctx_ref,
-                                                (as_list_order)order_type_int,
+        success = as_operations_list_create_all(ops, bin, ctx_ref, list_order,
                                                 pad, persist_index);
         break;
     }

src/main/conversions.c

@@ -2640,8 +2640,9 @@ as_status as_cdt_ctx_add_from_pyobject(AerospikeClient *self, as_error *err,
         break;
     case CDT_CTX_MAP_KEY_CREATE:;
         int map_order = 0;
-        status = get_int_from_py_dict(err, CDT_CTX_ORDER_KEY, py_extra_args,
-                                      &map_order);
+        status = get_enum_from_py_dict(err, CDT_CTX_ORDER_KEY, py_extra_args,
+                                       &map_order, AS_MAP_UNORDERED,
+                                       AS_MAP_KEY_VALUE_ORDERED, false);
         if (status != AEROSPIKE_OK) {
             goto CLEANUP_PY_EXTRA_ARGS;
         }
@@ -2664,8 +2665,9 @@ as_status as_cdt_ctx_add_from_pyobject(AerospikeClient *self, as_error *err,
     case CDT_CTX_LIST_INDEX_CREATE:;
         int list_order = 0;
         int pad = 0;
-        status = get_int_from_py_dict(err, CDT_CTX_ORDER_KEY, py_extra_args,
-                                      &list_order);
+        status = get_enum_from_py_dict(err, CDT_CTX_ORDER_KEY, py_extra_args,
+                                       &list_order, AS_LIST_UNORDERED,
+                                       AS_LIST_ORDERED, false);
         if (status != AEROSPIKE_OK) {
             goto CLEANUP_PY_EXTRA_ARGS;
         }

src/main/convert_expressions.c

@@ -1048,15 +1048,18 @@ add_expr_macros(AerospikeClient *self, as_static_pool *static_pool,
             APPEND_ARRAY(1, as_exp_list_clear(temp_expr->ctx,
                                               NIL)); // -1 for bin
             break;
-        case OP_LIST_SORT:
-            if (get_int64_t(err, LIST_ORDER_KEY, temp_expr->pydict, &lval1) !=
-                AEROSPIKE_OK) {
+        case OP_LIST_SORT: {
+            int tmp_value;
+            if (get_enum_from_py_dict(err, LIST_ORDER_KEY, temp_expr->pydict,
+                                      &tmp_value, AS_LIST_UNORDERED,
+                                      AS_LIST_ORDERED, false) != AEROSPIKE_OK) {
                 return err->code;
             }
 
-            APPEND_ARRAY(1, as_exp_list_sort(temp_expr->ctx, lval1,
+            APPEND_ARRAY(1, as_exp_list_sort(temp_expr->ctx, tmp_value,
                                              NIL)); // -1 for bin
             break;
+        }
         case OP_LIST_REMOVE_BY_VALUE:
             if (get_int64_t(err, AS_PY_LIST_RETURN_KEY, temp_expr->pydict,
                             &lval1) != AEROSPIKE_OK) {
@@ -1482,14 +1485,18 @@ add_expr_macros(AerospikeClient *self, as_static_pool *static_pool,
                                 temp_expr->ctx, lval1, NIL, NIL,
                                 NIL)); // - 3 for rank, count, bin
             break;
-        case _AS_EXP_BIT_FLAGS:
-            if (get_int64_t(err, AS_PY_VAL_KEY, temp_expr->pydict, &lval1) !=
-                AEROSPIKE_OK) {
+        case _AS_EXP_BIT_FLAGS: {
+            int tmp_value;
+            if (get_enum_from_py_dict(err, AS_PY_VAL_KEY, temp_expr->pydict,
+                                      &tmp_value, AS_BIT_RESIZE_DEFAULT,
+                                      AS_BIT_RESIZE_SHRINK_ONLY * 2 - 1,
+                                      false) != AEROSPIKE_OK) {
                 return err->code;
             }
 
-            APPEND_ARRAY(0, as_exp_uint((uint64_t)lval1));
+            APPEND_ARRAY(0, as_exp_uint(tmp_value));
             break;
+        }
         case OP_BIT_RESIZE:
             APPEND_ARRAY(4, as_exp_bit_resize(
                                 NULL, NIL, NO_BIT_FLAGS,