9:42 a.m.
During the validate method arguments call, ensure embedded objects have been parsed if the
CIMOM hasn't done so already.
9:42 a.m.
New subject: [PATCH 1 of 2] [CU] Add embedded object parse functionality to std_invokemethod
# HG changeset patch
# User Kaitlin Rupert <karupert(a)us.ibm.com>
# Date 1201621280 28800
# Node ID 0375f0b616f44cba8705b667a658663e891cb068
# Parent 2948ecbed2674aee61a994b06468c2ce9c763bb3
[CU] Add embedded object parse functionality to std_invokemethod.
Updates from set 2 to set 3:
-Fixed pointer silliness - changed CMPIArgs param in parse_eo_param() to a single
pointer.
Updates from set 1 to set 2:
-Change return type check_for_eo() to CMPIType and return CMPI_null incase of error.
-Updated parse_eo_array() to take an array arg instead of a CMPIData arg.
-Fixed argument lists of parse_eo_inst_arg() and parse_eo_array() so that the arg order
is similar between the two.
-parse_eo_param() - made the AddArg call generic enough to work with both CMPI_instance
and CMPI_instanceA
This adds 3 functions:
-check_for_eo(): Determine whether the argument is an embedded object that needs to be
parsed.
-parse_eo_inst_arg(): Calls cu_parse_embedded_instance() to parse the arg.
-parse_eo_array(): Calls parse_eo_inst_arg() for each item in the arry.
-parse_eo_param(): If argument is an array, walks through the array calling
parse_eo_inst_arg(), otherwise call parse_eo_inst_arg() directly.
parse_eo_inst_arg() and parse_eo_param() are based on the EO parsing pieces in
Virt_VirtualSystemManagementService.
The style of these changes matches the style in the rest of the file - return 0 for
failure, return 1 for success.
Signed-off-by: Kaitlin Rupert <karupert(a)us.ibm.com>
diff -r 2948ecbed267 -r 0375f0b616f4 std_invokemethod.c
--- a/std_invokemethod.c Tue Jan 15 12:54:04 2008 +0100
+++ b/std_invokemethod.c Tue Jan 29 07:41:20 2008 -0800
@@ -29,6 +29,147 @@
#include "std_invokemethod.h"
#define STREQ(a,b) (strcmp(a, b) == 0)
+
+static CMPIType check_for_eo(CMPIType type, CMPIType exp_type)
+{
+ if ((exp_type == CMPI_instance) && (type == CMPI_string)) {
+ return CMPI_instance;
+ }
+
+ if ((exp_type == CMPI_instanceA) && (type == CMPI_stringA)) {
+ return CMPI_instanceA;
+ }
+
+ return CMPI_null;
+}
+
+static int parse_eo_inst_arg(CMPIString *string_in,
+ CMPIInstance **instance_out,
+ const CMPIBroker *broker,
+ const char *ns,
+ CMPIStatus *s)
+{
+ int ret;
+ const char *str;
+
+ str = CMGetCharPtr(string_in);
+
+ if (str == NULL) {
+ CMSetStatus(s, CMPI_RC_ERR_INVALID_PARAMETER);
+ CU_DEBUG("Method parameter value is NULL");
+ return 0;
+ }
+
+ ret = cu_parse_embedded_instance(str,
+ broker,
+ ns,
+ instance_out);
+
+ /* cu_parse_embedded_instance() returns 0 on success */
+ if ((ret != 0) || CMIsNullObject(instance_out)) {
+ CMSetStatus(s, CMPI_RC_ERR_FAILED);
+ CU_DEBUG("Unable to parse embedded object");
+ return 0;
+ }
+
+ return 1;
+}
+
+static int parse_eo_array(CMPIArray *strings_in,
+ CMPIArray **instances_out,
+ const CMPIBroker *broker,
+ const char *ns,
+ CMPIStatus *s)
+{
+ int i;
+ int ret;
+ int count;
+
+ if (CMIsNullObject(strings_in)) {
+ CMSetStatus(s, CMPI_RC_ERR_INVALID_PARAMETER);
+ CU_DEBUG("Method parameter is NULL");
+ return 0;
+ }
+
+ count = CMGetArrayCount(strings_in, NULL);
+
+ for (i = 0; i < count; i++) {
+ CMPIData item;
+ CMPIInstance *inst;
+
+ item = CMGetArrayElementAt(strings_in, i, NULL);
+
+ ret = parse_eo_inst_arg(item.value.string,
+ &inst,
+ broker,
+ ns,
+ s);
+
+ if (ret != 1) {
+ CU_DEBUG("Parsing argument type %d failed",
item.type);
+ return 0;
+ }
+
+ CMSetArrayElementAt(*instances_out, i,
+ (CMPIValue *)&inst,
+ CMPI_instance);
+ }
+
+ return 1;
+}
+
+static int parse_eo_param(CMPIArgs *args,
+ CMPIData data,
+ CMPIType type,
+ const char *arg_name,
+ const CMPIBroker *broker,
+ const char *ns,
+ CMPIStatus *s)
+{
+ CMPIData newdata;
+ int count;
+ int ret = 0;
+
+ if (type == CMPI_instance) {
+ ret = parse_eo_inst_arg(data.value.string,
+ &newdata.value.inst,
+ broker,
+ ns,
+ s);
+ } else if (type == CMPI_instanceA) {
+ count = CMGetArrayCount(data.value.array, NULL);
+
+ newdata.value.array = CMNewArray(broker,
+ count,
+ CMPI_instance,
+ s);
+
+ ret = parse_eo_array(data.value.array,
+ &newdata.value.array,
+ broker,
+ ns,
+ s);
+ } else {
+ CMSetStatus(s, CMPI_RC_ERR_FAILED);
+ CU_DEBUG("Unable to parse argument type %d", type);
+ }
+
+ if (ret != 1)
+ return 0;
+
+
+ *s = CMAddArg(args,
+ arg_name,
+ &(newdata.value),
+ type);
+
+ if (s->rc != CMPI_RC_OK) {
+ CU_DEBUG("Unable to update method argument");
+ return 0;
+ }
+
+ return 1;
+}
static int validate_arg_type(struct method_arg *arg,
const CMPIArgs *args,
10:09 a.m.
New subject: [PATCH 1 of 2] [CU] Add embedded object parse functionality to std_invokemethod
KR> +static int parse_eo_array(CMPIArray *strings_in,
KR> + CMPIArray **instances_out,
KR> + const CMPIBroker *broker,
KR> + const char *ns,
KR> + CMPIStatus *s)
KR> +{
KR> + int i;
KR> + int ret;
KR> + int count;
KR> +
KR> + if (CMIsNullObject(strings_in)) {
KR> + CMSetStatus(s, CMPI_RC_ERR_INVALID_PARAMETER);
KR> + CU_DEBUG("Method parameter is NULL");
KR> + return 0;
KR> + }
KR> +
KR> + count = CMGetArrayCount(strings_in, NULL);
If you're not going to allocate the CMPIArray in here, then you don't
need a double pointer for it :). I'd say either allocate it here, or
change it to a single pointer.
I think in my previous example I had used a double-pointer to match
the call and behavior of the single-instance case, since it allocates
the instance at the next level up.
Either way is fine, but both require a change :)
--
Dan Smith
IBM Linux Technology Center
Open Hypervisor Team
email: danms(a)us.ibm.com
1:35 p.m.
New subject: [PATCH 1 of 2] [CU] Add embedded object parse functionality to std_invokemethod
Dan Smith wrote:
KR> +static int parse_eo_array(CMPIArray *strings_in,
KR> + CMPIArray **instances_out,
KR> + const CMPIBroker *broker,
KR> + const char *ns,
KR> + CMPIStatus *s)
KR> +{
KR> + int i;
KR> + int ret;
KR> + int count;
KR> +
KR> + if (CMIsNullObject(strings_in)) {
KR> + CMSetStatus(s, CMPI_RC_ERR_INVALID_PARAMETER);
KR> + CU_DEBUG("Method parameter is NULL");
KR> + return 0;
KR> + }
KR> +
KR> + count = CMGetArrayCount(strings_in, NULL);
If you're not going to allocate the CMPIArray in here, then you don't
need a double pointer for it :). I'd say either allocate it here, or
change it to a single pointer.
I think in my previous example I had used a double-pointer to match
the call and behavior of the single-instance case, since it allocates
the instance at the next level up.
Either way is fine, but both require a change :)
Yes, you're right. That was careless of me. =)
--
Kaitlin Rupert
IBM Linux Technology Center
kaitlin(a)linux.vnet.ibm.com
9:42 a.m.
New subject: [PATCH 2 of 2] [CU] Add parse_inst_arg() to validate_args() call in std_invokemethod
# HG changeset patch
# User Kaitlin Rupert <karupert(a)us.ibm.com>
# Date 1201621355 28800
# Node ID d49ff2c6fd5f4a8826d564aaf9ade4912fbab95c
# Parent 0375f0b616f44cba8705b667a658663e891cb068
[CU] Add parse_inst_arg() to validate_args() call in std_invokemethod.
Updates from set 2 to set 3:
-Fixed pointer silliness - changed CMPIArgs param in validate_arg_type() to a single
pointer.
Updates from set 1 to set 2:
-check_for_eo() return type changed from int to CMPIType
Signed-off-by: Kaitlin Rupert <karupert(a)us.ibm.com>
diff -r 0375f0b616f4 -r d49ff2c6fd5f std_invokemethod.c
--- a/std_invokemethod.c Tue Jan 29 07:41:20 2008 -0800
+++ b/std_invokemethod.c Tue Jan 29 07:42:35 2008 -0800
@@ -173,9 +173,14 @@ static int parse_eo_param(CMPIArgs *args
static int validate_arg_type(struct method_arg *arg,
const CMPIArgs *args,
+ const CMPIBroker *broker,
+ const char *ns,
+ CMPIArgs *new_args,
CMPIStatus *s)
{
CMPIData argdata;
+ CMPIType type;
+ int ret;
argdata = CMGetArg(args, arg->name, s);
if ((s->rc != CMPI_RC_OK) || (CMIsNullValue(argdata))) {
@@ -186,10 +191,34 @@ static int validate_arg_type(struct meth
}
if (argdata.type != arg->type) {
- CMSetStatus(s, CMPI_RC_ERR_TYPE_MISMATCH);
- CU_DEBUG("Method parameter `%s' type check failed",
- arg->name);
- return 0;
+ type = check_for_eo(argdata.type, arg->type);
+ if (type != CMPI_null) {
+ ret = parse_eo_param(new_args,
+ argdata,
+ type,
+ arg->name,
+ broker,
+ ns,
+ s);
+
+ if (ret != 1)
+ return 0;
+ } else {
+ CMSetStatus(s, CMPI_RC_ERR_TYPE_MISMATCH);
+ CU_DEBUG("Method parameter `%s' type check
failed",
+ arg->name);
+ return 0;
+ }
+ } else {
+ *s = CMAddArg(new_args,
+ arg->name,
+ &(argdata.value),
+ argdata.type);
+
+ if (s->rc != CMPI_RC_OK) {
+ CU_DEBUG("Unable to update method argument");
+ return 0;
+ }
}
CU_DEBUG("Method parameter `%s' validated type 0x%x",
@@ -200,19 +229,31 @@ static int validate_arg_type(struct meth
}
static int validate_args(struct method_handler *h,
- const CMPIArgs *args,
+ const CMPIArgs **args,
+ const CMPIObjectPath *ref,
+ const CMPIBroker *broker,
CMPIStatus *s)
{
+ CMPIArgs *new_args;
int i;
+
+ new_args = CMNewArgs(broker, s);
for (i = 0; h->args[i].name; i++) {
int ret;
struct method_arg *arg = &h->args[i];
- ret = validate_arg_type(arg, args, s);
+ ret = validate_arg_type(arg,
+ *args,
+ broker,
+ NAMESPACE(ref),
+ new_args,
+ s);
if (!ret)
return 0;
}
+
+ *args = new_args;
return 1;
}
@@ -247,7 +288,11 @@ CMPIStatus _std_invokemethod(CMPIMethodM
goto exit;
}
- ret = validate_args(h, argsin, &s);
+ ret = validate_args(h,
+ &argsin,
+ reference,
+ ctx->broker,
+ &s);
if (!ret)
goto exit;
6128
days inactive
6128
days old
4 comments
2 participants
participants (2)
-
Dan Smith -
Kaitlin Rupert